All Classes and Interfaces

Class
Description
An interface that can optionally use an AtomicBoolean as a signal to abort its execution.
The help window with About, Help and System sections.
A little helper class to hold a set of three angles and associated rates.
 
Defines all controller inputs
Contains some utils common to all extract systems.
Contains some utils common to all gamepad listeners.
Provides general methods and attributes that all GUIs should have
An abstract initialization system, providing some common utilities useful for concrete initializers.
 
Abstract mouse and keyboard input listener.
 
 
 
 
 
Represents a column type.
 
An abstract view that holds a reference to the current entity.
 
A motion blur effect which draws the last frame with a lower opacity.
Motion blur filter that draws the last frame (motion filter included) with a lower opacity.
 
Actor related utils.
 
 
Anaglyph 3D red-cyan effect
Anaglyph 3D red-cyan filter
 
This abstract class defines the fields and implements the methods that any analytically defined attitude (e.g., NSL or EPSL) need in addition to those in the superclass.
Renders grid annotations.
 
An archetype is a class of Entity containing a pre-defined set of Components for convenient creation and extension.
A container for data and logic concerning Archetypes.
This window shows the Gaia Archive information for a single star
 
 
Utility class to hold the assets that must be loaded when the OpenGL context is present.
Some astronomical algorithms and utilities to compute and convert Julian dates, work out the coordinates of the Moon, Pluto, and more.
Implements the same test as in Jean Meeus' Astronomical Algorithms page 343.
 
 
 
 
 
 
 
 
 
 
This component provides attitude to entities.
Convert a given set of heliotropic angles into a quaternion
A bean that holds the attitude and its activation time.
 
 
Class with static utility methods to deal with B-splines.
Utility class for manipulating knots and splines together
Parses the XML files with the attitudes and their activation times into a binary search tree.
Extend this class to implement a material attribute.
 
 
 
 
 
 
 
 
 
 
 
 
 
Holds a map with the relations of old object attributes to contained component.
 
 
 
 
 
 
 
Initializes axes objects.
 
 
Extracts background model object and UV grid data to feed to the render stage.
Initializes background models and UV grid objects.
Updates background models and UV grids.
 
Common base class for all attitude data servers.
Initializes the base and graph components of entities.
 
 
 
 
 
 
 
A basic view with the base and body components that all entities have.
Renders image files synchronously
Bias filter.
 
 
Holds a particle dataset with the metadata.
 
 
Renders billboards (camera-oriented quads), optionally with a global texture.
 
 
 
 
Renders billboard sets.
 
 
 
Reads arrays of star beans from binary files, usually to go in an octree.
Interface to read and write stars, to be implemented by different binary format versions.
Base implementation of binary version, which accommodates most versions.
Implements an unbalanced binary search tree.
Original binary version (0), used in DR1 and DR2.
Binary version 1, used in eDR3 mainly.
Binary version 2, used in latter eDR3 runs, and DR3+.
Renders bitmap fonts.
Backing data for a BitmapFont.
Represents a single character in a font page.
Caches glyph geometry for a BitmapFont, providing a fast way to render static text.
AssetLoader for BitmapFont instances.
Parameter to be passed to AssetManager.load(String, Class, AssetLoaderParameters) if additional configuration is necessary for the BitmapFont.
A bitset, without size limitation, allows comparison via bitwise operators to other bitfields.
 
 
 
 
 
 
 
 
Manages the bookmarks in Gaia Sky.
 
 
 
 
Encapsulates an axis aligned bounding box represented by a minimum and a maximum Vector.
BSplined<T extends Vectord<T>>
 
Buffers the writing of images to disk
 
Black-body based conversion between effective temperature and B-V color.
An InputStream whose source is a ByteBuffer.
 
Camera blur that relies on a precomputed velocity map for the scene
 
 
 
Minimalistic grouping strategy that splits decals into opaque and transparent ones enabling and disabling blending as needed.
 
 
 
