| dtDAL::AbstractEnumActorProperty | This actor property represents an abstract enumeration data member |
| dtDAL::AbstractParameter | Common base class for actor property and named parameter, especially helpful in the load/save process |
| dtABC::Action | |
| dtActors::ActionActorProxy | |
| dtDIS::ActiveEntityControl | Single point for associating known entities & actors |
| dtDAL::ActorActorProperty | This actor property represents an actor |
| dtGame::ActorDeletedMessage | |
| dtDIS::ActorMapConfig | Structure to maintain the one-to-one relationship between the DIS::EntityID and the dtDAL::ActorType |
| ActorMessageParameter | The ActorMessageParameter stores a unique id that can be used to retrieve the necessary GameActorProxy from the game manager |
| dtDAL::ActorPluginRegistry | The ActorPluginRegistry is the base class that developers extend to build their own registries |
| dtDAL::ActorProperty | The actor property class provides a get/set mechanism for accessing properties of a class |
| dtDAL::ActorProxy | This is the base class for all actor proxy objects |
| dtDAL::ActorProxy::RenderMode | This enumeration defines the different ways an actor proxy can be rendered in the level editor |
| dtDAL::ActorProxyIcon | |
| dtDAL::ActorProxyIcon::ActorProxyIconConfig | |
| dtDAL::ActorProxyIcon::BillBoardDrawable | |
| dtDAL::ActorProxyIcon::IconType | This enumeration enumerates the different types of billboard icons that are supported by default by the level editor |
| dtGame::ActorPublishedMessage | |
| dtDAL::ActorType | This class is more or less a simple data class that has information describing a particular type of Actor |
| dtDAL::ActorType::RefPtrComp | Simple less than comparison function for the ObjectFactory |
| dtGame::ActorUpdateMessage | Class the represents messages that are related to actors |
| dtAI::AIParticleManager | The AIParticleManager is almost like a particle system for agents, it is designed to support predicting another agents location using probability distribution analysis |
| dtAnim::Animatable | This class is used to specify the base class of an object which has semantics for animating |
| dtAnim::AnimationChannel | AnimationChannel derives from Animatable and holds an AnimationWrapper, and contains semantics for playing an animation using the Cal3DModelWrapper API |
| dtAnim::AnimationComponent | |
| dtActors::AnimationGameActor | This class is the game actor for an animated model |
| dtActors::AnimationGameActorProxy | This class is the proxy for an animated model game object |
| dtAnim::AnimationHelper | The AnimationHelper class is a utility class to simplify adding animation to an articulated entity, it provides support for loading, rendering and animating |
| dtAnim::AnimationSequence | AnimationSequence derives from Animatable and contains a child list of animations to play |
| dtAnim::AnimationSequence::AnimationController | AnimationController is responsible for updating the sequences child Animatables |
| dtAnim::AnimationWrapper | The AnimationWrapper is meant to be a wrapper around a Cal3D animation |
| dtAnim::AnimDriver | |
| dtAnim::AnimNodeBuilder | |
| dtAnim::AnimNodeBuilder::Cal3DBoundingSphereCalculator | |
| dtUtil::AppendTL< TList, T > | |
| dtUtil::AppendTL< NullType, T > | |
| dtABC::Application | Base generic Application class |
| dtABC::ApplicationConfigData | Defines API used to obtain values of the config file |
| dtABC::ApplicationConfigHandler | A class to perform the necessary features while a Xerces SAX parser is operating |
| dtABC::ApplicationConfigSchema | Defines API used to model the XML schema for the config file |
| dtABC::ApplicationConfigWriter | A class that writes config files for the dtABC::Application |
| dtHLAGM::ArticulatedParameter | A DIS/RPR-FOM articulated parameter |
| dtHLAGM::ArticulatedParts | A DIS/RPR-FOM articulated part |
| dtAI::AStar< _NodeType, _CostFunc, _Container, _Timer > | A generic implementation of the standard A* algorithm |
| dtAI::AStarConfig< _DataType, _CostType, _ContainerType > | AStarConfig contains the basic data that AStar operates on |
| dtAI::AStarCostFunc< _DataType, _CostType > | AStarCostFunc is a function that generates a cost between two nodes derive this class and implement operator() with your custom data type |
| dtAI::AStarNode< _NodeType, _DataType, _IterType, _CostType > | AStarNode is a data container for a single node in an AStar Path |
| dtAI::AStarTimer | This is a simple timer classed created with the dtCore::Timer |
| dtHLAGM::AttachedParts | DIS/RPR-FOM attached part |
| dtAnim::AttachmentController | Stores a list of attachments for a cal model and can update their positions based each frame based on the position of the bones |
| dtAnim::AttachmentMover | This is a helper functor for moving attachments |
| dtUtil::AttributeSearch | Searches a Xerces XML Attribute list for names of interest |
| dtHLAGM::AttributeToProperty | |
| dtHLAGM::AttributeToPropertyList | |
| dtHLAGM::AttributeType | |
| AudioConfigData | |
| dtAudio::AudioManager | DtAudio::AudioManager |
| dtABC::AutoTrigger | The AutoTrigger is a Trigger that does not need to be enabled or fired |
| dtActors::AutoTriggerActorProxy | This proxy wraps auto triggers |
| dtCore::AxesToAxis | Maps any number of source axes to a single target axis |
| dtCore::Axis | Axes are features with double-valued state |
| dtCore::AxisListener | An interface for objects interested in changes to axes |
| dtCore::AxisMapping | A mapping for a logical axis |
| dtCore::AxisToAxis | Maps an axis to a logical axis with an optional linear transformation |
| dtUtil::BarycentricSpace< VecT > | Transforms Cartesian data points into Barycentric coordinate systems |
| dtCore::Base | Base class to support naming and message passing |
| dtCore::Base::MessageData | Data that gets passed through SendMessage |
| dtABC::BaseABC | |
| dtUtil::BaseExceptionType | |
| dtGame::BaseInputComponent | This class is a base component that is setup to support keyboard and mouse events |
| dtActors::BaseLightActorProxy | This actor proxy is a wrapper for the dtCore::Light object |
| dtActors::BaseLightActorProxy::LightModeEnum | |
| dtAI::BaseNPC | This represents the base delta class used for AI agents having embedded support for the planning architecture and a generic FSM |
| dtGUI::BaseScriptModule | An abstract interface for classes used by CEUIDrawable |
| dtActors::BasicEnvironmentActor | |
| dtActors::BasicEnvironmentActor::CloudCoverEnum | |
| dtActors::BasicEnvironmentActor::SeasonEnum | |
| dtActors::BasicEnvironmentActor::TimePeriodEnum | |
| dtActors::BasicEnvironmentActor::VisibilityTypeEnum | Class that encapsulates Visibility Type |
| dtActors::BasicEnvironmentActor::WeatherThemeEnum | |
| dtActors::BasicEnvironmentActor::WindTypeEnum | |
| dtActors::BasicEnvironmentActorProxy | |
| dtCore::BatchIsector | To search the whole Scene for the height of terrain at a given xyz: |
| dtCore::BatchIsector::SingleISector | |
| dtABC::BezierController | |
| dtABC::BezierController::PathData | |
| dtActors::BezierControllerActorProxy | |
| dtABC::BezierControlPoint | |
| dtActors::BezierControlPointActorProxy | |
| dtABC::BezierNode | |
| dtActors::BezierNodeActorProxy | |
| dtGame::BinaryLogStream | This is a log stream class which supports a binary log file format |
| dtGame::BinaryLogStream::IndexTableHeader | This structure corresponds to the header located at the beginning of the logs index table file |
| dtGame::BinaryLogStream::MessageDataBaseHeader | This structure corresponds to the header located at the beginning of the messages database file |
| dtUtil::Binder< Incoming, BoundIdsTL > | |
| dtDAL::BooleanActorProperty | This actor property represents a boolean data member |
| dtUtil::BoundHelper< Incoming, IdsTL > | |
| dtCore::BoundingBoxVisitor | |
| dtUtil::BoundTL2< TL, IdsTL > | |
| dtUtil::BreakOverride | This macro should be used when deprecating (or removing) virtual functions |
| dtCore::Button | Buttons are features with binary state |
| dtCore::ButtonAxisToAxis | Maps a button and an axis to an axis, so that the value of the target axis is equal to the value of the source axis when the source button is pressed (the value is zero otherwise) |
| dtCore::ButtonListener | An interface for objects interested in button state changes |
| dtCore::ButtonMapping | A mapping for a logical button |
| dtCore::ButtonsToAxis | Maps two buttons to a logical axis |
| dtCore::ButtonToButton | Maps a button to a logical button |
| dtAnim::Cal3DAnimator | |
| dtAnim::Cal3DDatabase | |
| dtActors::Cal3DGameActor | This class is the game actor for an animated model |
| dtActors::Cal3DGameActor::PropertyNames | String constants for this actor |
| dtActors::Cal3DGameActorProxy | This class is the proxy for an animated model game object |
| dtAnim::Cal3DLoader | Loads a animation definition file and returns a valid CalModel |
| dtAnim::Cal3DModelData | |
| dtAnim::Cal3DModelWrapper | Wraps the Cal3D CalModel class |
| dtUtil::CallParms< TYPELIST_0()> | |
| dtUtil::CallParms< TYPELIST_1(P1)> | |
| dtUtil::CallParms< TYPELIST_2(P1, P2)> | |
| dtUtil::CallParms< TYPELIST_3(P1, P2, P3)> | |
| dtUtil::CallParms< TYPELIST_4(P1, P2, P3, P4)> | |
| dtUtil::CallParms< TYPELIST_5(P1, P2, P3, P4, P5)> | |
| dtUtil::CallParms< TYPELIST_6(P1, P2, P3, P4, P5, P6)> | |
| dtUtil::CallParms< TYPELIST_7(P1, P2, P3, P4, P5, P6, P7)> | |
| dtCore::Camera | A dtCore::Camera is a view into the Scene |
| dtActors::CameraActorProxy | This proxy wraps the Camera Delta3D object |
| dtGUI::CEGUIKeyboardListener | |
| dtGUI::CEGUIMouseListener | A mouse device listener to inject input to CEGUI |
| dtUtil::CelestialMesh | |
| dtUtil::CelestialMesh::Triangle | |
| dtUtil::CelestialMesh::TriangleEdge | |
| dtUtil::CelestialMesh::Vertex | |
| dtGUI::CEUIDrawable | A DeltaDrawable used to render CEGUI |
| dtAnim::CharacterFileHandler | Simple Xerces XML handler that will store the data read from a character definition .xml file |
| dtAnim::CharacterFileHandler::AnimatableStruct | |
| dtAnim::CharacterFileHandler::AnimationChannelStruct | |
| dtAnim::CharacterFileHandler::AnimationSequenceStruct | |
| dtAnim::CharacterFileHandler::AnimationStruct | Structure to contain all info related to an animation |
| dtAnim::CharacterFileHandler::MaterialStruct | |
| dtAnim::CharacterFileHandler::MeshStruct | Structure to contain all info related to a mesh |
| dtAnim::CharacterWrapper | A Wrapper around an animated character that will perform basic steering |
| dtAnim::CharDrawable | A "view" of the cal3d animation state |
| dtNetGM::ClientConnectionListener | Provides the interface to a GNE::Connection |
| dtNetGM::ClientNetworkComponent | |
| dtCore::CloudDome | CloudDome: This class can be used to generate procedural cloud cover |
| dtActors::CloudDomeActorProxy | This proxy wraps the CloudDome Delta3D object |
| dtCore::CloudPlane | This class can be used to simulate cloud cover it derives from EnvEffect |
| dtActors::CloudPlaneActorProxy | This proxy wraps Delta3D cloud planes |
| dtCore::CollisionMotionModel | Collision Motion Model uses ode collision meshes to allow typical FPS Camera interaction with the environment |
| dtTerrain::ColorMapDecorator | This terrain decorator is a terrain tile base texture decorator |
| dtDAL::ColorRgbaActorProperty | This actor property represents a color data member with 4 floats |
| dtUtil::Command< RetT > | An abstract class for all types which provide a uniform interface for executing Functors |
| dtUtil::Command0< RetT > | A Command which does not need arguments and has no return value |
| dtUtil::Command1< RetT, ArgT > | A Command which uses one argument and has no return value |
| dtUtil::Command2< RetT, ArgTMember1, ArgTMember2 > | A Command which uses two arguments and has no return value |
| dtCore::Compass | A special visual Object which constantly aligns with the world axes |
| dtAI::Conditional< _Type > | |
| dtDIS::Connection | Makes a multicast connection to support DIS networks |
| dtDIS::ConnectionData | Information needed to connect to the DIS network |
| dtNet::ConnectionListener | Provides the interface to a GNE::Connection |
| dtNet::ConnectionServer | This class is used as an interface to the GNE::Server connection |
| dtDIS::ConnectionXMLHandler | Reads the connection info from a config file |
| dtCore::ConvertToPointerUnary< T > | |
| dtActors::CoordinateConfigActor | |
| dtActors::CoordinateConfigActorProxy | |
| dtUtil::CoordinateConversionExceptionEnum | |
| dtUtil::Coordinates | |
| dtUtil::CreateIdsTL< i1, i2, i3, i4, i5, i6, i7, i8 > | |
| dtUtil::CreateIdsTL<-1,-1,-1,-1,-1,-1,-1,-1 > | |
| dtUtil::CreateTL< T1, T2, T3, T4, T5, T6, T7, T8 > | |
| dtUtil::CreateTL< NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType > | |
| dtABC::CurveNode | |
| dtUtil::DataStream | |
| dtUtil::DataStream::SeekTypeEnum | |
| dtUtil::DataStreamException | |
| dtNetGM::DataStreamPacket | A DataStreamPacket contains a dtGame::Message blocks to be sent over a Network ot other connected dtGame::GameManager's |
| dtDAL::DataType | The DataType class is an enumeration representing the different datatypes that are supported by the Delta3D engine |
| dtHLAGM::DDMAppSpaceCalculator | |
| dtHLAGM::DDMCalculatorGeographic | |
| dtHLAGM::DDMCalculatorGeographic::DDMForce | |
| dtHLAGM::DDMCalculatorGeographic::DDMObjectKind | |
| dtHLAGM::DDMCalculatorGeographic::RegionCalculationType | |
| dtHLAGM::DDMCameraCalculatorGeographic | This calculator is intended for generating subscription regions based on the view of the camera |
| dtHLAGM::DDMGeographicRegionData | |
| dtHLAGM::DDMMultiEnumeratedCalculator | |
| dtHLAGM::DDMRegionCalculator | This abstract calculator class provides the interface used to write concrete region calculators |
| dtHLAGM::DDMRegionCalculatorGroup | |
| dtHLAGM::DDMRegionData | An abstract class that will be extended by DDMRegionCalculator implementations to store object instance data used when updating the region for a given object |
| dtHLAGM::DDMRegionData::DimensionValues | |
| dtHLAGM::DDMUtil | |
| dtGame::DeadReckoningAlgorithm | |
| dtGame::DeadReckoningComponent | |
| dtGame::DeadReckoningHelper | |
| dtGame::DeadReckoningHelper::DeadReckoningDOF | |
| dtGame::DeadReckoningHelper::UpdateMode | |
| dtGame::DefaultMessageProcessor | |
| dtGame::DefaultNetworkPublishingComponent | |
| dtAI::delete_func | |
| dtCore::DeltaDrawable | A renderable object |
| dtActors::DeltaObjectActorProxy | This proxy wraps the Delta3D Object |
| dtCore::DeltaWin | The rendering area that a dtCore::Camera will render to |
| dtCore::DeltaWin::PositionSize | Set the size and position of the DeltaWin |
| dtCore::DeltaWin::Resolution | The data structure modeling monitor resolution |
| DeprecationMgr | Tally usage of deprecated functions and report at end of execution |
| dtCore::Detonation | A detonation effect |
| dtDAL::DirectoryResourceTypeHandler | Resource type handler for importing, removing, and describing directory based resources |
| dtDAL::DoubleActorProperty | This actor property represents a 64-bit precision decimal data member |
| DoubleMessageParameter | |
| dtTerrain::DTEDTerrainReader | This data reader loads DTED data mapping to a specified latitude and longitude |
| dtTerrain::DTEDTerrainReader::DTEDLevelEnum | This enumeration represents the different DTED levels available for loading |
| dtAI::Eff< _Type > | |
| dtCore::Effect | The base class of all effects |
| dtCore::EffectListener | An interface for objects interested in the addition and removal of effects from the manager |
| dtCore::EffectManager | An effect manager |
| dtUtil::EmptyType | |
| dtActors::EngineActorRegistry | This actor registry handles the actor proxies that are supported by the core Delta3D engine |
| dtDIS::EnginePropertyName | |
| dtHLAGM::EntityIdentifier | A DIS/RPR-FOM entity identifier |
| dtDIS::EntityMapXMLHandler | Stores configuration data loaded from a file for the purposes of mapping DIS to Delta3D |
| dtDIS::EntityPropertyName | |
| dtHLAGM::EntityType | A DIS/RPR-FOM entity type |
| dtDAL::EnumActorProperty< T > | This actor property represents an enumeration data member |
| dtUtil::Enumeration | This class represents a type-safe enumeration pattern |
| EnumMessageParameter | The EnumMessageParameter works like the string message parameter because there is no way for the message to efficiently know how to fetch proper enumeration object when the data is populated from a string or stream |
| dtActors::EnvActor | |
| dtActors::EnvActorProxy | |
| dtCore::EnvEffect | A base class for all Environmental Effects |
| dtActors::EnvEffectActorProxy | This proxy wraps environment effects |
| dtCore::Environment | A unique environment which controls lighting and visibility |
| dtCore::Environment::DateTime | |
| dtHLAGM::EulerAngles | A DIS/RPR-FOM euler angle type |
| dtABC::Event | The Event class is specific to the state manager where an event is an object whose Type can cause a Transition |
| dtHLAGM::EventIdentifier | A DIS/RPR-FOM event identifier |
| dtUtil::Exception | |
| dtGUI::ExceptionEnum | |
| dtHLAGM::ExceptionEnum | |
| dtDAL::ExceptionEnum | |
| dtCore::ExceptionEnum | Exceptions for the dtCore namespace |
| dtGame::ExceptionEnum | |
| dtUtil::FileExceptionEnum | An enumeration of exception types that will be thrown by fileutils |
| dtUtil::FileInfo | |
| dtUtil::FileUtils | |
| dtUtil::Filter2< TL, IdsTL, include > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< TL2, i, IdsTL2, Predicate > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< dtUtil::NullType, i, dtUtil::NullType, Predicate > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< dtUtil::NullType, i, IdsTL2, Predicate > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< TL2, 0, dtUtil::NullType, dtUtil::IsIntType > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< TL2, 0, dtUtil::NullType, dtUtil::NotIntType > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< TL2, 0, typename dtUtil::IdsFromTL< TL2 >::Type, dtUtil::IsIntType > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< TL2, 0, typename dtUtil::IdsFromTL< TL2 >::Type, dtUtil::NotIntType > | |
| dtUtil::Filter2< TL, IdsTL, include >::Temp< TL2, i, dtUtil::NullType, Predicate > | |
| dtTerrain::FixedPointNoise | This is a fixed point implementation of an improved Ken Perlin noise generator |
| Fl_DT_Window< T > | |
| dtDAL::FloatActorProperty | This actor property represents a floating point data member |
| FloatMessageParameter | |
| dtCore::FlyMotionModel | A motion model that simulates the action of flying |
| dtCore::FPSCollider | This class uses ode to simulate fps movement on collision meshes note: this is a simplified physical model and has a few caveats listed below |
| dtCore::FPSMotionModel | A motion model used for typical First Person Shooter motion |
| dtCore::FPSMotionModel::FPSAxisListener | Internal class, used by FPSMotionModel for InputDevice listening |
| dtUtil::Fractal< Real, Vector, Noise > | Fractal: This class is made to complement the noise classes where as the noise class hashes vectors to floats between -1 to 1 this class can be used to make summations of the noise to use this class I recommend including NoiseUtility.h and using the appropriate typedefs |
| dtAI::FSM | A class which represents a Finite State Machine |
| dtAI::FSM::PairRefPtrWithNameCompare< T > | Compares a pair, but assumes the 2nd type is a referenced pointer |
| dtAI::FSM::RefPtrWithNameCompare< T > | Compares 2 referenced pointer objects by pointer value and name |
| dtDAL::FunctionFunctor0< Func > | Special case of Functor0 which is used to store a regular function |
| dtDAL::FunctionFunctor0Ret< Func, RT > | Special case of Functor0Ret which is used to store a regular function |
| dtDAL::FunctionFunctor1< Func, P1 > | Special case of Functor1 which is used to store a regular function |
| dtUtil::Functor< R, TList, size > | |
| dtDAL::Functor | This class is the base Functor class |
| dtDAL::Functor0 | Functor which takes no parameters and returns no value |
| dtDAL::Functor0Ret< RT > | Functor which takes no parameters and returns a value |
| dtDAL::Functor1< P1 > | Functor which takes 1 parameter and returns no value |
| dtUtil::Functor< R, TList, size >::FunImplBase::VTable | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_0()> | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_1(P1)> | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_2(P1, P2)> | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_3(P1, P2, P3)> | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_4(P1, P2, P3, P4)> | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_5(P1, P2, P3, P4, P5)> | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_6(P1, P2, P3, P4, P5, P6)> | |
| dtUtil::FunctorCall< CallType, R, TYPELIST_7(P1, P2, P3, P4, P5, P6, P7)> | |
| dtUtil::FunTraits< R(*)()> | |
| dtUtil::FunTraits< R(*)(P1)> | |
| dtUtil::FunTraits< R(*)(P1, P2)> | |
| dtUtil::FunTraits< R(*)(P1, P2, P3)> | |
| dtUtil::FunTraits< R(*)(P1, P2, P3, P4)> | |
| dtUtil::FunTraits< R(*)(P1, P2, P3, P4, P5)> | |
| dtUtil::FunTraits< R(*)(P1, P2, P3, P4, P5, P6)> | |
| dtUtil::FunTraits< R(*)(P1, P2, P3, P4, P5, P6, P7)> | |
| dtUtil::FunTraits< R(O::*)() const > | |
| dtUtil::FunTraits< R(O::*)()> | |
| dtUtil::FunTraits< R(O::*)(P1) const > | |
| dtUtil::FunTraits< R(O::*)(P1)> | |
| dtUtil::FunTraits< R(O::*)(P1, P2) const > | |
| dtUtil::FunTraits< R(O::*)(P1, P2)> | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3) const > | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3)> | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4) const > | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4)> | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4, P5) const > | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4, P5)> | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4, P5, P6) const > | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4, P5, P6)> | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4, P5, P6, P7) const > | |
| dtUtil::FunTraits< R(O::*)(P1, P2, P3, P4, P5, P6, P7)> | |
| dtGame::GameActor | This class will be the main base class for actors being used by the Game Manager |
| dtGame::GameActorProxy | Class GameActorProxy This will be the base class for all of the actor proxies utilized by the Game Manager |
| dtGame::GameActorProxy::Ownership | Internal class to represent the ownership of an actor proxy |
| dtGame::GameApplication | Base application for a GameManager app |
| dtGame::GameEntryPoint | A class for specifying the entry point into a Game so that the entire game can be defined in a Game library and loaded at runtime |
| dtDAL::GameEvent | This is a simple data class which represents a game event |
| dtDAL::GameEventActorProperty | This actor property represents a game event property |
| dtDAL::GameEventManager | Simple class that manages a list of game events |
| dtGame::GameEventMessage | |
| GameEventMessageParameter | The GameEventMessageParameter stores a unique id that can be used to get the associated game event from the EventManager |
| dtGame::GameManager | |
| dtGame::GameManager::ComponentPriority | |
| dtGame::GameManager::TimerInfo | |
| dtActors::GameMeshActor | This class is the game actor for a basic game object that has a single static mesh |
| dtActors::GameMeshActor::GameMeshLoader | Inner class for implementing the loadable interface |
| dtActors::GameMeshActorProxy | This class is the proxy for a basic game object that has a single static mesh |
| dtDAL::GenericActorProperty< SetType, GetType > | The GenericActorProperty class implements the set and get functionality which defines the primary behavior of the ActorProperty |
| dtCore::GenericKeyboardListener | Provides generic callback support for Keyboard events |
| dtCore::GenericMouseListener | Provides generic callback support for Mouse events |
| dtTerrain::GeoCoordinates | This class is intended to represent cartesian and geographic coordinates |
| dtTerrain::GeoCoordinatesException | This class contains the various types of exceptions that the coordinate system class may throw during a given operation |
| dtTerrain::GeoTiffDecorator | This class is a terrain texturing decorator that supports the mapping of geospecific images onto terrain tiles |
| dtCore::CollectorUtil::GetElementType< T > | Template Function that is used to get the RefPtr's Element type from the map |
| dtGame::GMComponent | |
| dtGame::GroundClamper | This is a utility class for doing ground clamping |
| dtGame::GroundClamper::GroundClampingType | |
| dtGame::GroundClampingData | |
| dtDAL::GroupActorProperty | An actor property that contains a structure of NamedParameter Objects |
| dtAnim::HardwareSubmeshDrawable | |
| dtTerrain::HeightField | This class wraps an array of elevation posts |
| dtTerrain::HeightFieldException | This enumeration defines the different types of exceptions the height field may throw if an error occurs |
| dtTerrain::HeightFieldResizePolicy | This enumeration specifies the valid resize policies the data readers should follow when loading a new heightfield |
| dtDIS::HLABaseEntityPropertyName | |
| dtHLAGM::HLAComponent | |
| dtHLAGM::HLAComponentConfig | |
| dtHLAGM::HLAFOMConfigContentHandler | |
| dtCore::HotSpotAttachment | Maintains a mapping from HotSpotData instances to Transformable instances |
| dtUtil::HotSpotDefinition | |
| dtAnim::HotSpotDriver | Updates the body offset value for HotSpot instances |
| dtUtil::HotSpotFileHandler | |
| dtAnim::ICal3DDriver | |
| dtAI::IConditional | An expression that evaluates to true of false |
| dtDIS::IDISPlugin | Interface for all DIS plugins |
| dtUtil::IdsFromTL< TL, i > | |
| dtUtil::IdsFromTL< NullType, i > | |
| dtAI::IEffect | |
| dtGame::IEnvGameActor | Interface to the Environment Game Actor |
| dtGame::IEnvGameActorProxy | Interface to the proxy of the Environment Game Actor |
| dtDAL::IEnvironmentActor | Interface class to an "environment actor" |
| dtTerrain::ImageUtilException | Defines exceptions that may be thrown from the image utility methods |
| dtTerrain::ImageUtils | This class is a static class containing many methods for creating images procedurally, concatenating images, and building images from source height data |
| dtTerrain::ImageUtils::GeospecificImage | |
| dtTerrain::ImageUtils::HeightColorMap | Maps height values to colors with interpolation/extrapolation |
| dtDIS::IMessageToPacketAdapter | Interface for translating Delta3D messages into DIS packets |
| dtUtil::IncomingCoordinateType | |
| dtCore::InfiniteLight | Light located an infinite distance from origin and therefore only has direction |
| dtActors::InfiniteLightActorProxy | This proxy wraps the Infinite light Delta3D object |
| dtCore::InfiniteTerrain | An infinite terrain surface |
| dtActors::InfiniteTerrainActorProxy | This proxy wraps the InfiniteTerrain Delta3D object |
| dtGame::InputComponentKeyboardListener | Implementation of KeyboardListener |
| dtGame::InputComponentMouseListener | Implementation of MouseListener |
| dtCore::InputDevice | Represents an input device |
| dtCore::InputDeviceFeature | The base class of all input device features: buttons, axes, etc |
| dtCore::InputMapper | Acquires mappings for logical input device features by listening to a set of devices |
| dtCore::InputMapperCallback | The input mapper callback interface |
| dtInspector::Inspector | Creates and manages the UserInterface |
| dtUtil::InstantiateH< NullType, Holder, i > | |
| dtUtil::InstantiateH< TypeList< T, U >, Holder, i > | |
| dtUtil::InstantiateHAccessor< 0, InstantiateH< TypeList< T, U >, Holder, i >, i > | |
| dtUtil::InstantiateHAccessor< j, InstantiateH< TypeList< T, U >, Holder, i >, i > | |
| dtUtil::Int2Type< v > | |
| dtDAL::IntActorProperty | This actor property represents a signed integer data member |
| dtHLAGM::InteractionToMessage | Defines a one-to-one the mapping between and HLA interacion and a game message |
| IntMessageParameter | |
| dtGame::Invokable | An Invokable is a queriable method interface that can be added to a dtGame::GameActorProxy just as a dtDAL::ActorProperty represents a data value on the actor |
| dtDAL::IsCategorySeparator | |
| dtUtil::IsDelimeter | Generic string delimeter check function class |
| dtCore::Isector | This class is used to check for intersections of a line segment with geometry |
| dtUtil::IsIntType< T, i > | |
| dtUtil::IsIntType< Int2Type< i >, i > | |
| dtUtil::IsSlash | Determines if the current character is a forward slash |
| dtUtil::IsSpace | A functor which tests if a character is whitespace |
| dtAI::IStateVariable | A single entity of a dtAI::WorldState |
| dtInputPLIB::Joystick | A joystick device |
| dtCore::Keyboard | The model of the keyboard used throughout Delta3D |
| dtABC::KeyboardEvent | KeyboardEvent struct for passing keyboard events |
| dtCore::KeyboardListener | An interface for objects interested in receiving keyboard events |
| dtCore::KeyboardMouseHandler | |
| dtUtil::KeyFrameDecoder< RecordableT, FrameDataT > | A class that fills key frame data with DOM parsing |
| dtTerrain::LCCAnalyzer | The LCC Analyzer calculates LCC data for use in the vegetation decorator |
| dtTerrain::LCCAnalyzerException | Defines the exceptions thrown by the lcc analyzer |
| dtTerrain::LCCAnalyzerResourceName | This enumeration identitifies the resources that are cached and managed by the vegetation decorator layer |
| dtTerrain::LCCType | |
| dtTerrain::LCCType::LCCModel | Describes an LCC's geometric model info |
| dtUtil::Length< NullType > | |
| dtUtil::Length< TypeList< T, U > > | |
| dtDAL::LibraryManager | This class is the main class in the dynamic actor library portion of the DAL (Dynamic Actor Layer) |
| dtDAL::LibraryManager::RegistryEntry | Simple structure for grouping the data corresponding to a registry entry |
| dtUtil::LibrarySharingManager | Singleton for controlling loading and unloading libraries shared by mulitple bodies of code |
| dtUtil::LibrarySharingManager::ExceptionEnum | |
| dtUtil::LibrarySharingManager::LibraryHandle | Pure virtual class abstracting a checked-out handle to a library |
| dtCore::Light | An abstract class declaring the base functionality for a vertex light |
| dtAudio::Listener | DtAudio::Listener |
| dtLMS::LmsClientSocket | This class is designed to send and receive LMS messages over a TCP socket using a predetermined messaging protocol |
| dtLMS::LmsComponent | This class is a sub-class of the standard TaskComponent |
| dtLMS::LmsConnectionState | |
| dtLMS::LmsExceptionEnum | |
| dtLMS::LmsMessage | This class is used to encapsulate an LMS message that is sent to or received from an LMS |
| dtLMS::LmsMessageType | |
| dtLMS::LmsMessageValue | |
| dtLMS::LmsMessageValue::LaunchPageValue | |
| dtLMS::LmsMessageValue::ObjectiveCompletionValue | |
| dtLMS::LmsMessageValue::SimulationValue | |
| dtLMS::LmsTaskStatus | |
| dtCore::Loadable | The Loadable class is a simple mechanism for loading files |
| dtUtil::LocalCoordinateType | |
| dtAnim::LODOptions | A simple data class that stores the configuration options for level of detail |
| dtUtil::Log | Log class which the engine uses for all of its logging needs |
| dtGame::LogAvailableLogsMessage | This message class is sent from the ServerLoggerComponent to the log controller specifying the current logs available |
| dtGame::LogCaptureKeyframeMessage | This message class is sent to the ServerLoggerComponent to capture a keyframe |
| dtGame::LogController | The Log Controller is a GM Component |
| dtGame::LogDeleteLogfileMessage | This message class is sent to the ServerLoggerComponent to delete a log file |
| dtGame::LogEndLoadKeyframeMessage | This message class is sent from the ServerLoggerComponent to let clients know that a load keyframe is done |
| dtUtil::LogFile | |
| dtGame::LogGetKeyframeListMessage | This message class is sent from the ServerLoggerComponent to the log controller specifying the list of keyframes in the current log |
| dtGame::LogGetTagListMessage | This message class is sent from the ServerLoggerComponent to the log controller specifying the list of tags in the current log |
| dtCore::LogicalAxis | A logical axis |
| dtCore::LogicalButton | A logical button |
| dtCore::LogicalInputDevice | A logical input device |
| dtGame::LogInsertTagMessage | This message class is sent to the ServerLoggerComponent to insert a tag |
| dtGame::LogJumpToKeyframeMessage | This message class is sent to the ServerLoggerComponent to jump to a specific keyframe |
| dtGame::LogKeyframe | A simple data class for basic Log Keyframe information |
| dtGame::LogKeyFrameIndex | |
| dtGame::LogKeyFrameIndex::Entry | |
| dtGame::LogSetAutoKeyframeIntervalMessage | This message class is sent to the ServerLoggerComponent to change the current automatic keyframe interval (in seconds) |
| dtGame::LogSetLogfileMessage | This message class is sent to the ServerLoggerComponent to change the current log file |
| dtGame::LogStateEnumeration | Simple enumeration for the states of the logger |
| dtGame::LogStatus | A simple data class for basic Log Status information |
| dtGame::LogStatusMessage | This message class is sent by the ServerLoggerComponent - it has logger status info; it provides the complete status of the server logger component |
| dtGame::LogStream | This is an interface class to a stream used by the ServerLoggerComponent to stream data to and from a log file |
| dtGame::LogStreamException | This exception enumeration defines the possible exceptions that may be thrown by LogStream operations |
| dtGame::LogTag | A simple data class for basic Log Tag information |
| dtGame::LogTagIndex | |
| dtGame::LogTagIndex::TagEntry | |
| dtDAL::LongActorProperty | This actor property represents a signed long integer data member |
| LongIntMessageParameter | |
| dtGame::MachineInfo | A data class representing basic machine information |
| dtGame::MachineInfoCompare | |
| dtNetGM::MachineInfoMessage | A MachineInfoMessage contains a dtGame::MachineInfo to be used with different messages to send information about a GameManager accross the network |
| dtCore::MakeSkyDome | Internal class used by dtCore::SkyDome to create the actual geometry |
| dtDAL::Map | Holds the map information and all of the actor proxies |
| dtDAL::Map::MapGameEvents | |
| dtGame::MapChangeStateData | |
| dtGame::MapChangeStateData::MapChangeState | |
| dtDAL::MapContentHandler | The SAX2 content handler for loading maps |
| dtGame::MapMessage | Message used for all of the map change, close, load, etc messages |
| dtDAL::MapParser | Front end class for converting an XML map into a map instance |
| dtDAL::MapWriter | Writes a map out to an XML file |
| dtDAL::MapXMLConstants | Holds constants for all of the element names in the map XML |
| dtDIS::MasterComponent | Supports a framework to translate DIS PDUs into dtGame::Message instances |
| dtTerrain::MathUtils | |
| dtUtil::MatrixUtil | MatrixUtil is a utility class for operating on an osg::Matrix |
| dtDAL::MemberFunctor0< Callee, MemFunc > | Special case of Functor0 which is used to store a member function of a class |
| dtDAL::MemberFunctor0Ret< Callee, MemFunc, RT > | Special case of Functor0Ret which is used to store a member function of a class |
| dtDAL::MemberFunctor1< Callee, MemFunc, P1 > | Special case of Functor1 which is used to store a member function of a class |
| dtUtil::MergeParmsH< i, BoundPTL, UnboundPTL, IdsTL, TL > | |
| dtUtil::MergeParmsH< i, BoundPTL, UnboundPTL, IdsTL, TL >::Bound | |
| dtUtil::MergeParmsH< i, BoundPTL, UnboundPTL, IdsTL, TL >::Predicate< j, IdsTL2 > | |
| dtUtil::MergeParmsH< i, BoundPTL, UnboundPTL, IdsTL, TL >::Predicate< j, dtUtil::NullType > | |
| dtUtil::MergeParmsH< i, BoundPTL, UnboundPTL, IdsTL, TL >::Unbound | |
| dtUtil::MergeParmsH< 0, BoundPTL, UnboundPTL, dtUtil::NullType, TL > | |
| dtUtil::MergeParmsH< i, BoundPTL, UnboundPTL, IdsTL, dtUtil::NullType > | |
| dtActors::MeshTerrainActor | |
| dtActors::MeshTerrainActorProxy | This proxy wraps mesh terrains |
| dtGame::Message | |
| dtGame::MessageFactory | |
| dtGame::MessageFactory::MessageFactoryException | |
| dtNetGM::MessagePacket | A MessagePacket contains a dtGame::Message to be sent over a Network ot other connected dtGame::GameManager's |
| MessageParameter | |
| dtGame::MessageType | Class that enumerates the message types used by the GameManager |
| dtAnim::MorphDriver | |
| dtABC::MotionAction | |
| dtActors::MotionActionActorProxy | |
| dtActors::MotionActionActorProxy::ParentRelationEnum | |
| dtCore::MotionModel | The base class for all motion models: objects that update the transforms of Transformable objects according to input gathered from physical or logical input devices |
| dtCore::Mouse | The model of the mouse used throughout Delta3D |
| dtABC::MouseEvent | MouseEvent struct for passing mouse events |
| dtCore::MouseListener | An interface for objects interested in mouse events |
| dtCore::MoveEarthySkyWithEyePointTransform | |
| dtCore::MoveEarthySkyWithEyePointTransformAzimuth | |
| dtDAL::NamedActorParameter | |
| dtDAL::NamedBooleanParameter | |
| dtDAL::NamedDoubleParameter | |
| dtDAL::NamedEnumParameter | |
| dtDAL::NamedFloatParameter | |
| dtDAL::NamedGameEventParameter | |
| dtDAL::NamedGenericParameter< ParamType > | |
| dtDAL::NamedGroupParameter | |
| dtDAL::NamedIntParameter | |
| dtDAL::NamedLongIntParameter | |
| dtDAL::NamedParameter | |
| dtDAL::NamedPODParameter< ParamType > | This is a template for the single piece of data types to make reading data to and from a string easier |
| dtDAL::NamedResourceParameter | |
| dtDAL::NamedRGBAColorParameter | |
| dtDAL::NamedRGBColorParameter | |
| dtDAL::NamedShortIntParameter | |
| dtDAL::NamedStringParameter | |
| dtDAL::NamedUnsignedCharParameter | |
| dtDAL::NamedUnsignedIntParameter | |
| dtDAL::NamedUnsignedLongIntParameter | |
| dtDAL::NamedUnsignedShortIntParameter | |
| dtDAL::NamedVec2dParameter | |
| dtDAL::NamedVec2fParameter | |
| dtDAL::NamedVec2Parameter | |
| dtDAL::NamedVec3dParameter | |
| dtDAL::NamedVec3fParameter | |
| dtDAL::NamedVec3Parameter | |
| dtDAL::NamedVec4dParameter | |
| dtDAL::NamedVec4fParameter | |
| dtDAL::NamedVec4Parameter | |
| dtDAL::NamedVecParameter< ParamType > | This is a template for the vector types to make reading data from a string easier |
| dtAI::NavMesh | A NavMesh is the collection of all WaypointPairs This is used for finding traversal paths between points |
| dtNet::NetMgr | This class is used as the base of all networking applications |
| dtGame::NetServerRejectMessage | |
| dtNetGM::NetworkBridge | GNE components for communication across a network This class represents a single host on the other side of the network |
| dtNetGM::NetworkComponent | Baseclass GMComponent to communicate as client - server |
| dtNetGM::NetworkComponent::DestinationType | Enumeration class to address different stored connections |
| dtAI::node_type_comp_func< T, E > | |
| dtAI::node_type_gtr_func | |
| dtCore::NodeCollector | |
| dtDIS::Articulation::NodeName | Static definition of the scene graph node names to be used for articulated parts |
| dtUtil::NodePrintOut | |
| dtUtil::Noise1< Real, Vector > | An implementation of 1D Gradient Noise |
| dtUtil::Noise2< Real, Vector > | An implementation of 2D Gradient Noise |
| dtUtil::Noise3< Real, Vector > | An implementation of 3D Gradient Noise |
| dtUtil::NoiseTexture | Noise Texture is a class that uses SeamlessNoise to generate an osg::Image |
| dtUtil::NotIntType< T, i > | |
| dtAI::NPCEvent | |
| dtAI::NPCParser | The class used to parse NPCScript |
| dtAI::NPCState | |
| dtAI::NPCStateTypes | |
| dtUtil::NullType | |
| dtCore::Object | A visual Object with physical properties |
| dtUtil::ObjectFactory< UniqueIdTypeClass, BaseTypeClass, ltCmpClass > | This class is a template object factory |
| dtHLAGM::ObjectRuntimeMappingInfo | Simple class that holds all of the data used at runtime when mapping RTI objects to actor types |
| dtHLAGM::ObjectToActor | Defines a one-to-one the mapping between and HLA object and a game actor |
| dtHLAGM::ObjectToActor::LocalOrRemoteType | |
| dtCore::ObserverPtr< T > | |
| dtHLAGM::OneToManyMapping | Logically abstract class used to to define a one to many mapping between and HLA field and many message parameters |
| dtHLAGM::OneToManyMapping::ParameterDefinition | |
| dtHLAGM::OneToOneMapping | Logically abstract class used to to define a one to one mapping between two fields |
| dtAI::Operator | |
| dtCore::OrbitMotionModel | A motion model that causes its target to orbit around a point (initially its local origin) |
| observer_ptr | |
| ref_ptr | |
| dtDIS::OutgoingMessage | A framework for translating dtGame::Message instances to PDUs |
| dtTerrain::PagedTerrainTile | This class is the base class for a tile of data |
| dtTerrain::PagedTerrainTileFactory | This class is the base for a simple factory used to create new terrain tiles |
| dtTerrain::PagedTerrainTileLoadState | This enumeration defines the different states a tile could be in throughout its lifetime |
| dtTerrain::PagedTerrainTileResourceName | This enumeration is used to identity built in resources that the terrain tiles are aware of |
| dtABC::PairRefPtrWithNameCompare< T > | Compares a pair, but assumes the 2nd type is a referenced pointer |
| dtHLAGM::ParameterToParameter | |
| dtHLAGM::ParameterToParameterList | |
| dtHLAGM::ParameterTranslator | |
| dtHLAGM::ParameterValue | A DIS/RPR-FOM parameter value |
| dtCore::ParticleLayer | |
| dtCore::ParticleSystem | A particle system |
| dtActors::ParticleSystemActorProxy | This proxy wraps the ParticleSystem Delta3D object |
| dtABC::PathPoint | |
| dtABC::PathPointConverter | |
| dtCore::Physical | A rigid body object which can behave with realistic physical properties |
| dtDAL::PhysicalActorProxy | This proxy wraps the Physical Delta3D object |
| dtAnim::PhysiqueDriver | |
| dtAI::Planner | A game oriented Planner modeled after Jeff Orkin's F.E.A.R Planner |
| dtAI::PlannerConfig | |
| dtAI::PlannerHelper | A class used to interface with the planner |
| dtAI::PlannerNodeLink | The data structure used by the planner for navigating through a plan graph |
| dtAI::PlannerTimer | |
| dtActors::PlayerStartActor | |
| dtActors::PlayerStartActorProxy | |
| dtDIS::PluginManager | Manages a container of available plugins |
| dtCore::PointAxis | Creates a visible xyz axis which can be placed anywhere in the scene |
| dtUtil::PolarDecomp | PolarDecomp is a class that will take a 4x4 Matrix and break it up into the following components Rotation, Scale, and Translation |
| dtCore::PositionalLight | A transformable light |
| dtActors::PositionalLightActorProxy | This proxy wraps the PositionalLight Delta3D object |
| dtDAL::Project | Represents the project directory structure |
| dtABC::ProximityTrigger | The ProximityTrigger class contains a Trigger which it fires whenever a Transformable enters it's bounding shape |
| dtActors::ProximityTriggerActorProxy | This proxy wraps placeable triggers |
| dtDAL::RBodyResourceTypeHandler | Resource type handler for importing, removing, and describing Replicant Body resources |
| dtCore::Recorder< RecordableT, FrameDataT > | A generic utility for recording frame information |
| dtCore::RefPtr< T > | Smart pointer for handling referenced counted objects |
| dtABC::RefPtrWithNameCompare< T > | Compares 2 referenced pointer objects by pointer value and name |
| dtGUI::Renderer | Simple CEGui rendering class based on the CEGUI::OpenGLRender class |
| dtDAL::ResourceActorProperty | This actor property represents a resource |
| dtDAL::ResourceDescriptor | |
| dtDAL::ResourceHelper | This class is a registry of file types with handlers to allow file type specifice resource handling |
| dtUtil::ResourceLoader< ResourceDescriptor, Resource > | |
| dtUtil::ResourceManager< ResourceKey, Resource > | |
| dtDIS::ResourceMapConfig | Structure to maintain the relationship between the DIS::EntityID and the resources available |
| ResourceMessageParameter | |
| dtGUI::ResourceProvider | A simple CEGUI ResourceProvider based on the CEGUI::DefaultResourceProvider |
| dtDAL::ResourceTreeNode | A tree node used when indexing resources |
| dtDAL::ResourceTypeHandler | Pure virtual class that handles a kind of resource |
| dtGame::RestartMessage | |
| RGBAColorMessageParameter | |
| RGBColorMessageParameter | |
| dtHLAGM::RPRAttributeType | |
| dtHLAGM::RPRParameterTranslator | |
| dtCore::Scene | Scene: This class encapsulates the root of the delta scene graph |
| dtCore::Scene::CollisionData | The user data associated with "collision" messages |
| dtCore::Scene::ParticleSystemFreezer | |
| dtScript::ScriptManager | This class assists the user in executing Python scripts from within the C++ Delta3D world |
| dtGUI::ScriptModule | ScriptModule is the binding from CEGUI::Events to specific application callbacks |
| dtUtil::SeamlessNoise | SeamlessNoise is a noise class that creates tileable noise |
| dtUtil::Select< flag, T, U > | |
| dtUtil::Select< false, T, U > | |
| dtAnim::SequenceMixer | The SequenceMixer's job is to manage animations and animation sequences |
| dtUtil::Serializer | A place to implement functions for serialization |
| dtNetGM::ServerConnectionListener | This class is used as an interface to the GNE::Server connection |
| dtGame::ServerLoggerComponent | This is a GameManager component that servers as the primary component for trapping and logging all game messages that progress through the system |
| dtGame::ServerMessageRejected | |
| dtNetGM::ServerNetworkComponent | |
| dtCore::ShaderException | Defines the various exceptions that may be thrown when working with the shaders in the Shader Manager |
| dtCore::ShaderGroup | This class is a container for shaders |
| dtCore::ShaderManager | This class manages the currently loaded and/or active shaders in the current game |
| dtCore::ShaderManager::ActiveNodeEntry | This is a simple structure that holds a connection between an actively shaded node and it's shader instance |
| dtCore::ShaderManager::ShaderCacheEntry | This is a simple structure hold a shader program cache entry |
| dtCore::ShaderParameter | This class wraps parameters that may be passed on to Delta3D shaders |
| dtCore::ShaderParameter::ParamType | This enumeration contains the different types of shader parameters that may exist on a Delta3D shader |
| dtCore::ShaderParameterException | Exceptions a shader parameter may throw |
| dtCore::ShaderParamFloat | This class is a shader parameter containing a single floating point value |
| dtCore::ShaderParamInt | This class is a shader parameter containing a single integer value |
| dtCore::ShaderParamOscillator | This class is a shader parameter that has an oscillating parameter |
| dtCore::ShaderParamOscillator::OscillationTrigger | The type of trigger for this parameter |
| dtCore::ShaderParamOscillator::OscillationType | The type of oscillation for this parameter |
| dtCore::ShaderParamTexture | This class contains the logic and attributes necessary to contain a Texture shader parameter |
| dtCore::ShaderParamTexture2D | This class represents a 2D texture parameter |
| dtCore::ShaderParamTexture::AddressMode | Specifies the different texture addressing or texture wrap modes that can be assigned to this parameter |
| dtCore::ShaderParamTexture::TextureAxis | An enumeration of the four texture axis |
| dtCore::ShaderParamTexture::TextureSourceType | This enumeration defines the different types of sources that may be used for a texture parameter |
| dtCore::ShaderProgram | This class represents a single shader or rendering effect |
| dtCore::ShaderXML | |
| dtDIS::SharedState | The data to be shared among plugins |
| ShortIntMessageParameter | |
| dtAnim::SkeletalDrawable | Renders only the skeleton |
| dtAnim::SkeletalDrawable::IPrimitiveRenderObject::RenderPrimitive | Functor to be used in a loop algorithm |
| dtAnim::SkeletonDriver | |
| dtCore::SkyBox | A six-sided textured cube to represent distant scenery |
| dtCore::SkyBox::AngularMapProfile | This class will use an angular map or light probe to act as a skybox |
| dtCore::SkyBox::AngularMapProfile::UpdateViewCallback | |
| dtCore::SkyBox::ConfigCallback | |
| dtCore::SkyBox::CubeMapProfile | This class will use a 2D ortho quad and lookup into a cubemap to find the texture value |
| dtCore::SkyBox::CubeMapProfile::UpdateViewCallback | |
| dtCore::SkyBox::FixedFunctionProfile | This render profile will render the skybox as usual with the fixed function pipeline |
| dtCore::SkyBox::RenderProfile | Base class to allow the user to choose different ways to render the same scene |
| dtCore::SkyBox::SkyBoxDrawable | This is a custom drawable for the AngularMapProfile and the CubeMapProfile |
| dtActors::SkyBoxActorProxy | This proxy exposes skyboxes to the level editor |
| dtCore::SkyDome | A rendered dome that represents the sky |
| dtActors::SkyDomeActorProxy | This proxy wraps mesh sky domes |
| dtCore::SkyDomeShader | A light scattering pixel shader for use with dtCore::Environment |
| dtTerrain::SoarXCacheResourceName | |
| dtTerrain::SoarXDrawable | This class encapsulates the SoarX rendering algorithm itself |
| dtTerrain::SoarXDrawable::Index | This structure represents a location on the terrain's 2D grid |
| dtTerrain::SoarXDrawable::RawData | This structure is the raw data on disk |
| dtTerrain::SoarXDrawable::Vertex | This is the structure for a single processed vertex in the terrain |
| dtTerrain::SoarXTerrainRenderer | This renderer is an integration/implementation of the SoarX terrain rendering algorithm |
| dtTerrain::SoarXTerrainRenderer::DrawableEntry | This structure represents a drawable tile |
| dtAudio::Sound | DtAudio::Sound |
| dtAudio::Sound::FrameData | Callback function type |
| dtActors::SoundActorProxy | This proxy wraps the Sound Delta3D object |
| dtAudio::SoundEffectBinder | A class that binds audible effects to visual effects |
| dtHLAGM::Spatial | Class for encoding and decoding the RPR 2 spatial structure |
| dtCore::SpotLight | A light that has a position in the scene and also spotlight properties |
| dtActors::SpotlightActorProxy | This proxy wraps the Spotlight Delta3D object |
| dtAnim::SpringDriver | |
| dtABC::State | Base class for allowing the application to switch between different modes such as the splash screen, menu, and the Game |
| dtCore::StateAttributeCollector | |
| dtABC::StateManager | A class to manage State transitions due to an Event |
| dtABC::StateManager::EventType | Event::Type instances to be used by StateManager |
| dtABC::StateManager::TransitionOccurredEvent | An Event class specific to StateManager |
| dtAI::StateVar< _Type > | Utilities for making the use of the Planner even easier |
| dtActors::StaticMeshActorProxy | This proxy represents a static mesh |
| dtCore::StatsHandler | Used by dtABC::Application to render application statistics |
| dtDAL::StringActorProperty | This actor property represents a string data member |
| StringMessageParameter | |
| dtUtil::StringTokenizer< Pred > | |
| dtUtil::StringToXMLConverter | Utility methods for using strings, often for XML purposes |
| dtAnim::SubmeshDirtyCallback | |
| dtAnim::SubmeshDrawable | Adapter that converts cal3d submeshes into osg::Drawables |
| dtAnim::SubmeshLODCullCallback | |
| dtAnim::SubmeshUserData | |
| dtCore::SunlightShader | A light scattering pixel shader for use with dtCore::Environment |
| dtCore::System | Performs high-level frame coordination |
| dtHLAGM::Tag | A Tag type |
| dtUtil::TailAt< InstantiateH< TypeList< T, U >, Holder, i >, 0, i > | |
| dtUtil::TailAt< InstantiateH< TypeList< T, U >, Holder, i >, j, i > | |
| dtCore::TangentSpaceVisitor | This visitor is used to generate tangents for your node |
| dtUtil::TargetTriangle | |
| dtActors::TaskActor | This class is the base task actor in the Delta3D task system |
| dtActors::TaskActorGameEvent | Game event tasks are tasks that are responsible for tracking game events |
| dtActors::TaskActorGameEventProxy | Proxy for the game event task actor |
| dtActors::TaskActorOrdered | This ordered task actor is similar to the rollup task actor with the exception of additional constraints |
| dtActors::TaskActorOrdered::FailureType | This enumeration contains the different types of failures that may result in the rejection of a child task completed out of order |
| dtActors::TaskActorOrderedProxy | Proxy for the game event task actor |
| dtActors::TaskActorProxy | This class is a proxy for the base task actor following the Delta3D game actor design philosophy |
| dtActors::TaskActorRollup | Where as all tasks can contain children, a rollup task actually provides functional behavior centered around that property |
| dtActors::TaskActorRollupProxy | Proxy for the game event task actor |
| dtGame::TaskComponent | This task component is a game manager component responsible for managing a central repository of tasks in a given game or simulation instance |
| dtTerrain::Terrain | This is the base terrain class that provides most of the functionlity required for terrain rendering |
| dtTerrain::TerrainDataReader | This is mostly an interface class to the data reader functionality of Delta3D terrains |
| dtTerrain::TerrainDataReaderException | These exceptions are used by terrain data readers when an error occurs during the load process |
| dtTerrain::TerrainDataRenderer | This class is the interface for a terrain renderer |
| dtTerrain::TerrainDataType | This class defines the various types of terrain data supported by default in Delta3D |
| dtTerrain::TerrainDecorationLayer | This class is a terrain decoration layer |
| dtTerrain::TerrainException | This class enumerates the different exceptions that can be thrown by terrain instances |
| dtTerrain::TerrainRendererException | This enumeration contains generic errors that could occur in terrain renderers |
| dtAI::TGoal< _CostType, _Type > | |
| dtGame::TickMessage | |
| dtGame::TimeChangeMessage | |
| dtCore::Timer | High-level wrapper for osg::Timer |
| dtGame::TimerElapsedMessage | |
| dtAI::TOperator< _Type > | |
| dtInputISense::Tracker | A tracker device |
| dtCore::Transform | |
| dtCore::Transformable | The Transformable class is the base class of anything that can move in the virtual world and can be added to the Scene |
| dtCore::Transformable::CollisionGeomType | We need an enumeration to allow the user to set which type of collision geometry to use |
| dtDAL::TransformableActorProxy | This proxy wraps the Transformable Delta3D object |
| dtUtil::tree< T > | |
| dtUtil::tree_iterator< T > | |
| dtABC::Trigger | |
| dtActors::TriggerActorProxy | This proxy wraps placeable triggers |
| dtCore::Tripod | A Tripod is used to attach a Camera to a Transformable |
| dtActors::TripodActorProxy | This proxy wraps the dtCore::Tripod Delta3D object |
| dtActors::TripodActorProxy::TetherModeEnum | |
| dtUtil::TupleHolder< T, i > | |
| dtUtil::TypeAt< TypeList< T, U >, 0 > | |
| dtUtil::TypeAt< TypeList< T, U >, i > | |
| dtUtil::TypeAtNonStrict< TList, i, DefType > | |
| dtUtil::TypeAtNonStrict< TypeList< T, U >, 0, DefType > | |
| dtUtil::TypeAtNonStrict< TypeList< T, U >, i, DefType > | |
| dtUtil::TypeList< T, U > | |
| dtUtil::TypeTraits< U > | |
| dtCore::UFOMotionModel | A motion model that simulates the action of flying in a UFO |
| dtUtil::UnboundHelper< Incoming, IdsTL > | |
| dtUtil::UnboundTL2< TL, IdsTL > | |
| dtCore::UniqueId | Conforms to OSF DCE 1.1 |
| UnsignedCharMessageParameter | |
| UnsignedIntMessageParameter | |
| UnsignedLongIntMessageParameter | |
| UnsignedShortIntMessageParameter | |
| UserInterface | Do not create directly - use dtCore::GUI instead |
| dtDIS::ValueMap | Name scope for all sorts of mappings |
| dtDAL::Vec2ActorProperty | This actor property represents a vector data member with 2 values |
| dtDAL::Vec2dActorProperty | This actor property represents a vector data member with 2 values |
| Vec2dMessageParameter | |
| dtDAL::Vec2fActorProperty | This actor property represents a vector data member with 2 values |
| Vec2fMessageParameter | |
| Vec2MessageParameter | |
| dtDAL::Vec3ActorProperty | This actor property represents a vector data member with 3 values |
| dtDAL::Vec3dActorProperty | This actor property represents a vector data member with 3 values |
| Vec3dMessageParameter | |
| dtDAL::Vec3fActorProperty | This actor property represents a vector data member with 3 values |
| Vec3fMessageParameter | |
| Vec3MessageParameter | |
| dtDAL::Vec4ActorProperty | This actor property represents a vector data member with 4 values |
| dtDAL::Vec4dActorProperty | This actor property represents a vector data member with 4 values |
| Vec4dMessageParameter | |
| dtDAL::Vec4fActorProperty | This actor property represents a vector data member with 4 values |
| Vec4fMessageParameter | |
| Vec4MessageParameter | |
| dtTerrain::VegetationDecorator | This class is the vegetation decorator layer |
| dtTerrain::VegetationException | Defines the exception used by the vegetation decorator |
| dtHLAGM::VelocityVector | A DIS/RPR-FOM velocity vector type |
| dtCore::View | |
| dtCore::WalkMotionModel | A motion model that simulates the action of walking or driving |
| dtAI::Waypoint | This class encapsulates a Vec3 as a position and is a place holder for other potential data someone might want to store in a waypoint |
| dtAI::WaypointActor | This class is used as the actor for a WaypointActorProxy its positional data is used to save the actual waypoint data it is also the class used to interface between and the WaypointManager |
| dtDAL::WaypointActorProxy | An actor proxy for Waypoint |
| dtAI::WaypointCostFunc | This class is used to compute the cost between two DataType's, for us this DataType is const Waypoint* |
| dtAI::WaypointIter | This is an example of how to use class AStar for generic path finding |
| dtAI::WaypointManager | A static class which manages all waypoints |
| dtAI::WaypointNode | This is the NodeType derivative used by the AStar class |
| dtAI::WaypointPair | A WaypointPair is used to represent a pair of waypoints where the path between them is traversable |
| dtABC::Weather | High level controls for representing weather |
| dtABC::Widget | Widget class to handle all dtCore rendering for the application |
| dtABC::WinData | WinData struct for passing window handle and dimensions |
| dtABC::WinRect | WinRect struct for passing window dimensions |
| dtHLAGM::WorldCoordinate | A DIS/RPR-FOM world coordinate type |
| dtAI::WorldState | |
| dtUtil::XercesErrorHandler | Logs Xerces parsing errors |
| dtUtil::XercesParser | A class to unify the usage of Xerces parsing |
| dtUtil::XercesWriter | A class that manages one XML DOM document |
| dtDIS::XMLFiles | Constant definitions for the official schema files |
| dtUtil::XMLStringConverter | Utility methods for using strings, often for XML purposes |
2.0.0
generated 14 Feb 2008