| CAsteroidData | |
| CCometData | |
| CLunarCourseCorrection.CorrectionData | |
| CEarthOrbitUtils | |
| CGravityEngine.EngineRef | |
| CGravityEngine.FixedBody | |
| CForceChooser | Force chooser. A Factory pattern to select a force for integrators that support force delegates |
| ►CGEConsole.GEConsoleCommand | Commands for the console |
| CClearCommand | Dump GE state to console |
| CDumpCommand | Dump GE state to console |
| CFastForwardCommand | Fast forward by a specified amount. Runs a full Nbody sim to get to that time |
| CGoCommand | Dump GE state to console |
| CInfoCommand | Show all possible position/velocity representations of an Nbody object |
| CPauseCommand | Dump GE state to console |
| CSelectiveForceBase.ShowForceCommand | |
| CSetTimeCommand | |
| CSingleStepCommand | Dump GE state to console |
| CTimeZoomCommand | Dump GE state to console |
| ►CGEExternalAcceleration | |
| CEarthAtmosphere | Computes the acceleration due to drag in the Earth's atmosphere for a given height and velocity |
| CEarthRocket | Combine the acceleration from EarthAtmosphere and MultistageRocket |
| ►CRocketEngine | Rocket Engine Interface Used to update acceleration in the massless body engine on a per-integration step basis |
| CMultiStageEngine | |
| COneStageEngine | |
| CGEMapToSceneInterface | |
| CGEMath | |
| CGEMultiplayerInterface | |
| CGERewindMgr | Support for rewind in GE |
| CGravityEngine.GEStartListEntry | |
| CGETrigger | |
| CGETriggerMgr | Handle any GETrigger requests that have been registered with GE |
| CGEUtils | |
| CGEGraph.GraphLine | |
| CGravityState | Gravity state. Hold "most" of the information for gravitational evolution of the system |
| CIClosestApproach | Interface defining the callback for listeners in the ClosestApproach script |
| ►CIComparer | |
| CManeuver | Manuever. Holds a future course change for the spaceship. Will be triggered based on world time |
| CNBody | N body |
| CTrajectoryData.InterceptComparer | |
| CTrajectoryData.TpointCompare | |
| ►CIEnumerable | |
| CTrajectoryData | Trajectory data. Class to hold points in a trajectory in "sorted" order. Each point contains a position, velocity and time |
| ►CIFixedOrbit | Interface defining the fixed motion of an NBody object |
| CFixedObject | Fixed object |
| CKeplerSequence | Kepler elements maintains a time ordered list of OrbitUniversal segments. This allows a seqence of orbits around different bodies to be specified. For example, a free return trajectory around a moon would have: ellipse around Earth, hyperbola around moon, ellipse around Earth as three segements. By putting everything "on-rails" the scene can jump in time to any value requested without running NBody calculations for all the intermediate positions |
| COrbitEllipse | DEPREACTED: Please use OrbitUniversal Calculate the correct initial conditions for a specified elliptical orbit around a designated body OR moves the object in a fixed ellipse determined by Kepler's equation |
| COrbitHyper | DEPREACTED: Please use OrbitUniversal Class used to handle the hyperbolic orbital parameters and draw the orbit path in the editor using Gizmos |
| COrbitPoint | OrbitPoint places an object at a specified location on the orbit. The location can be specified in various ways according to the PointType enum |
| ►COrbitUniversal | A generic double precision orbit class. Can be used in place of OrbitEllipse and OrbitHyper |
| CBinaryOrbit | Binary Orbit |
| ►CIForceDelegate | |
| CCustomForce | Custom force. Sample code to show how to make a custom force. To use this set the GE force delegate to custom and attach this script to the object holding the GravityEngine |
| CForceR | |
| CForceR2 | |
| CInverseR | |
| CInverseR3 | |
| CJ2Gravity | Force model for the first order approximation for a non-spherical gravitational source |
| CNewtonForce | Newton force. This is not generally used - since Netwonian gravity is the more efficient default force built in to the integrators |
| ►CSelectiveForceBase | Base class for a selective (per-object) force that allows the force to be changed depending on which two objects are interacting |
| CSelectiveNewton | |
| CIGEOrbitTester | |
| ►CIGravityParticlesInit | Interface defining methods to be implemented to define particle positions and velocities for GravityParticles |
| CDustBall | Dust ball. Create particles in a sphere with a given initial velocity |
| CDustBox | Dust box. Create particles in a 3D rectangle with a specified initial velocity |
| CDustOrbit | Create a system of particles in an orbit specified by an OrbitUniversal attached to the same object |
| CDustRing | Dust ring. Create a ring of particles in orbit around an NBody mass. Allows full control over the orbital attributes of the ring particles |
| CExplosionFromNBody | Explosion from N body. Generates the particle positions/velocities for an "ejection cone" of debris when NBody objects collide |
| ►CINbodyInit | Interface defining method to initialize an NBody object prior to evolution beginning. Called by GravityEngine |
| CKeplerSequence | Kepler elements maintains a time ordered list of OrbitUniversal segments. This allows a seqence of orbits around different bodies to be specified. For example, a free return trajectory around a moon would have: ellipse around Earth, hyperbola around moon, ellipse around Earth as three segements. By putting everything "on-rails" the scene can jump in time to any value requested without running NBody calculations for all the intermediate positions |
| COrbitEllipse | DEPREACTED: Please use OrbitUniversal Calculate the correct initial conditions for a specified elliptical orbit around a designated body OR moves the object in a fixed ellipse determined by Kepler's equation |
| COrbitHyper | DEPREACTED: Please use OrbitUniversal Class used to handle the hyperbolic orbital parameters and draw the orbit path in the editor using Gizmos |
| COrbitPoint | OrbitPoint places an object at a specified location on the orbit. The location can be specified in various ways according to the PointType enum |
| COrbitUniversal | A generic double precision orbit class. Can be used in place of OrbitEllipse and OrbitHyper |
| ►CINBodyIntegrator | Common interface for numerical NBody integration. Used by the GravityEngine |
| CAZTripleIntegrator | Special purpose integrator for precise integration of the three body problem |
| CHermiteIntegrator | |
| CLeapfrogIntegrator | |
| CTrajectoryData.Intercept | Container class to hold the points on two trajectories at an intercept point |
| ►CIOrbitPositions | |
| ►CEllipseBase | DEPREACTED: Please use OrbitUniversal Ellipse base |
| CBinaryPair | Binary Pair |
| CDustRing | Dust ring. Create a ring of particles in orbit around an NBody mass. Allows full control over the orbital attributes of the ring particles |
| COrbitEllipse | DEPREACTED: Please use OrbitUniversal Calculate the correct initial conditions for a specified elliptical orbit around a designated body OR moves the object in a fixed ellipse determined by Kepler's equation |
| COrbitHyper | DEPREACTED: Please use OrbitUniversal Class used to handle the hyperbolic orbital parameters and draw the orbit path in the editor using Gizmos |
| COrbitUniversal | A generic double precision orbit class. Can be used in place of OrbitEllipse and OrbitHyper |
| ►CIOrbitScalable | |
| CBinaryOrbit | Binary Orbit |
| CBinaryPair | Binary Pair |
| COrbitEllipse | DEPREACTED: Please use OrbitUniversal Calculate the correct initial conditions for a specified elliptical orbit around a designated body OR moves the object in a fixed ellipse determined by Kepler's equation |
| COrbitHyper | DEPREACTED: Please use OrbitUniversal Class used to handle the hyperbolic orbital parameters and draw the orbit path in the editor using Gizmos |
| COrbitUniversal | A generic double precision orbit class. Can be used in place of OrbitEllipse and OrbitHyper |
| ►CIPatchedConicChange | Interface that defines a callback to be run when there is a change of the NBody providing the most force on an object. See PatchedConicSOI for details |
| COrbitUniversalSOIChange | Handle the change of centerbody when an object on rails enters/leaves a sphere of influence (SOI) |
| ►CISolutionSet | |
| CBrouckeA | |
| CBrouckeR | |
| CChoreos | |
| CFigureEights | |
| CHenon | |
| CLagrange | |
| CITrajectoryListener | |
| CJPLEphemerisParser | Utility function to parse JPL Ephemeris data of the form: 2451544.500000000 = A.D. 2000-Jan-01 00:00:00.0000 TDB
|
| CKeplerSequence.KeplerElement | |
| CEarthOrbitUtils.LatLonAlt | |
| CLeastSquaresFit | Routines to do a linear least-squares fit |
| CLeastSquaresFit.LSPoint | |
| CLunarCourseCorrection | |
| CLunarFreeReturn | |
| CManeuverMgr | Maneuver Manager Handles the GE delegation of maneuver lists for NBody objects in the GE workflow |
| CUnityEngine.Mathd | |
| CMatrix3 | Basic 3x3 Matrix manipulation code |
| ►CMonoBehaviour | |
| CAsteroidUnnumbered | |
| CClosestApproach | Monitor the distance between two NBody objects and trigger when the closest approach occurs. The trigger event is communicated to an array of listener objects that implement the OnClosestApproachTrigger defined in the IClosestApproach interface |
| CCustomForce | Custom force. Sample code to show how to make a custom force. To use this set the GE force delegate to custom and attach this script to the object holding the GravityEngine |
| CDustBall | Dust ball. Create particles in a sphere with a given initial velocity |
| CDustBox | Dust box. Create particles in a 3D rectangle with a specified initial velocity |
| CDustOrbit | Create a system of particles in an orbit specified by an OrbitUniversal attached to the same object |
| CEarthAtmosphere | Computes the acceleration due to drag in the Earth's atmosphere for a given height and velocity |
| CEarthRocket | Combine the acceleration from EarthAtmosphere and MultistageRocket |
| CEllipseBase | DEPREACTED: Please use OrbitUniversal Ellipse base |
| CExplosionFromNBody | Explosion from N body. Generates the particle positions/velocities for an "ejection cone" of debris when NBody objects collide |
| CFixedObject | Fixed object |
| ►CForceData | Abstract class to hold information for a force delegate for a given NBody |
| CJ2ForceData | |
| CGECOE | Shell for an editor script that display the elements of the orbit in the inspector using OrbitUtils.OrbitElements and RVtoCOE |
| CGEConsole | Command line console for interacting with GE and its objects during game exection. (Kudos to Jonathan Blow for sharing his developement of this feature in JAI on You Tube, from which the idea comes) |
| CGEConst | |
| CGEDistance | |
| CGEGraph | Utility singleton to allow scripts to update a quantity and see it displayed as a line graph via a secondary camera |
| CGEManeuuverDisplay | Dummy component. It's editor script displays a list of the pending manuevers when GE is running |
| CGEOrbitCompare | Debug component to compute the difference between the orbital elements of two objects with OrbitPredictor components and display them in the inspector |
| CGESGP4Log | Script to display information from the associated SGP4 Orbit in the inspector during development |
| CGravityEngine | GravityEngine Primary controller of Nbody physics evolution with selectable integration algorithms. Singleton |
| CGravityParticles | Evolve particles in the gravitation field computed by the GravityEngine |
| CGravityScaler | Handles scaling between: GE: internal values used in the physics integrators Scene: values in Unity units (raw Unity position values and game time seconds) World: The chosen units for values in inspector entries etc. (e.g. AU, km, m) SI: Metric system values |
| ►CImpactTrigger | Callback for EarthAtmosphere external acceleration script to register an impact with the surface of the Earth |
| CEarthImpact | |
| CJ2Gravity | Force model for the first order approximation for a non-spherical gravitational source |
| CKeplerSequence | Kepler elements maintains a time ordered list of OrbitUniversal segments. This allows a seqence of orbits around different bodies to be specified. For example, a free return trajectory around a moon would have: ellipse around Earth, hyperbola around moon, ellipse around Earth as three segements. By putting everything "on-rails" the scene can jump in time to any value requested without running NBody calculations for all the intermediate positions |
| CLagrangePoint | Place a game object or initialize an NBody at the specified Lagrange point with the indicated offset from the Lagrange point |
| CManeuverRenderer | Show the maneuvers as 3D on screen vectors |
| CNBody | N body |
| CNBodyCollision | N body collision. Script that is attached to NBody models (i.e. the mesh model that is a child of an NBody object) to handle collisions. Allows a choice of absorb, bounce or explode and adjusts physics as required to conserve momentum |
| CNewtonForce | Newton force. This is not generally used - since Netwonian gravity is the more efficient default force built in to the integrators |
| COrbitHyper | DEPREACTED: Please use OrbitUniversal Class used to handle the hyperbolic orbital parameters and draw the orbit path in the editor using Gizmos |
| COrbitPoint | OrbitPoint places an object at a specified location on the orbit. The location can be specified in various ways according to the PointType enum |
| COrbitPredictor | Orbit predictor. An in-scene object that will determine the future orbit based on either: the current position and velocity current position and velocity from script position and velocity from script |
| COrbitRenderer | Orbit renderer. Create the positions for a parents Orbit script (OrbitEllipse or OrbitHyper) and create the positions for the attached LineRenderer. (Use parent since a Line Renderer wants to be on a gameobject of its own) |
| COrbitSegment | Orbit Segment. An in-scene object that will determine the future orbit based on the current velocity and show a segment of the orbit between the body and the to position. The short or long way between the positions can be specified (in the case of an ellipse) |
| COrbitSimpleDecay | Orbit simple decay. This script causes a simple decay of a body in orbit by applying a small decay factor to the velocity on each frame |
| COrbitUniversal | A generic double precision orbit class. Can be used in place of OrbitEllipse and OrbitHyper |
| COrbitUniversalSOIChange | Handle the change of centerbody when an object on rails enters/leaves a sphere of influence (SOI) |
| CPatchedConicSOI | Determine the location of the sphere of influence of body2 with respect to body1. Monitor the position and trigger OnNewInfluencer when the spaceship moves across the sphere of influence boundary |
| CRandomPlanets | Random planets. Create a random planets that will be in orbit around the NBody that this object is a component of |
| CReportAngle | Debug code |
| CRocketEngine | Rocket Engine Interface Used to update acceleration in the massless body engine on a per-integration step basis |
| CSelectiveForceBase | Base class for a selective (per-object) force that allows the force to be changed depending on which two objects are interacting |
| CSelectiveForceTester | |
| CSolarBody | Solar body. A "data container" delegate used to hold information about a Solar System body. This is a collection of orbital parameters and some additional facts (mass, radius) that is useful for scaling and configuring the solar system |
| CSolarSystem | Solar system. This component is attached to a game object that is the Sun. It then manages the children of the Sun allowing editing and global scaling of planets, asteroids and comets |
| CThreeBodySolution | Three body solution |
| CTrajectory | |
| CTrajectoryIntercepts | Trajectory intercepts. Given two trajectories that have recorded data, determine the points at which they cross in space. There are two types: intercept - the paths cross at the same time, the spaceship intercepts the target and depending on deltaV may rendezvoud match - the paths cross but at different times. The spaceship can choose to match the path of the target (with appropriate deltaV) but the target is not at the match point |
| CGravityState.NbodyState | |
| CNUtils | |
| COrbitData | Orbit data. Hold the traditional orbit parameters for an elliptic/hyperbolic orbit |
| COrbitUtils.OrbitElements | A "struct-like" class that holds all the orbital elements determined by RVtoCOE and used by COEtoRV. There are some specific cases that need to be considered: |
| COrbitPropagator | OrbitPropagator provides a mechanism to initialize an orbit and then determine the position and velocity at a future time |
| ►COrbitTransfer | Orbit transfer. Base class for all orbit transfers |
| CBiellipticXfer | Bi-elliptic Transfer |
| CCircularizeXfer | |
| CHohmannGeneral | Hohmann transfer or rendezvous between any two circular orbits. Handles diffences in radius, inclination and RAAN (Omega) |
| CHohmannXfer | |
| CLambertBattin | |
| CLambertUniversal | Calculate the universal Lambert transfer. This algorithm allows the transfer to be elliptic or hyperbolic as necessary to meet the designated transfer time. The transfer code can be used to determine the minimum energy transfer between the desired points/orbits - in this case the time of transfer is not specified. Additional API calls can be used to request a specific transfer time. It is frquently useful to obtain the most efficient transfer time and then use this as a baseline from which to investigate the dV cost of faster transfers |
| CPatchedConicXfer | |
| COrbitUtils | |
| CPKepler | |
| CPlanetData | |
| CPolynomialSolver | |
| CRelativeMotion | Relative Motion for orbital transfers and rendezvous. The relative motion formalism describes the motion of the ship with repect to the target in a co-rotating coordinate frame in which the target is stationary. It is assumed that the target is in a circular orbit and that the ship is in a "nearby" orbit. The closer the ship and target orbit, the better the approximation to actual motion and computation of rendezvous maneuvers |
| CGERewindMgr.RewindEntry | |
| CSecantRootFind | Secant root find method |
| CSolarUtils | Solar utils. Utility functions for determining planet/comet positions |
| CChoreos.Solution | |
| CFigureEights.Solution | |
| CSolutionServer | Provide known three-body solutions
|
| CTrajectoryData.Tpoint | |
| CTransferCalc | Calculate the transfer options from one body to a target body given the gravitational field of a central mass |
| CGETriggerMgr.Trigger | |
| CTriggerAngleTargeting | Determine the burn required for a specific trigger angle for rendezvous |
| CTwoLineElementSetParser | Utility function to parse a two line element set from https://www.celestrak.com/NORAD/elements/ for Earth satellite data |
| CUnityEngine.Vector2d | |
| CUnityEngine.Vector3d | |
| CXZPlane | Class to adjust from Unity world with orbit in XZ plane to the physics world where orbits are in XY plane. z y ^ ^ | /y | /z | / ==> | / | / | / |/ |/ +-------—> x +--------—> x |
1.9.6