Convenience enum to describe the camera mode
Camera blur effect.
Contains camera utilities
Contains the logic to record the camera state at each frame.
 
 
 
 
 
 
 
 
Tests the change of base matrices
Tests the change of base matrices
 
A circular area about a centre c (which is defined by a Place object), and radius r.
 
 
Some properties for star cluster objects.
Extracts star cluster data to feed the render stage.
Initializes star cluster entities.
Updates star clusters.
 
A collapsible pane with a detach-to-window button.
A CollapsableWindow can be expanded/collapsed with a single click on the title bar.
 
 
A version of ColorPicker on steroids.
A little widget showing a color and allowing to change it using a color picker dialog.
 
 
 
Colour component containing information about a colour
 
 
 
The CommentedProperties class is an extension of java.util.Properties to allow retention of comment lines and blank (whitespace only) lines in the properties file.
Specifies a combination of Areas.
BitSet with some added functionality
 
Compresses all PNG and JPG files in the given location into ETC1A-compressed ZKTX files.
This class implements the Attitude interface and contains just the minimum fields necessary to define a unique attitude at a given time, plus a large number of methods to compute quantities that depend only on this attitude and time.
A ConcreteDuration is a duration that is linked to a time scale
Widget that captures and displays messages in a GUI.
This class contains some constant values, global to the workings of Gaia Sky
 
 
 
This radio is in charge of updating constellations when required.
 
 
 
 
 
 
 
 
 
 
 
Listener used to get events from ContextMenu.
 
 
GUI that is operated with a game controller and optimized for that purpose.
Reads inputListener mappings from a file
 
 
 
 
Encapsulates a separable 2D convolution kernel filter
 
Provides utility coordinate conversions between some astronomical coordinate systems and to Cartesian coordinates.
 
 
Displays info about the current crash.
Creates a report whenever Gaia Sky crashes and saves it to disk.
 
 
 
 
 
 
 
AssetLoader for OwnCubemap instances.
 
 
Fisheye effect
 
Cubemap projections (spherical, cylindrical, hammer, azimuthal equidistant) filter.
 
 
Widget that displays custom objects on screen.
 
 
 
 
 
Initializes objects that have a DatasetDescription component.
 
 
Dataset manager.
 
 
 
The datasets pane in the controls window
 
Listens to dataset manager events and relays them to the interested UI elements.
A dialog to pick a date.
A finite number of days There are two implementations provided of the conversions methods one as object interface, where an object of the current class has to be instantiated.
This GUI shows debug information in the top-right corner of the screen
 
This class provides utils to use Sprites and Fonts as if they were Decals, this is, flat textures in the 3D space.
 
 
 
 
 
 
 
 
 
 
Debug effect.
Debug filter, renders the contents of the depth texture attachment
 
 
 
 
 
 
This interface provides the method through which a set of ODEs may be coded and supplied to the methods in the class RungeKutta.
An Attribute which can be used to send an Array of DirectionalLight instances to the Shader.
 
 
Compares entities with respect to their distance to the camera.
 
 
A resizable, ordered or unordered double array.
 
 
Contains utilities to download files
Just copies the texture in the input to the output.
 
A Duration represents an amount of time on a proper time scale.
 
Renders single isolated particles defined with orbital elements.
 
 
 
Renders the particles of orbital elements groups as a whole.
 
 
Defines the interface for all entity initialization systems.
The entity radio picks up events associated with an entity and acts.
Defines the interface for all entity update systems.
This class contains some general utilities applicable to all entities.
 
Implementation of the Ecliptic Pole Scanning Law (EPSL)
Ecliptic pole scanning has two modes: PRECEDING (revolving phase angle = 0) and FOLLOWING (revolving phase angle = 180 deg).
This class implements a combination of the Ecliptic Pole Scanning Law (EPSL) and the Nominal Scanning Law (NSL), by switching from EPSL to NSL at the reference epoch (tRef).
 
A compound object for holding equatorial angles and their rates as per Fig.
This application displays an error in a window.
Represents an event.
Event manager that allows for subscription of observers to events (identified by strings), and also for the creation of event objects by anyone.
Time frame options
Implementation of the scripting interface using the event system
 
 
 
