Procedures

Add child to group (its handle is not kept).

Add an artist (it must stay alive while added). Artists added after the frame is shown are built and compiled at the next update.

Add an attitude quaternion [x, y, z, w] for the next time that has none. ok is false if every time already has an attitude.

Add child to this frame's children. Returns false (and does nothing) for this frame itself or an ancestor of it; true if it is already a child.

Add a color ([r, g, b], alpha 1, or [r, g, b, a], 0 to 1) for the next time that has none. ok is false if every time already has a color.

Add an elevation layer: uri of a source kind (LAYER_; default LAYER_TMS), heights in meters or encoding (ELEVATION_; default ELEVATION_HEIGHTS).

Show h in the window, on top of the scene (it must stay alive while shown), from the next frame.

Add an image layer: uri (a URL, URL template or file) of a source kind (LAYER_*; default LAYER_TMS). Layers added later are drawn on top.

Compute the intermediate markers not computed yet (all of them when counted from the end), and write them.

Keep layer, and add it to the map if it is made.

Remember the name of the star just read (self%n_stars), if it has one.

Add hit to hits(1:n) (growing the array).

Add a point: a time with an optional position, attitude and color ([r, g, b] or [r, g, b, a]).

Add points in bulk: times t(n), with optional positions pos(dof, n), attitudes att(4, n) and colors color(3 or 4, n). Times, positions, attitudes and colors must all have been complete before (as many of each as times) for the given ones to line up with t.

Add a position (the first dof elements of pos are used) for the next time that has none. ok is false if every time already has a position.

Add a time at the end of the time list.

Also follow traj (no effect if it is already followed).

Add v to the end of the window's views (it must stay alive while added).

The text of line after its first n fields (separated by blanks or tabs), trimmed: a star's name ('' if none: e.g. without a color index).

Which point of the text is at its position (an ALIGN_* constant).

Append points b to a (allocatable, (3, n)).

Add frame to list(1:n) (growing the array).

The attitude matrix (column-major 4x4) into a sky node's style.

Give the zoom speed and throw to the trackball (if open).

A region's color, through its mesh's material (the unlit shader multiplies the vertex color, white, by the diffuse color).

Give the highlight h to the line buffers chain.

Add layer to the map (a file found on VKFRAMES_DATA_PATH).

Give the light source's node its colors (if it has been made).

The material, with the diffuse color times the body's color (without a texture), and the twilight, on every mesh built.

The material, with the diffuse color times the body's color (without a texture), and the twilight, on mesh mesh (if not null).

Show or hide the texture, the constellations and the stars (and their names), as the draw mode says.

The sky's attitude into the star names' transform.

Give the lighting and the frame's color to the map (if made).

Give the chain's style (color, width or size, pattern, highlight, marker shape) to the node line.

Give the line width and dash pattern to the chain (if built).

Give the renderer's window light its colors and position (if open).

An arrow (OpenFrames' Vector: a cylinder body and a cone head) from base along direction: body of length body_length and radius body_radius, then a head of length head_length and base radius head_radius, closed at the bottom of the body and of the head, with n_segments around. Triangles are counter-clockwise seen from outside; indices are 0-based; uv is zero. Sizes are given by arrow_size.

An arrow mesh node (see arrow) of color rgba, with 24 segments by default. Null on failure.

Number of vertices and triangle indices of arrow(..., n_segments, ...).

The arrow's length, its head's length and radius (scene units).

Point i from sources, in the drawable's coordinates.

The point at time t between points k and k2 (interpolated in the data frame), in the drawable's coordinates (by the transform at time t).

Points i1 .. i2 (every stride-th) from sources, in the drawable's coordinates.

Artist i (1 to num_artists).

Whether pick tests what this artist draws.

Forget the render nodes (after the artist's group was removed from the scene): build starts again.

Whether pick tests what this artist draws (default true; e.g. false for a spacecraft's marker beside its orbit's curve).

The width / height of the window drawn: a host's (from resize), or of the window's own, as it is now.

Give the artists the frames: this one (their points' coordinates) and the data frame (if set, and in the same tree).

Attitude relative to the parent frame, a quaternion [x, y, z, w].

The sky's attitude in the root frame (quaternion [x, y, z, w]).

Attitude i (quaternion [x, y, z, w]).

Pointer to the attitudes (4, num_attitudes), without copying.

Whether the markers are auto-attenuated.

Whether level of detail is on.

The bounding sphere: the origin, radius the axis length.

Draw the axes under group (the contents); with a window's viewer, later drawings are compiled.

What kind of frame this is: 'CoordinateAxes'.

Which axes labels are shown (as axes_shown).

The axes' color (lines and ticks).

Which axes vectors are shown (NO_AXES, or X_AXIS, Y_AXIS, Z_AXIS combined).

The label text of axis X_AXIS, Y_AXIS or Z_AXIS.

The axes' length (scene units).

The axis lines' width (window units).

The background color [r, g, b].

A panel titled title, with the widgets up to end_panel. A title starting with ## (e.g. '##callout') gives a panel with no title bar, e.g. a callout next to an object: what follows ## still names the panel (Dear ImGui tells panels apart and keeps their state by it), but isn't shown. position ([x, y], 0 to 1 across the window, y up; default: where ImGui puts it) is where its point pivot is ([0, 0], the default: its top left; [0.5, 1]: the middle of its bottom); with follow, every frame (and it can't be moved), else at first.

A candidate closer to the cursor than the best so far (or as close, and nearer).

The body casting the shadow (null if not set).

The body's radius used (0: none known).

The body's equatorial radius in scene units (from its profile: the Moon's for 'moon', else the Earth's).

The bounding sphere of what the frame draws, in its own coordinates (radius 0 if it draws nothing; extensions override it). Views use it for their default distance.

Create artist k's node (compiled now if the frame is already shown).

Add what this frame draws to group (a node handle). ReferenceFrame draws nothing itself (its axes and labels come later); extensions such as Sphere and Model override this.

The axes (arrows), axes labels and name label, each under a switch, in the frame's color (OpenFrames' ReferenceFrame decorations).

The light source's node: a point light at the origin, under a switch.

Build level-of-detail mesh k (lod_segments(k) segments around) and add it to the level-of-detail node (compiled for the windows if compile).

The start, end and intermediate marker nodes, in the artist's group (compiled now if it is already shown).

A button: true once after it was clicked.

The cache directory, created if it doesn't exist yet (e.g. a VKFRAMES_CACHE_DIR not made yet); '' if there is none or it can't be created: nothing is cached.

The camera a fraction s (0 to 1) of the way from camera from to camera to (columns: eye, center, up; in one frame's coordinates): the center moved along a straight line, the distance to it changed by the same factor at each step (so far-to-near flights don't rush the near part), and the orientation turned by the shortest rotation.

A camera's orientation (columns: right, up, back, as a quaternion) and its distance from eye to center (at least a tiny one).

Whether the camera keeps moving after a released drag (set_camera_throw).

Save the last frame as an image (format from the file extension, e.g. .png). Returns false on failure.

Create the chain of buffers (sized for the points now) and the trace tail under group.

The chain, colored if the trajectory's colors are drawn.

Chain points per trajectory point: 1, or 2 for a surface (a pair each).

Forget the render nodes: the chain and the tail (see artist_release).

Write the points added (all of them on a redraw), and draw them all or, in trace mode, those passed and the tail to the point at time t.

Report a failed rendering-layer call (a status not 0), saying where (context, e.g. 'shapes').

A checkbox showing value: true (and value changed) after the user changed it.

Child i (1 to num_children).

Index of frame among the children, or 0.

The trajectory to follow at time t: the current one if it contains t, else the first that does, else the closest.

Chunk j's points (strips: first .. first + n - 1 of the chain) and the bounding box of them (n = 0 if none are measured yet), e.g. to skip a chunk when picking.

Remove all points (keeping the memory).

Delete the cache's files (converted fonts, compiled shaders; nothing else in the directory) and its fonts and shaders directories if left empty (the cache directory itself is kept): the number of files removed, or -1 if some couldn't be. They are made again when next needed.

Stop computing the segments with a callback (they stay as last set).

Forget the camera set by set_default_view_parameters (back to the default view distance).

Give the events to no handler (the built-in keys remain).

Remove all segments.

The window's simulation clock (e.g. to synchronize it with another window's).

The vertices' clock angles (radians).

Close the window (waiting for the GPU). The scene is kept, and can be shown again in another window. So are the window's settings (views, HUD texts, sky, handler, time): open again (e.g. on a host's new native window, after Qt destroyed the old one) shows them as before.

Points along a closed curve, as separate segments: pairs (p(i), p(i+1)).

The color: [r, g, b, a] (0 to 1).

The color of the frame's decorations, [r, g, b, a] (0 to 1).

Color i ([r, g, b, a]).

The trajectory's color at time t (between points i and i + 1: blended), own for points without one.

As slice, for the colors of a colored chain: c(rgba, point) of points lo .. hi of chunk j (null if not colored or nothing there).

Pointer to the colors (4, num_colors; single precision, as drawn), without copying.

A combo box (a drop-down menu) of items (trailing blanks trimmed), showing item index (1-based): true (and index changed) after the user chose another.

Free the storage not used: each array is reallocated to the points it holds (one copy, an array at a time), and arrays holding none are deallocated. For a trajectory that is complete: growing doubles the storage, so up to about half of it can be unused. The data and what is drawn of them don't change; pointers from times, positions, ... must be fetched again. Points can still be added (storage grows again).

The vertices' cone angles (radians).

The bound of the apex and the base.

Draw the cone under group (the contents); with a window's viewer, later drawings are compiled.

The sides' color [r, g, b, a].

What kind of frame this is: 'PolyhedralCone'.

