Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | Related Pages

NeoEngine Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
AABBAxis-aligned bounding box
ActivatorSimple 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
AnimatedNodeAnimated scene node An animated scene node extends the basic scene node with node animator control
AnimatedSubMeshA vertex animated submesh
AnimationAn animation is a collection of ordered keyframes
AnimatorControllerAn animator controller manages animations for an object
AxisAngleRotation expressed as axis-angle
BaseVisitableBase class for the visitable objects This class should be inherited by the base class in an hierarchy of visitable classes
BaseVisitorStrawman 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
BitParserRead bits from a stream A bitstream parser, capable of reading up to 0 to 32 bits from a stream in one method call
BlendModeData describing a blend mode
BoneData 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
BoneAdaptorAdaptor between bone and scene node An adaptor allowing scene nodes to be attached to bones
BoneInfluenceData for bone influences for a weighted vertex
BoundingVolumeBase class for bounding volumes All bounding objects (AABB, OBB, Sphere, Capsule) inherit from this base class, and implement specific collision and intersection tests
BufferReference counted buffers
BufferFileEmulate 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)
BufferFileStreamBufStream 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
CameraMain camera abstraction class. Use for rendering
CapsuleCapsule bounding volume
ColorColor abstraction Color represented by 4 float (32 bit), RGBA order
Color32Color 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::Color32UnionUnion for easy access as unsigned int or unsigned char[]
ConfigConfiguration 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
ConfigCallbackCallback 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
ConfigValueConfiguration data for a single key
ConsoleDropdown 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)
ConsoleCmdData for a command A console command is identified with a string (case sensetive) and matched to a callback object, receiving the command and arguments
ConsoleCmdCallbackCallback 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
ContactCollision detection contact data Used for returning collision detection contact results
ContactNodeNode in contact directed acyclic graph
ContactSetData defining a set of collision detection contact data Used for collision detection
CoreCore engine object
DiffuseTexVertexBasic vertex with position, a 2-dim texture coordinate and diffuse color
DiffuseVertexBasic vertex with position and diffuse color
DirectoryDirectory 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
EdgePrimitive 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
EulerAnglesEuler angles and order
FileOS 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
FileCodecLoads custom file data from a package
FileManagerPackage and file manager
FileTemplateData 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
FiletypeIdentifierBase class for file type identifier A file type identifier identifies file type from data and file name
FontFont abstraction. Loads, prints and other methods
FontCharacterData for a single character in font
FontManagerA collection of fonts
FrameCallbackCallback 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
FrustumBasic frustum data container
HashStringHashed 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)
HashTableHash 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
HashTableNodeHash table node template The hash table node is a container object for the key string and the data object
HierarchyNodeBase 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
ImageCodecLoads image file data
ImageDataRaw image data with optional mipmaps
InputDeviceInput event generator
InputEntityInterface 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
InputEventData for a single input event
InputGroupGroup of input objects for easy management
InputManagerCollects input from devices and distributes to groups
KeyframeAnimation keyframe base class
LightDynamic 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
LineData defining a 3D line Class defining a line in 3D
LoadableEntityInterface 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
LogErrorCallbackSimple 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
LogFileSinkFile 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
LogLevelStream 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
LogLevelPopLog manipulator popping log level Manipulator popping and restoring log level from the stack
LogLevelPushLog 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
LogManipulatorLog manipulator
LogMSVCDebugSinkLog sink for MSVC++ debugger
LogSinkBase 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
LogSourceThe 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
LogSourceStreamBufStream buffer for the log source Internal class, engine users probably shouldn't need to ever use this class
LogStdoutSinkStdout 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
MassParticleMass particle abstraction Simulate mass particle physics. A mass particle has a mass but no (infinetesimal) volume
MassParticleStateState data for a mass particle object
MaterialMaterial abstraction
Matrix4x4 matrix Simple 4x4 matrix class with useful math operations
MeshA blueprint for a mesh
MeshEntityAn instance of a mesh in a scene A mesh scene entity, an instance of a mesh
ModuleLoadable 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
ModuleDynamicModule abstraction layer for dynamically linked modules
ModuleManagerManages 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
ModuleStaticModule abstraction layer for statically linked modules
MutexLockSimple 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:
MutexObjectMutex object for thread safe programming
NodeAnimationAn animation for a node
NodeAnimatorControllerAnimator controller for scene nodes
NodeKeyframeData for a node keyframe A node keyframe holds rotation and translation data
NormalDiffuseTexVertexBasic vertex class with position, normal, diffuse and a 2-dim texture coordinate
NormalDiffuseVertexBasic vertex class with position, normal and diffuse color data
NormalTexVertexBasic vertex class with position, normal and a 2-dim texture coordinate
NormalVertexBasic vertex class with position and normal data
OBBGeneral bounding-box class
ODEBase class for ODE calculations Used primarily in physics simulation classes
OrthographicProjectionData describing orthographic projection mode
PackageFile management in packages A package can both contain real files and virtual files (read from package file)
ParticleAllocatorCallbackCallback class for particle generation Will be called by generator for allocating particles
ParticleGeneratorBase class for particle generators Generate particles for a particle system
ParticleSystemParticle system Manage system of particles
ParticleSystem::ParticleSubSystemAn array of a fixed numer of particles
PatchSurfaceDataData defining a patch object (for example a bezier patch)
PatchSurfaceSubMeshDerived shard created from a patch surface
PatchSurfaceTesselatorTesselator for patch surfaces
PerlinImagePerlin Noise image generation class
PerlinNoisePerlin Noise generation class
PerspectiveProjectionData describing perspective projection mode
PhysicsManagerManager of rigidbody nodes in a scene
PhysicsNodeBase class for all physics nodes Base class with methods for physic simulation objects
PhysicsNodeStateState date for a physics node
PixelBufferPixel buffer for offscreen rendering Pixelbuffers are used for render-to-texture effects. Create a pixelbuffer through the render device method CreatePixelBuffer
Plane3D plane Class describing a 3D plane
PointerSmart 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
PolygonPolygon abstraction class (triangles only)
PolygonBufferBuffer 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::AdjacencyDataAdjacency data for triangles Used in stripification process
PolygonStripBufferTriangle polygon strip buffer class Triangle strip buffers hold data for a single triangle strip
PoolPool 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
PoolNodePool node template The pool table node is a container object for the key string and the data objects associated with the key
ProfileDataData 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
ProfileManagerManager 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
ProgramPipeline 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)
ProgramParamPipeline program parameter definition
ProgramParam::ProgramParamValue
ProjectionData describing a projection mode
QuadraticBezierPatchTesselatorSpecialized tesselator for quadratic bezier patch surfaces
QuaternionUnit quaternion Simple unit quaternion class with useful math operations
RadixSortRadix 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
RayData defining a 3D ray Class defining a ray in 3D
RefCounterBase 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
RenderAdapterDevice and/or OS specific data for a render adapter
RenderCapsDescribe capabilities for a render device
RenderDeviceRender device
RenderEntityInterface 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)
RenderPrimitiveRender batch data Data for a single render operation
RenderResolutionData for a rendering area resolution
RenderWindowDevice and/or OS specific data for window
RigidBodyRigidbody physics simulation class Simulate a rigid body physics
RigidBodyStateState data for a rigid body
RoomScene 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
RoomManagerRoom manager The room manager creates rooms and loads extension modules on demand
RoomPartitionNodeBase class for space paritioning
SceneEntityBase 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
SceneNodeBase 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
ShadowGeneratorShadow 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
ShadowOpShadow primitive operation Storage object for shadow primitive operations, used by render callback for each active light object in the scene
SkeletalSubMeshDerived shard with bone weighted vertices for skeletal animation
SkeletonMaster class controlling a hierachy of bones A skeleton is a hierarchy of bone nodes with a single root
SkeletonAnimationA skeleton animation consists of a node animation object for each channel (bone)
SkeletonAnimatorControllerAnimator controller for skeletons
SkinAn array of bone weights defining a skin
SkinVertexInfluences for a weighted vertex in a skin
SkyBoxWrapper class for skybox rendering
SkyDomeWrapper class for skydome rendering
SocketAbstract interface for network sockets
SocketCallbackCallback method for socket events
SphereBase class for a 3D sphere
SphereParticleGeneratorParticle generator, spherical generation volume Generate particles in spherical outbursts
SpriteA sprite always faces the camera, but can have size, position and rotation around viewing axis
SRTNodeBase 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
StencilShadowGeneratorShadow generator using stencil buffer Generates self-shadowing dynamic shadows using the stencil buffer (support for stencil buffer must be present in render device)
SubMeshA chunk of polygons of same material
SubMeshAnimationAn animation for a submesh
SubMeshAnimatorControllerAnimator controller for submeshes
SubMeshKeyframeData for a submesh keyframe A submesh keyframe holds a vertex buffer
TaskManagerManaging tasks in threads
TCPSocketTCP/IP implementation of socket interface
TerrainHeightmapHeightmap 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
TerrainManagerManages modules for external terrain implementations
TextureTexture class
TextureLayerData for a single texture layer Base for texture in materials. Also used for multi-texturing
TextureLoaderBase loader for textures Loads texture files and returns raw data for device to process
TextureMatrixGenGenerator for texture coordinate effects in texture layers
TextureMatrixGenFactoryCreate texture generator objects from name
TextureMatrixGenRotateGenerator for rotation texture coordinate effects in texture layers
TextureMatrixGenScaleGenerator for scaling texture coordinate effects in texture layers
TextureMatrixGenScrollGenerator for scrolling texture coordinate effects in texture layers
TextureMatrixGenStretchGenerator for stretching texture coordinate effects in texture layers
TextureMatrixGenTransformGenerator for general transform texture coordinate effects in texture layers
TextureMatrixGenTurbulenceGenerator for turbulence texture coordinate effects in texture layers
TexVertexBasic vertex class with position and one 2-dim texture coordinate
ThreadThread abstraction class
ThreadCallbackCallback class for thread event notification
ThreadMethodMethod for entry point for thread execution
TimerTimer 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
UDPSocketUDP implementation of socket interface
UpdateEntityInterface 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
Vector3d3D vector Simple 3D vector class with useful math operations
VertexBasic vertex class with position data
VertexBufferVertex storage in buffer Vertex buffer with flexible format, with possible agp/video ram storage managed by device
VertexDeclarationComplete declaration of a vertex Complete declaration of a vertex format. All elements must be declared in offset order
VertexElementData describing a single element in a vertex declaration
ViewportData for a viewport
VirtualFileVirtual 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
VirtualFileTemplateData for a file in directory/package hierarchy
VisitorThis template is to define concrete visitors for each visitable type
ZBufferModeData describing a Z buffer mode

Generated on Wed Jan 21 14:21:09 2004 for NeoEngine by doxygen 1.3.5