A shader program encapsulates a vertex and fragment shader pair linked to form a shader program.
Draws batched quads using indices.
 
Initializes objects with a Fade component.
A simple utility object that collects the most-used families.
Uses jafama (FastMath) library.
A simple file chooser for scene2d.ui
The type of files that can be chosen with this file chooser
 
 
 
 
 
 
 
 
A filter on a dataset as a set of rules
The base class for any single-pass filter.
 
The base class for any single-pass filter.
 
 
 
 
 
Lens flare effect as described in John Chapman's article (without lens dirt or diffraction starburst).
 
This adds the lens dirt and starburst effects to the lens flare.
 
 
 
 
 
This class contains the implementation of IFocus.isFocusActive().
Part of the user interface which holds the information on the current focus object and on the camera.
An entity view that implements the IFocus methods.
 
 
FOV enumeration
The field of view cameras
A truncated rectangular pyramid.
Full OpenGL GUI with all the controls and whistles.
 
Encapsulates a fullscreen quad, geometry is aligned to the screen corners.
Encapsulates a fullscreen quad, geometry is aligned to the screen corners.
 
 
 
 
 
 
Implements the fast approximate anti-aliasing.
Fast approximate anti-aliasing filter.
 
 
Provides caching of the last Nsl37 attitude requested.
The main class.
 
Main class for the Gaia Sky desktop and VR launcher.
Contains the infrastructure to run tasks that sort and update the dataset metadata.
Exposes a builder accepting a buffer builder.
Extends hub connector to provide some very basic logging using the Gaia Sky internal logging system.
This application implements the external view of Gaia Sky, which renders the main back render buffer into a different window.
 
Mouse and keyboard input listener for the natural camera in game mode.
Dialog to configure a gamepad interactively.
 
Implements geometry warp and blending from MPCDI
This filter implements the geometry warp and blending defined in the MPCDI format.
 
Keeps pace of the simulation time vs real time and holds the global clock.
Holds and initialises resources utilised globally.
Scattering Light effect.
 
Stores runs of glyphs for a piece of text.
Stores glyphs and positions for a piece of text which is a single color and does not span multiple lines.
 
 
Processes entities in a scene graph, which have a GraphRoot component.
This is just a test for now
Fast approximate anti-aliasing filter.
 
 
 
 
 
 
 
 
 
 
 
 
 
Contains key definitions for Gaia Sky
A GTI (Good Time Interval), is a
A collection of Good Time Intervals (GTIs).
A GUI component.
Manages the Graphical User Interfaces of Gaia Sky
 
 
* General Purpose Hash Function Algorithms Library * * Author: Arash Partow - 2002 * URL: http://www.partow.net * URL: http://www.partow.net/programming/hashfunctions/index.html * * Copyright notice: * Free use of the General Purpose Hash Function Algorithms Library is * permitted under the guidelines and in accordance with the most current * version of the Common Public License.
 
A compound object for holding heliotropic angles and their rates as per Fig.
 
 
This abstract class contains the fields needed to store numerical attitude in the form of arrays (q and SRS rates), and a method to calculate the attitude for any given time using cubic Hermite interpolation
 
This guy implements high level operations which run concurrently to the main thread by starting new threads
 
 
 
Loads HIP star names.
A finite number of hours There are two implementations provided of the conversions methods one as object interface, where an object of the current class has to be instantiated.
Head-up display GUI which only displays information and has no options window.
Manages the i18n (internationalization) system
Format i18n bundle files according to a reference file.
This class computes the translation status for each language.
 
Interface to be implemented by all entities that can render a text in 3d space
 
This is the basic interface for all attitude representations and scanning laws.
Attitude server interface.
Represents an attribute
 
Implemented by all objects that can be rendered by a camera-oriented quad, otherwise called a billboard.
Defines the interface to get the coordinates of a body
Camera interface to be implemented by all cameras in Gaia Sky.
 
 
 
