Torque 3D 3.8

The following table lists classes in this documentation.

D3DXInclude plugin 
Internal struct used to track Cubemap texture information for FBO attachment 
Internal struct used to track texture information for FBO attachments This serves as an abstract base so we can deal with cubemaps and standard 2D/Rect textures through the same interface 
Internal struct used to track 2D/Rect texture information for FBO attachment 
Use FBOs to render to texture. This is the preferred implementation and is almost always used. 
Internal implementations 
A global table for the hashing and tracking of strings.
Only one _StringTable is ever instantiated in Torque. It is accessible via the global variable StringTable.
StringTable is used to manage strings in Torque. It performs the following tasks:
  • Ensures that only one pointer is ever used for a given string (through insert()).
  • Allows the lookup of a string in the table.

@code // Adding a string to the StringTable. StringTableEntry mRoot; mRoot = StringTable->insert(root);
// Looking up a string in the StringTable. StringTableEntry stName = StringTable->lookupn(name, len... more 
TorqueThreadStatic Base Class 
Auto-registration class and manager of the instances 
Core functionality for class manipulation.
@section AbstractClassRep_intro Introduction (or, Why AbstractClassRep?)
Many of Torque's subsystems, especially network, console, and sim, require the ability to programatically instantiate classes. For instance, when objects are ghosted, the networking layer needs to be able to create an instance of the object on the client. When the console scripting language runtime encounters the "new" keyword, it has to be able to fill that request.
Since standard C++ doesn't provide a function to create a new instance of an arbitrary class at runtime, one must be created. This is what AbstractClassRep and ConcreteClassRep... more 
A polygon filtering interface.
The various AbstractPolyList subclasses are used in Torque as an interface to handle spatial queries. SceneObject::buildPolyList() takes an implementor of AbstractPolyList (such as ConcretePolyList, ClippedPolyList, etc.) and a bounding volume. The function runs geometry data from all the objects in the bounding volume through the passed PolyList.
This interface only provides a method to get data INTO your implementation. Different subclasses provide different interfaces to get data back out, depending on their specific quirks.
The physics engine now uses convex hulls for collision detection.
@see Convex 
This is class AccuCoverageFeature. 
This is class AccuDirectionFeature. 
A volume in space that blocks visibility. 
This is class AccuScaleFeature. 
This is class AccuSpecularFeature. 
This is class AccuStrengthFeature. 
Accu texture 
Accu texture 
Map raw inputs to a variety of actions. This is used for all keymapping in the engine. @see ActionMap::Node 
This is class AdjustHeightAction. 
This is class AdvancedLightBinManager. 
This is class AdvancedLightBufferConditioner. 
This is class AdvancedLightingFeatures. 
This is class AdvancedLightManager. 
This is class AIClient. 
This is class ALDeviceList. 
rotation about an arbitrary axis through the origin: 
This is class AppMesh. 
This is class AppNode. 
This is class AppSequence. 
This is class AppVertConnectorGLSL. 
A data structure holding indexed sequences of key/value pairs for script use. 
Extension to update thread that also does automatic periodic updates. 
This structure keeps track of the objects that need updating. 
Abstract baseclass for async update threads. 
Formerly contained a certificate, showing that something was valid. 
List of available "systems" that the lighting kit can use 
This is class BadWordFilter. 
Helper class to keep track of bans. 
This is class BaseMaterialDefinition. 
Collada geometric primitives: Use the BasePrimitive class to access the different primitive types in a nice way. 
This is class BasicClouds. 
This is class BasicLightManager. 
This is class BasicSceneObjectLightingPlugin. 
This is class BasicSceneObjectPluginFactory. 
This class does bilinear mapping of quadrilateral to a square. 
This is class BiSqrToQuad3D. 
This is class BitfieldConsoleBaseType. 
A matrix of bits.
This class manages an array of bits. There are no limitations on the size of the bit matrix (beyond available memory).
@note This class is currently unused. 
A convenience class to manipulate a set of bits.
Notice that bits are accessed directly, ie, by passing a variable with the relevant bit set or not, instead of passing the index of the relevant bit. 
This is class BitStream. 
Manage a vector of bits of arbitrary size
see BitVector 
This is class BlobShadow. 
This is class blTerrainProxy. 
Lighting system interface 
Clone of Box3F, using 3D types.
3D types use F64.
@see Box3F 
Axis-aligned bounding box (AABB).
A helper class for working with boxes. It runs at F32 precision.
@see Box3D 
Bounding Box
A helper class for working with boxes. It runs at F32 precision.
@see Box3D 
Base class for box geometries. 
This is class BoxBrush. 
This is class Brush. 
This is class BtBody. 
This is class BtCollision. 
This is class BtDebugDraw. 
This is class BtPlayer. 
This is class BtPlayerSweepCallback. 
This is class BtPlugin. 
This is class BtWorld. 
The Bumpmap feature will read the normal map and transform it by the inverse of the worldToTanget matrix. This normal is then used by subsequent shader features. 
The Bumpmap feature will read the normal map and transform it by the inverse of the worldToTanget matrix. This normal is then used by subsequent shader features. 
This is class CachedInterfaceExampleComponent. 
Implements a basic camera object. 
Class: CameraBookmark 
This is class CameraData. 
Abstract camera effect template 
Camera shake effect 
The shared base class used by the catmull rom interpolation template class. @see CatmullRom 
This is class ClearAction. 
This is class ClientProcessList. 
The clipped polylist class takes the geometry passed to it and clips it against the PlaneList set.
It also contains helper functions for @see AbstractPolyList 
This is class CloudLayer. 
Core TorqueScript code management class.
This class represents a block of code, usually mapped directly to a file
Utility class to emit and patch bytecode 
This is class ColladaAppMaterial. 
This is class ColladaAppMesh. 
This is class ColladaAppNode. 
This is class ColladaAppSequence. 
Collada allows custom data to be included with many elements using the tag, followed by one or more named technique profiles. eg. value0value1 ... value0value1 ...
This class provides an easy way to read the custom parameters into a strongly typed subclass. 
Extensions for the element 
Extensions for the element (and its children) 
Extensions for the element 
Extensions for the element 
This is class CollisionList. 
This is class ColorF. 
-------------------------------------- ColorI's are missing some of the operations present in ColorF since they cannot recover properly from over/underflow. 
CodeReview [patw, 2, 14, 2007] This really should be a ref-counted object 
This class is just designed to isolate the functionality of querying for, and managing interfaces. 
An undo action that is comprised of other undo actions. 
A concrete, renderable PolyList
This class is used to store geometry from a PolyList query.
It allows you to render this data, as well.
@see AbstractPolyList 
This is class ConditionerFeature. 
ShaderDependancy that allows shadergen features to add a dependency on a conditioner method 
This event is used inside by the connection and subclasses to message itself when sequencing events occur. Right now, the message event only uses 6 bits to transmit the message, so 
The base class for Torque's networking protocol.
This implements a sliding window connected message stream over an unreliable transport (UDP). It provides a simple notify protocol to allow subclasses to be aware of what packets were sent succesfully and which failed.
Basically, a window size of 32 is provided, and each packet contains in the header a bitmask, acknowledging the receipt (or failure to receive) of the last 32 packets.
@see NetConnection, @ref NetProtocol 
Maintain a table of strings which are shared across the network.
This allows us to reference strings in our network streams more efficiently. 
Information about a console type. 
This is the backend for the ConsoleMethod()/ConsoleFunction() macros.
See the group ConsoleConstructor Innards for specifics on how this works.
@see @ref console_autodoc @nosubgrouping 
A class designed to be used as a console consumer and log the data it receives to a file
Interface class to the console.
@section ConsoleObject_basics The Basics
Any object which you want to work with the console system should derive from this, and access functionality through the static interface.
This class is always used with the DECLARE_CONOBJECT and IMPLEMENT_* macros.
@code // A very basic example object. It will do nothing! class TorqueObject : public ConsoleObject { // Must provide a Parent typedef so the console system knows what we inherit from. typedef ConsoleObject Parent;
// This does a lot of menial declaration for you. DECLARE_CONOBJECT(TorqueObject);
// This is for us to register our fields in.... more 
Utility class to save and restore the current console stack frame 
This is class ConsoleValue. 
Proxy class for console variables Can point to existing console variables, or act like a free floating value
New console value stack 
This is class ConvexEditorCreateTool. 
This is class ConvexEditorTool. 
This is class ConvexShape. 
Crap name, but whatcha gonna do. 
This is class CoverPoint. 
Creator tree from old editor. Not used in current editor. 
A sampler backend that outputs samples to a CSV file
This is class CubeLightShadowMap. 
A script interface for creating static or dynamic cubemaps. 
This is class CubeReflector. 
Custom Material 
Implements a chunked data allocator.
Calling new/malloc all the time is a time consuming operation. Therefore, we provide the DataChunker, which allocates memory in blocks of chunkSize (by default 16k, see ChunkSize, though it can be set in the constructor), then doles it out as requested, in chunks of up to chunkSize in size.
It will assert if you try to get more than ChunkSize bytes at a time, and it deals with the logic of allocating new blocks and giving out word-aligned chunks.
Note that new/free/realloc WILL NOT WORK on memory gotten from the DataChunker. This... more 
Decal Datablock Delete Undo Actions 
This is class DbgFileView. 
Decal Datablock Retarget Undo Actions 
Debug output class.
This class provides you with a flexible means of drawing debug output. It is often useful when debugging collision code or complex 3d algorithms to have them draw debug information, like culling hulls or bounding volumes, normals, simple lines, and so forth. In TGE1.2, which was based directly on a simple OpenGL rendering layer, it was a simple matter to do debug rendering directly inline.
Unfortunately, this doesn't hold true with more complex rendering scenarios, where render modes and targets may be in abritrary states. In addition, it is often useful to be able to freeze... more 
DataBlock implementation for decals. 
This is the data file for decals. Not intended to be used directly, do your work with decals via the DecalManager
DecalInstance represents a rendering decal in the scene. You should not allocate this yourself, add new decals to the scene via the DecalManager. All data is public, change it if you wish, but be sure to inform the DecalManager
Manage decals in the scene. 
DecalRoad Class 
DecalRoadNodeEvent Class 
DecalRoadNodeListNotify Class 
This is class DecalRoadUpdateEvent. 
A bounding sphere in world space and a list of DecalInstance(s) contained by it. DecalInstance(s) are organized/binned in this fashion as a lookup and culling optimization. 
! DecOp - Declaration Operation - Used when declaring a variable in a shader feature. It will automatically print the type of the variable and then the variable name. If a shader feature set up code like:
Var *foo = new Var; foo->setType( "float" ); foo->setName( "foo" ); LangElement *fooDecl = new DecOp( foo );
LangElement *statement = new GenOp( " @ = 8.0 * 5.0;", fooDecl );
The output in the shader file would be:
@code float foo = 8.0 * 5.0; @endcode 
The DedicatedWindowMgr is for Dedicated servers, which may not even have graphics hardware. However, the WindowManager is referenced (indirectly) by scripts, and therefore must exist. 
This is class DefaultPlatformTimer. 
This is used during the 
This is used during the 
Generates specular highlights in the forward pass from the light prepass buffer. 
Generates specular highlights in the forward pass from the light prepass buffer. 
This class is used to write PNGs in row batches 
Lights the pixel by sampling from the light prepass buffer. It will fall back to forward lighting functionality for non-deferred rendered surfaces.
Also note that this feature is only used in the forward rendering pass. It is not used during the prepass step. 
Lights the pixel by sampling from the light prepass buffer. It will fall back to forward lighting functionality for non-deferred rendered surfaces.
Also note that this feature is only used in the forward rendering pass. It is not used during the prepass step. 
This is class DemoNetInterface. 
This is class DepthOutGLSL. 
This is class DepthOutHLSL. 
Helper class for GFXDevice::describeResources
This is class DeselectAction. 
Detail map 
Detail map 
Decal Instance Create Undo Actions 
This is class Dictionary. 
Decal Instance Delete Undo Actions 
Diffuse color 
Diffuse color 
Base texture 
Base texture 
Diffuse vertex color 
Diffuse vertex color 
This is class DInputDevice. 
This is class DisplayPtrManager. 
Dynamic Library Interface for library objects loaded using the loadLibrary() function. 
This is class DualParaboloidLightShadowMap. 
brief Implements the duDebugDraw interface in Torque
This is class DXT5nmSwizzle. 
This is class DXT5nmSwizzleUp24t32. 
Early out check PolyList
This class is used primarily for triggers and similar checks. It checks to see if any of the geometry you feed it is inside its area, and if it is, it stops checking for any more data and returns a true value. This is good if you want to know if anything is in your "trigger" area, for instance.
@see AbstractPolyList 
the ease methods below all are static and take atomic types as params so they are the most generally useful. for convenience, define here a type that can contain all the params needed for below to make data structures that use these methods cleaner... 
This is class EaseF. 
! Like the name suggests, EchoOp merely echoes back whatever string it is assigned. 
This class is used to find the correct icon file path for different SimObject class types. It is typically used by the editors. 
This is class EditTSCtrl. 
This is class EllipseBrush. 
Information about the return and argument types of a function type. 
Singleton class that uses the C runtime memory routines for allocating objects. 
Table of values for an enumeration or bitfield type. 
Information about an entity exported by the engine API. This is an abstract base class. 
A group of engine exports. 
Table of fields for a struct type. 
A function exported by the engine for interfacing with the control layer.
A function can either be a call-in, transfering control flow from the control layer to the engine, or a call-out, transfering control flow from the engine to the control layer.
All engine API functions use the native C (@c cdecl) calling convention.
Be aware that there a no implicit parameters to functions. This, for example, means that methods will simply list an object type parameter as their first argument but otherwise be indistinguishable from other functions.
Variadic functions are supported.
@section engineFunction_strings String Arguments and Return Values... more 
Base class for all objects that may be passed to the control layer.
A set of rules applies to all EngineObject-derived classes:
  • Every EngineObject class must have a default constructor.
  • The default constructor and the destructor of every EngineObject class must be public.
  • If an EngineObject class inherits from multiple classes, the class leading back to EngineObject must be the @b first class in the list to ensure binary-compatible class layouts.
  • EngineObjects are cooperatively reference-counted by both the engine as well as the control layer.
Read-only properties only have a getXXX and no setXXX method. Static properties (value shared by all instances) don't take a 'this' parameter. 
Information about an engine type.
This class is used to store run-time type information about engine types.
Once created, type info objects must persist for the entire duration the engine is running.
All types are implicitly export scopes and may thus contain other exports within them. 
This is class EnumConsoleBaseType. 
The EventManager class is a wrapper for the standard messaging system. It provides functionality for management of event queues, events, and subscriptions.
Creating an EventManager is as simple as calling new EventManagerand specifying a queue name.
Example Usage:
@code // Create the EventManager. $MyEventManager = new EventManager() { queue = "MyEventManager"; };
// Create an event. $MyEventManager.registerEvent( "SomeCoolEvent" );
// Create a listener and subscribe. $MyListener = new ScriptMsgListener() { class = MyListener; }; $MyEventManager.subscribe( $MyListener, "SomeCoolEvent" );
function MyListener::onSomeCoolEvent( %this, %data ) { echo( "onSomeCoolEvent Triggered" ); }
// Trigger the event.... more 
Listener class used by the EventManager to dispatch messages to specific callbacks. 
Event for cleanup 
Thread for executing in 
This is class ExplodePrefabUndoAction. 
This is class ExprEvalState. 
List to keep track of GameBases to process. 
This is class ExtendedMoveList. 
This is class ExtendedMoveManager. 
This is class ExtendedServerProcessList. 
Extruded Polytope PolyList
This class is used primarily for collision detection, by objects which need to check for obstructions along their path. You feed it a polytope to extrude along the direction of movement, and it gives you a list of collisions.
@see AbstractPolyList 
This is class EyeSpaceDepthOutGLSL. 
This is class EyeSpaceDepthOutHLSL. 
This is class FFMaterialParameterHandle. 
FieldBrushObject for static-field copying/pasting. 
This is class File. 
This is class FileChunkEvent. 
@ingroup SystemDialogs FileDialog is a platform agnostic dialog interface for querying the user for file locations. It is designed to be used through the exposed scripting interface.
FileDialog is the base class for Native File Dialog controls in Torque. It provides these basic areas of functionality:
  • Inherits from SimObject and is exposed to the scripting interface
  • Provides blocking interface to allow instant return to script execution
  • Simple object configuration makes practical use easy and effective

