AABB | Axis-aligned bounding box |
Activator | Simple class for activator control, use virtual inheritance Used by any objects that need to keep track of activated/deactivated state. Use virtual inheritance to avoid multiple base objects in inheritance lattice. Remember to call base methods in overridden methods. A class only needs to overload the Activate and Deactivate methods |
AnimatedNode | Animated scene node An animated scene node extends the basic scene node with node animator control |
AnimatedSubMesh | A vertex animated submesh |
Animation | An animation is a collection of ordered keyframes |
AnimatorController | An animator controller manages animations for an object |
AxisAngle | Rotation expressed as axis-angle |
BaseVisitable | Base class for the visitable objects This class should be inherited by the base class in an hierarchy of visitable classes |
BaseVisitor | Strawman visitor class. All visitors have to inherit from this class. This class is intended to add RTTI info to all visitor subclasses and a polymorphically correct destruction sequence. And most important, it allows to use dynamic_cast to solve the identification |
BitParser | Read bits from a stream A bitstream parser, capable of reading up to 0 to 32 bits from a stream in one method call |
BlendMode | Data describing a blend mode |
Bone | Data defining a single bone A bone is a simple node in a hierarchy (a skeleton). Bones are managed by skeleton, and must belong to a single master skeleton object. A skeleton can only have a single root bone |
BoneAdaptor | Adaptor between bone and scene node An adaptor allowing scene nodes to be attached to bones |
BoneInfluence | Data for bone influences for a weighted vertex |
BoundingVolume | Base class for bounding volumes All bounding objects (AABB, OBB, Sphere, Capsule) inherit from this base class, and implement specific collision and intersection tests |
Buffer | Reference counted buffers |
BufferFile | Emulate File object on data buffer A buffer file implements file operations on an arbitrary memory buffer. This can be useful if you want to load resources from data embedded in your application, you can then create a BufferFile object and pass to all classes and methods accepting a File object for loading (all classes that are derived LoadableEntity supports loading from a File object) |
BufferFileStreamBuf | Stream buffer implementation for buffered files Stream buffer that reads and writes to a memory, used by BufferFile to provide the stream buffer interface for the stream |
Camera | Main camera abstraction class. Use for rendering |
Capsule | Capsule bounding volume |
Color | Color abstraction Color represented by 4 float (32 bit), RGBA order |
Color32 | Color abstraction in device native format storage, accessible through RGBA order Color represented by 32 bit unsigned int (8 bit unsigned char per element), RGBA (A high bit, R low bit) or BGRA (A high bit, B low bit) storage order. Access to components are always made through RGBA order with red as component 0 and alpha as component 3 |
Color32::Color32Union | Union for easy access as unsigned int or unsigned char[] |
Config | Configuration data repository Configuration can be loaded from a file through the loadable entity interface. The configuration repository will by default listen to the "set" and "showconfig" console commands, and the core config repository object will automatically register the commands with the core console object when the core is initialized |
ConfigCallback | Callback interface for config change notifications To use a config change callback, derive from this class and implement interface method, and pass object of derived class to register method in configuration repository object |
ConfigValue | Configuration data for a single key |
Console | Dropdown console for easy debugging A console is a semi-transparent quad rendered in orthographic mode displaying the debug output sent to it. A console also has a prompt that supports registering commands (and default fallback) |
ConsoleCmd | Data for a command A console command is identified with a string (case sensetive) and matched to a callback object, receiving the command and arguments |
ConsoleCmdCallback | Callback interface for console command processing To use a console command callback, derive from this class and implement interface method, and pass object of derived class to register method in console object |
Contact | Collision detection contact data Used for returning collision detection contact results |
ContactNode | Node in contact directed acyclic graph |
ContactSet | Data defining a set of collision detection contact data Used for collision detection |
Core | Core engine object |
DiffuseTexVertex | Basic vertex with position, a 2-dim texture coordinate and diffuse color |
DiffuseVertex | Basic vertex with position and diffuse color |
Directory | Directory abstraction A directory can contain files and other directories, and is the base class for packages. Each directory contains templates for all files, and the actual File objects gets allocated on request, the GetByName or GetAllFiles methods |
Edge | Primitive class for edges An edge is simply two connected vertices. Object of this class will be used in meshes to precaclulate edges and their dependencies for use in shadow volume generation. This class only holds two indices into some vertex array the owner will have to implement (probably indices into a VertexBuffer), a polygon (index into a polygon array) and some internal flags. An edge is shared by two polygons, we do not allow non-manifold meshes |
EulerAngles | Euler angles and order |
File | OS independant file wrapper with useful operations The File class gives access to a file in the file system, and abstracts away all platform and architecture specific issues for reading and writing. You can access a little/big endian file from a little/big endian system with no changes to your code. You can use the DetermineByteOrder method to support different endian versions of your data files on different systems (loading a little endian file on a little endian system is faster than a big endian file, and vice versa for big endian systems). The file class supports methods for reading and writing bytes, shorts, integers and strings, as well as raw byte arrays. It also has the standard printf and scanf style methods for easy text parsing |
FileCodec | Loads custom file data from a package |
FileManager | Package and file manager |
FileTemplate | Data for a file in directory/package hierarchy A file template holds information about a file in the directory/package hierarchy, and is responsible for allocating File objects on request. Specific implementations for normal and package files can then allocate the spcific class for the type of the requested file. For example, a file in a compressed package will be allocated of type VirtualFile, while a file in the normal file system will be of the base File type. With this construct the directory/package class does not need to know about the which implementation of the file type that needs to be allocated on request |
FiletypeIdentifier | Base class for file type identifier A file type identifier identifies file type from data and file name |
Font | Font abstraction. Loads, prints and other methods |
FontCharacter | Data for a single character in font |
FontManager | A collection of fonts |
FrameCallback | Callback interface for frame listeners Use frame callbacks to listen for frame rendering events, such as frame completion, or to be called for each light active in the frame |
Frustum | Basic frustum data container |
HashString | Hashed version of std::string for faster comparision The HashString stores a hash of the string for fast early-out comparision with other hashed strings by comparing the hash, and only if equal compare the actual string data. Overloads some useful operations of std::string but not all, if you need to access the string data directly, remember to call HashMe() if you modify it (not needed if you simply read from it, naturally) |
HashTable | Hash table template Hash table storing pointers to objects of template type. The hash table never deletes any pointers stored in the hash table. Use the GetAllNodeData to get all the pointers stored if you want to delete the data objects |
HashTableNode | Hash table node template The hash table node is a container object for the key string and the data object |
HierarchyNode | Base class for node hierarchies A hierarchy node is the building block of a node tree. Derived from the SRT node for basic capabilities, extended with hierarchy data (one parent, mutliple children). World data is cached and updated when needed by overloading SRT node methods and flagging for invalid caches |
ImageCodec | Loads image file data |
ImageData | Raw image data with optional mipmaps |
InputDevice | Input event generator |
InputEntity | Interface for objects processing input Input entites receive input events from the master InputGroup object the entity is attached to. Derived from Activator for easy on/off management. A deactivated input entity will not receive any events from the master InputGroup object |
InputEvent | Data for a single input event |
InputGroup | Group of input objects for easy management |
InputManager | Collects input from devices and distributes to groups |
Keyframe | Animation keyframe base class |
Light | Dynamic light object Dynamic lights are scene entities. The Render method will register the light as active with the render device for this frame, allowing bounding volume culling of light entities |
Line | Data defining a 3D line Class defining a line in 3D |
LoadableEntity | Interface for object which can be loaded A loadable entity can load its data from a file. Derived classes only needs to implement the LoadNode method, file locating/opening/closing is handled automatically by the this base class Load methods |
LogErrorCallback | Simple callback interface for monitoring error log messages Callback method is called by the log source object every time a log messages of level ERROR or more severe is parsed |
LogFileSink | File log sink The file sink writes log messages to a file specified or provided to the constructor. Messages are written per-line. For an example, look at the documentation for the logstream.h file |
LogLevel | Stream manipulator for the LogSource class Sets the loglevel state for the stream. Once a loglevel state is set, it will remain until it is changed, so it is not necessary to use this loglevel manipulator for every logging call. For an example, look at the documentation for the logstream.h file |
LogLevelPop | Log manipulator popping log level Manipulator popping and restoring log level from the stack |
LogLevelPush | Log manipulator pushing log level Manipulator pushing the current log level onto the stack and settings a new log level. Use PopLogLevel class to pop and restore stored level from the stack |
LogManipulator | Log manipulator |
LogMSVCDebugSink | Log sink for MSVC++ debugger |
LogSink | Base class for different log targets A log sink is attached to a log source and given a certain loglevel threshold. Whenever messages are sent to the log source by the program or the engine, the log source forwards it to all the attached log sinks that are listening for that loglevel threshold. The engine provides a number of sinks by default, the stdout sink (LogStdoutSink), the file sink (LogFileSink) and the console sink (Console). For an example, look at the documentation for the logstream.h file |
LogSource | The log source object Contains a loglevel state and a number of data sinks for logging output, each with a loglevel threshold. When it is given output to log, it gives that output to all sinks that will accept logs equal to the current loglevel state or higher. For an example, look at the documentation for the logstream.h file |
LogSourceStreamBuf | Stream buffer for the log source Internal class, engine users probably shouldn't need to ever use this class |
LogStdoutSink | Stdout log sink The stdout sink writes log messages to the stdout stream (cout) For an example, look at the documentation for the logstream.h file |
MassParticle | Mass particle abstraction Simulate mass particle physics. A mass particle has a mass but no (infinetesimal) volume |
MassParticleState | State data for a mass particle object |
Material | Material abstraction |
Matrix | 4x4 matrix Simple 4x4 matrix class with useful math operations |
Mesh | A blueprint for a mesh |
MeshEntity | An instance of a mesh in a scene A mesh scene entity, an instance of a mesh |
Module | Loadable module object A module is an abstraction of a loadable library Abstracts all platform-specific issues and allows easy query for symbols available in the loaded module |
ModuleDynamic | Module abstraction layer for dynamically linked modules |
ModuleManager | Manages loadable modules The module manager keeps track of search paths for modules and the loaded modules for quick access. An object wanting to load a module should do so through a ModuleManager interface, preferrably the module manager in the core object |
ModuleStatic | Module abstraction layer for statically linked modules |
MutexLock | Simple class for automatic locking/unlocking mutex object Makes it easier to manage a mutex lock by automatic lock on creation and unlock on destruction. An example: |
MutexObject | Mutex object for thread safe programming |
NodeAnimation | An animation for a node |
NodeAnimatorController | Animator controller for scene nodes |
NodeKeyframe | Data for a node keyframe A node keyframe holds rotation and translation data |
NormalDiffuseTexVertex | Basic vertex class with position, normal, diffuse and a 2-dim texture coordinate |
NormalDiffuseVertex | Basic vertex class with position, normal and diffuse color data |
NormalTexVertex | Basic vertex class with position, normal and a 2-dim texture coordinate |
NormalVertex | Basic vertex class with position and normal data |
OBB | General bounding-box class |
ODE | Base class for ODE calculations Used primarily in physics simulation classes |
OrthographicProjection | Data describing orthographic projection mode |
Package | File management in packages A package can both contain real files and virtual files (read from package file) |
ParticleAllocatorCallback | Callback class for particle generation Will be called by generator for allocating particles |
ParticleGenerator | Base class for particle generators Generate particles for a particle system |
ParticleSystem | Particle system Manage system of particles |
ParticleSystem::ParticleSubSystem | An array of a fixed numer of particles |
PatchSurfaceData | Data defining a patch object (for example a bezier patch) |
PatchSurfaceSubMesh | Derived shard created from a patch surface |
PatchSurfaceTesselator | Tesselator for patch surfaces |
PerlinImage | Perlin Noise image generation class |
PerlinNoise | Perlin Noise generation class |
PerspectiveProjection | Data describing perspective projection mode |
PhysicsManager | Manager of rigidbody nodes in a scene |
PhysicsNode | Base class for all physics nodes Base class with methods for physic simulation objects |
PhysicsNodeState | State date for a physics node |
PixelBuffer | Pixel buffer for offscreen rendering Pixelbuffers are used for render-to-texture effects. Create a pixelbuffer through the render device method CreatePixelBuffer |
Plane | 3D plane Class describing a 3D plane |
Pointer | Smart pointer template for reference counted classes Reference counted objects MUST be accessed through smart pointers at all times to make sure reference counting scheme operates correctly. Failure to do so will result in strange and unpredictable behaviour and crashes. The smart pointer class takes care of reference counting management at creation, destruction and assignement of pointers, and lets the reference counting scheme correctly free objects that are no longer referenced |
Polygon | Polygon abstraction class (triangles only) |
PolygonBuffer | Buffer for storing polygons (triangles) A polygon buffer holds data for a number of polygons (triangles) and optionally a strip, material and vertex buffer. Polygon buffers are managed and reference counted |
PolygonBuffer::AdjacencyData | Adjacency data for triangles Used in stripification process |
PolygonStripBuffer | Triangle polygon strip buffer class Triangle strip buffers hold data for a single triangle strip |
Pool | Pool template A pool is a hash table with mutliple objects per key. For more detailed description of the properties, read the HashTable documentation concerning the management and non-deletion principle of the data |
PoolNode | Pool node template The pool table node is a container object for the key string and the data objects associated with the key |
ProfileData | Data for a profile block A profiling block contains data for an execution block. It is identified by name and has data of total execution time and number of times the block has been executed. A profiling block can have any number of child blocks and a single parent block, arranging the blocks in a tree structure. This way relative percentages can be calculated to see where most of the time in a block is spent |
ProfileManager | Manager for profile data The profile manager keeps track of all profiling blocks, the current block and the total execution time. It can be activated and rendered onscreen from the console with the "<b>showprofile</b>" command, all profile block data can be reset to zero with the "<b>resetprofile</b>" command, and all data cleared with the "<b>clearprofile</b>" command. To start a profiling block you use the BEGIN_PROFILE( name ) macro, and to end the block you use the END_PROFILE() macro. You must match all begin calls with end calls. It is (naturally) not possible to overlap blocks, since the END_PROFILE macro closes the latest activated block. If the _PROFILE preprocessor symbol is not defined, the BEGIN/END macros resolve to a nothing, making it easy to turn on/off profiling at build time |
Program | Pipeline program Base class for pipeline programs, real implementation created by render device The program expects source code in format compatible with the target for the type of program that the render device selects during initialization. Programs are reference counted and should always be accessed through a smart pointer. When a program is loaded from file, the name of the program is automatically set to the base file name (i.e without extension) |
ProgramParam | Pipeline program parameter definition |
ProgramParam::ProgramParamValue | |
Projection | Data describing a projection mode |
QuadraticBezierPatchTesselator | Specialized tesselator for quadratic bezier patch surfaces |
Quaternion | Unit quaternion Simple unit quaternion class with useful math operations |
RadixSort | Radix sorter (original implementation by Pierre Terdiman, http://www.codecorner.com) Radix sorter that can sort signed/unsigned 32-bit integers, signed/unsigned 64-bit integers and floats. To use the sorted, pass the desired data type to the constructor and then Sort(), passing the pointer to your data (of the same type as you passed to the ctor) and number of elements in the array to sort. To access the sorted indices you use GetIndices() which will return a pointer to an index array for the sorted elements. This means the radix sorter does not modify your original data array, but gives you and index array allowing you to access the objects in sorted order |
Ray | Data defining a 3D ray Class defining a ray in 3D |
RefCounter | Base reference counter Used by all objects that are managed through smart pointers Once reference count reaches zero, deletes itself. You must NEVER delete a reference counted object directly! All access to a reference counted object MUST be done through the smart pointer interface as offered by the Pointer template class |
RenderAdapter | Device and/or OS specific data for a render adapter |
RenderCaps | Describe capabilities for a render device |
RenderDevice | Render device |
RenderEntity | Interface for renderable objects A renderable object overloads and implements the Render method, optionally using the base Render method to use the automatic check for redundant multiple render calls per frame. This base class keeps track of the last frame the object was rendered, and if already rendered the current frame, the base Render method will return false (otherwise true) |
RenderPrimitive | Render batch data Data for a single render operation |
RenderResolution | Data for a rendering area resolution |
RenderWindow | Device and/or OS specific data for window |
RigidBody | Rigidbody physics simulation class Simulate a rigid body physics |
RigidBodyState | State data for a rigid body |
Room | Scene management base class A room is the top-level class for scene management, capable of holding both static geometry and dynamic objects through the scene graph capabilities in SceneNode |
RoomManager | Room manager The room manager creates rooms and loads extension modules on demand |
RoomPartitionNode | Base class for space paritioning |
SceneEntity | Base class for entities in a scene graph A scene entity is an object in the scene graph, contained by scene nodes. The entity itself does not hold SRT data, that is stored in the parent scene node object. A scene entity can be anything that can be described as an object in a scene graph, such as meshes, lights, skyboxes. A scene entity has base methods for updating and rendering, as well as a collision detection interface |
SceneNode | Base class for hierarchies in a scene graph A scene node is the building block of a scene graph. Derived from the SRT node for basic capabilities, extended with hierarchy data (one parent, mutliple children). World data is cached and updated when needed by overloading SRT node methods and flagging for invalid caches. A scene node can contain an entity, which can be anything from a mesh, a light or a sprite to a forcefield or other modifier. With this container-entity relationship we can allow for derived scene node objects (such as a physics-controlled particle or rigid-body) to hold all kinds of entities. A scene node is derived from Activator and can thus be activated/deactivated. A deactivated node will turn off calls to Update and Render for the entire subtree with that node as root |
ShadowGenerator | Shadow generator A shadow generator processes input geometry and generates a shadow. Implementations can range from simple projected blobs to render-to-texture projected shadow textures and stencil buffer shadows |
ShadowOp | Shadow primitive operation Storage object for shadow primitive operations, used by render callback for each active light object in the scene |
SkeletalSubMesh | Derived shard with bone weighted vertices for skeletal animation |
Skeleton | Master class controlling a hierachy of bones A skeleton is a hierarchy of bone nodes with a single root |
SkeletonAnimation | A skeleton animation consists of a node animation object for each channel (bone) |
SkeletonAnimatorController | Animator controller for skeletons |
Skin | An array of bone weights defining a skin |
SkinVertex | Influences for a weighted vertex in a skin |
SkyBox | Wrapper class for skybox rendering |
SkyDome | Wrapper class for skydome rendering |
Socket | Abstract interface for network sockets |
SocketCallback | Callback method for socket events |
Sphere | Base class for a 3D sphere |
SphereParticleGenerator | Particle generator, spherical generation volume Generate particles in spherical outbursts |
Sprite | A sprite always faces the camera, but can have size, position and rotation around viewing axis |
SRTNode | Base class for hierarchy objects A SRT node contains data for scaling, rotation and translation, and core methods for modification and queries. Derived classes can implement hierarchies by overloading the SetScaling, SetRotation and SetTranslation methods and calculate world cache data |
StencilShadowGenerator | Shadow generator using stencil buffer Generates self-shadowing dynamic shadows using the stencil buffer (support for stencil buffer must be present in render device) |
SubMesh | A chunk of polygons of same material |
SubMeshAnimation | An animation for a submesh |
SubMeshAnimatorController | Animator controller for submeshes |
SubMeshKeyframe | Data for a submesh keyframe A submesh keyframe holds a vertex buffer |
TaskManager | Managing tasks in threads |
TCPSocket | TCP/IP implementation of socket interface |
TerrainHeightmap | Heightmap for terrain pages This object contains the elevation data and various other properties for storing terrain data in memory. Once the heightmap is created, scaling properties cannot be changed and elevation data cannot be changed. Heightmaps are necessarily square in shape, so the size property reflects the number of grid points of one side of it |
TerrainManager | Manages modules for external terrain implementations |
Texture | Texture class |
TextureLayer | Data for a single texture layer Base for texture in materials. Also used for multi-texturing |
TextureLoader | Base loader for textures Loads texture files and returns raw data for device to process |
TextureMatrixGen | Generator for texture coordinate effects in texture layers |
TextureMatrixGenFactory | Create texture generator objects from name |
TextureMatrixGenRotate | Generator for rotation texture coordinate effects in texture layers |
TextureMatrixGenScale | Generator for scaling texture coordinate effects in texture layers |
TextureMatrixGenScroll | Generator for scrolling texture coordinate effects in texture layers |
TextureMatrixGenStretch | Generator for stretching texture coordinate effects in texture layers |
TextureMatrixGenTransform | Generator for general transform texture coordinate effects in texture layers |
TextureMatrixGenTurbulence | Generator for turbulence texture coordinate effects in texture layers |
TexVertex | Basic vertex class with position and one 2-dim texture coordinate |
Thread | Thread abstraction class |
ThreadCallback | Callback class for thread event notification |
ThreadMethod | Method for entry point for thread execution |
Timer | Timer class Used to get delta time between two moments. The timer class abstracts away OS specific implementations and gives you a single interface for timing across all supported platforms. The timer is reset when you first create it, an successive calls to GetDeltaTime() will return the deltatime passed between the calls. If you do not wish to reset the timer when querying for the deltatime, you pass false as argument to GetDeltaTime The timer also has a static heartbeat counter that can be used to synchronize unrelated objects in the game. The heartbeat is reset on application startup and increases as it executes. Use the heartbeat divisor to get the factor of increase |
UDPSocket | UDP implementation of socket interface |
UpdateEntity | Interface for updateable objects An updateable object overloads and implements the Update method for updating the object using the deltatime passed since last call as passed by the caller. Derived from the Activator class for easy on/off management |
Vector3d | 3D vector Simple 3D vector class with useful math operations |
Vertex | Basic vertex class with position data |
VertexBuffer | Vertex storage in buffer Vertex buffer with flexible format, with possible agp/video ram storage managed by device |
VertexDeclaration | Complete declaration of a vertex Complete declaration of a vertex format. All elements must be declared in offset order |
VertexElement | Data describing a single element in a vertex declaration |
Viewport | Data for a viewport |
VirtualFile | Virtual file in package A virtual file exists inside an (optionally compressed) package, and is derived from BufferFile since it acts on a memory buffer. For compressed packages, the data for the file is uncompressed to a memory buffer when the file is opened, and released when the file is closed |
VirtualFileTemplate | Data for a file in directory/package hierarchy |
Visitor | This template is to define concrete visitors for each visitable type |
ZBufferMode | Data describing a Z buffer mode |