Helper generic class to create icospheres.
 
 
 
 
Contract that all focus objects must implement.
Defines the interface that all objects composed by a collection of vertices to be rendered with a VBO must adhere to.
An interface to be implemented by all top-level GUIs in Gaia Sky
 
 
Interface to implement by all entities that are to be rendered as lines whose points are floated by the camera position in the CPU
Utility class to render the current frame buffer to images
 
 
 
 
 
 
Interface to implement by all the entities that can be rendered as a model
Contains the index of objects.
Initializes the name and id indices.
This window controls the visibility of individual objects
 
 
Common code to all render systems that render quads with GPU instancing.
An Animation has an id and a list of IntNodeAnimation instances.
 
 
Takes a linear value in the range of 0-1 and outputs a (usually) non-linear, interpolated value.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Kind of interpolation: for derivative, value or integral
 
This implementation uses 32-bit integer indices instead of 16-bit shorts
This implementation uses 32-bit integer indices instead of 16-bit shorts
This implementation uses 32-bit integer indices instead of 16-bit shorts
An IntIndexData instance holds index data.
Class to construct a mesh, optionally splitting it into one or more mesh parts.
This implementation uses 32-bit integer indices instead of 16-bit shorts used in Mesh
 
A libgdx MeshPart which uses IntMesh (for integer indices) instead of a regular Mesh A MeshPart is composed of a subset of vertices of a IntMesh, along with the primitive type.
 
Class that contains all vertex information the builder can use.
This implementation uses IntMesh and IntMeshPart instead of Mesh and MeshPart.
Batches IntRenderable instances, fetches IntShaders for them, sorts them and then renders them.
 
Helper class to create IntModels from code.
Returned by a ModelLoader, contains meshes, materials, nodes and animations.
An instance of a IntModel, allows to specify global transform and modify the materials, as it has a copy of the model's materials.
 
 
 
 
 
A node is part of a hierarchy of Nodes in a IntModel.
A NodeAnimation defines keyframes for a IntNode in a IntModel.
A combination of IntMeshPart and Material, used to represent a IntNode's graphical properties.
A Renderable contains all information about a single render instruction (typically a draw call).
Returns a list of IntRenderable instances to be rendered by a IntModelBatch.
Responsible for sorting IntRenderable lists by whatever criteria (material, distance to camera, etc.)
Interface which is used to render one or more IntRenderables.
Returns IntShader instances for a IntRenderable on request.
 
A VertexData instance holds vertices for rendering with OpenGL.
Interface to be implemented by anyone willing to watch and be notified of events.
 
Describes the interface for all objects added to an octant in an octree.
 
Data provider for a particle group.
 
Interface to be implemented by those entities that can be rendered as a single point, floated by the camera position in the CPU
Interface that must implement all entities that have a position.
 
 
 
Any entity which contains a proper motion
A top-level renderable interface that all renderable objects must extend
Defines the interface for all render modes.
Defines the interface common to all render systems.
Defines the interface for scene loaders.
Defines the interface for scene renderers.
Scripting interface.
 
 
 
 
Data provider for a star group, which contains an index map with the names and indices of the stars.
 
ItemsManager<T extends com.badlogic.gdx.utils.Disposable>
 
Basic interface for entities that provide an time frame in the scene
Represents a generic matrix transformation
Trigonometry interface to enable multiple implementations
 
This interface must be implemented by all objects whose visibility can be manipulated using the per-object visibility controls.
 
Writes JPG images
A finite number of years.
 
Contains the key mappings and the actions.
 
A simple program action.
This input inputListener connects the input events with the key binding actions
Represents a keyframe and contains the camera state, the simulation time, the frame and a descriptor name.
 
 
 
 
 
 
 
 
 
Contains the logic to render labels for specific objects.
An entity view that implements the I3DTextRenderable methods.
 
 
 
 
Pseudo lens flare implementation.
 
Implements brightness, contrast, hue and saturation levels, plus auto-tone mapping HDR and gamma correction.
Controls levels of brightness and contrast
 
Light glow implementation.
 
 
 