@attention FileDialog is *NOT* intended to be used directly in script and is only exposed to script to expose generic file dialog attributes. @see... more 
This is class FileDownloadRequestEvent. 
This is class FileName. 
This is class FileObject. 
This is class FileStream. 
This is class FileStreamObject. 
This is class Filter. 
This is class FilterStream. 
This is class FindMatch. 
This is class FontRenderBatcher. 
Basically the same as RenderMeshMgr, but will override the material of the instance. 
This is class ForestBrushElement. 
This is class ForestBrushTool. 
This is class ForestBrushToolEvent. 
This is class ForestCellBatch. 
This is class ForestConvex. 
This is class ForestCreateUndoAction. 
This is the data file for Forests. 
This is class ForestDeleteUndoAction. 
This is class ForestEditorCtrl. 
This is class ForestItem. 
This is class ForestItemData. 
This is class ForestItemSelection. 
This is class ForestSelectionTool. 
This is class ForestTool. 
This is class ForestUndoAction. 
This is class ForestUpdateAction. 
This is class ForestWind. 
This simple class holds the state of the accumulated wind effect for a single tree. 
This is class ForestWindEmitter. 
This is class ForestWindMgr. 
Temporary memory pool for per-frame allocations.
In the course of rendering a frame, it is often necessary to allocate many small chunks of memory, then free them all in a batch. For instance, say we're allocating storage for some vertex calculations:
@code // Get FrameAllocator memory... U32 waterMark = FrameAllocator::getWaterMark(); F32 * ptr = (F32*)FrameAllocator::alloc(sizeof(F32)*2*targetMesh->vertsPerFrame);
... calculations ...
// Free frameAllocator memory FrameAllocator::setWaterMark(waterMark); @endcode 
Helper class for simulate lock/unlock on gfx buffers using FrameAllocator 
Helper class to deal with FrameAllocator usage.
The purpose of this class is to make it simpler and more reliable to use the FrameAllocator. Simply use it like this:
@code FrameAllocatorMarker mem;
char *buff = (char*)mem.alloc(100); @endcode
When you leave the scope you defined the FrameAllocatorMarker in, it will automatically restore the watermark on the FrameAllocator. In situations with complex branches, this can be a significant headache remover, as you don't have to remember to reset the FrameAllocator on every posssible branch. 
Floating point min/max range validator 
This is class FreeListChunkerUntyped. 
This class implements a view frustum for use in culling scene objects and rendering the scene.
@warn Frustums are always non-inverted by default which means that even if the frustum transform applies a negative scale, the frustum will still be non-inverted. 
Class: fxFoliageCulledList 
Class: fxFoliageItem 
Class: fxFoliageQuadNode 
Class: fxFoliageRenderList 
Class: fxFoliageReplicator 
Class: fxShapeReplicatedStatic 
Class: fxShapeReplicator 
Base class for game objects which use datablocks, networking, are editable, and need to process ticks.
@section GameBase_process GameBase and ProcessList
GameBase adds two kinds of time-based updates. Torque works off of a concept of ticks. Ticks are slices of time 32 milliseconds in length. There are three methods which are used to update GameBase objects that are registered with the ProcessLists:
This is class GameConnection. 
This class manages shader constant data in a system memory buffer. It is used by device specific classes for batching together many constant changes which are then copied to the device thru a single API call.
@see GenericConstBufferLayout 
This class defines the memory layout for a GenericConstBuffer
! GenOp - General Operation - Very useful for combining several variables into one LangElement statement. It uses an elipses as a parameter, so it can take as many variables as you can throw at it. It takes a string and parses it for the '@' symbol which it replaces with passed in parameters. Similar to the C statement printf(). Here's an example:
@code ( assuming three variables var1, var2, var3 exist and their assigned names are var1Name, var2Name, and var3Name )
LangElement *statement = new GenOp( " @ = @ * @.x + @.y;", var1, var1, var2, var3 );... more 
This is class GFont. 
GFXCardProfiler provides a device independent wrapper around both the capabilities reported by the card/drivers and the exceptions recorded in various scripts.
See the Torque Scripting Manual for more details. 
A reference counted handle to a cubemap resource. 
This is class GFXD3D9CardProfiler. 
Cube map 
This is class GFXD3D9OcclusionQuery. 
This is class GFXD3D9PrimitiveBuffer. 
This is class GFXD3D9QueryFence. 
The D3D9 implementation of a shader. 
This is class GFXD3D9ShaderBufferLayout. 
The D3D9 implementation of a shader constant buffer. 
The D3D9 implementation of a shader constant handle
This is class GFXD3D9StateBlock. 
GFX D3D Texture Manager 
This is class GFXD3D9TextureObject. 
You shouldn't use this class directly... use the following macros:
GFXDevice is the TSE graphics interface layer. This allows the TSE to do many things, such as use multiple render devices for multi-head systems, and allow a game to render in DirectX 9, OpenGL or any other API which has a GFX implementation seamlessly. There are many concepts in GFX device which may not be familiar to you, especially if you have not used DirectX. @n Buffers There are three types of buffers in GFX: vertex, index and primitive. Please note that index buffers are not accessable outside the GFX layer, they are wrapped by primitive buffers. Primitive... more 
A class that hold a simple set of device stats. 
Helper class containing utility functions for useful drawing routines (line, box, rect, billboard, text). 
This is class GFXFrustumSaver. 
This is class GFXGLAppleFence. 
A note on workarounds - The following settings are used exclusively to work around driver bugs: GL::Workaround::needsExplicitGenerateMipmap GL::Workaround::X1600DepthBufferCopy GL::Workaround::HD2600DepthBufferCopy If you find that you need to work around additional driver bugs, add a new setting of the form GL::Workaround::and set it to false in GFXGLCardProfiler::setupCardCapabilities() Enclose your workaround code in if(GFX->getCardProfiler()->queryProfile("GL::Workaround::")) { } Remember to set the work around to true in the card profile script! 
This is class GFXGLCubemap. 
This is class GFXGLDevice. 
This is class GFXGLOcclusionQuery. 
Simple class which preserves a given GL integer. This class determines the integer to preserve on construction and restores it on destruction. 
This is class GFXGLPreserveTexture. 
This is a primitive buffer (index buffer to GL users) which uses VBOs. 
Register this device with GFXInit 
This is class GFXGLShader. 
This is class GFXGLShaderConstBuffer. 
This is class GFXGLShaderConstHandle. 
This is class GFXGLStateBlock. 
GFXGLStateCache store OpenGL state to avoid performance penalities of glGet* calls GL_TEXTURE_1D/2D/3D, GL_FRAMEBUFFER, GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER 
This is class GFXGLTextureManager. 
This is class GFXGLTextureObject. 
Render to texture support for OpenGL. This class needs to make a number of assumptions due to the requirements and complexity of render to texture in OpenGL. 1) This class is only guaranteed to work with 2D textures or cubemaps. 3D textures may or may not work. 2) This class does not currently support multiple texture targets. Regardless of how many targets you bind, only Color0 will be used. 3) This class requires that the DepthStencil and Color0 targets have identical dimensions. 4) If the DepthStencil target is GFXTextureTarget::sDefaultStencil, then the Color0 target should be the same size as the... more 
This is a vertex buffer which uses GL_ARB_vertex_buffer_object. 
This is class GFXGLVertexDecl. 
This is class GFXGLWindowTarget. 
Interface for tracking GFX adapters and initializing them into devices. @note Implement this class per platform. @note This is just a class so it can be friends with GFXDevice
This class is used to interact with an API's fixed function lights. See GFX->setLight 
This is class GFXNullCardProfiler. 
This is class GFXNullCubemap. 
This is class GFXNullDevice. 
This is class GFXNullPrimitiveBuffer. 
Register this device with GFXInit 
This is class GFXNullTextureManager. 
This is class GFXNullTextureObject. 
This is class GFXNullVertexBuffer. 
This is class GFXNullWindowTarget. 
A geometry visibility query object. @see GFXDevice::createOcclusionQuery 
Handle for GFXOcclusionQuery than store last valid state 
This is class GFXPCD3D9Device. 
Register this device with GFXInit 
This is class GFXPCD3D9TextureTarget. 
This is class GFXPCD3D9WindowTarget. 
This is class GFXPrimitiveBuffer. 
This is class GFXPrimitiveBufferHandle. 
Mixin for the purpose of tracking GFX resources owned by a GFXDevice.
There are many types of resource that are allocated from a GFXDevice that must be participatory in device resets. For instance, all default pool DirectX resources have to be involved when the device resets. Render targets in all APIs need to unbind themselves when resets happen.
This system is also handy for accounting purposes. For instance, we may want to traverse all registered VBs, IBs, Textures, or RTs in order to determine what, if any, items are still allocated. This can be used in leak reports, memory... more 
Allows definition of sampler state via script, basically wraps a GFXSamplerStateDesc 
GFXShaderConstBuffer is a collection of shader data which are sent to the device in one call in most cases.
The content of the buffer is persistant and if a value does not change frequently there is a savings in not setting the value every frame. 
This is an opaque handle used by GFXShaderConstBuffer clients to set individual shader constants. Derived classes can put whatever info they need into here, these handles are owned by the shader constant buffer (or shader). Client code should not free these. 
This is class GFXStateBlock. 
Allows definition of render state via script, basically wraps a GFXStateBlockDesc 
Base class for a target to which GFX can render.
Most modern graphics hardware supports selecting render targets. However, there may be multiple types of render target, with wildly varying device-level implementations, resource requirements, and so forth.
This base class is used to represent a render target; it might be a context tied to a window, or a set of surfaces or textures. 
A reference counted handle to a texture resource. 
This is class GFXTextureManager. 
This is class GFXTextureObject. 
This is class GFXTextureProfile. 
Helper struct for gathering profile stats. 
A render target associated with one or more textures.
Although some APIs allow directly selecting any texture or surfaces, in some cases it is necessary to allocate helper resources to enable RTT operations.
@note A GFXTextureTarget will retain references to textures that are attached to it, so be sure to clear them out when you're done!
@note Different APIs have different restrictions on what they can support here. Be aware when mixing cubemaps vs. non-cubemaps, or targets of different resolutions. The devices will attempt to limit behavior to things that are safely portable, but they cannot catch every possible situation... more 
Helper class to store viewport and matrix stack state, and restore it later.
When doing complex out-of-scene rendering, for instance, doing a render to texture operation that needs its own transform state, it is very easy to nuke important rendering state, like the viewport or the projection matrix stored in vertex shader constant zero.
This class simplifies save and cleanup of those properties. You can either treat it as a stack helper, e.g.
@code void myFunc() { GFXTransformSaver saver;
// Lots of nasty render state changes...
// Everything is magically cleaned up when saver is destructed! } @endcode
Or you... more 
GFXVertexBuffer - base vertex buffer class 
This is a non-typed vertex buffer handle which can be used when your vertex type is undefined until runtime. 
This is class GFXVertexColor. 
This is a simple wrapper for the platform specific vertex declaration data which is held by the vertex format.
If your using it... you probably shouldn't be.
@see GFXVertexFormat 
The element structure helps define the data layout for GFXVertexFormat.
@see GFXVertexFormat 
The vertex format structure usually created via the declare and implement macros.
You can use this class directly to create a vertex format, but note that it is expected to live as long as the VB that uses it exists.
@see GFXDeclareVertexFormat @see GFXImplementVertexFormat @see GFXVertexElement 
A render target associated with an OS window.
Various API/OS combinations will implement their own GFXTargets for rendering to a window. However, they are all subclasses of GFXWindowTarget.
This allows platform-neutral code to safely distinguish between various types of render targets (using dynamic_cast<>), as well as letting it gain access to useful things like the corresponding PlatformWindow
This is class GhostAlwaysObjectEvent. 
This class contains code for rendering and manipulating a 3D gizmo, it is usually used as a helper within a TSEdit-derived control.
The Gizmo has a MatrixF transform and Point3F scale on which it will operate by passing it Gui3DMouseEvent(s).
The idea is to set the Gizmo transform/scale to that of another 3D object which is being manipulated, pass mouse events into the Gizmo, read the new transform/scale out, and set it to onto the object. And of course the Gizmo can be rendered.
Gizmo derives from SimObject only because this allows its properties to be initialized directly from... more 
This is class GLCircularVolatileBuffer. 
This is class GLFenceRange. 
This is class GLOrderedFenceRangeManager. 
Special feature used to mask out the RGB color for non-glow passes of glow materials. @see RenderGlowMgr 
Special feature used to mask out the RGB color for non-glow passes of glow materials. @see RenderGlowMgr 
This is class GridInfo. 
This is class GroundCover. 
This defines one grid cell. 
This is class GroundCoverShaderConstHandles. 
A virtually infinite XY ground plane primitive.
For rendering, a subset of the plane spanning the view frustum is generated and rendered. Tesselation is determined by the given squareSize property.
For collision detection, a finite bounding box is used to deal with finite precision of floating-point operations (we can't use floating-point infinity as infinity*0 is undefined.)
The ground plane can be textured like regular geometry by assigning a material name to its 'material' property. UVs mirror grid coordinates so that when using UV wrapping, textures will tile nicely. 
Renders a grid of cells. 
A control that automatically scrolls its child control upwards. 
Renders a background, so you can have a backdrop for your GUI. 
Renders a skinned border. 
A button control that uses bitmaps as its different button states.
Set 'bitmap' console field to base name of bitmaps to use. This control will
append '_n' for normal append '_h' for highlighted append '_d' for depressed append '_i' for inactive
If a bitmap cannot be found it will use the default bitmap to render.
Additionally, a bitmap button can be made to react to keyboard modifiers. These can be either CTRL/CMD, ALT, or SHIFT (but no combination of them.) To assign a different bitmap for a modifier state, prepend "_ctrl", _"alt", or "_shift" to the state postfix.
To implement... more 
Extension of GuiBitmapButtonCtrl that also display a text label on the button. 
Renders a bitmap. 
This is class GuiBorderButtonCtrl. 
A single-line text control that displays its text in a multi-line popup when clicked. 
Base class for all button controls. Subclasses are mostly for specific rendering types. 
This is class GuiButtonCtrl. 
A canvas on which rendering occurs.
@section GuiCanvas_contents What a GUICanvas Can Contain...
@subsection GuiCanvas_content_contentcontrol Content Control A content control is the top level GuiControl for a screen. This GuiControl will be the parent control for all other GuiControls on that particular screen.
@subsection GuiCanvas_content_dialogs Dialogs
A dialog is essentially another screen, only it gets overlaid on top of the current content control, and all input goes to the dialog. This is most akin to the "Open File" dialog box found in most operating systems. When you choose to open a file, and the "Open File" dialog... more 
A checkbox button. 
This is class GuiChunkedBitmapCtrl. 
Vary basic HUD clock. Displays the current simulation time offset from some base. The base time is usually synchronized with the server as mission start time. This hud currently only displays minutes:seconds. 
This control draws a box containing a color specified by mPickColor, in a way according to one of the PickMode enum's, stored as mDisplayMode.
The color the box represents is stored as mBaseColour (for pPallete, pBlendColorRange), whilst the color chosen by the box is stored as mPickColor.
Whenever the control is clicked, it will do one of many things :
-# If its in pPallete mode, execute the regular "command" -# If its in pBlendColorRange mode, update the selector position. The position will be re-read upon the next render. In addition, a cross will be drawn... more 
This is class GuiConsole. 
This is class GuiConsoleEditCtrl. 
This is class GuiConsoleTextCtrl. 
Base class for controls that act as containers to other controls.
@addtogroup gui_container_group Containers
@ingroup gui_group Gui System 
@addtogroup gui_core_group Core @section GuiControl_Intro Introduction
GuiControl is the base class for GUI controls in Torque. It provides these basic areas of functionality:
@ref GUI has an... more 
This is class GuiControlArrayControl. 
A GuiControlProfile is used by every GuiObject and is akin to a datablock. It is used to control information that does not change or is unlikely to change during execution of a program. It is also a level of abstraction between script and GUI control so that you can use the same control, say a button, and have it look completely different just with a different profile. 
This is class GuiConvexEditorCtrl. 
This is class GuiConvexEditorUndoAction. 
Vary basic cross hair hud. Uses the base bitmap control to render a bitmap, and decides whether to draw or not depending on the current control object and it's state. If there is ShapeBase object under the cross hair and it's named, then a small health bar is displayed. 
This is class GuiCursor. 
This is class GuiDecalEditorCtrl. 
This is class GuiDecoyCtrl. 
This is class GuiDirectoryFileListCtrl. 
A special control that implements drag-and-drop behavior. 
This is class GuiDynamicCtrlArrayControl. 
Control to visualize an EaseF
Native side of the GUI editor. 
A control that fades a bitmap in and out. 
This is class GuiFileTreeCtrl. 
This is class GuiFilterCtrl. 
@addtogroup gui_container_group Containers
@ingroup gui_group Gui System 
A gui control allowing a window to be subdivided into panes, each of which displays a gui control child of the GuiFrameSetCtrl. Each gui control child will have an associated FrameDetail through which frame-specific details can be assigned. Frame-specific values override the values specified for the entire frameset.
Note that it is possible to have more children than frames, or more frames than children. In the former case, the extra children will not be visible (they are moved beyond the visible extent of the frameset). In the latter case, frames will be empty.
If a frameset had two columns... more 
class GuiGameListMenuCtrl A base class for cross platform menu controls that are gamepad friendly. 
class GuiGameListMenuProfile A gui profile with additional fields specific to GuiGameListMenuCtrl
class GuiGameListOptionsCtrl A control for showing pages of options that are gamepad friendly. 
class GuiGameListOptionsProfile A gui profile with additional fields specific to GuiGameListOptionsCtrl
This is class GuiGradientSwatchCtrl. 
This is class GuiGraphCtrl. 
A basic health bar control. This gui displays the damage value of the current PlayerObjectType control object. The gui can be set to pulse if the health value drops below a set value. This control only works if a server connection exists and it's control object is a PlayerObjectType. If either of these requirements is false, the control is not rendered. 
This is class GuiHealthTextHud. 
The GuiIconButtonCtrl draws an icon and text caption within a normal button control with several layout options. 
This is class GuiIdleCamFadeBitmapCtrl. 
This is class GuiImageList. 
A control that locks the mouse and reports all keyboard input events to script. This is useful for implementing custom keyboard handling code. 
A control that allows to edit the properties of one or more SimObjects. 
This is class GuiInspectorCustomField. 
GuiInspectorDatablockField - custom field type for datablock enumeration 
This is class GuiInspectorDynamicField. 
This is class GuiInspectorDynamicGroup. 
The GuiInspectorField control is a representation of a single abstract field for a given ConsoleObject derived object. It handles creation getting and setting of it's fields data and editing control.
Creation of custom edit controls is done through this class and is dependent upon the dynamic console type, which may be defined to be custom for different types.
@note GuiInspectorField controls must have a GuiInspectorGroup as their parent. 
The GuiInspectorGroup control is a helper control that the inspector makes use of which houses a collapsible pane type control for separating inspected objects fields into groups. The content of the inspector is made up of zero or more GuiInspectorGroup controls inside of a GuiStackControl 
This is class GuiInspectorTypeBitMask32. 
This is class GuiInspectorTypeBitMask32Helper. 
GuiInspectorTypeCheckBox Class 
This is class GuiInspectorTypeColor. 
TypeColorF GuiInspectorField Class 
TypeColorI GuiInspectorField Class 
TypeCommand GuiInspectorField Class 
TypeCubemapName GuiInspectorField Class 
TypeEaseF GuiInspectorField Class 
TypeEnum GuiInspectorField Class 
TypeFileName GuiInspectorField Class 
GuiInspectorTypeGuiProfile Class 
TypeImageFileName GuiInspectorField Class 
This is class GuiInspectorTypeMaterialName. 
A base class for other inspector field types which wish to display a popup/dropdown menu. 
TypeName GuiInspectorField Class 
TypePrefabFilename GuiInspectorField Class 
TypeRectUV GuiInspectorField Class 
This is class GuiInspectorTypeRegularMaterialName. 
TypeS32 GuiInspectorField class 
TypeSFXAmbienceName GuiInspectorField Class 
TypeSFXDescriptionName GuiInspectorField Class 
TypeSFXEnvironmentName GuiInspectorField Class 
TypeSFXParameterName GuiInspectorField Class 
TypeSFXSourceName GuiInspectorField Class 
TypeSFXStateName GuiInspectorField Class 
TypeSFXTrackName GuiInspectorField Class 
TypeShapeFilename GuiInspectorField Class 
TypeTerrainMaterialIndex GuiInspectorField Class 
TypeTerrainMaterialName GuiInspectorField Class 
This is class GuiInspectorVariableField. 
This is class GuiInspectorVariableGroup. 
This is class GuiListBoxCtrl. 
This is class GuiMaterialPreview. 
This is class GuiMenuBackgroundCtrl. 
This is class GuiMeshRoadEditorCtrl. 
This is class GuiMeshRoadEditorUndoAction. 
Render a MessageVector (chat HUD)
This renders messages from a MessageVector; the important thing here is that the MessageVector holds all the messages we care about, while we can destroy and create these GUI controls as needed. (For instance, Tribes 2 used seperate GuiMessageVectorCtrl controls in the different HUD modes.) 
This is class GuiMissionAreaCtrl. 
This is class GuiMissionAreaEditorCtrl. 
This is class GuiMissionAreaUndoAction. 
This is class GuiMLTextCtrl. 
This is class GuiMLTextEditCtrl. 
This is class GuiMouseEventCtrl. 
This is class GuiNavEditorCtrl. 
This is class GuiNavEditorUndoAction. 
A control that displays a TSShape in its view. 
This is class GuiOffscreenCanvas. 
Collapsable pane control.
This class wraps a single child control and displays a header with caption above it. If you click the header it will collapse or expand. The control resizes itself based on its collapsed/expanded size.
In the GUI editor, if you just want the header you can make collapsable false. The caption field lets you set the caption. It expects a bitmap (from the GuiControlProfile) that contains two images - the first is displayed when the control is expanded and the second is displayed when it is collapsed. The header is sized based off of... more 
The GuiPanel panel is a container that when opaque will draw a left to right gradient using its profile fill and fill highlight colors.
@addtogroup gui_container_group Containers
@ingroup gui_group Gui System 
This is class GuiParticleGraphCtrl. 
This is class GuiPlatformGenericMenuBar. 
This is class GuiPopUpBackgroundCtrl. 
This is class GuiPopUpBackgroundCtrlEx. 
This is class GuiPopUpMenuCtrl. 
This is class GuiPopUpMenuCtrlEx. 
This is class GuiPopupTextListCtrl. 
This is class GuiPopupTextListCtrlEx. 
A control that renders a horizontal progress bar from a repeating bitmap image. 
This is class GuiProgressCtrl. 
the radio button renders exactly the same as the check box the only difference is it sends messages to its siblings to turn themselves off. 
This is class GuiRectHandles. 
This is class GuiRiverEditorCtrl. 
This is class GuiRiverEditorUndoAction. 
This is class GuiRoadEditorCtrl. 
This is class GuiRoadEditorUndoAction. 
A container with an optional header that allows its child control to be collapsed using an animated effet. 
This is class GuiScriptNotifyCtrl. 
A control providing a window inside a larger client area which can be scrolled using scrollbars. 
Renders a separator line with optional text. 
This is class GuiShapeEdPreview. 
Displays name & damage above shape objects.
This control displays the name and damage value of all named ShapeBase objects on the client. The name and damage of objects within the control's display area are overlayed above the object.
This GUI control must be a child of a TSControl, and a server connection and control object must be present.
This is a stand-alone control and relies only on the standard base GuiControl
A slider control that selects out of a floating-point value range. 
A Speedometer control. This gui displays the speed of the current Vehicle based control object. This control only works if a server connection exists and its control object is a vehicle. If either of these requirements is false, the control is not rendered. 
@addtogroup gui_container_group Containers
@ingroup gui_group Gui System 
A stack of GUI controls.
This maintains a horizontal or vertical stack of GUI controls. If one is deleted, or resized, then the stack is resized to fit. The order of the stack is determined by the internal order of the children (ie, order of addition). 
This is class GuiSubmenuBackgroundCtrl. 
A color swatch button. 
Tab Book Control for creation of tabbed dialogs
@see GUI for an overview of the Torque GUI system.
@section GuiTabBookCtrl_Intro Introduction
GuiTabBookCtrl is a container class that holds children of type GuiTabPageCtrl
GuiTabBookCtrl creates an easy to work with system for creating tabbed dialogs allowing for creation of dialogs that store a lot of information in a small area by separating the information into pages which are changeable by clicking their page title on top or bottom of the control
tabs may be aligned to be on top or bottom of the book and are changeable while the GUI editor... more 
This is class GuiTabPageCtrl. 
This is class GuiTerrPreviewCtrl. 
This is class GuiTextCtrl. 
This is class GuiTextEditCtrl. 
This is class GuiTextEditSliderBitmapCtrl. 
This is class GuiTextEditSliderCtrl. 
This is class GuiTextListCtrl. 
Control to play back a Theora video file
This Gui Control is designed to be subclassed to let people create controls which want to receive update ticks at a constant interval. This class was created to be the Parent class of a control which used a DynamicTexture along with a VectorField to create warping effects much like the ones found in visualization displays for iTunes or Winamp. Those displays are updated at the framerate frequency. This works fine for those effects, however for an application of the same type of effects for things like Gui transitions the framerate-driven update frequency is not desirable because it does not allow... more 
This is class GuiToggleButtonCtrl. 
This is class GuiToolboxButtonCtrl. 
Abstract base class for 3D viewport GUIs. 
This is class GuiVariableInspector. 
@addtogroup gui_container_group Containers
Legacy control. Use GuiWindowCtrl with canCollapse=true.
@deprecated Functionality moved into GuiWindowCtrl.
@ingroup gui_group Gui System 
@addtogroup gui_container_group Containers
@ingroup gui_group Gui System 
This should be the final feature on most pixel shaders which encodes the color for the current HDR target format. @see HDRPostFx @see LightManager @see torque.glsl 
This should be the final feature on most pixel shaders which encodes the color for the current HDR target format. @see HDRPostFx @see LightManager @see torque.hlsl 
List to keep track of GameBases to process. 
This is class HifiMoveList. 
This is class HifiServerProcessList. 
This is class HTTPObject. 
This is class HuffmanProcessor. 
This is class ICallMethod. 
This is class IdGenerator. 
This is class IDisplayDevice. 
This is class IInputDevice. 
This is class ImposterCapture. 
A material hook used to hold imposter generation rendering materials for an object. 
Special feature for unpacking imposter verts. @see RenderImposterMgr 
Special feature for unpacking imposter verts. @see RenderImposterMgr 
This class acts to provide an "infinitely extending" stream.
Basically, it does what ResizeBitStream does, but it validates on every write op, so that you never have to worry about overwriting the buffer. 
Handles input device plug-ins 
This is class InspectorFieldUndoAction. 
This is class InstancingMaterialHook. 
Interface for objects that need continuous explicit updates from an outside source. 
Interface for structures that represent processes. 
CodeReview : Input can come from a number of places to end up in torque, but in the torque world we don't want to expose this information to the user. This interface bridges the gap between other input devices working details and input as torque understands it. Thoughts? [7/6/2007 justind] 
Signed integer min/max range validator 
Scaled integer field validator
@note This should NOT be used on a field that gets exported - the field is only validated once on initial assignment 
This is class IRenderable3D. 
Interface for structures that allow their state to be reset
When the scene is queried for lights, the light manager will get this interface to trigger a register light call. 
This is class ISolid3D. 
This interface is used to provide the amount of bytes actually written/read when using the stream as a file. The Stream interface does not provide this information. This is a lame workaround. 
This interface allows you to let any object be ticked. You use it like so: @code class FooClass : public SimObject, public virtual ITickable { // You still mark SimObject as Parent typdef SimObject Parent; private: ...
protected: // These three methods are the interface for ITickable virtual void interpolateTick( F32 delta ); virtual void processTick(); virtual void advanceTime( F32 timeDelta );
public: ... }; @endcode Please note the three methods you must implement to use ITickable, but don't worry. If you forget, the compiler will tell you so. Also note that the typedef for Parent... more 
Journaling System.
The journaling system is used to record external events and non-deterministic values from an execution run in order that the run may be re-played for debugging purposes. The journaling system is integrated into the platform library, though not all platform calls are journaled.
File system calls are not journaled, so any modified files must be reset to their original state before playback. Only a single journal can be recored or played back at a time.
For the journals to play back correctly, journal events cannot be triggered during the processing of another event. 
brief Class for working with language files 
brief Language file table 
This is class LeapMotionDevice. 
This is class LeapMotionFrame. 
This is class LeapMotionFrameStore. 
This is class LevelInfo. 
A datablock which defines and performs light animation. @see LightBase, LightDescription 
This is class LightBase. 
This is class LightDescription. 
This is class LightFlareData. 
This is the base light information class that will be tracked by the engine. Should basically contain a bounding volume and methods to interact with the rest of the system (for example, setting GFX fixed function lights). 
This is the base class for extended lighting info that lies outside of the normal info stored in LightInfo
The extended light info type wrapper object. 
This is class LightManager. 
This is class LightMapParams. 
This is class LightMatInstance. 
Used to gather an score lights for rendering. 
This represents everything we need to render the shadowmap for one light. 
A very simple, default depth conditioner feature 
This is class MacCarbFont. 
This is class MacCarbPlatState. 
This is class MacCursorController. 
This is class MacDLibrary. 
Mac filesystem. 
File system change notifications on Mac. 
This is class MacWindow. 
This is class MacWindowManager. 
The basic material definition. 
This is class MaterialList. 
This is class MaterialManager. 
Similar class to GFXShaderConsts, but this is to describe generic material parameters. 
This is class MaterialParameters. 
This class is used to define hook objects attached to material instances and provide a registration system for different hook types.
@see BaseMatInstance @see MaterialManager 
The hook type wrapper object 
This is class MatInstanceParameterHandle. 
4x4 Matrix Class
This runs at F32 precision. 
This is class MatrixSet. 
A simple object for generating and comparing string based hints used for sorting and identifying materials uniquely by its shaders and states. 
This is class MECreateUndoAction. 
This is class MEDeleteUndoAction. 
The MemStream class is used to read and write to a memory buffer. 
This is class MenuBar. 
This is class MeshFit. 
This is class MeshRoad. 
MeshRoadConvex Class 
MeshRoadNodeEvent Class 
MeshRoadNodeListNotify Class 
MeshRoadSegment Class 
This is class MeshRoadSplineNode. 
Collada scatters the data required for geometry all over the place; this class helps to group it all together. 
@brief Base class for messages
Message is the base class for C++ defined messages, and may also be used in script for script defined messages if no C++ subclass is appropriate.
Messages are reference counted and will be automatically deleted when their reference count reaches zero. When you dispatch a message, a reference will be added before the dispatch and freed after the dispatch. This allows for temporary messages with no additional code. If you want to keep the message around, for example to dispatch it to multiple queues, call addReference() before dispatching it and freeReference() when you... more 
@brief Forward messages from one queue to another
MessageForwarder is a script class that can be used to forward messages from one queue to another.Example @code %fwd = new MessageForwarder() { toQueue = "QueueToSendTo"; };
registerMessageListener("FromQueue", %fwd); @endcode
Where "QueueToSendTo" is the queue you want to forward to, and "FromQueue" is the queue you want to forward from
Store a list of chat messages.
This is responsible for managing messages which appear in the chat HUD.
@see GuiMessageVectorCtrl for more details on how this is used. 
This is class MissionArea. 
Class: MissionMarker 
This is class MissionMarkerData. 
An engine component that requires initialization and/or cleanup. 
This is a slightly more advanced component which will be used to demonstrate components which are dependent on other components. 
This is class MoveList. 
This is class MoveManager. 
Base class for random number generators 
Linear Congruential Method, the "minimal standard generator"
Fast, farly good random numbers (better than using rand)
@author Park & Miller, 1988, Comm of the ACM, 31(10), pp. 1192-1201 
Fast, very good random numbers
Period = 2^249
Kirkpatrick, S., and E. Stoll, 1981; A Very Fast Shift-Register Sequence Random Number Generator, Journal of Computational Physics, V. 40.
Maier, W.L., 1991; A Fast Pseudo Random Number Generator, Dr. Dobb's Journal, May, pp. 152 - 157 
! MultiLine - Multi Line Statement - This class simply ties multiple 
This class is similar to the Chunker<> class above. But it allows for multiple types of structs to be stored. CodeReview: This could potentially go into DataChunker directly, but I wasn't sure if CodeReview: That would be polluting it. BTR 
This is class Mutex. 
Helper for simplifying mutex locking code.
This class will automatically unlock a mutex that you've locked through it, saving you from managing a lot of complex exit cases. For instance:
@code MutexHandle handle; handle.lock(myMutex);
if(error1) return; // Auto-unlocked by handle if we leave here - normally would // leave the mutex locked, causing much pain later.
handle.unlock(); @endcode 
Custom warning/error message handler 
This is class NamedFeatureGLSL. 
This is class NamedFeatureHLSL. 
A dictionary of function entries.
Namespaces are used for dispatching calls in the console system. 
brief Implements the rcContext interface in Torque
@class NavMesh Represents a set of bounds within which a Recast navigation mesh is generated. @see NavMeshPolyList @see Trigger 
This is class NavPath. 
class for doing asynchronous network operations on unix (linux and hopefully osx) platforms. right now it only implements dns lookups 
Torque network connection.
@section NetConnection_intro Introduction
NetConnection is the glue that binds a networked Torque game together. It combines the low-level notify protocol implemented in ConnectionProtocol with a SimGroup to provide a powerful basis for implementing a multiplayer game protocol.
On top of this basis it implements several distinct subsystems:
  • Event manager, which is responsible for transmitting NetEvents over the wire. It deals with ensuring that the various types of NetEvents are delivered appropriately, and with notifying the event of its delivery status.
  • Move manager, which is responsible for transferring a Move to the server 32 times a... more 
Used when simulating lag.
We post this SimEvent when we want to send a packet; it delays for a bit, then sends the actual packet. 
An event to be sent over the network.
@note Torque implements two methods of network data passing; this is one of them. See NetConnection for details of the other, which is referred to as ghosting.
Torque's network layer lets you pass events to/from the server. There are three types of events:
  • Unguaranteed events are events which are sent once. If they don't make it through the link, they are not resent. This is good for quick, frequent status updates which are of transient interest, like position updates or voice communication.
  • Guaranteed events are events which are guaranteed... more 
NetInterface class. Manages all valid and pending notify protocol connections.
@see NetConnection, GameConnection, NetObject, NetEvent 
Superclass for ghostable networked objects.
@section NetObject_intro Introduction To NetObject And Ghosting
One of the most powerful aspects of Torque's networking code is its support for ghosting and prioritized, most-recent-state network updates. The way this works is a bit complex, but it is immensely efficient. Let's run through the steps that the server goes through for each client in this part of Torque's networking:
  • First, the server determines what objects are in-scope for the client. This is done by calling onCameraScopeQuery() on the object which is considered the "scope" object. This is usually the player object, but... more 
This is class NetStringEvent. 
This class represents what is known as a "tagged string" in script. It is essentially a networked version of the string table. The full string is only transmitted once; then future references only need to transmit the id. 
This is class NetStringTable. 
This is class NodeListManager. 
This is class Noise2D. 
This is class Noncopyable. 
This feature is used to render normals to the diffuse target for imposter rendering. 
This feature is used to render normals to the diffuse target for imposter rendering. 
A volume in space that blocks visibility. 
This is class OculusVRDevice. 
This is class OculusVRHMDDevice. 
This is class OculusVRSensorDevice. 
Single substream in a multiplexed OGG stream. 
A multiplexed OGG input stream feeding into stream decoders. 
Decodes a Theora substream into frame packets.
Frame packets contain raw pixel data in the set pixel format (default is R8G8B8). Reading on a thread is safe, but remember to keep a reference to the OggInputStream master from the worker thread. 
A single decoded Theora video frame. 
Decodes a Vorbis substream into sample packets.
Vorbis samples are always 16bits. 
This is class OpenFolderDialog. 
This is class OpenGLDevice. 
A concrete, renderable PolyList
This class is used to store geometry from a PolyList query.
@see AbstractPolyList 
An oriented bounding box (OBB) described by a center point, three normalizes axis vectors, and half-extents along each of the axes. 
This is class OrthoBoxConvex. 
Overlay texture 
Overlay texture 
This is class PaintNoiseAction. 
This is class ParaboloidLightShadowMap. 
This is class ParaboloidVertTransformGLSL. 
This is class ParaboloidVertTransformHLSL. 
This feature either generates the cheap yet effective offset mapping style parallax or the much more expensive occlusion mapping technique based on the enabled feature flags. 
This feature either generates the cheap yet effective offset mapping style parallax or the much more expensive occlusion mapping technique based on the enabled feature flags. 
This is to provide common functionalty needed by vertex and pixel main defs 
This is class ParamsDefHLSL. 
Particle Data 
Particle Emitter 
Particle Emitter Data 
This is class ParticleNormalFeatureGLSL. 
This is class ParticleNormalFeatureHLSL. 
This is class PathManager. 
This is class PersistenceManager. 
This is class PhysicalZone. 
Simple physics object that represents a single rigid body. 
The shared collision representation for a instance of a static or dynamic physics body.
Note that making very big convex primitives can cause bad queries and collisions in some physics providers.
@see PhysicsBody 
This is class PhysicsDebris. 
Debris Data 
A physics force controller used for gameplay effects. 
A simple single body dynamic physics object. 
This is class PhysicsShapeData. 
The base class for physics user data
This is class PhysicsWorld. 
This is class PixelParamsDefGLSL. 
This is class PixelParamsDefHLSL. 
A per-pixel specular feature. 
A per-pixel specular feature. 
This is class PlaneD. 
Fill a Vectorwith the planes from the geometry passed through this PolyList.
@see AbstractPolyList 
A 3D plane defined by a normal and a distance along the normal.
@note The distance is stored negative. 
This is class PlaneReflector. 
This is class PlatformAssert. 
This is class PlatformCursorController. 
This is class PlatformCursorControllerSDL. 
This is class PlatformFont. 
This is class PlatformMenuBarData. 
Platform-specific timer class.
This exists primarily as support for the TimeManager, but may be useful elsewhere. 
The purpose of this class is to abstract the gathering of video adapter information. This information is not specific to the API being used to do the rendering, or the capabilities of that renderer. That information is queried in a different class. 
Abstract representation of a native OS window.
Every windowing system has its own representations and conventions as regards the windows on-screen. In order to provide Torque with means for interfacing with multiple windows, tracking their state, etc. we provide this interface.
This interface also allows the app to access the render target for the window it represents, as well as control mode switches, get mode info, and so on.
@see PlatformWindowManager 
Abstract representation of a manager for native OS windows.
The PlatformWindowManager interface provides a variety of methods for querying the current desktop configuration, as well as allocating and retrieving existing windows. It may also manage application-level event handling. 
SDL2 implementation of the window manager interface. 
Implementation of a window on SDL. 
2D high-precision point.
Uses F64 internally. 
2D floating-point point. 
2D integer point
Uses S32 internally. 
3D integer point
Uses S32 internally. 
Vector normalization validator 
4D floating-point point.
Uses F32 internally.
Useful for representing quaternions and other 4d beasties. 
4D integer point
Uses S32 internally. Currently storage only. 
This is class PointLight. 
PopupMenu represents a menu. You can add menu items to the menu, but there is no torque object associated with these menu items, they exist only in a platform specific manner. 
Event class used to remove popup menus from the event notification in a safe way 
A transitioning zone that connects other zones.
Basically a portal is two things:
1) A zone that overlaps multiple other zones and thus connects them. 2) A polygon standing upright in the middle of the portal zone's world box.
When traversing from zone to zone, portals serve as both zones in their own right (i.e. objects may be located in a portal zone) as well as a peek hole that determines what area of a target zone is visible through a portal.
Torque's portals are special in that they are two-way by default. This greatly simplifies zone setups but... more 
This is class PostEffectManager. 
This is class PostEffectVis. 
Precipitation datablock. 
This is class Prefab. 
Event generation signal.
Objects that generate events need to register a callback with this signal and should only generate events from within the callback.
This signal is triggered from the ProcessEvents() method. 
Fixed function rendering. Does not load or use shaders. Does not rely on GFXMaterialFeatureData. Tries very hard to not rely on anything possibly related to shaders.
@note Does not always succeed. 
This is an abstract base class which provides the external interface all subclasses must implement. This interface primarily consists of setting state. Pass creation is implementation specific, and internal, thus it is not in this base class. 
This is class ProcessedShaderMaterial. 
List of ProcessObjects. 
This is class ProcessObject. 
Register a command line handling function.
To use this, put it as a member variable into your module definition. 
Register a processing function
To use this, put it as a member variable into your module definition. 
The Profiler is used to see how long a specific chunk of code takes to execute. All values outputted by the profiler are percentages of the time that it takes to run entire main loop.
First, you must #define TORQUE_ENABLE_PROFILER in profiler.h in order to active it. Examples of script use: @code //enables or disables profiling. Data is only gathered when the profiler is enabled. profilerEnable(bool enable); profilerReset(); //resets the data gathered by the profiler profilerDump(); //dumps all profiler data to the console profilerDumpToFile(string filename); //dumps all profiler data to a given file profilerMarkerEnable((string markerName, bool enable); //enables... more 
This is class ProjectedShadow. 
Base class for all projectiles. 
Datablock for projectiles. This class is the base class for all other projectiles. 
This is class PSSMLightShadowMap. 
This is class Px3Body. 
This is class Px3Collision. 
This is class Px3ConsoleStream. 
This is class Px3MemInStream. 
This is class Px3MemOutStream. 
This is class Px3Player. 
This is class Px3Plugin. 
This is class Px3World. 
This is class PxBody. 
This is class PxCloth. 
This is class PxCollision. 
This is class PxConsoleStream. 
This is class PxContactReporter. 
This is class PxFluid. 
This is class PxMaterial. 
This is class PxMemStream. 
This is class PxMultiActor. 
This is class PxMultiActor_Notify. 
This is class PxMultiActorData. 
This is class PxPlayer. 
This is class PxPlugin. 
This is class PxUserData. 
This is class PxUserNotify. 
This is class PxWorld. 
Quadratic spline patch. This is a special type of spline that only had 3 control points. @see SplinePatch 
Helper class to perform a fast, recursive ray cast against a set of hierarchical bounding boxes.
This class assumes that it is working on a unit quadtree (ie, one that extends from 0..1 in the XY dimensions. Z scale is unaffected).
Node indexing is done TGE Terrain style - 0 is the largest level of the quadtree, while coordinates are always in the full range of the quadtree (in a 6 deep tree, 0..63, for instance). This allows the quadtree descent to be very fast! 
unit quaternion class: 
This is class QuitEvent. 
When this NetEvent is processed on the client-side it applies a radial impulse to objects in the physics simulation. 
Raw byte buffer. This isn't a typedef to allow forward declarations. 
This is class RazerHydraDevice. 
This is class RazerHydraFrame. 
This is class RazerHydraFrameStore. 
Represents polygons in the same manner as the .obj file format. Handy for padding data to Recast, since it expects this data format. At the moment, this class only accepts triangles. @see AbstractPolyList 
This is class RectClipper. 
This is class RectD. 
This is class RectF. 
This is class RectI. 
This is class RedBook. 
This is class RedBookDevice. 
Reflect Cubemap 
Reflect Cubemap 
This is class ReflectionManager. 
This is class ReflectionMaterialHook. 
This is class ReflectionMatInstance. 
This is class ReflectorBase. 
This is class ReflectorDesc. 
This is class RemoteCommandEvent. 
The RenderBinManager manages and renders lists of MainSortElem, which is a light wrapper around RenderInst
This is class RenderFormatToken. 
This is a special render manager for processing single billboard imposters typically generated by the tsLastDetail class. It tries to render them in large batches with as few state changes as possible. For an example of use see TSLastDetail::render(). 
A a tiny wrapper around String that exposes a U32 operator so that we can assign the RIT to RenderInst::type field. 
This class implements a basic SceneObject that can exist in the world at a 3D position and render itself. There are several valid ways to render an object in Torque. This class implements the preferred rendering method which is to submit a MeshRenderInst along with a Material, vertex buffer, primitive buffer, and transform and allow the RenderMeshMgr handle the actual setup and rendering for you. 
This class implements a basic SceneObject that can exist in the world at a 3D position and render itself. Note that RenderObjectExample handles its own rendering by submitting itself as an ObjectRenderInst (see renderInstancerenderPassmanager.h) along with a delegate for its render() function. However, the preffered rendering method in the engine is to submit a MeshRenderInst along with a Material, vertex buffer, primitive buffer, and transform and allow the RenderMeshMgr handle the actual rendering. You can see this implemented in RenderMeshExample
This is class RenderParticleMgr. 
This is class RenderPassStateToken. 
This render manager renders opaque objects to the z-buffer as a z-fill pass. It can optionally accumulate data from this opaque render pass into a render target for later use. 
This class implements a basic SceneObject that can exist in the world at a 3D position and render itself. There are several valid ways to render an object in Torque. This class makes use of the "TS" (three space) shape system. TS manages loading the various mesh formats supported by Torque as well was rendering those meshes (including LOD and animation...though this example doesn't include any animation over time). 
This is class RenderTargetZeroGLSL. 
This is class RenderTargetZeroHLSL. 
This is class RenderTexTargetBinManager. 
This is class RenderTranslucentMgr. 
This is class ResizeBitStream. 
This is class ResizeFilterStream. 
All resources are derived from this type. The base type is only instantiated by the resource manager (the resource manager will return a base resource which a derived resource, Resource, will construct itself with). Base class handles locking and unlocking and provides several virtual functions to be defined by derived resource. 
This is a utility class used by the resource manager. The prime responsibility of this class is to delete a resource. The base type is never used, but a template version is always derived that knows how to delete the particular type of resource. Normally, one needs not worry about this class. However, if one wants to delete a particular resource in a special manner, one may override the ResourceHolder::~ResourceHolder method. 
This is class ResourceManager. 
This is class RigidShapeData. 
This is class River. 
RiverNodeEvent Class 
RiverNodeListNotify Class 
This is class RiverSegment. 
This is class RiverSplineNode. 
Vertex lighting based on the normal and the light direction passed through the vertex color. 
Vertex lighting based on the normal and the light direction passed through the vertex color. 
This is class RuntimeRegisteredSimObject. 
This is class SaveFileDialog. 
This is class ScatterSky. 
An object that combines all the state that is relevant to looking into the scene from a particular point of view. 
Database for SceneObjects.
ScenceContainer implements a grid-based spatial subdivision for the contents of a scene. 
An object that gathers the culling state for a scene. 
A volume used to include or exclude space in a scene.
Culling volumes are represented as sets of clipping planes.
@note Culling is performed in world space so the plane data for culling volumes must be in world space too. 
This is class SceneLighting. 
This object is responsible for returning PersistChunk and ObjectProxy classes for the lighting system to use We may want to eventually split this into scene lighting vs. dynamic lighting. getColorFromRayInfo is a dynamic lighting thing. 
An object that manages the SceneObjects belonging to a scene. 
A 3D object.
@section SceneObject_intro Introduction
SceneObject exists as a foundation for 3D objects in Torque. It provides the basic functionality for:
  • A scene graph (in the Zones and Portals sections), allowing efficient and robust rendering of the game scene.
  • Various helper functions, including functions to get bounding information and momentum/velocity.
  • Collision detection, as well as ray casting.
  • Lighting. SceneObjects can register lights both at lightmap generation time, and dynamic lights at runtime (for special effects, such as from flame or a projectile, or from an explosion).
  • Manipulating scene objects, for instance varying scale.

@section SceneObject_example An Example
Melv... more 
This is class SceneObjectLightingPlugin. 
A SceneObjectLink represents the link between a SceneObject and a SceneTracker
Reference to a scene object
A simple zone space that is described by a polyhedron.
By default, if no other polyhedron is assigned to a polyhedral zone, the polyhedron is initialized from the zone's object box. 
The SceneRenderState describes the state of the scene being rendered.
It keeps track of the information that objects need to render properly with regard to the camera position, any fog information, viewing frustum, the global environment map for reflections, viewable distance, etc.
It also owns the current culling state. 
Root zone in a scene.
The root zone is an infinite zone that contains all others zones and objects in the scene.
This class is not declared as a ConsoleObject and is not visible from TorqueScript. SceneRootZone objects are not registered with the Sim system. 
Abstract base class for a zone space that contains only a single zone.
Simple zones are required to be convex. 
Abstract base class for SceneObjects that define subspaces in a scene.
Use SceneObject::containsPoint to find out whether a given space contains a particular point. 
A SceneTracker tracks SceneObjects.
This is an abstract base class. 
Temporary state for zone traversals. Keeps track of the zones that were visited in the current traversal chain as well as of the total area that so far has been visited in the traversal. 
Culling state for a zone.
Zone states keep track of the culling volumes that are generated during traversal for a particular zone in a scene.
@note This class has no meaningful constructor; the memory for all zone states is cleared en bloc. 
Abstract base class for an object that manages zones in a scene.
This class adds the ability to SceneSpace to define and manage zones within the object's space. Zones are used to determine visibility in a scene.
Each zone space manages one or more zones in a scene. All the zones must be within the AABB of the zone space but within that AABB, the zone space is free to distribute and manage zones in arbitrary fashion.
For scene traversal, zone spaces are interconnected. By default, zone spaces get a chance to connect to each other when being moved into... more 
Object that manages zone spaces in a scene. 
This is class ScopeAlwaysShape. 
This is class ScopedProfiler. 
! This class will eventually support various capabilities such as panoramics, high rez captures, and cubemap captures.
Right now it just captures standard screenshots, but it does support captures from multisample back buffers, so antialiased captures will work. 
D3D implementation of screenshot 
@brief Script accessible version of Dispatcher::IMessageListener
The main use of ScriptMsgListener is to allow script to listen for messages. You can subclass ScriptMsgListener in script to receive the Dispatcher::IMessageListener callbacks.
Alternatively, you can derive from it in C++ instead of SimObject to get an object that implements Dispatcher::IMessageListener with script callbacks. If you need to derive from something other then SimObject, then you will need to implement the Dispatcher::IMessageListener interface yourself. 
This is class ScriptTimerMan. 
This is class SelectionBrush. 
This is class Semaphore. 
This is class ServerProcessList. 
used to set the crc for the current mission (mission lighting) 
This is class SettingSaveNode. 
SFXObject implementation for the 3D system. 
Manager for the 3D sound world.
Any SceneObject in the world can be made the current listener. It's ear position (if it's a ShapeBase) will then be used as the reference center for attenuating 3D sounds, traversing ambient spaces, etc. 
This is class SFXALBuffer. 
This is class SFXALDevice. 
This is class SFXALProvider. 
This is class SFXALVoice. 
Datablock for describing an ambient audio space. 
The buffer interface hides the details of how the device holds sound data for playback.
A sound buffer may either be loaded once completely and then played as needed or it may be progressively streamed from an SFXStream. In the latter case, there can only be a single voice tied to the buffer.
@note SFXDevice is the last instance when it comes to ownership of SFXBuffers. If the SFXDevice goes away, it will take all SFXBuffers with it, regardless of whether there are still strong refs to it. Use StrongWeakRefPtrs to keep pointers to SFXBuffers!
@see SFXStream 
SFXSource that drives multi-source playback.
Basically, this class is an interpreter for the instruction slots in SFXPlayLists.
Controllers can be switched between states. When no state is set, all tracks from playlists that do not have a state set will be played. When setting a state, only tracks with the given state will be played. If currently tracks with a different state are playing, the respective controllers will transition out of their respective slots. 
The SFXDescription defines how a sound should be played.
If mConeInsideAngle and mConeOutsideAngle are not both 360 then the sound will be directional and facing out the Y axis. To reorient the cones, reorient the emitter object.
A few tips:
Make sure that server SFXDescription are defined with the datablock keyword, and that client SFXDescription are defined with the 'new' or 'singleton' keyword. 
Abstract base class for back-end sound API implementations. 
DirectSound SFXBuffer implementation.
Note that the actual sound buffer held by the buffer may get duplicated around for individual voices. This is kind of ugly as the resulting buffers aren't tied to a SFXDSBuffer anymore. 
The DirectSound device implementation exposes a couple of settings to script that you should be aware of:
$DirectSound::dopplerFactor - This controls the scale of the doppler effect. Valid factors are 0.0 to 10.0 and it defaults to 0.75.
$DirectSound::distanceFactor - This sets the unit conversion for
$DirectSound::rolloffFactor - ; 
This is class SFXDSProvider. 
This is class SFXDSVoice. 
The SFXEmitter is used to place 2D or 3D sounds into a mission.
If the profile is set then the emitter plays that. If the profile is null and the filename is set then the local emitter options are used.
Note that you can call and SFXEmitter.stop() to control playback from script. 
A datablock that defines a reverb environment. 
A volume fade effect (fade-in or fade-out). 
An SFXStream that streams from a file
This is class SFXFMODBuffer. 
This is class SFXFMODDevice. 
An event in an FMOD Designer project.
This class must not be manually instanced by the user. Instead, SFXFMODEvents are automatically created when an SFXFMODProject is loaded.
Be aware that as all the playback happens internally within FMOD's event system, this bypasses the SFX layer and will thus not work with features that rely the structures there. Namely, sound occlusion (except for FMOD's own occlusion) will not work with FMOD events.
The parameters of an FMOD event are automatically created and designed using the information in the project. 
An SFXSource that controls the playback of an SFXFMODEvent.
SFXFMODEvents can be played back directly through their console methods. However, this class integrates them with the remaining SFX system and makes events usable wherever SFX tracks are usable though with the important distinction that there can only ever be a single source for a given event.
Note that calling playback methods directly on an event will cause a source for the event to be created if there is not already one.
Be aware that using fade-outs in events in combination with play-once sources does not work well at... more 
SFXSystem plugin that adds the capability to create SFXSources for Designer SFXFMODEvents.
The plugin will only be installed if an FMOD device has been created. While SFXFMODEvents may be constructed without an FMOD device, trying to play such an event then will result in an error. 
Datablock that loads an FMOD Designer project.
All events in the project are automatically made available as SFXFMODEvent track datablock instances. Each event object is automatically named by substituting the slashes in its fully qualified name with underscores and preprending the project name to this; event 'group1/group2/event' in the SFXFMODProject instance called 'project', for example, will be available as a TorqueScript object called 'project_group1_group2_event'.
This class also works in a client-server environment where the server is not running FMOD. The event objects are cached in an auto-generated TorqueScript file alongside the .fev project file (x/y.fev -> x/y.fev.cs) which, when... more 
This is class SFXFMODProvider. 
This is class SFXFMODVoice. 
This class defines the various types of sound data that may be used in the sound system.
Unlike with most sound APIs, we consider each sample point to comprise all channels in a sound stream rather than only one value for a single channel. 
A modifer that calls a method on the SFXSource when a particular playback position is passed.
@note At the moment, doing a setPosition() on a source will not cause markers that have been jumped over in the operation to be ignored. Instead they will trigger on the next update
A stream filter that converts sample packets from its source stream to a continuous sample stream. Useful for feeding sound from a source that pushes sample data in discrete packets.
@note For the SFXMemoryStream to allow a reset(), the source input stream must implement IResettable
An SFXModifier modifies the properties of an SFXSource while its playback is running. 
This is class SFXNullBuffer. 
This is class SFXNullDevice. 
This is class SFXNullProvider. 
This is class SFXNullVoice. 
An SFXModifier that is triggered once after passing a certain playback position. 
Parameter for interactive audio.
Parameters are tied to sound sources and will signal value changes so that sound sources may react.
All parameters are global. The name of a parameter is its internal object name.
Like sources, parameters are exclusively client-side. 
A playback list of SFXTracks.
Note that since SFXPlayLists are SFXTracks, play lists can be cascaded.
Play lists are comprised of a sequence of slots. Each slot can be assigned a track (SFXProfile or another SFXPlayList) as well as a number of options that determine how the particular slot should behave.
In addition to playing a track, each slot can do an arbitrary combination of the following operations:
  • Wait: wait for the previous or all sources to stop playing
  • Stop: stop the previous or all sources from playing
  • Delay: wait some (optionally randomized) amount of time
  • Shift Pitch: scale... more 
