| salt::AABB2 | AABB2 provides an axis aligned two dimensional bounding box |
| salt::AABB3 | AABB3 provides an axis aligned three dimensional bounding box |
| oxygen::ActionObject | |
| oxygen::AgentAspect | |
| oxygen::AgentControl | NetControl node that manages the communication with agents in cooperation with the GameControlServer |
| AgentState | |
| AgentStatePerceptor | |
| oxygen::AngularMotor | An angular motor allows the relative angular velocities of two bodies to be controlled |
| kerosin::Axis | |
| Ball | Ball on the soccer field ;) |
| oxygen::BallJoint | |
| BallStateAspect | |
| oxygen::BaseNode | BaseNode is the base class for all nodes which are part of the scene hierarchy |
| oxygen::BaseParser | Interface for a parser and generator that is used with the GameControlServer |
| BeamAction | |
| BeamEffector | |
| oxygen::Body | Body encapsulates an ODE rigid body object |
| oxygen::BodyController | Baseclass for nodes that control the motion of an associated body |
| salt::BoundingSphere | BoundingSphere provides a three dimensional sphere |
| kerosin::Box | Box is a SingleMatNode that automatically loads and renders a box mesh that is scaled to the given extents |
| oxygen::BoxCollider | BoxCollider encapsulates an ODE box geometry object |
| oxygen::Camera | Camera encapsualtes all data needed to describe the viewpoint from which a scene is rendered |
| CatchAction | |
| CatchEffector | |
| kerosin::CCylinder | CCylinder is a SingleMatNode that creates and renders a capped cylinder mesh with the given length and radius |
| oxygen::CCylinderCollider | CCylinderCollider encapsulates an ODE capped cylinder geometry object |
| zeitgeist::Class | This class is quite essential for the Zeitgeist Core |
| zeitgeist::Class_Class | This is the class object beloging to the class 'zeitgeistClass' |
| zeitgeist::Class_Leaf | Declare the clss object for leaf |
| zeitgeist::Class_LogServer | |
| zeitgeist::Class_Node | |
| zeitgeist::Class_Object | |
| oxygen::Collider | ODE geometry object- geom for short |
| oxygen::CollisionHandler | Interface for handlers that take action in response to a collision |
| CollisionPerceptor | To store collisions as they occur within the scenegraph |
| oxygen::ContactJointHandler | CollisionHandler that creates an ODE contact joint between the two bodies associated with the two affected collision geoms |
| oxygen::ControlAspect | |
| zeitgeist::Core | The Core is the hierarchy, i.e |
| zeitgeist::Core::CacheKey | CacheKey is a struct used as the key for the internal node lookup cache |
| zeitgeist::CoreContext | This class is responsible for representing a browsing context within the object hierarchy |
| oxygen::CreateAction | |
| oxygen::CreateAction | |
| CreateEffector | |
| oxygen::CustomMonitor | |
| kerosin::CustomRender | CustomRender is the base class for all nodes installed below the Spark RenderControl node |
| oxygen::DragController | BodyController that applies a linear and angular drag the controlled body |
| DriveAction | |
| DriveEffector | |
| oxygen::Effector | |
| salt::ExponentialRNG< RealType > | A random number generator with an exponential distribution |
| FieldFlag | Flag that marks a position on the playing field |
| zeitgeist::FileServer | FileServer - the global interface for file system access |
| zeitgeist::FileSystem | This class defines the interface which derived filesystems must implement in order to be used with the fileserver |
| FileSystemSTD | FileSystemSTD - The 'Standard' File System |
| FileSystemZIP | |
| FileSystemZIP::TArchiveEntry | |
| FileSystemZIP::TCentralDirectoryEnd | |
| FileSystemZIP::TFileHeader | |
| FileSystemZIP::TLocalHeader | |
| oxygen::FixedJoint | The fixed joint maintains a fixed relative position and orientation between two bodies, or between a body and the static environment |
| kerosin::Font | Font allows the use of a 'texture'-based font |
| kerosin::Font::GlyphMetric | |
| kerosin::FontServer | |
| ForceAction | |
| ForceEffector | |
| oxygen::FPSController | BodyController, that provides first person shooter (FPS) movement, i.e |
| salt::Frustum | This class implements a frustum, which is an arbitrary volume in space (possibly infinite) defined by a set of planes |
| oxygen::GameControlServer | |
| GameStateAspect | |
| GameStateItem | |
| GameStatePerceptor | |
| zeitgeist::GCValue | Ruby VALUE wrapper |
| oxygen::GeometryServer | Set of triangle meshes and a set of plugins to import or generate them |
| kerosin::Glyph | |
| HearPerceptor | |
| Hinge2Action | |
| Hinge2Effector | |
| oxygen::Hinge2Joint | |
| Hinge2Perceptor | |
| HingeAction | |
| HingeEffector | |
| oxygen::HingeJoint | |
| HingePerceptor | |
| kerosin::Image | |
| kerosin::ImageServer | |
| oxygen::IndexBuffer | IndexBuffer is intended as a cache for indeces pointing into a vertexbuffer to describe a set of triangles |
| InitAction | |
| InitEffector | |
| kerosin::InputControl | SimControlNode that processes any pending input events from the InputServer at the begin of each simulation cycle |
| kerosin::InputDevice | |
| InputDeviceSDL | This class introduces SDL-specific callback functions for the event filtering |
| kerosin::InputItem | InputItem is the base class for all nodes installed below the Spark InputControl node |
| kerosin::InputServer | |
| kerosin::InputServer::Bind | This defines a bind, i.e |
| kerosin::InputServer::Input | This defines the input data structure, encapsulating all input events generated by the devices |
| kerosin::InputSystem | |
| InputSystemSDL | |
| isUnique< T > | |
| oxygen::Joint | ODE joint object |
| kerosin::Kerosin | This is the main class, which initializes the Kerosin framework |
| KeyboardSDL | |
| KickAction | |
| KickEffector | |
| zeitgeist::Leaf | Leaf defines the beginning of the hierarchy |
| kerosin::Light | |
| zeitgeist::LogServer | The log server is responsible for holding a bunch of ostreams, which data can be streamed to |
| LogServerStreamBuf | |
| zeitgeist::LogServerStreamBuf | |
| zeitgeist::LogServerStreamBuf::MaskStreamEQ | A predicate to compare streams in a MaskStream list (or vector) |
| kerosin::MapHolder | |
| mat3 | |
| mat4 | |
| kerosin::Material | |
| kerosin::Material2DTexture | |
| kerosin::MaterialServer | |
| kerosin::MaterialSolid | |
| salt::Matrix | Matrix provides a 4x4 float Matrix along with methods to set up and manipulate it |
| salt::MemFile | Memfile implements the RFile interface using an inmemory buffer |
| oxygen::MeshImporter | Interface for classes that import or generate trimeshes |
| oxygen::MonitorCmdParser | |
| MonitorConrol | NetControl node that manages the communication with monitors in cooperation with the MonitorServer |
| oxygen::MonitorControl | |
| oxygen::MonitorItem | |
| oxygen::MonitorServer | |
| oxygen::MonitorSystem | |
| MonitorTest | MonitorTest - A simple monitor plugin to use with app/spadestest |
| MouseSDL | |
| oxygen::NetBuffer | Buffer that is used to hold the raw network stream of data |
| oxygen::NetClient | |
| oxygen::NetControl | SimControlNode that accepts and manages a set of network client connections via UDP or TCP |
| oxygen::NetControl::Client | |
| oxygen::NetMessage | For the segmentation of raw received network data into meaningful messages, stripping any meta message information (e.g |
| zeitgeist::Node | Node makes up the hierarchy |
| salt::NormalRNG< RealType > | A random number generator producing normally distributed numbers |
| NVMeshMender | |
| NVMeshMender::Edge | |
| NVMeshMender::VertexAttribute | |
| zeitgeist::Object | Object is the base class of all objects in the Zeitgeist framework |
| ObjectState | |
| oxygen::ODEObject | ODEObject is the base of all classes encapsulating ODE concepts |
| kerosin::OpenGLServer | |
| oxygen::Oxygen | This is the main class, which initializes the Oxygen framework |
| PanTiltAction | |
| PanTiltEffector | |
| zeitgeist::ParameterList | List of values |
| oxygen::ParameterName | A functional class to find a specific parameter for use as STL predicate |
| oxygen::ParamReader | |
| oxygen::ParamStorer | This class implements the spades::ParamReader::ParamStorer interface |
| salt::Path | This class serves as a helper for path strings within the object hierarchy |
| oxygen::Perceptor | |
| PerceptorHandler | CollisionHandler that passes collision information on to a CollisionPerceptor |
| PerfectVisionPerceptor | |
| oxygen::PhysicsServer | |
| salt::Plane | A mathematical plane is modeled by this class |
| oxygen::PlaneCollider | PlaneCollider encapsulates an ODE plane geometry object |
| oxygen::Predicate | Assemble a string representing a given list of predicates |
| oxygen::Predicate::Iterator | ParameterList::TVectr::const_iterator together with a reference to the ParameterList the iterator belongs to |
| oxygen::PredicateList | |
| quat | |
| salt::RandomEngine | A wrapper to a boost random number generator |
| zeitgeist::RandomServer | The random server provides access to the salt RandomEngine from with the zeitgeist framework |
| oxygen::RayCollider | RayCollider encapsulates an ODE ray geometry "object" |
| zeitgeist::RbArguments | RbArguments is a structure that describes a ruby function call |
| oxygen::RecorderHandler | CollisionHandler that accumulates collision information of the Collider it belongs to |
| salt::Rect | This class provides rectangle in two dimensional space |
| kerosin::RenderControl | SimControlNode that renders the current scene and pumps the SDL event loop at the end of each simulation cycle, counting the total number of frames rendered |
| kerosin::RenderNode | RenderNode is the base class for all nodes which are part of the scene hierarchy and are able to render itself |
| kerosin::RenderServer | |
| RestrictedVisionPerceptor | |
| RestrictedVisionPerceptor::ObjectData | |
| salt::RFile | RFile defines an interface and some basic support functions for classes providing read only file services |
| kerosin::RGBA | |
| RubySceneImporter | |
| RubySceneImporter::MethodInvocation | Defines a method invocation |
| RubySceneImporter::ParamEnv | Parameter environment |
| SayAction | |
| SayEffector | |
| kerosin::ScanCodeMap | |
| kerosin::ScanCodeMap::TScanCodeEntry | |
| oxygen::Scene | Scene is the root node of a simulatable/displayable hierarchy |
| SceneAction | |
| SceneEffector | |
| oxygen::SceneImporter | |
| oxygen::SceneServer | The scene server manages displayable subtrees within the object hierarchy |
| zeitgeist::ScriptServer | The ScriptServer provides scripting facilities to the zeitgeist framework |
| SexpMonitor | Monitor plugin that generates S-Expressions for the rcssmonitor3D |
| SexpParser | |
| salt::SharedLibrary | SharedLibrary defines a commmon interface for the usage of shared libraries |
| oxygen::SimControlNode | Interface for classes that are registered to the SimulationServer |
| oxygen::SimulationServer | |
| SimulationServer | Runloop of a simulation, i.e |
| kerosin::SingleMatNode | BaseNode that renders itself using a single material |
| oxygen::SliderJoint | |
| SoccerBase | |
| SoccerControlAspect | Base class for all ControlAspects implemented in the soccer bundle |
| SoccerInput | |
| SoccerMonitor | |
| SoccerRender | |
| SoccerRuleAspect | |
| kerosin::SoundEffect | |
| SoundEffectFMOD | |
| kerosin::SoundModule | |
| SoundModuleFMOD | |
| kerosin::SoundObject | |
| kerosin::SoundServer | |
| kerosin::SoundStream | |
| SoundStreamFMOD | |
| kerosin::SoundSystem | |
| SoundSystemFMOD | |
| oxygen::Space | Space encapsulates an ODE space object |
| oxygen::SpadesActEvent | |
| oxygen::SpadesCreateSenseEvent | SpadesCreateSenseEvent implements the spades::CreateSenseEvent interface |
| oxygen::SpadesServer | |
| oxygen::SpadesServer::AgentItem | |
| spark::Spark | Application framework for apps that use oxygen and kerosin classes |
| SparkMonitor | |
| SparkMonitorClient | |
| kerosin::Sphere | SingleMatNode that automatically loads and renders a sphere mesh |
| oxygen::SphereCollider | SphereCollider encapsulates an ODE sphere geometry object |
| kerosin::StaticMesh | Render that renders a TriMesh |
| salt::StdFile | StdFile implements the WFile interface using the standard file system |
| oxygen::StdMeshImporter | MeshImporter that generates a standard set of meshes |
| kerosin::Texture | |
| kerosin::Texture2D | |
| kerosin::TextureServer | |
| TimePerceptor | |
| TimerSDL | Elapsed time since the last call in milliseconds |
| TrainerCommandParser | |
| oxygen::Transform | Transform is used to do local transforms relative to a parent node |
| oxygen::TriMesh | ) encapsulates a list of vertices, texture coordinates and normals together with an associated list of index lists |
| oxygen::TriMesh::Face | |
| salt::TVector< DATATYPE, ELEMENTS, TYPE > | TVector is a template class for vector implementations |
| salt::TVector2< DATATYPE, TYPE > | TVector2 is a two dimensional version of TVector |
| salt::TVector3< DATATYPE, TYPE > | TVector3 is a two dimensional version of TVector |
| salt::UniformRNG< RealType > | This random number generator should be used to produce uniformly distributed random numbers |
| oxygen::UniversalJoint | |
| UniversalJointAction | |
| UniversalJointEffector | |
| UniversalJointPerceptor | |
| vec2 | |
| vec3 | |
| vec4 | |
| salt::Vector2f | |
| salt::Vector3f | |
| oxygen::VelocityController | BodyController that restricts the maximum velocity a body can attain |
| VisionPerceptor | |
| VisionPerceptor::ObjectData | |
| VoidMeshImporter | MehsImporter the reads the custom .void format |
| salt::WFile | WFile extends the RFile interface with methods for writing to a file and related support funtions |
| oxygen::World | World encapsulates an ODE world object |
| zeitgeist::Zeitgeist | Main class, which initializes the Zeitgeist framework, manages the core and the main core context |