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 |