Derived Types

One of a DrawableTrajectory's artists: a pointer to it (Fortran has no arrays of pointers) and the node it is drawn under.

A camera flight (see the module documentation): from camera start (in view from's frame) to camera finish (in view to's).

The base of the artists drawing a trajectory's points through one chain of buffers (CurveArtist: a line, a chain point per trajectory point; RibbonArtist: a surface, a pair of chain points per trajectory point): the chain and how much of it is written and drawn, the trace tail, the trajectory's colors, and the update (chain_update: the points written as they change, then drawn all or, in trace mode, those passed and the tail to the point at the current time). Each extension says what its chain is (chain_kind), how many points it draws (points), its tail's node (new_tail), its style (apply_style), how its points are written (write_points) and its tail drawn (draw_tail).

A constellation of those read: its name and its lines (columns of self%lines).

Coordinate axes with tick marks (OpenFrames' CoordinateAxes): lines from the origin along x, y and z, major and minor tick marks at their spacings, in the frame's color. Tick marks shrink beyond the axis length from the camera (OpenFrames' tick attenuation). The frame's own axes (arrows) are moved to the lines' ends when the length is set (as OpenFrames'); move them after that with move_x_axis, ..., or, for axes on a body, hide them (show_axes(NO_AXES)) and show the body's, which start at its surface.

Draws a trajectory's points connected by a line (OpenFrames' CurveArtist). The x, y and z of the points come from data sources (default: the trajectory's positions). The line is in the artist's color, or in the trajectory's point colors if it has any (see the module documentation).

Line segments with a color per endpoint (see the module documentation).

Where one component (x, y or z) of a point is taken from, as OpenFrames' Trajectory::DataSource: src is a SOURCE_* constant; for SOURCE_POSOPT, element (1 to dof) of the position (opt = 0) or of optional opt; for SOURCE_ATTITUDE, element (1 to 4) of the quaternion. The value is multiplied by scale.

A window's Vulkan device and driver (each '' if unknown).

A handle the mouse drags (see the module documentation): extensions give its point and draw it.

A frame for drawing trajectories (OpenFrames' DrawableTrajectory): it holds artists, which draw in its coordinates.

An elliptic cone (OpenFrames' EllipticCone): half-angles a along x and b along y (set_primary_angles; default 60 and 30 degrees).

A font read (or looked for) by name.

The root frame of a scene (OpenFrames' FrameManager). The frame is not owned: it must stay alive while managed.

A frame in a list of frames (a frame's children and parents): a pointer to it (Fortran has no arrays of pointers).

A window's GUI panels (see the module documentation).

A line artist's highlight (see the module documentation and set_highlight).

A HUD text shown in a window, with the window's node for it.

HUD text (see the module documentation).

Latitude and longitude lines on an ellipsoid (OpenFrames' LatLonGrid): at geodetic latitudes (matching a Sphere's texture), every lat_spacing from the equator and every lon_spacing from the prime meridian (the equator and prime meridian thicker), in the frame's color.

The versions of vkframes and the libraries it uses (each '' if unknown).

A chain of point buffers (see the module documentation).

A buffer holding points first .. first+capacity-1 of the chain.

Computes a CustomLineSegments' segments each frame: extend it with a compute procedure, which calls segments%set_segments (OpenFrames' CustomLineSegments::Callback). The program owns the callback object (it must stay alive while set).

Error bounds of a strip's segments at one stride (level of detail).

A map layer as given (applied when the map is made).

Draws markers at a trajectory's points (OpenFrames' MarkerArtist): at its start and end, and intermediate markers spaced by time, arc length or data points, counted from the start or from the end. Markers keep their size on screen (window units), or with auto-attenuation shrink when the camera is farther than the trajectory's size. In trace mode (an addition), the markers passed are drawn: the end marker (at the trajectory's end) only once the time reaches the end. Point colors (an addition, off by default: set_point_colors): each marker in the trajectory's color there (see set_point_colors).

A model (see the module documentation).

The camera and cursor of a pick (see the module documentation).

What a pick found (pick): the frame it belongs to and, for trajectories, the artist (select type to use it) and the trajectory.

A cone of polygonal cross-section (OpenFrames' PolyhedralCone), with its apex at the origin and boresight along -z: vertex i at clock angle clock(i) (from +x toward +y) and cone angle cone(i) (from the boresight), cone_length along the boresight. Drawn as transparent sides, edges from the apex and the base outline (set_draw_mode).

A surface fixed in its frame (not in OpenFrames): vertices and faces, given as polygons (set_faces: e.g. a polyhedron's), triangles (set_triangles) or a grid of points (set_grid: e.g. a tube of trajectories, an invariant manifold). Drawn as faces, edges (the polygons' outlines, the triangles' sides, or the grid's lines) and vertices (set_draw_mode).

A plane disk in the xy plane (OpenFrames' RadialPlane): transparent, with circles every radial_spacing and radial lines every lon_spacing (the one along +x thicker).

A rectangular cone (OpenFrames' RectangularCone): half-angles x and y (set_primary_angles; default 60 and 30 degrees).

A reference frame (see the module documentation).

A window's frame rate and frame times (see the module documentation). Times are in milliseconds; the rate and frame time are averaged over about half a second, the rest are the last frame's.

Draws a translucent surface swept between two points at each point of a trajectory (not in OpenFrames): from the point given by the start data sources to the one given by the end data sources, with a quad between each point's pair and the next's. Default: from the frame's origin to the positions, sweeping out an orbit's plane (a fan, as the radius vectors of a SegmentArtist would fill it); other sources give e.g. a curtain from the positions down to a ground track stored as an optional. Unlit, seen from both sides, depth tested but writing no depth (as the equatorial plane of a RadialPlane), drawn to double precision as the curves (its edge on a CurveArtist's line through the same points).

The size of a window's scene graph: what is switched off isn't counted.

Draws a line segment at every stride-th point of a trajectory (OpenFrames' SegmentArtist), from the point given by the start data sources to the one given by the end data sources: e.g. radius vectors (the origin to the positions), or from the positions to points stored as an optional (a target). Default (an addition to OpenFrames, which draws nothing until the sources are set): from the frame's origin to the trajectory's positions.

A body's shadow cones (see the module documentation).

A shadow region's surface: a frustum along z from z0 (radius r0) to z1 (radius r1), in the shadow frame's coordinates.

A shape's nodes: made under the frame's contents, replaced when the shape changes.

A simulation clock (see the module documentation).

The sky behind a scene (OpenFrames' SkySphere; see the module documentation).

A sphere or ellipsoid (see the module documentation).

A named star of those read: its name and magnitude, its direction in the stars read (self%stars).

A body drawn from map layers by Rocky (see the module documentation).

A marker dragged along a path to change its time (see the module documentation).

A path for a TimeHandle (see the module documentation): a position for any time.

A curve's trail (see the module documentation and set_trail).

A trajectory (see the module documentation).

The base of the trajectory artists (OpenFrames' TrajectoryArtist).

Follows trajectories (see the module documentation).

A TimePath along a Trajectory's points, interpolated linearly (before its first time: its first point; after its last: its last).

A pointer to a followed trajectory (for an array of them).

An arrow whose tip the mouse drags (see the module documentation).

A view (see the module documentation).

One of a window's views: a pointer to it (Fortran has no arrays of pointers).

A program's handler of a window's keyboard and mouse events (see the module documentation): extend it and override the procedures wanted (the others do nothing).

A window showing a scene (see the module documentation).