Whether point (in the cone's frame) is inside the cone, between distances min_distance and max_distance along the boresight (defaults 0 and unlimited): inside the polygon of the vertices' directions (OpenFrames' isVisible; its PolyhedralCone always answers false).

The cone's length along the boresight (scene units).

The edges' and base outline's color [r, g, b, a].

The edges' and base outline's color.

The constellation file read ('' for none).

Constellation line i (1 to num_constellation_lines): its ends' directions (unit vectors, sky frame).

Constellation i's lines (1 to num_constellations): first .. last (see constellation_line; none if last < first).

Constellation i's name (1 to num_constellations).

Whether the constellations are drawn (as set).

Where the ray (origin, unit dir; root frame) meets the constraint taken at the grab, the frame at transform m to the root: h, in the frame's coordinates. False if it doesn't.

The handle's constraint (HANDLE_*).

The constraint's normal or direction (unit vector, frame coordinates).

Whether what the frame draws is shown (show_contents).

The CoordinateAxes constructor: CoordinateAxes(...) makes one (see new_coordinate_axes for its arguments).

Count a frame for the frame rate (render_stats): its duration, and the rate over about half a second.

Index of the j-th point counted in the intermediate markers' direction.

The node of HUD text k, added to the window (compiled if it runs).

Create the window's nodes for its HUD texts (before its first frame).

The cross product a x b.

The view shown (the default view of the scene's root if none were added).

The ray from the eye through point (x, y) of the window (-1 to 1 across it, y up: as the event handler's positions), in the root frame, as at the last frame: its origin (the eye; in an orthographic view, on the eye's plane) and its direction (a unit vector). False before the first frame. E.g. where the cursor points on a plane: vkf_pick's ray_plane.

The chain: a line strip.

The line's color [r, g, b, a].

The dash pattern's layout: DASH_SCENE, DASH_SCREEN or DASH_FIXED.

The curve's highlight: HIGHLIGHT_* (added; HIGHLIGHT_NONE: not highlighted).

The chain (ChainArtist's), with the curve's level of detail.

The trace tail: a line of two points (white unless the points' colors are drawn).

The dash pattern: its factor and 16 pattern bits.

A curve's best hit: on the segments drawn (and the trace tail).

Number of points to draw (1 if all sources are zero: a point at the origin).

The line's color: [r, g, b] (alpha unchanged) or [r, g, b, a], 0 to 1 (with the trajectory's point colors drawn: for points without one).

How the dash pattern (and a trail's) is laid out: DASH_SCENE (the default) anchored to the line: a dash stays put on it as the view changes, its size in scene units (one per line and view, from 0.7 to 1.4 times the pattern's on screen, changing by doubling as it zooms); DASH_SCREEN screen-locked, as OpenGL's line stipple (OpenFrames'): every dash the pattern's length in pixels, at any zoom and depth, sliding along the line as the view changes; DASH_FIXED a fixed length of the line, as paint on it: never changing, so zooming in the dashes grow on screen, and out they shrink (under a pixel, blending into a fainter solid line); length (scene units, for the whole pattern: the other patterns, a trail's future's and the arrows', in proportion), else the pattern's length on screen where the line is first drawn. DASH_SCREEN and DASH_FIXED cost projecting the points drawn on the CPU, per view and frame.

Highlight the curve (see the module documentation): mode a sum of HIGHLIGHT_PULSE and HIGHLIGHT_ARROWS (HIGHLIGHT_NONE: not highlighted), in color ([r, g, b] or [r, g, b, a]; default white). The other settings are kept when not given.

A dash pattern, as OpenGL's line stipple (OpenFrames' setPattern): each bit of the 16-bit pattern (bit 0 first; z'FFFF', the default, is solid) covers factor window units, along the whole curve (the dashes run on across its points). The dashes' length on screen is kept within 0.7 to 1.4 times the pattern's (see shaders/line.vert).

Draw traj; with the default data sources, its positions (per its DOF).

The line's width in window units (logical pixels).

The style: the artist's color, or white if the points' colors are drawn (the shader multiplies them by it).

Write the points added (all of them on a redraw), and draw them all, or in trace mode those passed and the tail to the point at time t, or with a trail the window about time t.

The line's width (window units).

The CurveArtist constructor: CurveArtist(...) makes one (see new_curve_artist for its arguments).

The CustomLineSegments constructor: CustomLineSegments(...) makes one (see new_custom_line_segments for its arguments).

The dashes' layout (set_dash_mode).

Whether the trajectory changed since last drawn; redraw if everything must be drawn again (cleared, or a new trajectory or data sources).

The frame the data are in (set_data_frame; null: this frame).

The sum of the followed trajectories' revisions and generations: it grows with any change to their data (the set of trajectories itself changes the motion_stamp).

The x, y and z data sources.

Where the followed position's x, y and z come from.

The transform from the data frame's coordinates to the drawable's at time t.

True if every followed trajectory has the data the position sources use.

The DataSource constructor: DataSource(...) makes one (see new_data_source for its arguments).

Whether points 1 .. n have decreasing times (a trajectory propagated backwards).

The built-in keys (OpenFrames'): v the next view, V the previous one, the space bar resets the view; not with control, alt or meta held.

Whether the built-in keys are on (set_default_keys).

The radius framed when the view is reset (<= 0: the viewed frame's bound).

The camera after a reset (view-frame coordinates; all zero if none is set).

Remove the chunks from the group (also while running), and release them.

Remove this frame from all its parents and children (before it goes out of scope or is deallocated while in a tree).

The window's Vulkan device and driver (see vkf_diagnostics); '' while it isn't open.

One event (see vkf_viewer_events): kind, key, key base, modifiers, button, buttons held, x, y (framebuffer pixels from the top left), the render area (x, y, width, height).

The keyboard and mouse events of the last frame, to the handler and the built-in keys (stopping if the window is closed meanwhile).

The display scale.

The distance between the body and the light at the last update.

A strip's distance along it at point i, as written.

Degrees of freedom (2 or 3) of positions and optionals.

Drag the grabbed handle to the cursor's ray (origin, unit dir; root frame), held to its constraint. False (and not moved) if it isn't grabbed or the ray doesn't meet the constraint.

The grabbed handle dragged to (x, y).

Whether the mouse may grab the handle.

The handle is grabbed (until released).

Draw points 1 .. k (no upload).

Which axes are drawn: an ior of X_AXIS, Y_AXIS, Z_AXIS.

What is drawn: an ior of CONE_SIDES, CONE_EDGES, CONE_BASE_OUTLINE.

What is drawn: SKY_NONE, or a sum of SKY_TEXTURE and SKY_STARS.

Draw points i1 .. i2 only (chain indices; none if i2 < i1): e.g. a trace of decreasing times, its last points.

A trail at time t: the points within its window (and the one beyond each end: the GPU cuts the segments at the cutoffs) drawn, and the distances along the curve at t and at the window's edges given to the shader (see vkf_line_set_trail), as distances from t's in the direction of time; times beyond the trajectory's are extrapolated from its end segments.

Draw the points written: all of them (the tail hidden) or, in trace mode, those passed by time t (times up to it) and the tail from the latest of them to the point at t (unchanged if nothing changed and t is the time it was drawn for).

Build the artists' nodes under group (viewer, may be null: those made later are compiled if not null).

What kind of frame this is: 'DrawableTrajectory'.

Picks what the artists draw (see the module documentation), then the frame's origin (if it shows axes or its name label).

Highlight all the frame's curve and segment artists (see set_highlight; HIGHLIGHT_NONE: none of them).

Update the frame (and its descendants), then its artists.

The DrawableTrajectory constructor: DrawableTrajectory(...) makes one (see new_drawable_trajectory for its arguments).

The color of point i (1 to num_drawn) as drawn: read back from the line buffers.

The distance along the curve at point i (1 to num_drawn), as drawn (for the dash pattern): read back from the line buffers.

The length drawn at the last update.

Where marker which (MARKER_START, MARKER_END, or MARKER_INTERMEDIATE number i) is drawn, read back from its buffer; false if not drawn.

The pair at trajectory point i (1 to num_drawn) as drawn, its start a and end b: read back from the buffers.

Point i (of the trajectory's: first_drawn to first_drawn + num_drawn - 1 drawn) as written: read back from the line buffers.

Segment s (at point 1 + (s-1) stride; first_drawn to first_drawn + num_drawn - 1 drawn) as written: read back from the line buffers.

Segment i as drawn (read back from the GPU buffers, for checks): its endpoints and colors.

No colors per vertex.

The height of the terrain (scene units, above the body's sphere or ellipsoid) at latitude and longitude lat, lon (degrees), from the last elevation layer added that is a file (LAYER_GDAL), read directly (also before the body is shown); found is false (and the height 0) without such a layer or data there, or without Rocky.

A triaxial ellipsoid with semi-axes radii (x, y, z) centered at the origin, for an equirectangular texture in geodetic coordinates.

An ellipsoid mesh node with semi-axes radii (x, y, z) and color (rgba, multiplying the texture), with an optional equirectangular texture and night texture (image handles; the night texture shows where the light is weak). n_lon and n_lat default to 128 and 64 segments. With translucent, a translucent surface (its material's alpha; drawn after the opaque scene, sorted by depth). Null on failure.

Number of vertices and triangle indices of ellipsoid(radii, n_lon, n_lat, ...).

What kind of frame this is: 'EllipticCone'.

Inside the elliptic cone (exactly; OpenFrames' EllipticCone::isVisible).

The half-angles along x (a) and y (b), radians.

The half-angles along x (a) and y (b), radians (0 to 90 degrees).

120 vertices (every 3 degrees), cone angle a b / sqrt(b^2 cos^2 + a^2 sin^2) (OpenFrames' createEllipticCone).

The EllipticCone constructor: EllipticCone(...) makes one (see new_elliptic_cone for its arguments).

ffmpeg's encoder options for codec and quality (see start_recording).

The x, y and z data sources of the segments' end points.

End the panel started by begin_panel.

Whether the ends are relative (see set_end_relative).

The color of point i for a start or end marker: the trajectory's (its own if none), with point colors.

The event handler (null if none).

The faces' color [r, g, b, a].

The vertical field of view (degrees) of the perspective projection.

Index of frame in list(1:n), or 0.

The path of data file name: name itself if it exists (a path, or a file in the current directory), else the first match in the directories of the VKFRAMES_DATA_PATH environment variable; '' if not found.

The path of font name (a file name or a path), or '' if not found.

The path dir/name of the first directory in dirs (separated by ';' or ':', except a ':' after a drive letter) that has name, or ''.

The first point drawn (1, or in trace mode of decreasing times the earliest point passed): points first_drawn .. first_drawn + num_drawn - 1.

The camera of an active flight to view v, at this moment: both cameras in the root frame (their views' frames as they are now), in between by the eased fraction of the time passed, back in v's frame.

The root frame (null if none).

Number of scene updates so far (update).

Set the root frame of the scene (not owned: it must stay alive while managed). (The scene is for a window: this also starts loading the Vulkan driver for the first one, in the background, which can take a few tenths of a second.)

Update the scene for time t (followed trajectories, artists) and copy the frames' positions and attitudes to the renderer, unless another window already did for this time since this window's last frame. seen is the window's own: the number of updates at its last frame.

Follow traj (in addition to trajectories already followed, if add is true), with what to follow (data: FOLLOW_POSITION and/or FOLLOW_ATTITUDE; default both) and how (mode: FOLLOW_LOOP, the default, or FOLLOW_LIMIT). traj must stay alive while followed.

What is followed: FOLLOW_POSITION and/or FOLLOW_ATTITUDE (combined with ior).

The frame the followed data are in (follow's data_frame; null: the parent).

How time outside the trajectories is handled: FOLLOW_LOOP or FOLLOW_LIMIT.

The followed position and attitude at time t, in the parent's coordinates (from the data frame's, if follow had one, by both frames' poses at time t); pos and att unchanged where nothing is followed.

The frame's trajectory follower, for finer control (data sources, time offset, ...).

The font file ('' for the default font).

No handle hovered or grabbed (the scene or the window changes).

Render one frame: advance the clock, update the frames and draw. Returns false once the window has been closed (or on failure).

What kind of frame this is (shown by frame_string; extensions override it).

A frame's local-to-parent transform, as OpenFrames' FrameTransform builds it: translate(position) * rotate(attitude) * scale(scale) * translate(-pivot).

A body's own radius: a Sphere's equatorial one, a TerrainBody's; else 0.

The tree below this frame, one line per frame ("name (info)"), in OpenFrames' createFrameString format: children are prefixed "|-->".

The transform from f to the view's root frame (the tree root if none).

The FrameManager constructor: FrameManager(...) makes one (see new_frame_manager for its arguments).

Number of times the data were cleared (by clear, set_dof or set_num_optionals): while it is unchanged, data were only appended.

The camera of the view shown (from the last frame): eye, center and up in the view frame's coordinates (OpenFrames' trackball getTransformation), or in its root frame's if in_root. Zero before the window's first frame.

The font handle for name (found with find_font, read on first use); the default font if name is ''; null if it cannot be found or read.

The trajectory drawn (null if none).

Grab the handle with the cursor's ray (origin, unit dir; root frame): its constraint is taken as it is now, and the point's offset from where the ray meets it. False if it isn't draggable.

A left press grabbed the mouse (the grab armed): the hovered handle grabbed.

The bounding sphere: the origin, radius the largest semi-axis.

Draw the grid under group (the contents); with a window's viewer, later drawings are compiled.

What kind of frame this is: 'LatLonGrid'.

The ellipsoid's semi-axes and the line spacings, as OpenFrames' getParameters.

The lines' color.

The ellipsoid's semi-axes (> 0; e.g. a Sphere's radii, a little larger to draw above its surface) and the line spacings (radians; 0 for no latitude or longitude lines), as OpenFrames' setParameters.

Grow the attitudes' storage to hold at least n.

Grow the colors' storage to hold at least n.

Grow the positions' (and optionals') storage to hold at least n.

Grow the times' storage to hold at least n (see new_capacity).

Called each frame just before drawing, the scene at time t and the camera placed (see the module documentation): e.g. to move HUD text next to a moving object, or frames. A view following a frame moved here follows it in this frame's drawing (its transform is taken again after); trajectories' points changed here are drawn from the next frame (change them in before_update).

Called each frame with its time t, before the scene is updated for it and the camera placed (see the module documentation): to change the data for time t (trajectories' points, frames' positions), drawn and followed by the views in this frame.

A mouse button (MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT) was pressed at (x, y) (see mouse_motion).

A mouse button was released at (x, y) (see button_press).

A handle (vkf_handles) was grabbed (DRAG_START), dragged (DRAG_MOVE: it has moved) or released (DRAG_END) with the mouse: e.g. compute again what depends on it (see the module documentation).

A key was pressed: key (a character's code, iachar('v'), or KEY_), with the modifier keys held (MOD_ bits). Set handled (false on entry) to skip the built-in key's action.

A key was released (see key_press).

The mouse moved to (x, y) (-1 to 1 across the window, y up), with the buttons held (left, middle, right): moving (none held, OpenFrames' mouse motion) or dragging.

Whether any handle has been shown in a window (so windows look for handles under the cursor).

Whether this frame or one of its descendants has a light source enabled.

True if a model was read (or shared).

Whether the curve has a trail (set_trail).

Whether the faces have a color per vertex.

The head's length set (0: 0.2 of the arrow's).

The default camera (eye, center, up in view-frame coordinates) for a viewport of aspect ratio aspect (width / height): OpenFrames' resetView.

The handle under (x, y), if any, hovered (the one before not), and the grab armed for it. Of handles on the same spot: the nearest on the screen; within same_spot pixels of it, the highest priority, then the nearest to the eye (vkf_handles).

The handle is under the cursor.

The HUDText constructor: HUDText(...) makes one (see new_hud_text for its arguments).

The 4x4 identity matrix.

Along the boresight (-z) between the distances (a point ahead of the apex).

True while the camera is flying (a transition).

Draw under group (a CHAIN_* kind; markers with image, a vkf_image_read handle, for the image shape). Chunks made later are compiled once set_compile says so.

Where intermediate markers are counted from (MARKER_START or MARKER_END).

Spacing of intermediate markers.

How intermediate markers are spaced (INTERMEDIATE_*).

Every int(spacing)-th point after the first, before the last.

Every spacing of arc length (the points joined by straight lines).

Every spacing time units after the first time, before the last (counted from the start or the end).

Slerp of the attitude at time t; the first/last attitude outside the time range. status and index: the trajectory's time_index for t.

Linear interpolation of the position (from sources) at time t; the first/last point outside the time range. status and index: the trajectory's time_index for t.

True if the chain has a group to draw under (between init and release).

For lines and markers, whether each point has its own color (init's colored).

True if frame is root or one of its descendants.

True if the trajectory has no times.

Whether the frame follows trajectories (at least one, since follow).

True if following the simulation time plus an offset, false for a fixed time.

Whether the window is open (not closed, by the program or the user).

True if the simulation time is paused.

The sources are x, y, z of the position, unscaled.

Whether the window is recording a video.

True if the text is shown.

Whether the simulation time is paused.

False if the window has no GUI (not open).

True if the view has a frame to view.

A key press (pressed true) or release, as VSG key symbols and modifiers (ASCII for printable keys; vsg/ui/KeyEvent.h).

The labels' alignment (ALIGN_*).

A label node: text at position in color rgba, in font font_name ('' for the default), aligned by alignment (an ALIGN_* constant of vkf_frames). size > 0: size window units tall; size < 0: -size scene units tall, but at most max_size window units on screen. Null if the font is missing.

The labels' font as set ('' for the renderer's default).

Change label node's position, size, maximum size and alignment (as label_create's), in place. False on failure.

The labels' size in pixels.

The time (after looping) at the last update.

The trajectory followed at the last update (null if none).

After the whole tree's update for time t (all frames at their positions for t): for contents that depend on other frames' positions, e.g. CustomLineSegments between spacecraft. Here, only the descendants'.

The LatLonGrid constructor: LatLonGrid(...) makes one (see new_lat_lon_grid for its arguments).

The length set (0: automatic).

Whether level of detail is on.

The versions of vkframes and the libraries it uses.

The light (null if not set).

The ambient color of the window's light [r, g, b].

The light source's ambient color [r, g, b].

The diffuse color of the window's light [r, g, b].

The light source's diffuse color [r, g, b].

The position of the window's light (see set_light_position).

The light's radius used (0: none known).

Whether this frame carries a light source.

The specular color of the window's light [r, g, b].

The light source's specular color [r, g, b].

True if the body is lit by the scene's lights.

The point buffer of a line or marker node: (xyz and distance, high/low, point).

A line node through points xyz(3, n): a strip, or separate segments (points 1-2, 3-4, ...).

Set a line's dash pattern, as OpenGL's line stipple: each bit of the 16-bit pattern (bit 0 first; z'FFFF' solid) covers factor window units (see shaders/line.vert). Returns 0, or -1 on failure.

Set the points of a line strip (xyz(3, n), double precision), splitting each coordinate, and the distance along the strip, into the (high, low) float pair the line shader reads, in place in the strip's buffer. Returns 0, or -1 if n exceeds the capacity.

Draw a line's points as separate segments (pairs of points: 1-2, 3-4, ...) instead of a strip. Set before its points are drawn. Returns 0, or -1 on failure.

Set the color (rgba) and width (window units: logical pixels) of a line strip. Returns 0, or -1 on failure.

Line width (window units).

Widths of the grid lines and of the equator and prime meridian (window units).

Whether the faces are lit.

The transform from this frame to its parent (4x4).

The transform from this frame to its parent at simulation time t: its fixed position and attitude, with what it follows at time t (the followed trajectories' state then, in the parent's coordinates). The same as local_matrix after update at time t, for any t, without changing anything.

The error bounds of chunk j of the curve's points (for checks): how far the points skipped can be from the segments drawn at stride 2^k, k = 1, 2, ... (scene units).

Chunk j's error bounds: how far the points skipped can be from the segments drawn at stride 2^k (k = 1 .. lod_levels; 0 where not known).

The frame looked at, for a view between frames (null if none).

Make the axes' lines and tick marks, in place of the old (nothing before build_contents).

Axis k's arrow and label, in their switches (in place of the old ones; compiled first if the window already runs).

Make the sides, edges and base outline (those the draw mode says), in place of the old.

Place the cone's apex at apex (in the parent frame) with its boresight along dir and its +y axis toward up (OpenFrames' makeConeLookAt).

Make the grid's lines (circles in 1 degree steps, meridians in 0.5 degree steps), in place of the old.

The constellations node for the lines read and the settings, in place of the old one (none unless shown).

The map (in the contents group) for viewer, with the settings and layers.

The name label (in place of the old one; compiled first if shown).

The star names node for the current names and settings, in place of the old one: a label per named star drawn up to the names' magnitude, under the stars' switch (shown with them), turned by the sky's attitude.

Make the disk, its circles and its radial lines (1 degree steps), in place of the old.

The polyhedron's nodes, made again (if shown).

The star node for the current stars, in place of the old one.

The texture node for the current image, in place of the old one.

Create the marker nodes under group (see artist_build).

The color of the start, intermediate or end markers (which: one MARKER_* flag).

The x, y and z data sources.

The color marker k of which (one MARKER_* flag; k: the intermediate marker's number) is drawn in: read back from its buffer with point colors, else the marker's own color.

The marker image file ('' for none).

A marker node at points xyz(3, n), px window units (MarkerArtist's shapes and attenuation).

A marker artist's best hit: its start, end and intermediate markers drawn.

Point i from the data sources (the origin if zero).

Whether the trajectory's colors are drawn (set_point_colors).

Forget the render nodes (see artist_release).

How intermediate markers are spaced: INTERMEDIATE_TIME, _DISTANCE or _DATA. Point colors (default off): with the trajectory's colors (Trajectory% add_color, or add's color), each marker is drawn in the color at its point (intermediate markers between points: blended between theirs, by time), points without a color yet in the marker's own color (set_marker_color). Off, or without colors: the markers' own colors.

Set the color (rgba), size (window units), shape (see shaders/ marker.frag) and attenuation radius (scene units; 0 for none) of markers. Returns 0, or -1 on failure.

Draw traj; with the default data sources, its positions (per its DOF).

Where the x (y, z) of the markers come from. Returns whether the trajectory has those data.

Where the y of the markers come from (see set_x_data).

Where the z of the markers come from (see set_x_data).

The marker's shape (MARKER_*).

Marker shape (a MARKER_* shape constant).

The marker's size (window units).

Marker size (window units).

Apply the colors, size, shape and attenuation radius (0: off) to the marker nodes.

Write the start, end and new intermediate markers if the trajectory changed, and draw them all or, in trace mode, those passed at time t.

Whether the markers are drawn in the trajectory's colors: wanted, and it has some.

The MarkerArtist constructor: MarkerArtist(...) makes one (see new_marker_artist for its arguments).

Which markers are drawn (an ior of MARKER_* flags).

The intermediate markers (in trajectory order) whose times are at most t: count from first (the first ones for increasing times, the last for decreasing), by bisection.

The material (each optional): ambient, diffuse, specular and emission colors and shininess.

The distances along the strip of points lo .. hi of chunk j: from the previous point (in this chunk; the first point of a chunk after the first is the previous chunk's last, measured before), or 0 at point 1. From x (as in written) if given, else from the floats written.

Pointers to the arrays of a mesh of n_vertices vertices and n_indices indices (as created by vkf_mesh_create), to fill in place before the first frame. Indices are 0-based.

Set a lit mesh's material: ambient, diffuse, specular and emissive colors (rgba) and shininess (VSG's Phong: the ambient color scales the diffuse color reflected from ambient light). Returns 0, or -1 on failure (e.g. a mesh without a material).

The Model constructor: Model(...) makes one (see new_model for its arguments).

Attitude of the model in its frame (quaternion [x, y, z, w]).

The model's bounding sphere, in the model's own coordinates (before its transform).

The model under the model transform.

The model file ('' if none).

The model's bounding sphere in the frame (through the model transform).

The kind of frame: 'Model'.

Picked on the model's bounding sphere (not its triangles); else at the frame's origin.

The model's pivot, in its own coordinates (see set_model_pivot).

Where the model's pivot is placed in its frame (frame coordinates).

Scale along the model's x, y and z axes.

With data in another frame (transformed): redraw set if either frame's motion changed, the data frame changed, or the transform began or ended since the points were written.

What the frame's motion depends on, for drawings that depend on it to know when to redraw: stamp, the latest change of the motion of it and its ancestors (through first parents), and of the frames their followed data are in (poses set, parents changed, what is followed and how); and data, the followed trajectories' revisions summed. Either changes when the frame's motion over time changes.

The stamp of the last change of the follower's settings (the trajectories followed, what and how, the time); 0 if never changed.

A mouse event: kind MOUSE_MOVE, MOUSE_PRESS or MOUSE_RELEASE.

Place axis k (as move_x_axis), made again if the frame is shown.

Chunks moved to a new array (their level-of-detail bounds moved, not copied).

Place the x axis vector: from base, length long, with a head of head_ratio of the length (default 0.3) and body and head radii (default 0.05 and 0.1 of the length); its label is at the tip, 0.4 of the length tall (at most label_size pixels). As OpenFrames' moveXAxis. Set before the frame is first shown.

Place the y axis vector (as move_x_axis; OpenFrames' moveYAxis).

Place the z axis vector (as move_x_axis; OpenFrames' moveZAxis).

Whether a frame moves in time: it or an ancestor (first parents) follows trajectories.

The frame's name ('' if none).

Whether the name label is drawn on top of the scene (set_name_label_on_top).

Whether the name label is shown.

The capacity to grow to for needed points: twice the current, or what is needed and a quarter more (so that appending after a large bulk add doesn't copy everything at once); exact (reserve): what is needed.

Coordinate axes named name, of color color ([r, g, b] or [r, g, b, a]), 1 long, with major ticks every 0.5 and minor every 0.25 (OpenFrames' defaults).

A curve artist for traj (optional), drawn in color color ([r, g, b] or [r, g, b, a]; default white) and width (window units; default 1).

Line segments named name, of color (for segments set without colors; default white) and width (window units; default 1).

A data source (see DataSource); element defaults to 1, opt to 0, scale to 1.

A drawable trajectory frame named name (decorations of color color).

An elliptic cone named name, of color color (sides and base outline drawn).

A frame manager for the scene with root frame (optional).

HUD text text, optionally at position ([x, y], 0 to 1; default near the bottom left), with alignment (default ALIGN_LEFT_BOTTOM), size (window units; default 20), color ([r, g, b] or [r, g, b, a]; default white) and font (default: the default font).

A latitude/longitude grid named name, of color color, on a unit sphere, every 30 degrees (OpenFrames' defaults).

A marker artist for traj (optional; without one, or with all data sources zero, a start marker at the origin: in a DrawableTrajectory that follows a trajectory, or is a child of a frame that does, it marks the current position, as in OpenFrames), drawing markers (an ior of MARKER_START, MARKER_INTERMEDIATE, MARKER_END; default start and end) of size window units (default 10) in color (all markers; default red start and end, white intermediate).

A model frame named name (decorations of color color), with the model file file if given (see set_model).

A polyhedral cone named name, of color color (its sides and lines): 3 vertices at clock angles 0, 120 and 240 degrees, cone angles 45 degrees, 1 long (OpenFrames' defaults).

A polyhedron named name, of color color (its faces, edges and vertices), with no faces yet (set_faces, set_triangles or set_grid).

A radial plane named name (decorations of color color): radius 1, circles every 0.5, radial lines every 30 degrees, light gray and transparent (OpenFrames' defaults).

A rectangular cone named name, of color color.

A frame named name, with decorations of color color ([r, g, b] or [r, g, b, a], 0 to 1; default white, 90% opaque).

A ribbon artist for traj (optional), of color color ([r, g, b], alpha unchanged, or [r, g, b, a]; default white, alpha 0.25), from the frame's origin to the positions (see set_start_x_data, ... for others).

A segment artist for traj (optional), drawn in color color ([r, g, b] or [r, g, b, a]; default white) and width (window units; default 1), at every stride-th point (default 1).

The shadow named name of body in the light of light (frames of the same tree; optional here, set later with set_body and set_light), with their radii if given (else the frames': see the module documentation). Its axes and name label are hidden.

A sphere named name, of radius radius (default 1) and color color ([r, g, b] or [r, g, b, a]; default white, 90% opaque).

A body named name in Rocky's tiling profile profile (default '': the Earth; 'moon': the Moon), drawn at units_per_meter scene units per meter (default 1e-3), in color color where it has no imagery ([r, g, b] or [r, g, b, a]; default the frame's).

A time handle (see the module documentation) on path (which must stay alive while used), at time time (default 0) within t_min to t_max (default: the time), in color ([r, g, b] or [r, g, b, a]). Its axes and labels are hidden (its name label can be shown: e.g. the time).

A trajectory with dof (2 or 3, default 3) degrees of freedom and nopt (default 0) optional vectors per position.

A path along traj (which must stay alive while used).

A vector handle (see the module documentation): vector in its frame's coordinates (default [1, 0, 0]), drawn scale times as long (default 1), in color ([r, g, b] or [r, g, b, a]). Its axes and labels are hidden.

A view of frame (in the tree of root), with base frame_type (default RELATIVE_FRAME); with lookat, a view from frame at lookat, turned by rotation_type (default VIEW_AZEL). Without frames, the view looks at the root frame's origin. The frames must stay alive while the view is used.

A new motion stamp: larger than all before (a change of some frame's motion: its pose, its parents, what it follows and how).

Show the next view (wrapping around); duration as select_view's.

The night texture file ('' for none).

The frame's transform node (null until realized).

The sky's node, made on first use, for a window (set_sky). For a window's viewer (null: headless), nodes made later (a new texture or catalog) are compiled for the windows running.

The wall time (s): wall if present, else wall_time().

Number of artists.

Number of attitudes (at most num_times).

Number of children.

Number of buffers the artist is drawn with (0 until built).

Number of chunks.

Number of colors (at most num_times).

Number of constellation lines read (of all of them).

Number of constellations read.

Number of trajectory points drawn now (all of them, or in trace mode those passed).

Segments drawn now (0 until shown and updated).

The number of edges.

Number of intermediate markers drawn now.

Number of layers (image and elevation).

Number of level-of-detail meshes built so far (0 without level of detail).

Number of optional vectors per position.

Number of parents.

Number of points available with these sources: the number of times, limited by the positions or attitudes they use; huge() if all are zero.

Number of positions (at most num_times).

Number of segments set.

Number of named stars read (of the stars read).

Number of star names drawn now (0 until the sky is shown, or if the names aren't).

Number of stars read.

Number of times.

Number of trajectories followed.

The number of triangles drawn (polygons: as fans).

The number of vertices.

Number of views added.

The body's opacity (set_opacity).

Open the window: width x height (logical pixels) titled title, or, with native_window (a host window's native handle) and its pixel_ratio, render into that window. vsync (default true): frames are presented at the display's refresh; false: as soon as they are ready (where the driver allows it), e.g. to measure frame times. Returns false on failure.

Points along an open curve, as separate segments.

Optional vector k (1 to num_optionals) of position i.

The sources of optional opt's x, y, (z) (zero beyond dof, default 3), each times scale (default 1): e.g. a thrust vector stored per point, for set_end_data with relative ends.

The bounds [left, right, bottom, top] of the orthographic projection.

Parent i (1 to num_parents).

Index of frame among the parents, or 0.

The dash pattern (see set_pattern).

Pause (true) or resume (false) the simulation time.

Pause (true) or resume (false) the simulation time.

Pick what the frame draws (see the module documentation): to_root is its transform to the root frame; hits are added to hits(1:n). A plain frame: its origin, if it shows axes or its name label.

The camera of a pick: eye, center and up (root frame), a perspective projection (fovy, degrees, and aspect) or an orthographic one (ortho: left, right, bottom, top), a viewport of width x height framebuffer pixels, the cursor (x, y: -1 to 1, y up) and the tolerance (framebuffer pixels).

Pick a body of frame self: the ellipsoid centered at center with semi-axes radii along the columns of axes (unit vectors; all in the frame's coordinates), hit by the ray through the cursor. Adds a PICK_BODY hit (with the geodetic latitude and longitude of the point on the ellipsoid if geodetic); true if hit.

Whether pick tests what this frame draws (set_pickable).

Framebuffer pixels per window unit of a host's window (as given to open or resize; 1 for a window of its own).

Move the shadow to the body's center (in the parent's coordinates) with its +z axis away from the light, and reshape the cones if the radii, the distance or the length set changed.

The frame's own axes (arrows) at length along x, y and z, half as long.

Set the renderer's camera for the current view: keep the previous view's trackball state and restore (or reset) the current one's when the view changes, then set its world-to-view transform and projection.

The frame's own axes (arrows) at the ellipsoid's semi-axes, half as long.

The bounding sphere: the origin, radius the plane's radius.

Draw the plane under group (the contents); with a window's viewer, later drawings are compiled.

The plane's color [r, g, b, a].

What kind of frame this is: 'RadialPlane'.

The lines' color [r, g, b, a].

The plane's radius, circle spacing and radial line spacing, as OpenFrames' getParameters.

The lines' color (default white, 0.2 opaque).

The plane's radius (> 0), circle spacing and radial line spacing (radians; 0 for none), as OpenFrames' setParameters.

Point i as written: read back from the buffers (zero if not held).

Point i with components from sources (OpenFrames' getPoint). No checks: use verify_data and num_points first.

The point at time t (components from sources; default: the position's), linear in time between the points about it; outside the times, the first or last point. ok (optional) false, and v 0, if there is no point (or the search for the time failed).

The point at time t between points k and k2 (components from sources): linear in time, within the two (time_fraction). Point k if k2 isn't a point (beyond the ends, or more times than data).

The color of point i of a colored chain, as stored (rgba; white if not colored).

The vertices' color [r, g, b, a].

Whether a trajectory's colors are drawn.

Point p (root frame) is within the tolerance (plus extra pixels, e.g. half a marker's size) of the cursor: its distance from it (pixels) and its depth.

Color of point i as drawn by a colored chain: the trajectory's, or the artist's if it has none yet.

Color of point i: the trajectory's, or own if it has none yet.

The vertices' size (window units).

Points i1, i1 + stride, ... (up to i2) with components from sources, into v(3, :) (as many columns as points; point for a range, a whole array slice per component). No checks: use verify_data and num_points first.

The bounding sphere: about the vertices' box's center.

What is drawn: an ior of POLY_FACES, POLY_EDGES, POLY_VERTICES.

What kind of frame this is: 'Polyhedron'.

The edges' color [r, g, b, a].

The edges' width (window units).

The faces' opacity.

What to draw: an ior of POLY_FACES, POLY_EDGES, POLY_VERTICES (default faces and edges).

The edges' color.

The edges' width (window units; default 1).

The faces' opacity (0 to 1; default 1, opaque): below 1 translucent.

The PolyhedralCone constructor: PolyhedralCone(...) makes one (see new_polyhedral_cone for its arguments).

The Polyhedron constructor: Polyhedron(...) makes one (see new_polyhedron for its arguments).

Where the text is: [x, y] (0 to 1 across the window, y up).

Position relative to the parent frame.

Position i (z = 0 for a 2-DOF trajectory).

The origin of other (a frame of the same tree) in this frame's coordinates, from both frames' transforms to the root (through their first parents).

The sources of a trajectory's positions: x, y, (z) of the position, and zero for components beyond dof.

Pointer to the positions (3, num_positions), without copying.

Show the previous view (wrapping around); duration as select_view's.

The handle's priority over others on the same spot.

Rocky's tiling profile ('': Rocky's default, the Earth).

The screen offset (framebuffer pixels) of point p (root frame) from the cursor, and its depth; false if it is behind the eye.

The projection: ORTHOGRAPHIC or PERSPECTIVE.

Append an intermediate marker at v, time t (the arrays grown as needed).

The renderer's camera (columns: eye, center, up; the shown view's frame).

The conjugate of q: the inverse rotation, for a unit quaternion.

The rotation by angle (radians) about axis (need not be unit length).

The unit quaternion of a 3x3 rotation matrix (columns: the rotated axes; the inverse of quat_to_matrix), by Shepperd's method (from the largest of w and the vector components, for accuracy).

The shortest rotation taking the direction of from to that of to (OpenSceneGraph's osg::Quat::makeRotate(from, to)); a half turn about a perpendicular axis if they are opposite, the identity if either is zero.

The product a*b: rotating by b, then by a.

q / |q| (the identity for a zero quaternion).

The vector v rotated by the unit quaternion q.

Spherical linear interpolation from a (t = 0) to b (t = 1), along the shorter arc; linear when the two are nearly equal. As OpenSceneGraph's osg::Quat::slerp, which OpenFrames' TrajectoryFollower uses, except that the linear case is normalized (OSG's isn't: a quaternion a little short of unit length, its rotation matrix then also scaling, by a millionth for attitudes 0.25 deg apart, a kilometre at the Moon's distance).

The 3x3 rotation matrix of the unit quaternion q (columns: the rotated axes).

The RadialPlane constructor: RadialPlane(...) makes one (see new_radial_plane for its arguments).

The semi-axes: radius * sphere_scale.

The sphere's radius (scene units).

A star's pixel diameter from its apparent magnitude, from its brightness and luminance (OpenFrames' getStarPixelSizeFromMagnitude).

The ray from the eye through the cursor (root frame; dir a unit vector).

Where the ray (origin, unit dir) first meets the ellipsoid centered at center with semi-axes radii along the columns of axes (unit vectors): the distance along the ray, the point, and the point in the ellipsoid's axes (from its center). False if it misses (or the ellipsoid is behind).

The point of the line through point along axis closest to the ray (origin, unit dir): its parameter s (the point is point + s * axis, axis normalized) and the point. False if the ray and the line are parallel (within 1e-6 of it, as a sine squared), or the closest point of the ray is behind its origin.

Where the ray (origin, unit dir) meets the plane through point with normal normal: the distance along the ray and the point. False if the ray is parallel to the plane (within 1e-6 of it, as a cosine) or the plane is behind.

Where the ray (origin, unit dir) meets the sphere of center and radius: the distances along the ray of where it enters and leaves (near <= far; near < 0 if the origin is inside). False if it misses, or the sphere is behind.

Read the constellations of file (found with find_data_file; '' for none) into self%lines and self%groups, in place of those read before. False (those kept) if it can't be found or read.

Read the stars of the catalog into self%stars.

An image handle for texture file file (null if none or unreadable).

Create the render nodes of this frame and its descendants (once; for viewer, a window's viewer handle, which some contents need while they are built (not kept); null: headless).

New marker nodes (for a new image), in place of the old ones.

Frames recorded since recording started (the video's length: frames / fps).

What kind of frame this is: 'RectangularCone'.

The half-angles along x and y, radians.

The half-angles along x and y, radians (0 to 90 degrees).

The 4 corners (OpenFrames' createRectangularCone).

The RectangularCone constructor: RectangularCone(...) makes one (see new_rectangular_cone for its arguments).

Compute and write everything again at the next update.

The ReferenceFrame constructor: ReferenceFrame(...) makes one (see new_reference_frame for its arguments).

A region's color [r, g, b, a] (0 for an unknown region).

A region's surface at the last update, along the frame's +z axis (away from the light; the body's center at the origin): drawn, from z0 (radius r0) to z1 (radius r1).

The index in self%region of SHADOW_UMBRA, SHADOW_PENUMBRA or SHADOW_ANTUMBRA (0 for anything else).

The regions drawn: an ior of SHADOW_UMBRA, SHADOW_PENUMBRA and SHADOW_ANTUMBRA.

The labels' size and alignment changed: the name label's in place, the axes' labels made again.

Let the handle go.

Forget the chunks (after their group was removed from the scene): init starts again.

The grabbed handle released at (x, y); then the handle under the cursor hovered.

The axes and their labels made again (another color, size or font).

Remove frame from list(1:n); false if it is not in it.

Stop following all trajectories.

Remove all the artists.

Remove all the window's views (the default view is then used).

Remove an artist (it stops being drawn; it can be added again, also to another frame).

Remove child from this frame's children. Returns false if it is not one.

Stop showing h in the window.

No trail: the whole curve (or trace mode, if set) again.

Stop following traj.

The face color again, for every vertex.

Remove all instances of v from the window's views.

The window's frame rate and frame times (see vkf_diagnostics); zeros while it isn't open.

Show new (a switch made by the shape) in place of the shape's current nodes; compiled first if the window already runs.

Put new in switch in place of old (a kept handle, deleted).

Place the axes for what the frame draws, when it is first shown (unless move_*_axis was called): at its bound's surface, half the bound's radius long (as OpenFrames' Sphere and Model do); at the origin, 1 long, for a frame that draws nothing.

Chunks for at least n points (at least one chunk). Separate segments and ribbons: chunks hold whole pairs (n should be even).

Reserve memory for n points: times, positions (with their optionals) unless positions is false, and attitudes and colors only if attitudes / colors is true. Optional: storage grows as needed, but reserving avoids reallocations for a known size. It never shrinks the storage (see compact).

Start the intermediate markers and the bounds again.

Put the camera back at the default position (applied at the next frame in which the view is shown).

The host window was resized (framebuffer pixels), and pixel_ratio: its framebuffer pixels per window unit (Qt's devicePixelRatio), if it may have changed (the window moved to a screen of another scale, or the display's scaling changed: sizes in window units, such as line widths, markers and labels, are scaled by it). Once the scene is shown, a frame of the new size is rendered at once (call this from the host's resize event), so that the window isn't shown stretched or blank while it is resized.

Number of changes so far (for the windows drawing the text to update it).

Number of changes so far (any added, set or cleared data).

Colors c (3 or 4 rows) into rgba(4, n) (alpha 1 if not given).

The chain: a surface (a pair of points per trajectory point).

The surface's color [r, g, b, a].

The color of the pair at trajectory point i as drawn (rgba: the trajectory's color times the artist's alpha, or the artist's color).

The x, y and z data sources of the surface's end points.

The trace tail: a quad (white unless the points' colors are drawn).

Color of point i in a colored chain: the trajectory's, or the artist's (opaque: the style has the alpha) if it has none yet.

Number of trajectory points to draw the surface through (none if all sources are zero).

The surface's color: [r, g, b] (alpha unchanged) or [r, g, b, a]; its alpha is the surface's opacity (also with the trajectory's colors).

Where the x of the surface's end points come from (see set_start_x_data).

Where the y of the surface's end points come from (see set_start_x_data).

Where the z of the surface's end points come from (see set_start_x_data).

Where the x (y, z) of the surface's start (end) points come from. Returns whether the trajectory has the data of all sources.

Where the y of the surface's start points come from (see set_start_x_data).

Where the z of the surface's start points come from (see set_start_x_data).

Draw traj; with the default data sources, from the origin to its positions (per its DOF).

The x, y and z data sources of the surface's start points.

The style: the artist's color, or white with its alpha if the points' colors are drawn (the shader multiplies them by it).

In trace mode, the pair at the current time (the tail's end) as drawn; false if no tail is drawn.

The RibbonArtist constructor: RibbonArtist(...) makes one (see new_ribbon_artist for its arguments).

The inverse of a rigid transform (rotation and translation): [R' -R't].

Whether vkframes was built with Rocky (the rocky pixi environment).

The root of a frame's tree (through first parents).

rotate(r) * m, for a rotation r (3x3).

Render frames until the window is closed (or for max_frames frames).

True if a points to the clock b.

True if a and b are the same frame (object).

The next widget on the same line as the last.

Whether two frame pointers are both null or point to the same frame.

Keep the trackball state while another view is shown.

The kept trackball state; false if there is none.

The size of the window's scene graph (see vkf_diagnostics): traverses it all, for an occasional update, not every frame. Zeros while it isn't open.

Where point p (root frame) is in the window, as HUD text positions: (x, y) from 0 to 1, left to right and bottom to top (as at the last frame). False if it is behind the eye (or before the first frame). E.g. to keep HUD text next to a moving object, each frame: a callout.

The scroll wheel: dy > 0 away from the user.

Segment i: its endpoints, and their colors (rgba).

A segment artist's best hit: on the segments drawn (as drawn: relative ends included; a segment of no length isn't drawn).

Create the chain of line buffers (sized for the segments now) under group.

The segments' color [r, g, b, a].

Color i of c (color_a or color_b), or the frame's color if c is not allocated.

Number of segments to draw (none if all sources are zero).

The dash pattern's layout: DASH_SCENE or DASH_SCREEN.

Distance from point v to the segment from a to b.

The first segment drawn (1, or in trace mode of decreasing times the earliest passed): segments first_drawn .. first_drawn + num_drawn - 1.

The segments' highlight: HIGHLIGHT_* (added; HIGHLIGHT_NONE: not highlighted).

Number of line buffers the segments are drawn with (0 until built).

Number of segments drawn now (all of them, or in trace mode those at the points passed).

The dash pattern: its factor and 16 pattern bits.

Segment a-b (root frame) passes within the tolerance (plus extra pixels, e.g. half the line's width) of the cursor: the distance (pixels) of its closest point, the fraction s of the way from a to b of that point in the scene (perspective-correct), and its depth. The part behind the eye is cut off.

Forget the render nodes (see artist_release).

The segments' color: [r, g, b] (alpha unchanged) or [r, g, b, a], 0 to 1.

The dash pattern's layout (see set_dash_mode): screen-locked dashes start again at each segment's start, as GL_LINES; DASH_FIXED (strips only) is taken as DASH_SCENE.

Highlight the segments (see set_highlight): the arrows run along each segment from its start to its end.

A dash pattern (see set_pattern), starting again at the start of each segment.

Draw traj; with the default data sources, from the origin to its positions (per its DOF).

The segments' width in window units (logical pixels).

Write the segments added (all of them on a redraw), and draw them all or, in trace mode, those at the points passed at time t.

The segments' width (window units).

The SegmentArtist constructor: SegmentArtist(...) makes one (see new_segment_artist for its arguments).

The segments' bounding sphere (frame coordinates).

The chain of separate segments with a color per point, under group.

The kind of frame: 'CustomLineSegments'.

After the tree's update for time t: the callback's segments (all frames at their positions for t), written and uploaded if they changed.

The frame's color: also that of segments set without colors.

Show view i (1 to num_views), flying there over duration s (default: the view transition, set_view_transition; 0: a cut).

Give chunk j's level of detail to the renderer (none if switched off).

A horizontal separator line.

Set which point of the text is at its position.

Attitude relative to the parent frame, a quaternion [x, y, z, w] (normalized here; overridden by a followed trajectory).

The sky's attitude in the root frame (quaternion [x, y, z, w]): e.g. to turn an equatorial catalog into an ecliptic root frame.

Shrink markers farther from the camera than the trajectory's size (OpenFrames' auto-attenuation; see shaders/marker.vert). On by default (OpenFrames': off).

Level of detail (default on; see the module documentation): meshes of several resolutions, the one drawn chosen per view. Off: one mesh of set_resolution's segments. Set it before a window shows the sphere.

The axes' length (scene units, >= 0; default 1); the frame's own axes are moved to the lines' ends.

The axis lines' width (window units; default 1).

The background color [r, g, b] (0 to 1; default black).

The body casting the shadow (it must stay alive while set), and its radius (optional: see set_body_radius).

The body's radius (scene units; 0: the body's own, a Sphere's equatorial radius or a TerrainBody's).

Compute the segments each frame with callback (see the module documentation; it must stay alive while set).

Set the camera of the current view: eye, center and up in the view frame's coordinates (OpenFrames' trackball setTransformation), or in its root frame's if in_root (as the frames are now). With duration (s), fly there from the camera shown. Before the view is shown, it is its camera when it is (set_camera).

Whether the camera keeps moving (turning, zooming, panning) after a drag is released while the mouse moves (default true, VSG's and OSG's throw); false: it stops where it is released.

[r, g, b] (alpha unchanged) or [r, g, b, a], 0 to 1.

The color of the frame's decorations: [r, g, b] (alpha unchanged) or [r, g, b, a].

Compile chunks made from now on (for the windows running): once the group is shown (not while building, when they are compiled with it).

The sides' color ([r, g, b] or [r, g, b, a]; their alpha makes them transparent).

The cone's length along the boresight (> 0; default 1).

Draw the constellations: faint lines between their stars, from constellation file file (found with find_data_file; read when given, or when first shown without one: default_constellations), shown (default false), in color rgba (default a faint blue, alpha 0.45) and width window units wide (default 1). Also while shown; the settings not given are kept. Returns false if the file can't be read (the constellations read before are kept) or width isn't > 0 (nothing changed).

Where the handle can be dragged (HANDLE_*; see the module documentation), with axis: the plane's normal (HANDLE_PLANE) or the line's direction (HANDLE_LINE), in the frame's coordinates. Taken when the handle is next grabbed.

Set data source k (1: x, 2: y, 3: z); returns whether the trajectory has the data.

For lines, how the dashes are laid out: 0 anchored to the line (the default), 1 screen-locked (a constant length in pixels, following the line on screen), 2 a fixed length of the line (strips): length scene units for the pattern, or if 0 its length on screen when first drawn.

The frame of the scene its trajectories' data are in (see the module documentation): each point drawn where it is in this frame at the point's own time. Absent: this frame's own coordinates (the default). frame must be in the same tree (else the data are drawn as they are, with a warning) and stay alive while set. The frames' poses at the points' times are as the scene would place them then, follow modes included: a frame following with FOLLOW_LOOP (the default) wraps the points' times into its data's range too (at its data's last time, the first), so a frame following an ephemeris usually wants FOLLOW_LIMIT.

Use the trajectories' positions (per the first trajectory's DOF).

The built-in keys (default on): v the next view, V the previous one, the space bar resets the view.

The radius to frame when the view is reset (<= 0: the viewed frame's bound, the default), as OpenFrames' default view distance.

The camera after a reset, in view-frame coordinates (overrides the default view distance).

Scene units per unit of the vector (> 0; default 1): the arrow is scale * vector.

Set the degrees of freedom (2 or 3) of positions and optionals; clears the trajectory.

Whether the mouse may grab the handle (default true).

Which axes to draw: an ior of X_AXIS, Y_AXIS, Z_AXIS.

What to draw: an ior of CONE_SIDES, CONE_EDGES, CONE_BASE_OUTLINE.

What to draw: SKY_NONE, or SKY_TEXTURE + SKY_STARS (default; each only if given).

The edges drawn (2, k) (vertex numbers), in place of the faces' (after set_faces, set_triangles or set_grid).

All three end sources at once (see set_start_data).

Relative ends (default false): each segment ends at its start plus the end sources' values (a vector drawn from each point), not at them.

Set the scale of all three end sources (with relative ends: the length drawn per unit of the stored vector, e.g. km per newton). Only this artist's segments are written again.

Where the x of the segments' end points come from (see set_start_x_data).

Where the y of the segments' end points come from (see set_start_x_data).

Where the z of the segments' end points come from (see set_start_x_data).

Give the window's keyboard and mouse events to handler (not owned: it must stay alive while set), in place of any handler set before.

The faces' color (the alpha times the opacity).

Faces given as polygons: faces the vertex numbers (1-based) of each polygon in turn, sizes how many each has (>= 3; convex, or at least star-shaped from its first vertex: drawn as a fan of triangles from it); the edges are the polygons' sides. E.g. a cube: 8 vertices, 6 faces of 4. A face's front: its vertices counterclockwise.

What to follow (FOLLOW_POSITION and/or FOLLOW_ATTITUDE, combined with ior) and how (FOLLOW_LOOP or FOLLOW_LIMIT).

Set the font (the text is made again when next drawn).

Faces given as a grid of points (3, nu, nv): quadrilaterals between neighbours (two triangles each), joined around if closed_u (the last point i to the first, for each j; e.g. a tube's circumference) or closed_v. The edges: the grid's lines, those of constant i (along j) every lines(1) and of constant j (along i) every lines(2) (default: every one; 0 for none).

The head's length (scene units; at most half the arrow); 0 (the default): 0.2 of the arrow's length.

For lines, the highlight (see shaders/line.vert): flags (1 pulse, 2 arrows; 0 none), its color (rgba), the arrows' spacing and speed (window units, and per second), the band's width (window units) and the pulse's period (s).

The handle is under the cursor (set by the window), or not.

Count intermediate markers from the start (MARKER_START, default) or from the end (MARKER_END; recomputed whenever points are added).

Spacing of intermediate markers (> 0): time units, arc length, or a number of data points (rounded down, at least 1).

The alignment of the labels relative to their positions (ALIGN_*; default ALIGN_LEFT_BASE_LINE).

The font of the labels: a font file name (found on the data search path) or a full path; default: the renderer's default font.

The size of the labels in pixels (default 20): the name label's size, and the maximum size of the axes labels (which shrink with distance).

How far behind the body's center the shadow is drawn (scene units; 0: automatic, twice the umbra's length).

Level of detail (default on): seen from far away, the curve is drawn from every 2nd, 4th, ... point (and its last), as many as can be skipped while staying within half a pixel of all of them, chosen per view and per chunk of points. Off: every point is drawn.

The light (e.g. the Sun; it must stay alive while set), and its radius (optional: see set_light_radius).

The ambient, diffuse and specular colors ([r, g, b], 0 to 1) of the window's light (OpenFrames' defaults: 0.2 gray, white, none). The window's light is used while no frame of the scene has a light source (set_light_source_enabled).

The light source's ambient, diffuse and specular colors ([r, g, b], 0 to 1; defaults 0.05, 0.8 and 0.05 gray).

The diffuse color of the window's light (see set_light_ambient).

The light source's diffuse color (see set_light_ambient).

The light's position in eye coordinates (x right, y up, z toward the viewer): [x, y, z, 0] for a directional light from direction (x, y, z), [x, y, z, 1] for a point light (OpenFrames' setLightPosition; default [0, 0, 1, 0], a headlight).

The light's radius (scene units; 0: the light's own, if a Sphere).

Whether this frame carries a light source: a point light at its origin (e.g. the Sun), not dimmed with distance (default false; OpenFrames' setLightSourceEnabled). While any frame of a window's scene has one, the window's own light (WindowProxy%set_light_*) is off.

The specular color of the window's light (see set_light_ambient).

The light source's specular color (see set_light_ambient).

Light the body with the scene's lights (default), or show its imagery as it is.

Line width (window units: logical pixels).

Widths of the grid lines and of the equator and prime meridian (window units; defaults 1 and 3).

Faces lit by the scene's lights (the default), or unlit (their color as is, transparent as a cone's sides: writing no depth).

Level of detail on (the default: seen from far away, a strip is drawn from fewer points, within half a pixel of all of them) or off (every point drawn).

The color of the markers in which (an ior of MARKER_* flags): [r, g, b] (alpha unchanged) or [r, g, b, a].

Draw the markers as an image file (tinted by the marker color; its transparent parts left out), or as a disk again with ''. Returns false if the image cannot be read (the markers are then unchanged).

The marker's shape (a MARKER_* shape of vkf_artists but MARKER_IMAGE; default MARKER_DISK).

Marker shape: a MARKER_ shape constant (MARKER_DISK to MARKER_SPIRAL; MARKER_IMAGE after set_marker_image). These are OpenFrames' disk and its marker shaders (Demos/Shaders/Marker_.frag), built in.

The marker's size (window units, > 0; default 14).

Marker size in window units (logical pixels; > 0).

Set data source k (1: x, 2: y, 3: z), redrawing the markers; returns whether the trajectory has the data.

For markers, the color (rgba), size (window units), shape (shaders/marker.frag) and attenuation radius (scene units, 0 for none).

Which markers to draw: an ior of MARKER_START, MARKER_INTERMEDIATE and MARKER_END (0 for none).

The material (OpenFrames' setMaterial; each optional): ambient, diffuse, specular and emission colors ([r, g, b] or [r, g, b, a], 0 to 1) and shininess (0 to 128: the specular highlight's sharpness; 0 for none). The ambient and diffuse colors scale the body's color or texture (VSG's Phong); the specular color is reflected from the lights' specular parts. Defaults: ambient and diffuse white, no specular reflection or emission.

Read the model file (now, so its bound is known). Returns false if it could not be read. Set it before a window first shows the model.

Attitude of the model in its frame (quaternion [x, y, z, w]).

The point of the model (in its own coordinates) placed at model_position, about which it is rotated and scaled.

Where the model's pivot is placed in its frame (frame coordinates).

Scale along the model's x, y and z axes.

The frame's name, shown by its name label (also once shown: e.g. a readout that follows the frame).

Draw the name label on top of the scene (true: not hidden by bodies in front of it, as HUD text; e.g. a readout) or depth-tested (false, the default, as OpenFrames').

The texture for the side away from the light (e.g. city lights; an equirectangular image file as the texture, '' for none), shown where the diffuse light is weak.

Set the number of optional vectors per position; clears the trajectory.

Follow at the simulation time plus offset (the default, offset 0).

The body's opacity, 0 (invisible) to 1 (opaque, the default): below 1 it is drawn translucent (see the module documentation). Set below 1 before a window first shows it to make it translucent; then the opacity can change at any time (a translucent body stays translucent, an opaque one opaque).

Set optional vector index (1 to num_optionals) of the most recently added position. ok is false if there is no position or no such optional.

An orthographic projection with the given bounds (in view units).

The path the handle moves along (which must stay alive while used); its time kept (the frame placed on the new path).

For lines, a dash pattern (see line_set_pattern; z'FFFF' solid).

Dash pattern: OpenGL's line stipple (16 bits, bit 0 first, each factor window units; 65535: solid), as set_pattern.

A perspective projection with vertical field of view fovy (degrees; default 45).

Whether pick tests what this frame draws (default true; e.g. false for an overlay such as a selection marker). Its children are picked or not by their own setting.

The plane's color ([r, g, b] or [r, g, b, a]; default 0.8 gray, 0.2 opaque).

The vertices' color (POLY_VERTICES).

Whether a trajectory with colors is drawn in them (default true); points without a color yet (colors arriving after positions) in the artist's color. A curve: each segment blended from its first point's color to its second's (with level of detail, a color lasting fewer points than are skipped may not show from far away); a surface: each point's pair in its color, times the artist's alpha. False: all in the artist's color.

The vertices' size (window units; default 6).

Set where the text is.

Position relative to the parent frame (overridden by a followed trajectory).

The handle's priority over others on the same spot of the screen (higher first; default 0, a TimeHandle's 1; see the module documentation).

The sphere's radius (scene units, > 0; default 1); can change at any time.

A region's color (region: one of SHADOW_UMBRA, SHADOW_PENUMBRA, SHADOW_ANTUMBRA; [r, g, b], alpha unchanged, or [r, g, b, a]).

The regions to draw: an ior of SHADOW_UMBRA, SHADOW_PENUMBRA and SHADOW_ANTUMBRA (default SHADOW_ALL).

The mesh resolution without level of detail: segments in longitude and latitude (default 128 x 64).

Set rgba from color: [r, g, b] (alpha unchanged) or [r, g, b, a].

Set component k of the start (side 1) or end (side 2) sources.

Show the scene of fm (which must stay alive while shown). For now, set it before the window's first frame.

Set component k of the start (side 1) or end (side 2) sources.

The segments: from a(:, i) to b(:, i) (frame coordinates), colored color_a(:, i) at a and color_b(:, i) at b ([r, g, b] or [r, g, b, a] columns; one of them for both ends; neither: the frame's color). Setting the same segments again changes nothing (no upload).

Set the size of the text.

Draw sky behind the scene (it must stay alive while shown; it can be shown in several windows), in place of the window's sky so far; at any time (its texture and stars can change too).

Shading smooth across the vertices (normals averaged over the faces around each: a curved surface, e.g. a grid's), or flat faces (the default: a polyhedron's).

Attitude of the body in its frame (quaternion [x, y, z, w]), e.g. to orient its texture.

Position of the body's center in its frame.

Scale the sphere along its x, y and z axes (all > 0), making an ellipsoid with semi-axes radius * scale.

Draw the stars of catalog (found with find_data_file; '' for none) with magnitudes from min_mag to max_mag (default -2 to 8), at most max_stars (default 10000), sized from min_size to max_size window units (default 1 to 10) by brightness, the smallest dimmed to min_dim_ratio (0 to 1, default 0.5) of their color (OpenFrames' setSkySphereStarData). Returns false if the catalog cannot be read or the limits are invalid (min_mag > max_mag, max_stars < 1, min_size > max_size, a ratio outside 0 to 1).

Draw the names of the named stars drawn (those of the catalog's last field), beside them: shown (default false), of the stars up to magnitude max_mag (default all of them), size window units tall (default 12), in color rgba (default a pale blue) and font font ('' or default: vkframes' default font). Also while shown; the settings not given are kept. Returns false (nothing changed) if size isn't > 0.

All three start (end) sources at once, e.g. position_sources(3) or optional_sources(1). Returns whether the trajectory has their data.

Where the x (y, z) of the segments' start (end) points come from. Returns whether the trajectory has the data of all sources.

Where the y of the segments' start points come from (see set_start_x_data).

Where the z of the segments' start points come from (see set_start_x_data).

Draw a segment at points 1, 1 + stride, 1 + 2 stride, ... (stride >= 1).

Color (rgba) and width (window units) of the whole chain.

Set the text (up to 256 characters, or twice the first text's length; see the module documentation).

The texture: an equirectangular image file ('' for none).

Draw an image file as the sky (found with find_data_file); '' for none. Returns false if it cannot be read (the sky is then unchanged).

Draw the ticks as an image (OpenFrames' setTickImage; found with find_data_file; '' for disks again). False if it cannot be read.

Tick shape: a MARKER_* shape (default MARKER_DISK; OpenFrames' setTickShader with its marker shaders).

Major and minor tick sizes (window units; default 8 and 4).

Major and minor tick spacings (>= 0; 0 for none).

Set the simulation time (limited to the time range).

The handle's time (kept within its time range): the frame placed at the path's point for it.

Follow at a fixed time (independent of the simulation time).

Set the simulation time (limited to the time range) and restart counting from it.

Limit the simulation time to [t_min, t_max] (ignored if t_max < t_min).

The times a drag may reach (t_min <= t_max; else swapped); the handle's time brought within them. Taken at the next grab.

Limit the simulation time to [t_min, t_max] (ignored if t_max < t_min).

Simulation seconds per wall-clock second (may be 0 or negative).

Simulation seconds per wall-clock second (may be 0 or negative).

Draw only the part up to the current time (see the module documentation).

A trail (see the module documentation): only the part within past before the current time and future after it (s, >= 0; 0: none of it; huge(1.0_wp): no limit), each fading out over the last fade (0 to 1, default 0.25) of its window toward its cutoff. Replaces trace mode while set.

For strips, the trail (see vkf_line_set_trail: 20 values; the third 0: none), given to every chunk (changed every frame the time does: a few floats per chunk uploaded).

The style of a trail's part, which TRAIL_PAST or TRAIL_FUTURE: color ([r, g, b] or [r, g, b, a]: drawn in it instead of the line's colors), opacity (its alpha multiplied by it: translucency, default 1), a dash pattern (factor and 16 pattern bits, as set_pattern; default solid). Settings not given are kept.

Draw traj (it must stay alive while drawn).

Follow only traj (none if it is not associated).

Faces given as triangles (3, m) of vertex numbers (1-based); the edges are their sides (each once).

The twilight: the diffuse light extended past the terminator to where the light is angle (radians, 0 to 1.5) below the horizon, fading out smoothly (where it meets the light on the day side: the same brightness and slope, so no line shows), and the night texture fading in across it. 0 (the default): none, the light ends at the terminator (an airless body). Not in OpenFrames. Can change at any time.

Both sides of the faces drawn and lit (the default: open surfaces), or only their fronts (a closed surface, its faces counterclockwise seen from outside: translucent, its far side isn't drawn through it).

The vector (frame coordinates); can change at any time.

The vertices: clock angles (from +x toward +y) and cone angles (from the boresight, -z; below 90 degrees), radians, the same number of each (>= 3).

A color per vertex (4, n) or (3, n) ([r, g, b(, a)], 0 to 1), for the faces, blended across them (in place of the face color; the opacity still applies). Dropped when the faces are set again.

Move the vertices (3, n), keeping the faces and edges (as many as before; e.g. a surface changing in time).

Look from frame at lookat (both in the tree of root).

View frame (in the tree of root) with base frame_type (default RELATIVE_FRAME).

The time (s) a change of view or a reset flies from one camera to the other (default 0: a cut, as OpenFrames).

Where the x (y, z) of the points come from. Returns whether the trajectory has those data.

Where the x, y and z of the followed position come from (default: the trajectories' positions). Returns whether all followed trajectories have those data.

The text of the x-axis label (default 'X').

Where the y of the points come from (see set_x_data).

Where the y of the followed position comes from (see set_x_data).

The text of the y-axis label (default 'Y').

Where the z of the points come from (see set_x_data).

Where the z of the followed position comes from (see set_x_data).

The text of the z-axis label (default 'Z').

How fast the mouse zooms (default 1, VSG's: 10% per wheel step, and a right drag's rate): e.g. 0.3 for a gentler zoom. Scales scroll steps however they come (a mouse wheel, a trackpad, a host's scroll).

The drawn regions' bounding sphere (frame coordinates).

A switch with a mesh for each region (vertices written at each change of shape), under group.

What kind of frame this is: 'ShadowCones'.

After the tree's update for time t: the shadow moved to the body, turned away from the light, and reshaped if the distance or a setting changed.

The ShadowCones constructor: ShadowCones(...) makes one (see new_shadow_cones for its arguments).

The regions' frustums for body radius r, light radius rs and distance d (see the module documentation), written to their meshes.

Use the model already read by other (no second copy in memory).

Show (true) or hide the text (OpenFrames' enable HUD text).

Which axes vectors to show: NO_AXES, or X_AXIS, Y_AXIS, Z_AXIS combined with ior.

Which axes labels to show (as show_axes).

Show or hide what the frame draws (its sphere, model, ...), but not its axes, labels or children.

Show (true) or hide all the frame's decorations at once: its axes, their labels and its name label (show_axes, show_axes_labels, show_name_label).

Show or hide the name label (at the frame's origin; default shown).

Which side of the line from a to b q is on: > 0 left, < 0 right, 0 on it (twice the signed area of the triangle a, b, q).

The size of the text: character height (window units).

The number of columns of a (the stars' capacity).

The sky drawn behind the scene (null if none).

The unit vector of a direction on the sky from its right ascension (hours) and declination (degrees), as the stars' (star_to_point).

The part lo .. hi of points i1 .. i2 that chunk j holds, and its buffer p(xyz and distance, high/low, lo:hi) (null if none).

A slider showing value, from low to high: true (and value changed) after the user moved it. format: how the value is shown (printf's, e.g. '%.0f km'; default '%.4g').

Whether the shading is smooth.

Sort keys, increasing (a bottom-up merge sort).

Number of points the data sources give: 0 for invalid sources or no trajectory, huge() if all are zero.

The Sphere constructor: Sphere(...) makes one (see new_sphere for its arguments).

Attitude of the body in its frame (quaternion [x, y, z, w]).

The body's bounding sphere: its center, and its largest semi-axis.

The body: an ellipsoid mesh under the sphere's transform.

A sphere mesh node: ellipsoid_create with equal semi-axes.

What kind of frame this is: 'Sphere'.

A sphere (root frame: center c, radius r) might be within the tolerance (plus extra pixels) of the cursor on the screen (false only if it surely isn't: to skip what it bounds).

Picked on the ellipsoid (exact), with the geodetic latitude and longitude of the point hit (in the body's axes: sphere_attitude); else the frame's origin.

Position of the body's center in its frame (scene units).

The scale along the sphere's x, y and z axes.

The body's color (used without a texture); [r, g, b] or [r, g, b, a].

Update the frame (followed trajectories, children) and, with level of detail, build the mesh the views have wanted if it isn't built yet (the coarsest with as many segments as wanted, or the finest).

Distances s(n) into d(high/low, n).

Points x(3, n) into p(xyz and distance, high/low, n): the floats nearest, and the rest (the distances are left as they are).

Star i (1 to num_stars): its direction (unit vector, sky frame), color (rgb, dimmed) and size (window units).

The star catalog file ('' for none).

The range of magnitudes of the stars read.

The magnitude range drawn (as set).

Named star i (1 to num_star_names): its name, apparent magnitude and star (1 to num_stars: see star).

Whether the star names are drawn (as set).

The size range of the stars (window units).

A star's direction, color (from its B-V color index: Ballesteros' temperature, then Tanner Helland's temperature to RGB) and raw size (OpenFrames' SkySphere::StarToPoint).

The x, y and z data sources of the segments' start points.

Fly from camera start (in view from's frame) to finish (in view to's) over duration s, from now.

Start recording the frames drawn to the video file (see the module documentation), fps frames per second (default 30). Encoded by codec (an ffmpeg encoder; default libx264, H.264) at quality (for libx264, libx265 and libvpx-vp9 the CRF: 0 lossless to 51, default 18, visually lossless), scaled by scale (default 1; e.g. 0.5 for half the size of a Retina window's pixels), the size made even. options replaces the encoder options (codec, quality; and the scale, unless there is a watermark), e.g. '-c:v prores_ks -profile:v 3'. watermark: an image (e.g. a logo; PNG, SVG, ... with transparency) drawn over the video's bottom right corner by ffmpeg, watermark_width of the video's width (default 0.2), watermark_opacity opaque (default 0.6). ffmpeg: the program (default: VKFRAMES_FFMPEG, else ffmpeg on the path). Returns false if the window isn't open, is already recording or the watermark doesn't exist; ffmpeg's errors (e.g. an unknown encoder) show when it starts, at the next frame, and end the recording.

The position and attitude followed at simulation time sim_time, as update (the same time mapping, choice of trajectory and interpolation) but without changing the follower: for any time, e.g. a frame's pose at a trajectory point's own time.

Stop recording: ffmpeg finishes the file. The window's time goes on from where the video was, on the wall clock again. frames: the frames written. Returns false if not recording or if the recording failed (ffmpeg's messages are on the standard error).

End a flight where the camera is now.

The memory the trajectory's data take (bytes), used or not: its storage's capacity (see reserve, compact).

The stride: a segment at every stride-th point.

Give the chain's style to line, a node not in the chain (e.g. a curve's trace-mode tail, drawn as part of it).

A surface of triangles idx(3, m) (1-based) through points xyz(3, n), of color rgba: unlit and transparent (seen from both sides, writing no depth: planes, cones' sides), or, given normals, lit by the scene's lights: opaque, or translucent if an alpha is below 1 (drawn after the opaque scene, sorted by depth by the bounding sphere sphere); two_sided: both faces drawn and lit. colors: a color per vertex (4, n), times rgba.

The point at geodetic latitude lat and longitude lon on the ellipsoid (OpenFrames' LatLonGrid formula: the surface point whose normal has those angles).

Copy the positions and attitudes of this frame and its descendants to their transform nodes (only those that changed since the last sync).

Follow master's time (it must stay alive while synchronized), or stop following (master not associated, or this clock itself), keeping the master's current time and settings. Returns false, and changes nothing, if this would make a cycle.

The clock this one is synchronized to (null if none).

The tail's colors: from point k's to the color at frac along to point k2's (white, showing the style's color, if the chain has none).

Trace mode's tail, for the points passed i1 .. i2 of the n written: from the latest passed (k) toward the next in time (k2: i2 + 1, or i1 - 1 for decreasing times); none (0, 0) without a trajectory.

True (once) if a camera was set (set_camera), and that camera.

True (once) if a reset is pending.

The body's bounding sphere (frame coordinates): its equatorial radius, at the origin.

The map, made for the viewer showing the body (none headless or without Rocky).

The kind of frame: 'TerrainBody'.

Picked on a sphere of the body's radius (not the terrain's heights), with the latitude and longitude of the point hit; else the frame's origin.

Each frame: if the map's window has closed (the map was released with it), the map again for a window still open (compiled for the windows running), then the frame's update.

The TerrainBody constructor: TerrainBody(...) makes one (see new_terrain_body for its arguments).

A line of text.

The text (as shown: '' while hidden).

The texture file ('' for none).

The texture file ('' for none).

The tick image file ('' for none).

Tick shape: a MARKER_* shape.

Major and minor tick sizes (window units).

Major and minor tick spacings.

The simulation time (at the last frame).

The handle's time.

Time i.

The simulation time at the last update (or as last set).

The marker's bounding sphere: the frame's origin.