Light scattering implementation.
 
 
Lineard<T extends Vectord<T>>
 
Implements line rendering for the different families of entities.
 
 
Renders lines as Polyline Quadstrips (Polyboards).
 
 
An entity view that implements the ILineRenderable methods.
Link widget.
 
Displays the loading screen.
Manages and generates sentences to display during loading.
 
 
 
 
 
This guy is in charge of logging the visited locations and serving them to the corresponding subsystems.
A single location
 
 
Initializes location mark entities.
 
 
 
 
 
 
 
Least Recently Used cache implementation
 
 
Definition of a spacecraft with its parameters, model, etc.
 
Gamepad input listener for the natural camera.
Mouse and keyboard input listener for the natural camera.
 
Centralized repository for all post-processing effects in Gaia Sky.
Centralized repository of component mappers.
 
 
Manages a master instance which makes available state information to others in order to synchronize a session.
 
 
A basic component that contains the info on a material
 
Utility and fast math functions.
 
 
Encapsulates a column major 4 by 4 matrix.
RAM memory information
 
MenuItem contains text or text with icon.
 
 
 
 
 
 
 
 
Widget that displays big messages on screen.
Writes and reads the metadata to/from binary.
 
 
 
 
 
A finite number of minutes.
 
 
 
 
 
Contains the logic to render model entities, the ones that have a Model component.
Extracts model object data to feed to the render stage.
Initializes the old ModelBody objects, together with Planet, Satellite, HeliotropicSatellite, GenericSpacecraft, Spacecraft, Billboard and BillboardGalaxy.
Renders simple models using a model batch.
 
Updates model objects.
 
Class to generate Gaia Modified Scanning Law (MSL).
There are three modes of scanning, enumerated by the ScanState: NOMINAL = running as in NSL, MODIFIED = running at reduced precession speed, TRANSITION = the precession speed is ramping up or down between the NOMINAL and MODIFIED states.
Enumerates the various transition functions tested.
Coordinates of the Moon given by the algorithm in Jean Meeus' Astronomical Algorithms book.
Mosaic with 4 textures
 
 
 
This class implements the Modified Scanning Law (MSL) by Hermite interpolation of the attitude quaternion among values obtained by numerical integration of the basic equations in heliotropic angles.
The base class for any multi-pass filter.
 
This guy is in charge of managing the music playlist and actually playing the sounds
 
A finite number of nanoseconds.
Models the default camera in Gaia Sky.
This class contains various unit conversion constants for angles, distance and time units
 
 
Loads GeoJson files into ECS entities.
 
Loads the star cluster catalogs from CSV files or STIL data sources.
Implements the normal filter anti-aliasing.
Normal filtered anti-aliasing filter.
 
A 3x3 grid of texture regions.
Contains the parameters and functions for procedural elevation
Widget that captures and displays messages in a GUI.
Improved analytical representation of the Gaia Nominal Scanning Law (NSL).
Analytical representation of the Nominal Sun for the Gaia NSL.
Class with various static methods for analytical scanning laws.
This abstract class defines the fields and implements the methods that any numerically defined attitude need in addition to those in the superclass.
An unordered map where the keys are objects and the values are unboxed doubles.
 
 
 
 
Utility class to create octahedron spheres.
Component that contains a reference to the octree node this object belongs to.
A component that defines an octree structure.
Extracts octant data to render an octree with lines.
Implements the loading and streaming of octree nodes from files.
The daemon loader thread.
Octree node implementation which contains a list of IPosition objects and possibly 8 sub-nodes.
A view that implements IOctreeObject methods for entities.
 
 
Generates particles that make up the Oort cloud.
 
 
Reads an orbit file into an OrbitData object.
 
An orbit data loader to rule them all.
 
 
 
This system initializes orbital element set objects.
Reads an orbit file into an OrbitData object.
Reads an orbit file into an OrbitData object.
 
Refreshes sampled orbit data from the underlying data provider algorithms.
The orbit refresher thread.
Samples an orbit for a particular Body.
Operating system related utils.
 