The SFXProfile is used to define a sound for playback.
An SFXProfile will first try to load its file directly through the SFXDevice. Only if this fails (which is the case for most SFXDevices as these do not implement their own custom sound format loading), the file is loaded through SFXResource.
A few tips:
Make sure each of the defined SFXProfile's fileName doesn't specify an extension. An extension does not need to be specified and by not explicitly saying .ogg or .wav it will allow you to change from one format to the other without having to... more 
This is class SFXProvider. 
An SFXModifier that is spans a certain range of playback time. 
This is the base class for all sound file resources including streamed sound files. It acts much like an always in-core header to the actual sound data which is read through an SFXStream.
The first step occurs at ResourceManager::load() time at which only the header information, the format, size frequency, and looping flag, are loaded from the sound file. This provides just the nessasary information to simulate sound playback for sounds playing just out of the users hearing range.
The second step loads the actual sound data or begins filling the stream buffer. This is triggered... more 
Reverb environment properties.
@note A given device may not implement all properties. 
A scriptable controller playing a specific single sound file
Sound reverb properties.
@note A given SFX device may not implement all properties. 
An instance of an SFXAmbience on the soundscape mixer stack. 
The soundscape manager produces a dynamic mix between multiple active soundscapes.
@note The more layered soundscapes there are, the costlier ambient sound updates will get. 
Baseclass for sources and controllers. 
A convex space that defines a custom ambient sound space. 
A boolean switch used to modify playlist behavior. 
The base sound data streaming interface.
@note Streams that support seeking should implement the IPositionableinterface. @note Since SFXStreams are byte streams, all offset/size information is in bytes and not in number of samples. 
This class provides access to the sound system.
There are a few script preferences that are used by the sound providers.
$pref::SFX::frequency - This is the playback frequency for the primary sound buffer used for mixing. Although most providers will reformat on the fly, for best quality and performance match your sound files to this setting.
$pref::SFX::bitrate - This is the playback bitrate for the primary sound buffer used for mixing. Although most providers will reformat on the fly, for best quality and performance match your sound files to this setting. 
SFXSystemPlugins are used to allow other subsystems hook into core functionality of the sound system. 
A datablock that describes sound data for playback. 
The voice interface provides for playback of sound buffers and positioning of 3D sounds.
This abstract class is derived from in the different device layers to implement device-specific playback control.
The primary responsibility of this class is to mediate between the user requests (play(), stop(), pause(), setPosition()), the buffer (which may change state asynchronously), and the underlying device playback control (_play(), _stop(), _pause(), _seek()). 
An SFXFileStream that loads sample data from a Vorbis file
An SFXFileStream that loads sample data from a WAV file
Audio data buffer for the XAudio device layer. 
This is class SFXXAudioDevice. 
This is class SFXXAudioProvider. 
This is class SFXXAudioVoice. 
This is class sgSceneLightingProcessEvent. 
Shader Component - these objects are the main logical breakdown of a high level shader. They represent the various data structures and the main() procedure necessary to create a shader. 
Connector Struct Component - used for incoming Vertex struct and also the "connection" struct shared by the vertex and pixel shader 
This is class ShaderConnectorHLSL. 
This is class ShaderConstHandles. 
The base class for shader dependencies 
Shader Feature 
This is class ShaderFeatureGLSL. 
This is class ShaderFeatureHLSL. 
Shader generator 
Abstract factory for created (and initializating, if necessary) shader components. 
This is class ShaderGenComponentFactoryGLSL. 
This is class ShaderGenComponentFactoryHLSL. 
Base class used by shaderGen to be API agnostic. Subclasses implement the various methods in an API specific way. 
This is class ShaderGenPrinterGLSL. 
This is class ShaderGenPrinterHLSL. 
A shader dependency for adding #include's into shadergen shaders. 
This is class ShaderMaterialParameterHandle. 
This is the union of all of the shaders contained in a material 
Shader operation base class 
This is class ShaderRenderPassData. 
This is class ShadowBase. 
This is class ShadowManager. 
This is class ShadowMapManager. 
This is class ShadowMapParams. 
ShadowMapPass, this is plugged into the SceneManager to generate ShadowMaps for the scene. 
This is class ShadowMaterialHook. 
This is class ShadowMatInstance. 
This is class ShadowRenderPassManager. 
Used to calculate shadows. 
ShapeBase is the renderable shape from which most of the scriptable objects are derived, including the player, vehicle and items classes. ShapeBase provides basic shape loading, audio channels, and animation as well as damage (and damage states), energy, and the ability to mount images and objects.
Represents a sigmoid function 
Signals (Multi-cast Delegates)
Signals are used throughout this engine to allow subscribers to listen for generated events for various things.
Signals are called according to their order parameter (lower numbers first).
Signal functions can return bool or void. If bool then returning false from a signal function will cause entries in the ordered signal list after that one to not be called.
This allows handlers of a given event to say to the signal generator, "I handled this message, and it is no longer appropriate for other listeners to handle it" 
This is class Sim2DAudioEvent. 
This is class Sim3DAudioEvent. 
This is class SimComponent. 
Implementation of schedule() function.
This allows you to set a console function to be called at some point in the future. 
This is class SimConsoleThreadExecEvent. 
Root DataBlock class.
@section SimDataBlock_intro Introduction
Another powerful aspect of Torque's networking is the datablock. Datablocks are used to provide relatively static information about entities; for instance, what model a weapon should use to display itself, or how heavy a player class is.
This gives significant gains in network efficiency, because it means that all the datablocks on a server can be transferred over the network at client connect time, instead of being intertwined with the update code for NetObjects.
This makes the network code much simpler overall, as one-time initialization code is segregated from the standard object update... more 
Event for sending a datablock over the net from the server to the client.
Datablock events are GuaranteedOrdered client events. 
General purpose SimEvent which calls a Delegatecallback. 
Represents a queued event in the sim.
Sim provides an event queue for your convenience, which can be used to schedule events. A few things which use this event queue:
  • The scene lighting system. In order to keep the game responsive while scene lighting occurs, the lighting process is divided into little chunks. In implementation terms, there is a subclass of SimEvent called SceneLightingProcessEvent. The process method of this subclass calls into the lighting code, telling it to perform the next chunk of lighting calculations.
  • The schedule() console function uses a subclass of SimEvent called SimConsoleEvent to keep track of... more 