A regular scene2d.ui Button on steroids.
 
Wraps a standard OpenGL ES Cubemap.
Enum to identify each side of a Cubemap
 
A regular scene2d.ui ImageButton on steroids.
 
 
 
 
 
Small overriding that returns the user set size as preferred size.
 
 
Same as a regular slider, but contains the title (name) and the value within its bounds.
 
TextButton in which the cursor changes when the mouse rolls over.
TextButton in which the cursor changes when the mouse rolls over.
A tooltip that shows a label and a hotkey shortcut in gray.
OwnTextButton with an icon.
 
A tooltip that shows a label.
OVERWRITE LINE 176 (setBounds) to remove the Math.round() calls, which makes the labels snap to integer pixel values.
 
Simple implementation of a pair of objects.
A simple EntitySystem that iterates over each entity in parallel and calls processEntity() for each entity every time the EntitySystem is updated.
Tests the speed of ParallelSystem and compares it to IteratingSystem, for multiple numbers of entities.
 
Parser utilities.
 
Extra attributes for stars and particles.
Extracts single particle and star data to feed to the render stages.
Initializes the old Particle and Star objects.
 
 
Extracts particle and star set data to feed to the render stages.
Initializes old ParticleGroup and StarGroup objects.
Renders particle groups using instancing via billboards with geometry (quads as two triangles).
 
Renders particle groups using regular arrays via billboards with geometry (quads as two triangles).
Updates particle and star sets.
Implements index update process of particle sets.
 
Updates single particles and star objects.
Contains utilities common to particle and star objects and sets.
Interface that specifies a path of type T within the window 0.0invalid input: '<'=tinvalid input: '<'=1.0.
 
 
 
 
 
 
 
 
 
 
 
 
Encapsulates a framebuffer with the ability to ping-pong between two buffers.
Provides a simple mechanism to query OpenGL pipeline states.
Specifies a celestial position
A plane defined via a unit length normal and the distance from the origin, as you learned in your math class.
Enum specifying on which side a point lies respective to the plane and it's normal.
 
Contains a point cloud dataset, with cartesian XYZ positions in the equatorial system with the origin in the barycenter of the solar system, and optionally times for each of those.
Adds some utils to build quads as a couple of triangles.
Contains some common code to all point cloud renderers and some scaffolding to make life easier.
Contains some common code to all point cloud renderers and some scaffolding to make life easier.
Adds some utils to build quads as a couple of triangles.
This provider loads point data into particle beans.
 
An Attribute which can be used to send an Array of PointLight instances to the Shader.
Point particle record, only contains a double array to hold the data
Renders symbolic objects (usually part of the UI) as points.
An entity view that implements the IPointRenderable methods.
 
 
 
 
Helper class that transforms various positional information into the internal position of the application.
 
 
A view which exposes position and velocity properties of an entity.
Provides a way to capture the rendered scene to an off-screen buffer and to apply a chain of effects on it before rendering to screen.
This interface defines the base class for the concrete implementation of post-processor effects.
 
 
Provides the information for the precession of this body
The default preferences window.
 
 
Renders vertices using a VBO.
An unbounded priority queue based on a priority heap.
 
 
Proper motion component.
Holds information on the order and properties of nearby particles to the camera.
A wee utility class that provides unit conversion mechanisms.
 
 
 
 
 
 
A simple quaternion class.
Generic dialog that displays the confirmation quit message and offers options to cancel it or go through.
 
 
 
 
 
Encapsulates a Rayd having a starting position and a unit length direction.
 
Implements a raymarching effect, usually for SDFs.
 
Raymarching filter.
 
Initializes invisible and raymarching container entities.
 
Implements a real time clock.
 
 
 
 
 
Central hub where the parameters of the current relativistic effects (aberration, doppler, grav waves) are updated and served to the renderers.
 
 
 
 
 
 
 
This component marks the entity as renderable, and keeps a reference to it.
Centralizes the creation and loading of render assets: shaders, fonts, batch objects, etc.
 
Describes to which render group this node belongs at a particular time step
Only for frame output mode, it displays the current time.
Holds some context information useful when rendering
 
Abstract implementation with some useful methods for all SGRs.
Scene graph renderer that renders six scenes in the six cartesian directions (front, back, right, left, up, down) to a cubemap.
Renders the cube map projection mode.
Renders the Gaia Field of View camera mode.
Normal single-window desktop render mode.
Renders to OpenVR.
Renders all the 3D/stereoscopic modes.
 
Contains utilities to render stuff
An entity view that implements the IRenderable methods.
Fisheye effect
A re-projection filter with a bunch of projection types, encoded in mode.
 
REST Server class to implement the REST API
A finite number of revolutions There are two implementations provided of the conversions methods one as object interface, where an object of the current class has to be instantiated.
 
Helper generic class to create rings.
 
 
Provides the information for the rotation of this body
A structure composed of a set of collections of a given size in which additions happen to the next list in the roulette before it is spun.
 
 
 
 
 
Provides an implementation of the Runge-Kutta method for solving single or sets of ordinary differential equations (ODEs).
 
 
Contains elements which depend on the current state of the program, such as the running scripts, the buttons to pause the camera subsystem, etc.
Implements the SAMP client, which attempts the connection to a hub and handles SAMP messages over that connection.
Clone of the Satellite class in GaiaParams with very few needed parameters.
 
 
 
Scattering Light effect.
 
Represents a scene, contains and manages the engine.
Builds the scene graph once all nodes are in the index.
Loads JSON files into a scene object, which contains an ECS world.
Loads the world and all its entities from a list of JSON descriptor files.
 
Deals with all events related to the scene.
Initializes the render infrastructure renders the scene using different render systems.
Manages screen mode (fullscreen, windowed) and screen resolution updates.
 
The scripting server of Gaia Sky, backed by a Py4J GatewayServer.
The dialog to search objects.
A finite number of seconds.
A separator widget (horizontal or vertical bar) that can be used in menus, tables or other widgets, typically added to new row with growX() (if creating horizontal separator) OR growY() (if creating vertical separator) PopupMenu and VisTable provides utilities addSeparator() methods that adds new separator.
 
 
A thread that waits for a task to be executed.
This class contains the settings for Gaia Sky, organized into several inner classes by topic.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Initializes and stores the YAML configuration file for Gaia Sky.
This class converts settings from the old Java properties file to the new YAML-based configuration.
 
AssetLoader for ExtShaderProgram instances loaded from text files.
 
Loads shaders with extra functionality to add code from other shaders.
 
 
 
 
 
 
 
System that renders shapes through a ShapeRenderer
 
Contains a single 4x4 matrix.
Renders single points.
Component that contains a single texture.
 
Manages a slave instance configured with an MPCDI file.
 
 
Properties which are sorted by key
Compares performances of different lists such as ArrayList and Array.
Implements a spacecraft-like movement.
Computes the coordinates of the spacecraft object.
Gamepad input listener for the spacecraft camera.
 
Keyboard and mouse input listener for the spacecraft mode.
Picks up spacecraft events and relays them to the entity.
 
 
An Attribute which can be used to send an Array of SpotLight instances to the Shader.
Holds the geometry, color, and texture information for drawing 2D sprites using Batch.
Screen Space Reflections effect.
Screen space reflections filter.
 
 
Renders star sets using instancing via billboards with geometry (quads as two triangles).
Renders star sets using GL_POINT primitives.
 
Renders star sets using regular arrays via billboards with geometry (quads as two triangles).
Utilities to construct star sets.
A position that never changes.
The StdRandom class provides static methods for generating random number from various discrete and continuous distributions, including Bernoulli, uniform, Gaussian, exponential, pareto, Poisson, and Cauchy.
Full OpenGL GUI with all the controls and whistles.
Loads VOTables, FITS, etc.
 
Wee utility class to check the operating system and the desktop environment.
A TabbedPane widget not full featured but somewhat reusable.
The style for a TabbedPane.
 