Dictionary to keep track of dynamic fields on SimObject
This is class SimFieldDictionaryIterator. 
A group of SimObjects.
A SimGroup is a stricter form of SimSet. SimObjects may only be a member of a single SimGroup at a time.
The SimGroup will automatically enforce the single-group-membership rule.
@code // From engine/sim/ - getting a pointer to a SimGroup SimGroup* pMissionGroup = dynamic_cast(Sim::findObject("MissionGroup"));
// From game/ - iterating over a SimObject's group. SimObject* trigger = ...; SimGroup* pGroup = trigger->getGroup(); for (SimGroup::iterator itr = pGroup->begin(); itr != pGroup->end(); itr++) { // do something with *itr } @endcode 
An iterator that recursively and exhaustively traverses all objects in an SimGroup object tree. 
Map of ID's to SimObjects.
Provides fast lookup for ID->object and for fast removal of an object given object* 
This is class SimManagerNameDictionary. 
Map of names to SimObjects
Provides fast lookup for name->object and for fast removal of an object given object* 
Base class for objects involved in the simulation.
@section simobject_intro Introduction
SimObject is a base class for most of the classes you'll encounter working in Torque. It provides fundamental services allowing "smart" object referencing, creation, destruction, organization, and location. Along with SimEvent, it gives you a flexible event-scheduling system, as well as laying the foundation for the in-game editors, GUI system, and other vital subsystems.
@section simobject_subclassing Subclassing
You will spend a lot of your time in Torque subclassing, or working with subclasses of, SimObject. SimObject is designed to be easy to subclass.
You should not need to... more 
A vector of SimObjects.
As this inherits from VectorPtr, it has the full range of vector methods. 
This simple class is used to store an SimObject and its state so it can be recreated at a later time.
The success of restoring the object completely depends on the results from SimObject::write(). 
A globally unique persistent ID for a SimObject
A SimSet that can be safely persisted. Uses SimPersistIDs to reference objects in the set while persisted on disk. This allows the set to resolve its references no matter whether they are loaded before or after the set is created. 
The purpose of this component is to provide a minimalistic component that exposes a simple, cached interface 
This is a very simple interface. Interfaces provide ways for components to interact with each-other, and query each-other for functionality. It makes it possible for two components to be interdependent on one another, as well. An interface should make accessor calls to it's owner for functionality, and generally be as thin of a layer as possible. 
This is class SimpleMessageEvent. 
ConsoleFunction( msg, void, 3, 3, "(NetConnection id, string message)" "Send a SimpleNetObject message to the specified connection.") { NetConnection *con = (NetConnection *) Sim::findObject(argv[1]); if(con) con->postNetEvent(new SimpleMessageEvent(argv[2])); 
For simple queries. Simply creates a vector of the objects 
A ResponseCurvewrapped as a SimObject 
A set of SimObjects.
It is often necessary to keep track of an arbitrary set of SimObjects. For instance, Torque's networking code needs to not only keep track of the set of objects which need to be ghosted, but also the set of objects which must always be ghosted. It does this by working with two sets. The first of these is the RootGroup (which is actually a SimGroup) and the second is the GhostAlwaysSet, which contains objects which must always be ghosted to the client.
Some general notes on SimSets:
This is class SimXMLDocument. 
SingleLightShadowMap, holds the shadow map and various other things for a light.
This represents everything we need to render the shadowmap for one light. 
This is class SkyBox. 
This is class SmoothHeightAction. 
This is class SmoothSlopeAction. 
This is class SoftSelectAction. 
Class: SpawnSphere 
A texture source for the PixSpecular feature 
A texture source for the PixSpecular feature 
This is class SphereF. 
Class: SphereMesh 
Splash Data 
Class for spline control points. @see SplinePatch 
Base class for spline patches. The only child of this class is QuadPatch.
Spline utility class for drawing nice pretty splines. In order to draw a spline, you need to create a SplCtrlPts data structure, which contains all control points on the spline. See SplCtrlPts for more information on how to submit points to the spline utility. Next, submit the SplCtrlPts structure to the spline utility. @code SplinePatch patch; patch.submitControlPoints(ctrlPts); @endcode Next, use the SplineUtil namespace to draw your spline. @code SplineUtil::drawSplineBeam(camPos, numSegments, width, patch[, uvOffset, numTexRep]); @endcode
You can also create a SplineBeamInfo structure (SplineUtil::SplineBeamInfo) and... more 
This is class SpotLight. 
This is class StackWalker. 
Support class to simplify the process of writing a main loop for Torque apps. 
A statically allocated engine object.
Static objects have an implicit initial reference count of one and will not delete themselves even when asked to do so. 
List to keep track of GameBases to process. 
This is class StdConsole. 
This is class StdMoveList. 
This is class StdServerProcessList. 
-------------------------------------- Base Stream class
Base stream class for streaming data across a specific media 
@brief Script wrapper for the Stream class
It is not possible to instantiate StreamObject in script. Instead, it is instantiated in C++ code and returned to script.
This was mainly intended to allow the ref zip_group "zip code" to provide the stream interface to script. 
The String class represents a 0-terminated array of characters. 
Utility class to wrap string manipulation in a representation independent way.
Length does NOT include the null terminator. 
This is class StringBufferManager. 
Utility class for formatting strings. 
For use in hash tables and the like for explicitly requesting case sensitive hashing. Meant to only appear in hash table definition (casting will take care of the rest). 
For use in hash tables and the like for explicitly requesting case insensitive hashing. Meant to only appear in hash table definition (casting will take care of the rest). 
Transparently converts const char** to ConsoleValue 
Helper class which stores a relative pointer in the StringStack buffer 
Transparently converts ConsoleValue[] to const char 
Base class for StrongRefBase strong reference pointers. 
Base class for objects which can be strongly referenced (i.e., as long as reference exists, object will exist, when all strong references go away, object is destroyed). 
This is class T3DSceneClient. 
This is class T3DSceneComponent. 
This is class T3DSolidSceneClient. 
This is class TagDictionary. 
This is class TCPObject. 
Telnet admin console.
Torque supports remote access to its console. This is most useful when running a dedicated server, as you can remotely administer the game (for instance, kicking people). In the context of a MMORPG, this sort of functionality would be useful for managing a server.
There are a number of products for Tribes2 which allow remote administration via a nice GUI.
@section telnetconsole_use Using the Telnet Console
The TelnetConsole is designed to be used globally, so you don't instantiate it like a normal class. 
Telnet debug service implementation.
This is the C++ side of the built-in Torque debugger.
To use the debugger, use dbgSetParameters(port, password); in the console of the server to enable debugger connections. Then on some other system, start up the app (you don't have to start a game or connect to the server) and exec("common/debugger/debugger.cs"); in the console. Then use the debugger GUI to connect to the server with the right port and password.
@see for more thorough discussion. 
This is class TerrainAction. 
This is class TerrainAdditiveFeatGLSL. 
This is class TerrainAdditiveFeatHLSL. 
This is class TerrainBaseMapFeatGLSL. 
This is class TerrainBaseMapFeatHLSL. 
This is class TerrainBlock. 
This is a complex material which holds one or more optimized shaders for rendering a single cell. 
This is class TerrainConvex. 
This is class TerrainDetailMapFeatGLSL. 
This is class TerrainDetailMapFeatHLSL. 
This is class TerrainEditor. 
A shared base class for terrain features which includes some helper functions. 
A shared base class for terrain features which includes some helper functions. 
Allows a lighting system to plug into terrain rendering 
This is class TerrainLightMapFeatGLSL. 
This is class TerrainLightMapFeatHLSL. 
This is class TerrainMacroMapFeatGLSL. 
This is class TerrainMacroMapFeatHLSL. 
The TerrainMaterial class orginizes the material settings for a single terrain material layer. 
This is class TerrainNormalMapFeatGLSL. 
This is class TerrainNormalMapFeatHLSL. 
This is class TerrainProcessActionEvent. 
An undo action used to perform terrain wide smoothing. 
The TerrCell is a single quadrant of the terrain geometry quadtree. 
This is class TestStruct. 
Tex Anim 
Tex Anim 
TheoraTexture decodes Ogg Theora files, and their audio.
TheoraTexture objects can be used similarly to TextureObjects. Just set the video, call play(), and then refresh every frame to get the latest video. Audio happens automagically.
@note Uses Theora and ogg libraries which are Copyright (C) Foundation 
A single frame in the video frame stream.
Frames are uploaded directly into textures by the asynchronous streaming system. This offloads as much work as possible to the worker threads and guarantees the smoothest possible playback.
Frame records are re-used and are managed directly by the video frame stream. The number of textures concurrently used by a Theora stream is determined by its stream read-ahead. 
This is class TheoraTextureObject. 
This is class Thread. 
Asynchronous work manager.
Thread pooling allows to submit work items for background execution. Each work item will be placed on a queue and, based on a total priority ordering, executed when it has the highest priority and a worker thread becomes available.
@note The global pool maintains the invariant that only the main thread may submit items in order to be able to flush the item queue reliably from the main thread itself. If other threads were issuing items to the queue, the queue may never empty out and the main thread will deadlock.
Flushing is the simplest method to... more 
Platform independent per-thread storage class. 
This is class TickCache. 
Utility class to fire journalled time-delta events at regular intervals.
Most games and simulations need the ability to update their state based on a time-delta. However, tracking time accurately and sending out well-conditioned events (for instance, allowing no events with delta=0) tends to be platform specific. This class provides an abstraction around this platform mojo.
In addition, a well behaved application may want to alter how frequently it processes time advancement depending on its execution state. For instance, a game running in the background can significantly reduce CPU usage by only updating every 100ms, instead of trying to maintain a... more 
This is class TimeOfDay. 
This is class Tokenizer. 
A transform expressed as a combination of a position vector and an angular orientation. 
This is class Trigger. 
Instance versions of shape objects 
Decals! The lovely detailing thingies, e.g. bullet hole marks. DEPRECATED: This class is here for compatibility with old files only. Performs no actual rendering. 
This is class TSForestCellBatch. 
This is class TSForestItemData. 
The standard mathmatical set, where there are no duplicates. However, this set uses bits instead of numbers. 
This neat little class renders the object to a texture so that when the object is far away, it can be drawn as a billboard instead of a mesh. This happens when the model is first loaded as to keep the realtime render as fast as possible. It also renders the model from a few different perspectives so that it would actually pass as a model instead of a silly old billboard. In other words, this is an imposter. 
Specialized material list for 3space objects. 
This is class TSPartInstance. 
A simple class for passing render state through the pre-render pipeline.
@section TSRenderState_intro Introduction
TSRenderState holds on to certain pieces of data that may be set at the preparation stage of rendering (prepRengerImage etc.) which are needed further along in the process of submitting a render instance for later rendering by the RenderManager.
It was created to clean up and refactor the DTS rendering from having a large number of static data that would be used in varying places. These statics were confusing and would often cause problems when not properly cleaned up by various objects after submitting their RenderInstances.... more 
TSShape stores generic data for a 3space model.
TSShape and TSShapeInstance act in conjunction to allow the rendering and manipulation of a three dimensional model.
@note The material lists are the only thing that is not loaded in TSShape. instead, they are loaded in TSShapeInstance because of a former restriction on the resource manager where only one file could be opened at a time. The resource manager restriction has been resolved, but the material lists are still loaded in TSShapeInstance.
@see TSShapeInstance for a further discussion of the 3space system. 
Alloc structure used in the reading/writing of shapes.
In read mode we assemble contents of 32-bit, 16-bit, and 8-bit buffers into a single destination buffer.
In write mode we dissemble a stream of memory (which may be scattered in physical memory) into 32-bit, 16-bit, 8-bit, Point3F, and Point2F buffers using function calls similar to the read calls.
Read usage:
  1. call "setRead" with each incoming memory buffers and clear=true.
  2. run through set of operations for allocating and transfering memory to target buffer these are the operations under "DECLARE_ALLOC" that call readOnly in the .cc file... more 
This class allows an artist to export their animations for the model into the .dsq format. This class in particular matches up the model with the .dsqs to create a nice animated model. 
An instance of a 3space shape.
@section TSShapeInstance_intro Introduction
A 3space model represents a significant amount of data. There are multiple meshes, skeleton information, as well as animation data. Some of this, like the skeletal transforms, are unique for each instance of the model (as different instances are likely to be in different states of animation), while most of it, like texturing information and vertex data, is the same amongst all instances of the shape.
To keep this data from being replicated for every instance of a 3shape object, Torque uses the ResManager to instantiate and track... more 
This is class TSShapeLoader. 
This is class TSSkinMesh. 
TSSortedMesh is for meshes that need sorting (obviously). Such meshes are usually partially or completely composed of translucent/parent polygons. 
A simple mesh shape with optional ambient animation. 
This is class TSStaticPolysoupConvex. 
3space animation thread.
An animation thread: runtime data associated with a single sequence that is running (or two sequences if in transition between them).
A shape instance can have multiple threads running. When multiple threads are running, which thread/sequence controls which node or object is determined based on priority of the sequence.
@note all thread data and methods are private (but TSShapeInstance is a friend). Users should treat thread pointers like keys -- they are used to ID the thread when interfacing with the shape, but are not manipulated by anything but the TSShapeInstance. See "Thread control" methods... more 
This is class TypeValidator. 
Script Undo Action Creation
Undo actions can be created in script like this:
... %undo = new UndoScriptAction() { class = SampleUndo; actionName = "Sample Undo"; }; %undo.addToManager(UndoManager); ...
function SampleUndo::undo() { ... }
function SampleUndo::redo() { ... 
utility class for running a unix command and capturing its output 
TODO SDL remove 
This is class UnixUtils. 
This is class VertexParamsDefGLSL. 
This is class VertexParamsDefHLSL. 
A simple polylist which only gathers the unique verticies passed to it. 
Baked lighting stored on the vertex color 
Baked lighting stored on the vertex color 
This is class VertPixelConnectorGLSL. 
Vertex position 
Vertex position 
Video capture interface class 
Abstract video encoder class 
This is a very basic "encoder" that records the video as a series of numbered PNGs Good if you're having problems with container-based formats and need extra flexibility. 
Theora video capture encoder 
Abstract frame grabber class implementation and initalization depends on video device 
This is class VideoFrameGrabberD3D9. 
WaterObject Class 
This is class WayPoint. 
Base class for objects which can be weakly referenced (i.e., reference goes away when object is destroyed). 
This is class Win32CursorController. 
This is class Win32DLibrary. 
This is class Win32RedBookDevice. 
This is class Win32Timer. 
Implementation of a window on Win32. 
Win32 implementation of the window manager interface. 
This is class WinConsole. 
This is class WindDeformationConstHandles. 
This is class WindDeformationGLSL. 
This is class WindDeformationHLSL. 
This is class WindEmitter. 
This is class WindowInputGenerator. 
This is class WinFont. 
This is class WMIVideoInfo. 
A selection set in the World Editor.
Selections are by default transient objects, but can be made persistent and saved to disk. 
This is class x86UNIXDLibrary. 
This is class x86UNIXFont. 
This is class x86UNIXPlatformState. 
This is class XClipboard. 
This is class XMessageBox. 
This is class XMessageBoxButton. 
This is class ZipCryptRStream. 
brief Script wrapper for Zip::ZipArchive
This is class ZipSubRStream. 
This is class ZipSubWStream. 
A volume in space that encloses objects.
Zones do not physically contain objects in the scene. Rather, any object that has its world box coincide with the world box of a zone is considered to be part of that zone. As such, objects can be in multiple zones at the same time. 
Internal helper for callback support in legacy console system. 
This is class _ConsoleConstType. 
This is class _ConstructPrim. 
This is class _ConstructPtr. 
This is class _DestructPrim. 
This is class _DestructPtr. 
This is class _EngineArgumentTypeTable< R( ... ) >. 
This is class _EngineArgumentTypeTable< R( A ) >. 
This is class _EngineArgumentTypeTable< R( A, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B ) >. 
This is class _EngineArgumentTypeTable< R( A, B, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, ... ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, L ) >. 
This is class _EngineArgumentTypeTable< R( A, B, C, D, E, F, G, H, I, J, K, L, ... ) >. 
Function Argument Type Infos. 
This is class _EngineBitfieldTypeTraits. 
Internal helper class for doing call-outs in the new interop. 
Base helper for console callbacks 
Override for when first parameter is presumably a SimObject*, in which case A will be absorbed as the callback 
Override for when first parameter is const char 
This is class _EngineConsoleThunk< startArgc, R( A ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J, K ) >. 
This is class _EngineConsoleThunk< startArgc, R( A, B, C, D, E, F, G, H, I, J, K, L ) >. 
This is class _EngineConsoleThunk< startArgc, R() >. 
This is class _EngineConsoleThunk< startArgc, void( A ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I, J ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I, J, K ) >. 
This is class _EngineConsoleThunk< startArgc, void( A, B, C, D, E, F, G, H, I, J, K, L ) >. 
This is class _EngineConsoleThunk< startArgc, void() >. 
Helper struct to count the number of parameters in a function list. The setup through operator () allows omitting the the argument list entirely. 
Helper class to determine the type of callback registered with the console system. 
This is class _EngineConsoleThunkType< bool >. 
This is class _EngineConsoleThunkType< F32 >. 
This is class _EngineConsoleThunkType< S32 >. 
This is class _EngineConsoleThunkType< U32 >. 
This is class _EngineConsoleThunkType< void >. 
This is class _EngineEnumTypeTraits. 
This is class _EngineFunctionDefaultArguments< void( A ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E, F ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K ) >. 
This is class _EngineFunctionDefaultArguments< void( A, B, C, D, E, F, G, H, I, J, K, L ) >. 
This is class _EngineFunctionDefaultArguments< void() >. 
Helper to allow flags argument to DEFINE_FUNCTION to be empty. 
This is class _EngineFunctionTrampoline< R( A ) >. 
This is class _EngineFunctionTrampoline< R( A, B ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E, F ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E, F, G ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I, J ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I, J, K ) >. 
This is class _EngineFunctionTrampoline< R( A, B, C, D, E, F, G, H, I, J, K, L ) >. 
This is class _EngineFunctionTrampoline< R() >. 
This is class _EngineFunctionTrampolineBase. 
This is class _EngineFunctionTypeTraits. 
This is class _EngineMethodTrampoline< Frame, R( A ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I, J ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I, J, K ) >. 
This is class _EngineMethodTrampoline< Frame, R( A, B, C, D, E, F, G, H, I, J, K, L ) >. 
This is class _EngineMethodTrampoline< Frame, R() >. 
Base type trait definitions for different type kinds. 
This is class _EngineStructTypeTraits. 
This is class _EngineTrampoline< R( A ) >. 
This is class _EngineTrampoline< R( A, B ) >. 
This is class _EngineTrampoline< R( A, B, C ) >. 
This is class _EngineTrampoline< R( A, B, C, D ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E, F ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E, F, G ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E, F, G, H ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E, F, G, H, I ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E, F, G, H, I, J ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E, F, G, H, I, J, K ) >. 
This is class _EngineTrampoline< R( A, B, C, D, E, F, G, H, I, J, K, L ) >. 
@name Engine Type Traits
Type traits allow to access the static properties of a type at compile-time. This is primarily useful for templating in order to make decisions based on static typing. 
This is class _EngineTypeTraits< void >. 
This is class _privateRegisterBMP. 
This is class _privateRegisterGIF. 
This is class _privateRegisterJPG. 
This is class _privateRegisterMNG. 
This is class _privateRegisterPNG. 
This is class _privateRegisterTGA. 
Helper to retrieve a scope instance through a C++ type. The setup here is a little contrived to allow the scope parameters to the various macros to be empty. What makes this difficult is that T need not necessarily be a structured type. 
This is class _TypeTraits< T* >. 
Collada allows any element with an SID or ID attribute to be the target of an animation channel, which is very flexible, but awkward to work with. Some examples of animated values are:
  • single float
  • single int
  • single bool
  • single string
  • list of floats (transform elements or morph weights)

This class provides a generic way to check if an element is animated, and to get the value of the element at a given time. 
This is class AnimatedElementList. 
Collada animation data 
This is class AnimData. 
This is class AppMaterial. 
This is class AssertCallExprNode. 
This is class AssignExprNode. 
This is class AssignOpExprNode. 
This is class AutoPtrRef. 
Functions for rendering to 1bpp bitmaps.
Used primarily for fast shadow rendering. 
This is class blTerrainChunk. 
This is class BreakStmtNode. 
This is class CacheEntry. 
This is class CommaCatExprNode. 
This is class CompoundKey3. 
This is class ConditionalExprNode. 
An arbitrary fragment of auto-doc text for the script reference. 
Extended information about a console function. 
This is class ConstantNode. 
This is class ContainerQueryInfo. 
This is class ContinueStmtNode. 
Represents the Sizing Options for a GuiControl 
This is class CoverSearch. 
Function table 
This is class DDSFile. 
Debris Data 
DecalRoadNodeList Struct 
Functor for deleting a pointer. @see for_each 
Delete an array of objects policy. 
Delete a single object policy. 
A delete policy for the AutoPtr class 
This is class DocString. 
This is class DragMeshCallbackData. 
Function table 
name Axis-Aligned Edge Structure 
Structure storing the default argument values for a function invocation frame. 
Networking related information for an engine API type. 
This is class EngineTypeTraits< String >. 
Unmarshal data from client form to engine form.
This is wrapped in an a struct as partial specializations on function templates are not allowed in C++. 
This is class EngineUnmarshallData< ConsoleValueRef >. 
This is class EngineUnmarshallData< const char* >. 
This is class EngineUnmarshallData< F32 >. 
This is class EngineUnmarshallData< S32 >. 
This is class EngineUnmarshallData< T* >. 
This is class EngineUnmarshallData< U32 >. 
This is class EngineUnmarshallData< U8 >. 
This is class EngineUnmarshallData< void >. 
A mathematical expression. 
This is class ExtendedMove. 
@ingroup SystemDialogs @internal Platform Agnostic Structure for holding information about a file dialog. 
This is class FloatBinaryExprNode. 
This is class FloatNode. 
This is class FloatUnaryExprNode. 
FMOD API function table.
FMOD doesn't want to be called concurrently so in order to not force everything to the main thread (where sound updates would just stall during loading), we thunk all the API calls and lock all API entry points to a single mutex. 
The aerial fog settings. 
This is class FPSTracker. 
Polyhedron data for use by frustums. Uses fixed-size vectors and a static vector for the edge list as that never changes between frustums. 
This is class FuncCallExprNode. 
This is class FunctionDeclStmtNode. 
Scriptable, demo-able datablock.
This variant of SimDataBlock performs these additional tasks:
  • Linking datablock's namepsaces to the namespace of their C++ class, so that datablocks can expose script functionality.
  • Linking datablocks to a user defined scripting namespace, by setting the 'class' field at datablock definition time.
  • Adds a category field; this is used by the world creator in the editor to classify creatable shapes. Creatable shapes are placed under the Shapes node in the treeview for this; additional levels are created, named after the category fields.
  • Adds support for demo stream recording. This support takes the form of the member variable... more 
local work class 
This is class GFXAdapter. 
Some information about a GFXFormat
This is class GFXSamplerStateDesc. 
Passed to GFX for shader defines. 
GFXStateBlockDesc defines a render state, which is then used to create a GFXStateBlock instance. 
Each 2D grid position must be associated with a terrainBlock 
Represent a mouse event with a 3D position and vector.
This event used by the EditTSCtrl derived controls. 
Represents a single GUI event.
This is passed around to all the relevant controls so they know what's going on. 
This is class handle. 
This is class IDxDiagContainer. 
This is class IDxDiagProvider. 
This is class IDXGIAdapter. 
This is class IDXGIFactory. 
This is class IDXGIObject. 
This is class IfStmtNode. 
This is a render instance for a cached multiple imposter batch. 
This is a render instance for a single imposter. 
Generic input event. 
This is class IntBinaryExprNode. 
This is class InternalSlotAccessNode. 
Base class for intersector implementations. 
This is class IntNode. 
This is class IntUnaryExprNode. 
A sampler backend is responsible for storing the actual sampling data
Shared interface for polyhedral objects. 
A "foreach" statement. 
This is class JournalHandle. 
Keycode mapping. 
This is class KillInternTable. 
Language element 
This is class LeapMotionDeviceData. 
The light animation state required by LightAnimData
This is class LightFlareState. 
Shader constant handle lookup This isn't broken up as much as it could be, we're mixing single light constants and pssm constants. 
This is class LightState. 
Stores information about a link. 
This is class LoopStmtNode. 
MaterialFeatureData, this is basically a series of flags which a material can ask for. Shader processed materials will use the shadergen system to accomplish this, FF processed materials will do the best they can. 
This is class MeshRenderInst. 
MeshRoadNodeList Struct 
This is class MeshRoadSlice. 
This is class ModuleManager. 
This is class Move. 
Structure used for synchronizing move lists on client/server 
Add constructor to GUID. 
Platform-specific network operations. 
internal structure for storing information about a name lookup request 
Work item issued to the thread pool for each lookup request. 
This is class ObjectDeclNode. 
This is class ObjectRenderInst. 
A special render instance for occlusion tests. 
This is class OculusVRSensorData. 
A special render instance for particles. 
This is class PersistInfo. 
Helper structure which defines the state of a single physics body. 
Platform Menu Data 
This is class PlatformSemaphore. 
Convex polyhedron / AABB intersection.
This class implements the algorithm described in "Detecting Intersection of a Rectangular Solid and a Convex Polyhedron", Graphics Gems IV, Chapter 1.7, by Ned Greene.
The polyhedron is preprocessed when an object of this class is constructed.
This class also assumes that the polyhedron is represented in object space and thus also stores local copies of the polyhedron's planes transformed into world space.
The approach of the algorithm is simple. It uses a maximum of three successive stages to determine intersection. Each stage can early out if it can draw a conclusive result already.... more 
Base class for helping to abstract over how a polyhedron stores and updates its data.
The PolyhedronData class hierarchy is designed to give users of PolyhedronImpl maximum freedom in modifying those behaviors. This leads to some duplicating in the various PolyhedronData classes but it ultimately provides greater control.
All accesses to the data go through accessors on the base classes. This gives the base class the freedom to implement lazy updates, for example.
A given base implementation is also free to store additional data or derive extended classes from the base classes expected for points (Point3F), edges... more 
Polyhedron data stored in fixed size arrays. 
A polyhedron.
Polyhedrons are stored as both sets of planes as well sets of edges and vertices (basically a winged-edge format).
Polyhedrons must be convex.
@note The default orientation for the plane normals of a polyhedron is *inwards*. 
Polyhedron data stored as raw points with memory being managed externally. 
Polyhedron data stored in Vectors. 
A helper class for fitting primitives (Box, Sphere, Capsule) to a triangulated mesh 
Processor info manager. 
This is class ProfilerRootData. 
compressed quaternion class 
This is class Raindrop. 
Extension of the collision structure to allow use with raycasting. @see Collision 
This is class RazerHyrdaControllerData. 
Timer that queries the real-time ticker. 
name Margin Padding Structure 
Render Instance 
This contains the common data needed to render a pass. 
This is class ReturnStmtNode. 
Helper templates to determine the return type of functions. 
This is class ReturnType<R (*)()>. 
This is class ReturnType<R (*)(A)>. 
This is class ReturnType<R (*)(A,B)>. 
This is class ReturnType<R (*)(A,B,C)>. 
This is class ReturnType<R (*)(A,B,C,D)>. 
This is class ReturnType<R (*)(A,B,C,D,E)>. 
This is class ReturnType<R (*)(A,B,C,D,E,F)>. 
This is class ReturnType<R (*)(A,B,C,D,E,F,G)>. 
This is class ReturnType<R (O::*)()>. 
This is class ReturnType<R (O::*)(A)>. 
This is class ReturnType<R (O::*)(A,B)>. 
This is class ReturnType<R (O::*)(A,B,C)>. 
This is class ReturnType<R (O::*)(A,B,C,D)>. 
This is class ReturnType<R (O::*)(A,B,C,D,E)>. 
This is class ReturnType<R (O::*)(A,B,C,D,E,F)>. 
This is class ReturnType<R (O::*)(A,B,C,D,E,F,G)>. 
This is class RiverSlice. 
This is class RoadEdge. 
Bookkeeping structure for registered sampling keys. 
This is class SceneData. 
Helper struct for counting nodes, meshes and polygons down through the scene hierarchy 
Game Server Information 
This is class SFXDeviceInfo. 
Ugly workaround to keep the constructor protected. 
An array of float values with optional random variances. 
This is class ShapeBaseDataProto. 
@file Routines for extracting silhouette polygons from polyhedrons. 
Silhouette extraction routines for orthographic projections. 
Silhouette extraction routines for perspective projections. 
Common implementation parts for silhouette extraction. 
Silhouette edge extraction for orthographic projections. 
Silhouette edge extraction for perspective projections. 
Timer that queries Sim::getCurrentTime(). 
This is class SkyMatParams. 
This is class SlotAccessNode. 
This is class SlotAssignNode. 
This is class SlotAssignOpNode. 
the Socket structure helps us keep track of the above states 
Splash Ring 
Collection of statically registered named singletons.
This class is useful as a mix-in for classes that are supposed to represent a range of named singleton instances from which a specific instance is then selected at run-time.
@param T Arbitrary type parameter; identical types will share static data
Representation of a node for the scripting language parser.
When the scripting language is evaluated, it is turned from a string representation, into a parse tree, thence into byte code, which is ultimately interpreted by the VM.
This is the base class for the nodes in the parse tree. There are a great many subclasses, each representing a different language construct. 
This is class StrcatExprNode. 
This is class StrConstNode. 
This is class StreqExprNode. 
Core stack for interpreter operations.
This class provides some powerful semantics for working with strings, and is used heavily by the console interpreter. 
This is class StringTableEntryEq. 
This is class StringTableEntryHash. 
Dictionary functions 
This is class TcpHandle. 
This is class TempAlloc. 
The render instance for terrain cells. 
This is class ThreadPool::GlobalThreadPool. 
Value wrapper for work items while placed on priority queue. Conforms to interface dictated by ThreadSafePriorityQueueWithUpdate.
@see ThreadSafePriorityQueueWithUpdate @see ThreadPool::WorkItem 
Fast, lock-free priority queue implementation for concurrent access.
Equal priorities are allowed and are placed beforeexisting items of identical priority in the queue.
Based on (but with significant deviations from) "Fast and Lock-Free Concurrent Priority Queues for Multi-Thread Systems" by Hakan Sundell and Philippas Tsigas. Parts of the skiplist code is based on work by William Pugh.
@param T The item value type. Must have a default constructor. @param K The priority key type. Must be comparable, have a default constructor, and be a valid template parameter to TypeTraits. @param SORT_MIN_TO_MAX If true, the... more 
Fast, lock-free priority queue implementation for concurrent access that performs dynamic re-prioritization of items.
Within the bounds of a set update interval UPDATE_INTERVAL, the takeNext method is guaranteed to always return the item that has the highest priority at the time the method is called rather than at the time items were inserted into the queue.
Values placed on the queue must implement the following interface:
@code template< typename K > struct IThreadSafePriorityQueueItem { // Default constructor. IThreadSafePriorityQueueItem();
// Return the current priority. // This must run normally even if the item is already dead. K getPriority();
// Return true... more 
This is class TickCacheEntry. 
This is class TriggerData. 
class to handle general scaling case
transform = rot * scale * inv(rot) 
struct for encapsulating ts transform related static functions 
This is class TTagDerefNode. 
This is class TTagExprNode. 
This is class TTagSetStmtNode. 
This is class TypeTraits. 
Type traits for primitive types. 
This is class TypeTraits< F32 >. 
This is class TypeTraits< RawDataT< T >* >. 
This is class TypeTraits< S16 >. 
This is class TypeTraits< S32 >. 
This is class TypeTraits< S8 >. 
This is class TypeTraits< StrongRefPtr< T > >. 
This is class TypeTraits< StrongWeakRefPtr< T > >. 
This is class TypeTraits< T* >. 
This is class TypeTraits< T* const >. 
This is class TypeTraits< U16 >. 
This is class TypeTraits< U32 >. 
This is class TypeTraits< U8 >. 
This is class UpdateQueueEntry. 
Cache data for UTF16 strings. This is wrapped in a class so that data is automatically freed when the hash table is deleted. 
This is class ValueHolder< void >. 
! Var - Variable - used to specify a variable to be used in a shader. Var stores information such that when it is printed out, its context can be identified and the proper information will automatically be printed. For instance, if a variable is created with 'uniform' set to true, when the shader function definition is printed, it will automatically add that variable to the incoming parameters of the shader. There are several similar cases such as when a new variable is declared within a shader. 
This is class VarNode. 
Torque unifies the vert position, normal and UV values, so that a single index uniquely identifies all 3 elements. A triangle then contains just 3 indices, and from that we can get the 3 positions, 3 normals and 3 UVs.
for i=1:3 index = indices[triangle.start + i] points[index], normals[index], uvs[index]
Collada does not use unified vertex streams, (each triangle needs 9 indices), so this structure is used to map a single VertTuple index to 3 indices into the Collada streams. The Collada (and Torque) primitive index is also stored because the Collada document may use different streams... more 
Timer that queries the simulation-time ticker. 
The water fog settings. 
This is class WaterMatParams. 
This is class Win32PlatState. 
Structure used to store Windows events for delayed dispatching 
This is class ZoneArrayIterator. 
This template class is usused to initialize the format in the GFXImplement/DeclareVertexFormat macros. You shouldn't need to use it directly in your code.
@see GFXVertexFormat @see GFXImplementVertexFormat 
Collada s are extremely flexible, and thus difficult to access in a nice way. This class attempts to provide a clean interface to convert Collada source data to the appropriate Torque data structure without losing any of the flexibility of the underlying Collada DOM.
Some of the conversions we need to handle are:
The _SourceReader object is initialized with a list of parameter names that it tries to match to  
This is a fixed size class that will align its elements on configurable boundaries. 
Asynchronous work item for reading an element from the source stream. 
Abstract superclass of async I/O work items.
Supports both offset-based stream I/O as well as I/O on streams with implicit positions. Note that if you use the latter type, make sure that no other thread is messing with the stream at the same time or chaos will ensue.
@param T Type of elements being streamed. 
Stream packet read by an asynchronous packet stream. 
A packet stream turns a continuous stream of elements into a stream of discrete packets of elements.
All packets are of the exact same size even if, for end-of-stream packets, they actually contain less data than their actual size. Extraneous space is cleared.
@note For looping streams, the stream must implement the IResettable interface. 
Time-based packet stream queue.
AsyncPacketQueue writes data packets to a consumer stream in sync to a tick time source. Outdated packets may optionally be dropped automatically by the queue. A fixed maximum number of packets can reside in the queue concurrently at any one time.
Be aware that using single item queues for synchronizing to a timer will usually result in bad timing behavior when packet uploading takes any non-trivial amount of time.
@note While the queue associates a variable tick count with each individual packet, the queue fill status is measured in number of packets rather than in total... more 
RDTODO: error handling Work item to asynchronously read from a stream.
The given stream type may implement any of the input stream interfaces. Preference is given to IAsyncInputStream, then to IOffsetInputStream, and only if none of these are implemented IInputStream is used.
For IAsyncInputStreams, the async read operation is issued immediately on the constructing thread and then picked up on the worker thread. This ensures optimal use of concurrency. 
A stream filter that performs background read-aheads on its source stream and buffers the results.
As each element is read in an independent threaded operation, reading an element should invole a certain amount of work for using this class to make sense.
@note For looping streams, the stream must implement the IResettable interface. 
Work item for writing to an output stream.
The stream being written to may implement any of the given output stream interfaces. Preference is given to IAsyncOutputStream, then to IOffsetOutputStream, and only if none of these is implemented IOutputStream is used.
A useful feature is to yield ownership of the data buffer to the write item. This way, this can be pretty much used in a fire-and-forget manner where after submission, no further synchronization happens between the client and the work item.
@note Be aware that if writing to an output stream that has an implicit position property,... more 
A simple smart pointer. An extended version of std::auto_ptr which supports a deletion policy. The delete policy indicates how the ptr is to be deleted. DeleteSingle, the default, is used to delete individual objects. DeleteArray can can be used to delete arrays.  
The catmull-rom template class for performing interpolation over an arbitraty type. 
Templatized data chunker class with proper construction and destruction of its elements.
DataChunker just allocates space. This subclass actually constructs/destructs the elements. This class is appropriate for more complex classes. 
Template child class for supported Collada primitive elements 
CodeReview [patw, 2, 13, 2007] I am very interested in making this as thin as possible. I really like the possibilities that it exposes as far as exposing "properties" to other components. I want it to be performant, however, so if anyone has notes on this, mark up the source, e-mail me, whatever. 
Helper class for AbstractClassRep.
@see AbtractClassRep @see ConsoleObject 
This is class DelegateRemapper. 
Template for class type infos. 
Template for function type infos. 
Template for type infos of primitive, enum, and bitfield types. 
Template for struct type infos. 
Not exactly a specialization, just a vector to use when speed is a concern 
A double-ended queue with a fixed number of entries set at construction time. Implemented as an array.
@param T Element type of the queue. 
A vector with a compile-time constant size
This is class FloatCurve. 
Class for temporary variables that you want to allocate easily using the FrameAllocator. For example: @code FrameTemptempStr(32); // NOTE! This parameter is NOT THE SIZE IN BYTES. See constructor docs. dStrcat( tempStr, SomeOtherString ); tempStr[2] = 'l'; Con::printf( tempStr ); Con::printf( "Foo: %s", ~tempStr ); @endcode
This will automatically handle getting and restoring the watermark of the FrameAllocator when it goes out of scope. You should notice the strange operator in front of tempStr on the printf call. This is normally a unary operator for ones-complement, but in this class it will simply return the memory of... more 
A handle object for allocating, filling, and reading a vertex buffer. 
A HashTable template class.
The hash table class maps between a key and an associated value. Access using the key is performed using a hash table. The class provides methods for both unique and equal keys. The global ::hash(Type) function is used for hashing, see util/hash.h @ingroup UtilContainers 
An input stream over elements of type "T" that works in the background. 
An output stream that writes elements of type "T" in the background. 
Interface for object memory allocation. 
An input stream delivers a sequence of elements of type "T".
@note This stream has an inherent position property and is thus not safe for concurrent access. 
An input stream filter takes an input stream "Stream" and processes it into an input stream over type "To". 
A property that smoothly transitions to new values instead of assuming them right away.
@param T Value type. Must have "interpolate( from, to, factor )" method. @param TimeSource Time source to which interpolation is synchronized. 
An input stream over elements of type "T" that reads from user-specified explicit offsets. 
An output stream that writes elements of type "T" to a user-specified explicit offset. 
An output stream that writes elements of type "T".
@note This stream has an inherent position property and is thus not safe for concurrent access. 
An output stream filter takes an output stream "Stream" and processes it into an output stream over type "To". 
Interface for streams with an explicit position property. 
Interface for structures of finite size
A specialized signal object for journaling input. @see Journal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
copydoc JournaledSignal 
This is a managed singleton class with explict creation and destruction functions which must be called at startup and shutdown of the engine.
Your class to be managed must implement the following function:
static const char* getSingletonName() { return "YourClassName"; }
This allow us to provide better asserts. 
A Map template class. The map class maps between a key and an associated value. Keys are unique. The hash table class is used as the default implementation so the the key must be hashable, see util/hash.h for details. @ingroup UtilContainers 
This is class MRandomDeck. 
This is class MRandomSet. 
A helper template class for registering creation methods to name strings. 
Null swizzle 
Set of planes which can be tested against bounding volumes.
This class is meant as a helper to collect functionality for working with sets of planes. As a helper, it does not define means to manage the data it uses.
@warn This class does not manage the memory needed for the set. 
This is class RawDataT. 
Resource template. When dealing with resources, this is the class that will be used. One creates resources by opening or creating them via the resource manager. The resource manager returns ResourceBases, which can be used to construct any type of resource (see the constructors for this template). When instantiating classes using this template, it is always necessary to define the create and getSignature methods. The createMethod will be responsible for loading a resource from disk using passed path. 
This is a utility class used by resource manager. Classes derived from this template pretty much just know how to delete the template's type. 
This template may be used to register a load signal as follows: static ResourceRegisterLoadSignalsgAuto( staticLoadFunction ); 
This is class ResourceRegisterPostLoadSignal. 
This is class ResourceRegisterUnloadSignal. 
Represents a response curve, can query values 
This class is to allow new types to be added, at run-time, to Torque. This is primarily for dynamic libraries, plugins etc.
The idea is the same, one instance per type which is getting registered however it doesn't get added to the dictionary until it is told to add itself. It can be removed, as well, though no safe-execution assurances are made by this class. If an object type is removed behavior of existing console objects of that type is undefined. (aka bad stuff will probably happen but I don't know exactly what) 
Template mixin to add ability to hold a custom SFXAmbience to a SceneObject
This is class SceneObjectRefBase. 
Helper template for mixing a polyhedral volume definition into the superclass hierarchy of a SceneSpace-derived class. 
Helper class to track the position of a point in N-dimensional space relative to a collection of N-dimensional volumes.
This class works by breaking the N-dimensional case down into N one-dimensional cases. By tracking objects independently along each of their axes, intersection testing becomes a trivial matter of doing point-on-line tests. The line segments can be conveniently represented as ordered linked lists along which the reference point is being moved.
To determine N-dimensional containment of the reference point, the result of each of the one-dimensional point-on-line tests simply has to be combined. If the point lies on each of N... more 
Base class for objects registered with a ScopeTracker
This is class Selection. 
Information about an object in the SFX world.
SFXObjects are:
  • Occluders: blocking sound
  • Zones: ambient sound spaces
  • Portals: connectors between zones
  • Listeners: receiving sound

Note that emitters are not managed by the SFX world. Instead, the set of 3D voices active on the device at any one point is defined as the set of current sound sources. 
SFXWorld tracks an N-dimensional world of SFXObjects.
This class uses two systems as back-ends: occlusion handling is passed on to the occlusion manager installed on the system and tracking the listener traveling through the ambient spaces is 
circuit signal implementations 
This is class Signal<bool(A)>. 
This is class Signal<bool(A,B)>. 
This is class Signal<bool(A,B,C)>. 
This is class Signal<bool(A,B,C,D)>. 
This is class Signal<bool(A,B,C,D,E)>. 
This is class Signal<bool(A,B,C,D,E,F)>. 
This is class Signal<bool(A,B,C,D,E,F,G)>. 
This is class Signal<bool(A,B,C,D,E,F,G,H)>. 
This is class Signal<bool(A,B,C,D,E,F,G,H,I)>. 
This is class Signal<bool(A,B,C,D,E,F,G,H,I,J)>. 
This is class Signal<bool(A,B,C,D,E,F,G,H,I,J,K)>. 
This is class Signal<bool(A,B,C,D,E,F,G,H,I,J,K,L)>. 
This is class Signal<bool(A,B,C,D,E,F,G,H,I,J,K,L,M)>. 
Non short-circuit signal implementations 
This is class Signal<void(A)>. 
This is class Signal<void(A,B)>. 
This is class Signal<void(A,B,C)>. 
This is class Signal<void(A,B,C,D)>. 
This is class Signal<void(A,B,C,D,E)>. 
This is class Signal<void(A,B,C,D,E,F)>. 
This is class Signal<void(A,B,C,D,E,F,G)>. 
This is class Signal<void(A,B,C,D,E,F,G,H)>. 
This is class Signal<void(A,B,C,D,E,F,G,H,I)>. 
This is class Signal<void(A,B,C,D,E,F,G,H,I,J)>. 
This is class Signal<void(A,B,C,D,E,F,G,H,I,J,K)>. 
This is class Signal<void(A,B,C,D,E,F,G,H,I,J,K,L)>. 
This is class Signal<void(A,B,C,D,E,F,G,H,I,J,K,L,M)>. 
This is class SignalBaseT. 
Class for handle automatic diconnect form Signal when destroyed 
Smart SimObject pointer.
This class keeps track of the book-keeping necessary to keep a registered reference to a SimObject or subclass thereof.
Normally, if you want the SimObject to be aware that you have a reference to it, you must call SimObject::registerReference() when you create the reference, and SimObject::unregisterReference() when you're done. If you change the reference, you must also register/unregister it. This is a big headache, so this class exists to automatically keep track of things for you.
@code // Assign an object to the SimObjectPtrmOrbitObject = Sim::findObject("anObject");
// Use it as a GameBase*. mOrbitObject->getWorldBox().getCenter(&mPosition);... more 
This is class SimpleHashTable. 
An iterator that recursively and exhaustively traverses the contents of a SimSet.
@see SimSet 
This is a simple thread safe singleton class based on the design of boost::singleton_default (see
This singleton is guaranteed to be constructed before main() is called and destroyed after main() exits. It will also be created on demand if Singleton::instance() is called before main() begins.
This thread safety only works within the execution context of main(). Access to the singleton from multiple threads outside of main() is is not guaranteed to be thread safe.
To create a singleton you only need to access it once in your code:
You do not need to derive... more 
This is class SparseArray. 
Reference counted object template pointer class Instances of this template class can be used as pointers to instances of StrongRefBase and its subclasses. The object will not be deleted until all of the StrongRefPtr instances pointing to it have been destructed. 
Union of an arbitrary type with a StrongRefBase. StrongRefBase will remain locked until the union is destructed. Handy for when the exposed class will become invalid whenever the reference becomes invalid and you want to make sure that doesn't happen. 
This oxymoron is a pointer that reference-counts the referenced object but also NULLs out if the object goes away.
This is useful for situations where an object's lifetime is ultimately governed by a superior entity but where individual objects may also die independently of the superior entity. All client code should use StrongWeakRefs that keep object live as long as the superior entity doesn't step in and kill them (in which case, the client code sees the reference disappear). 
This class will swizzle 'sizeof( T )' length chunks of memory into different patterns which are user described. The pattern is described by an instance of Swizzle and this swizzle can then be executed on buffers. The following must be true of the buffer size: size % ( sizeof( T ) * mapLength ) == 0 
Fast, lock-free double-ended queue for concurrent access.
@param T Type of list elements; must have default contructor. 
Freelist for re-using allocations in a concurrent setting.
@note Make sure that there are no more allocations in use when the free list is destructed. @note Allocated instances come with a reference already counted on the instance.
@param T Type of elements to allocate; must be derived from ThreadSafeRefCount and have at least define one additional pointer-sized field. 
Baseclass for objects allocated from ThreadSafeFreeLists. 
Reference to a concurrently reference-counted object.
This class takes care of the reference-counting as well as protecting the reference itself from concurrent operations.
Tagging allows the pointer contained in the reference to be flagged. Tag state is preserved through updates to the reference.
@note If you directly assign a freshly created object with a reference count of zero to a ThreadSafeRef, make absolutely sure the ThreadSafeRef is accessed only by a single thread. Otherwise there's a risk of the object being released and freed in midst of trying to set the reference. 
Baseclass for concurrently reference-counted objects.
@note NOTE that freshly instantiated objects start out with a reference count of ZERO! Depending on how this class is used, this may not be desirable, so override this behavior in constructors if necessary.
@param T the class being reference counted; this is passed to this class, so it can call the correct destructor without having to force users to have virtual methods 
Template class that will get used as a base for the thread statics 
An array that does not manage the memory it gets passed. Conversely, the array cannot be enlarged.
@note As the array does not manage the instances it uses, it will also not destruct them when it is itself destructed. 
A dynamic array template class.
The vector grows as you insert or append elements. Insertion is fastest at the end of the array. Resizing of the array can be avoided by pre-allocating space using the reserve() method.
Template for vectors of pointers. 
Weak reference pointer class. Instances of this template class can be used as pointers to instances of WeakRefBase and its subclasses. When the object referenced by a WeakRefPtr instance is deleted, the pointer to the object is set to NULL in the WeakRefPtr instance. 
Union of an arbitrary type with a WeakRefBase. The exposed type will remain accessible so long as the WeakRefBase is not cleared. Once it is cleared, accessing the exposed type will result in a NULL pointer. 
Copyright (c) 2015. All rights reserved.
What do you think about this topic? Send feedback!