A TabSelectionChangeListener for a TabbedPane widget.
This tag marks background models.
Marks billboard galaxies.
 
 
Entities tagged with this can't be the camera's closest body.
This tag prevents the entity from being included in any of the processing families.
Tag that marks the entity as a set of entities.
This tag prevents the entity from being processed by the graph updater.
A tag that marks an entity as being in an octree.
A tag to mark billboards.
This tag marks the element as a part of a set.
Produces a plot of ColorXP (BP-RP) vs log(tEff)).
A delayed message used internally by the EventManager.
Renders model objects with tessellation shaders.
 
 
 
 
 
 
A validator that compares the current value to the value of the given text fields (lessThan and greaterThan).
Renders text (labels, annotations, titles, etc.) in two and three dimensional space.
Loads images from texture atlases created by TexturePacker.

A TextureAtlas must be disposed to free up the resources consumed by the backing textures.
Describes the region of a packed image and provides information about the original image before it was packed.
A sprite that, if whitespace was stripped from the region when it was packed, is automatically positioned as if whitespace had not been stripped.
 
 
 
 
Defines a rectangular area of a texture.
 
 
Contains some general utilities to deal with text and strings.
 
 
 
An enumeration to distinguish between the different times that attitude can be expressed in.
A small class to convert between GaiaTime/TCB and OBMT transparently.
Gaia Data Model.
 
 
 
 
 
 
 
 
 
The HUD UI at the top of the regular view
 
 
Extracts trajectory and orbit data to feed to the render stages.
Initializes entities with a Trajectory component.
Updates trajectories and orbit objects of all classes and types.
Contains methods that act on trajectory entities.
Implements a smooth transition from Nsl37 to Epsl, or vice versa.
 
Uses the default Math library.
Simple impelementation of a trio of objects.
Simple two-way hashmap implemented with two maps.
Very naive class that represents and UCD and does the parsing.
Parses the ucds of a star table and builds some metadata on the relevant quantities for Gaia Sky (position, proper motion, magnitudes, colors, etc.)
 
Implements an unsharp mask filter.
Fast approximate anti-aliasing filter.
 
Popup window that informs the user of new updates.
 
A record that holds a variable star.
Renders variable star sets using instancing via billboards with geometry (quads as two triangles).
Renders variable star sets which have periodical light curve data using GL_POINT primitives.
Renders variable star sets using regular arrays via billboards with geometry (quads as two triangles).
 
Encapsulates a 2D vector.
 
Vector of arbitrary precision floating point numbers using ApFloat.
Copy of libgdx's Vector3d class using 64-bit floating point numbers.
 
Vectord<T extends Vectord<T>>
Encapsulates a general vector.
 
 
 
 
Produces a table with status information (version, build, build time, OpenGL version, GLSL version, etc.) to be shown at startup.
Convenience class for working with OpenGL vertex arrays.
A VertexData implementation based on OpenGL vertex buffer objects.
A VertexData implementation that uses vertex buffer objects and vertex array objects to construct a global buffer and an instance buffer for instanced rendering.
A VertexData implementation based on OpenGL vertex buffer objects.
A VertexData implementation that uses vertex buffer objects and vertex array objects.
 
 
 
 
A view which exposes common vertex buffer renderable operations.
Compares entities depending on the solid angle from the camera.
 
 
 
 
 
 
 
Responsible for initializing the VR system, managing rendering surfaces, getting tracking device poses, submitting the rendering results to the HMD and rendering the surfaces side by side to the companion window on the desktop.
Space in which matrices and vectors are returned in by VRContext.VRDevice methods taking a VRContext.Space.
Axes ids on VR controllers
Button ids on VR controllers
Represents the pose of a VRContext.VRDevice, including its transform, velocity and angular velocity.
 
 
 
 
 
 
VRGui<T extends IGui>
 
 
 
 
 
Welcome screen that allows access to the main application and the dataset manager.
 
 
 
 
 
Implements a zooming effect: either a radial blur filter or a zoom filter is used.