TGEA Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_StringTableA global table for the hashing and tracking of strings
_StringTable::NodeThis is internal to the _StringTable class
_TorqueThreadStatic
_TorqueThreadStaticReg
AbstractClassRepCore functionality for class manipulation
AbstractClassRep::Field
AbstractPolyListA polygon filtering interface
ActionMapMap raw inputs to a variety of actions
ActionMap::BreakEntry
ActionMap::DeviceMapUsed to represent a devices
ActionMap::Node
AdjustHeightAction
GL::AGLExtensionFlags
GL::AGLExtensionPtrs
AIClient
AIConnection
AIPlayer
AISpecialNode
ALDEVICEINFO
ALDeviceList
AlignedArray< T >This is a fixed size class that will align its elements on configurable boundaries
AngAxisF
AppVertConnectorGLSL
AsciiData
AsciiData::KeyData
AssignDecl
AssignExprNode
AssignOpExprNode
AtlasBaseStubBase class for all Atlas stubs
AtlasBaseTOC< StubType >Templated base class for TOCs
AtlasChunkBase class for paged Atlas data
AtlasChunkGeomCollisionBufferGeneratorHelper class to optimize collision index data
AtlasClassFactoryHelper class to manage RTTI for a bunch of different possible fields
AtlasClipMapBatcherManage optimal rendering of a set of AtlasGeomChunks with a clipmap applied
AtlasClipMapBatcher::RenderNote
AtlasClipMapImageSource
AtlasConfigChunkA dictionary of configuration data
AtlasConfigChunk::DictEntry
AtlasConvexImplementation of a triangle-based convex for Atlas collision
AtlasDeferredFileBasic background IO implementation for Atlas files
AtlasDeferredIOBasic structure for describing an IO operation on an AtlasDeferredFile
AtlasDiscreteMeshA discrete mesh, for use when modifying Atlas mesh data
AtlasExportHelper class to hook back into export feedback mechanisms from the Atlas codebase
AtlasFileRepresents a single .atlas file; provides an interface for performing threaded reads and writes against that file, as well as tracking the TOCs in that file
AtlasFile::IOStatusInformation about the current I/O system status
AtlasFile::IOStatus::TOCIOStatusI/O status of a single resource TOC
AtlasGenStatsStat-tracking helper for AtlasOldMesher
AtlasGeomChunkAtlas chunk subclass for geometry
AtlasGeomChunk::ColNodeA quadtree of ColNodes lets us do a quick broad filter against collision queries and efficiently reduce the number of triangles we have to individually check
AtlasGeomChunkTracerTrace rays against an AtlasGeomChunk
AtlasImageImporter
AtlasImportOldCHUHelperHelper class to assist in importing the old .chu format into an Atlas file
AtlasImportOldCHUHelper::OldCHUChunk
AtlasImportOldCHUHelper::OldCHUChunk::ColTreeNode
AtlasImportOldCHUHelper::OldCHUChunk::Vert
AtlasImportOldCHUHelper::OldCHUHeader
AtlasImportOldCHUHelper::OldCHUStub
AtlasImportOldTQTHelperHelper class to assist in importing an old-style .tqt file into a TOC in an AtlasFile
AtlasImportOldTQTHelper::OldTQTHeader
AtlasInstanceAn instance of an Atlas terrain
AtlasInstanceColorSource
AtlasInstanceGeomStubAtlas instance stub subclass for geometry data
AtlasInstanceGeomTOCAtlas instance TOC for geometry
AtlasInstanceGeomTOC::StackNode
AtlasInstanceStub< _ChunkType, thisT >
AtlasInstanceTexStub
AtlasInstanceTexTOC
AtlasInstanceTOC< _StubType, _ResourceTOCType >Atlas instance TOC base class
AtlasOldActivationHeightfieldAdds activation level tracking functionality for AtlasOldHeightfield
AtlasOldHeightfieldAn unsigned 16bit heightfield, used in situations where we need to manipulate heightfield information directly (ie, mesh generation, collision, and so forth)
AtlasOldMesherHelper class for generating and outputting chunk geometry for an Atlas terrain
AtlasOldMesher::VertRepresents a vertex in our mesh
AtlasReadNoteUsed to track a load request made upon an AtlasFile
AtlasRenderPlugin
AtlasRequestHeaderHelper class for AtlasResourceStub book-keeping
AtlasRequestHeader::ARHNote
AtlasResourceConfigStubAtlas resource stub subclass for configuration chunks
AtlasResourceConfigTOCAtlas resource TOC subclass for configuration data
AtlasResourceGeomStubAtlas resource stub subclass for geometry
AtlasResourceGeomTOCAtlas resource TOC subclass for geometry
AtlasResourceStub< ChunkTypeT >Base class for resource stubs
AtlasResourceTexStubAtlas stub subclass for textures
AtlasResourceTexTOCAtlas TOC subclass for textures
AtlasResourceTOC< StubTypeT >Base resource TOC implementation
AtlasSurfaceQueryHelperAllow traversal over atlas geometry using UV coordinates
AtlasTexChunkAtlas chunk subclass for textures
AtlasTOCBase class for all Atlas Table Of Contents classes
AtlasTOCAggregator< TOC >Class to aggregate LOD and stub request operations on multiple Atlas TOCs
Auth2CertificateFormerly contained a certificate, showing that something was valid
AuthInfoFormerly contained data indicating whether a user is valid
AutoPtr< T, P >A simple smart pointer
AutoPtrRef< T >
AvailableSLInterfaces
BadWordFilter
BadWordFilter::FilterTable
BanListHelper class to keep track of bans
BanList::BanInfo
BaseMaterialDefinition
BaseMaterialInfo
BaseMatInstance
BaseTexFeatGLSLBase texture
BaseTexFeatHLSLBase texture
BasicLightInfo
BasicLightManager
BasicLightManager::LightingShaderConstants
BinaryExprNodeA binary mathematical expression (ie, left op right)
BitMatrixA matrix of bits
BitRenderFunctions for rendering to 1bpp bitmaps
BitSet32A convenience class to manipulate a set of bits
BitStream
BitVectorManage a vector of bits of arbitrary size
BitVectorW
BlobShadow
Box3DClone of Box3F, using 3D types
Box3FBounding Box
Box3IBounding Box
BoxBrush
BoxConvex
BreakStmtNode
Brush
BrushAdjustHeightAction
BSPNode
BumpFeatGLSL
BumpFeatHLSL
BVPT< Tstoreobj >
Torque::ByteBuffer
CameraImplements a basic camera object
Camera::StateDelta
CameraBookmark
CameraData
CameraFX
CameraFXManager
CameraQuery
CameraScopeQuery
CameraShake
CameraSpline
CameraSpline::Knot
CameraSpline::TimeMap
Zip::CentralDir
ChunkCornerPoint
ChunkEdge
Chunker< T >
ChunkScanEdge
ChunkTriangleBufferGeneratorThis is a utility class to generate an optimized triangle buffer for the Atlas terrain collision engine
ClassChunker< T >Templatized data chunker class with proper construction and destruction of its elements
ClearAction
ClearEmptyAction
ClearMaterialsAction
ClearModifiedAction
ClientProcessListList to keep track of GameBases to process
ClipMapA clipmap texturing helper
ClipMap::ClipStackEntry
ClipMapBlenderCache
ClipMapImageCache_DebugA clipmap "cache" that produces a variety of debug patterns on the fly
ClipMapUniqueCacheFill clipmap with data from a single large image source
ClippedPolyList
ClippedPolyList::Poly
ClippedPolyList::Vertex
fastdelegate::detail::ClosurePtr< GenericMemFunc, StaticFuncPtr, UnvoidStaticFuncPtr >
Cloud
CodeBlockCore TorqueScript code management class
Collision
CollisionList
CollisionState
CollisionStateList
CollisionWorkingList
CollisionWorkingList::RLink
CollisionWorkingList::WLink
ColorF
ColorI
ColorMultiplyFeatGLSLColorMultiply
ColorMultiplyFeatHLSLColorMultiply
CommaCatExprNode
Compiler::CompilerFloatTable
Compiler::CompilerFloatTable::Entry
Compiler::CompilerIdentTable
Compiler::CompilerIdentTable::Entry
Compiler::CompilerStringTable
Compiler::CompilerStringTable::Entry
ComponentInterface
ComponentInterfaceCacheThis class is just designed to isolate the functionality of querying for, and managing interfaces
ComponentInterfaceCache::_InterfaceEntry
CompoundKey< A, B >
Zip::Compressor
ConcreteClassRep< T >Helper class for AbstractClassRep
ConcretePolyListA concrete, renderable PolyList
ConcretePolyList::Poly
ConditionalExprNode
ConnectionProtocolThe base class for Torque's networking protocol
ConnectionStringTableMaintain a table of strings which are shared across the network
ConnectionStringTable::Entry
ConsoleBaseType
ConsoleConstructorThis is the backend for the ConsoleMethod()/ConsoleFunction() macros
ConsoleLogEntryRepresents an entry in the log
ConsoleLoggerA class designed to be used as a console consumer and log the data it receives to a file
ConsoleObjectInterface class to the console
Compiler::ConsoleParserList of parsers for the compiler
ConstantNode
Container
Container::CallbackInfo
Container::Link
ContinueStmtNode
ControlSizingRepresents the Sizing Options for a GuiControl
Convex
ConvexFeature
ConvexFeature::Edge
ConvexFeature::Face
CreateSPSessionTask
CreatorTree
CreatorTree::Node
CubemapData
CustomMaterial
D3D8XFNTable
D3DXFNTable
DataChunkerImplements a chunked data allocator
DataChunker::DataBlockBlock of allocated memory
DbgFileView
DbgFileView::FileLine
DDSFile
DDSFile::SurfaceData
Debris
DebrisData
DebugDrawer
DebugDrawer::DebugPrim
DecalDataDataBlock implementation for decals
DecalInstanceStore an instance of a decal
DecalManagerManage decals in the world
DecOp
DefaultPlatformTimer
fastdelegate::detail::DefaultVoidToVoid< T >
fastdelegate::detail::DefaultVoidToVoid< DefaultVoid >
fastdelegate::DelegateMemento
DelegateRemapper< T >
DeleteArrayDelete an array of objects policy for AutoPtr
DeleteSessionTask
DeleteSingleDelete a single object policy, this is the default policy for AutoPtr
DepthSortList
DepthSortList::PolyExtents
DeselectAction
DetailFeatGLSLDetail map
DetailFeatHLSLDetail map
DetailManager
DetailManager::DetailData
DetailManager::DetailProfile
Dictionary
Dictionary::Entry
Dictionary::HashTableData
DiffuseFeatureGLSLDiffuse color
DiffuseFeatureHLSLDiffuse color
DInputDevice
DInputManager
Torque::FS::DirectoryDirectory in a FileSystem
DisplayDevice
DisplayPtrManager
DLibraryDynamic Library Interface for library objects loaded using the loadLibrary() function
DSoundFNTable
DXT5nmSwizzle
DXT5nmSwizzleUp24t32
DynamicConsoleMethodComponent
DynamicLightingDummyFeatureGLSL
DynamicLightingDummyFeatureHLSL
DynamicLightingFeatureGLSL
DynamicLightingFeatureHLSL
UnitTesting::DynamicTestRegistration
EarlyOutPolyListEarly out check PolyList
EarlyOutPolyList::Poly
EarlyOutPolyList::Vertex
EchoOp
Edge
EdgeParent
EdgePoint
EdgeRectI
EditManager
EditTSCtrl
elapsedTime
elapsedTimeAggregate
EllipseBrush
EmitChunk
EmptyType
Zip::EndOfCentralDir
EndSessionTask
EnumTableScripting engine representation of an enum
EnumTable::EnumsThis represents a specific item in the enumeration
EventDescriptor
EventManagerWrapper for the standard messaging system
EventManagerListenerListener class used by the EventManager to dispatch messages to specific callbacks
EventManagerListener::SubscriberStores subscription information for a subscriber
Explosion
ExplosionData
ExposureFeatureX2GLSL
ExposureFeatureX2HLSL
ExposureFeatureX4GLSL
ExposureFeatureX4HLSL
ExprEvalState
ExprNodeA mathematical expression
Zip::ExtraField
ExtrudedPolyListExtruded Polytope PolyList
ExtrudedPolyList::ExtrudedFace
ExtrudedPolyList::Poly
ExtrudedPolyList::Vertex
fastdelegate::FastDelegate0< RetType >
fastdelegate::FastDelegate0< RetType >::SafeBoolStruct
fastdelegate::FastDelegate1< Param1, RetType >
fastdelegate::FastDelegate1< Param1, RetType >::SafeBoolStruct
fastdelegate::FastDelegate2< Param1, Param2, RetType >
fastdelegate::FastDelegate2< Param1, Param2, RetType >::SafeBoolStruct
fastdelegate::FastDelegate3< Param1, Param2, Param3, RetType >
fastdelegate::FastDelegate3< Param1, Param2, Param3, RetType >::SafeBoolStruct
fastdelegate::FastDelegate4< Param1, Param2, Param3, Param4, RetType >
fastdelegate::FastDelegate4< Param1, Param2, Param3, Param4, RetType >::SafeBoolStruct
fastdelegate::FastDelegate5< Param1, Param2, Param3, Param4, Param5, RetType >
fastdelegate::FastDelegate5< Param1, Param2, Param3, Param4, Param5, RetType >::SafeBoolStruct
fastdelegate::FastDelegate6< Param1, Param2, Param3, Param4, Param5, Param6, RetType >
fastdelegate::FastDelegate6< Param1, Param2, Param3, Param4, Param5, Param6, RetType >::SafeBoolStruct
fastdelegate::FastDelegate7< Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType >
fastdelegate::FastDelegate7< Param1, Param2, Param3, Param4, Param5, Param6, Param7, RetType >::SafeBoolStruct
fastdelegate::FastDelegate8< Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType >
fastdelegate::FastDelegate8< Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8, RetType >::SafeBoolStruct
fastdelegate::FastDelegate< R() >
fastdelegate::FastDelegate< R(Param1) >
fastdelegate::FastDelegate< R(Param1, Param2) >
fastdelegate::FastDelegate< R(Param1, Param2, Param3) >
fastdelegate::FastDelegate< R(Param1, Param2, Param3, Param4) >
fastdelegate::FastDelegate< R(Param1, Param2, Param3, Param4, Param5) >
fastdelegate::FastDelegate< R(Param1, Param2, Param3, Param4, Param5, Param6) >
fastdelegate::FastDelegate< R(Param1, Param2, Param3, Param4, Param5, Param6, Param7) >
fastdelegate::FastDelegate< R(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) >
FeatureMgr
Torque::FS::FileFile object in a FileSystem
File
Torque::FS::FileBaseBase class for all FileIO objects
FileDialogFileDialog is a platform agnostic dialog interface for querying the user for file locations
FileDialogData
Zip::FileHeader
Platform::FileInfo
FileName
Torque::FS::FileNodeBase class for objects in a FileSystem
Torque::FS::FileNode::Attributes
FileObject
FileStream
FileStreamObject
Torque::FS::FileSystemCollection of FileNode objects
Torque::FS::FileSystemChangeNotifier
Torque::FS::FileSystemChangeNotifier::FileInfo
FileTimePlatform dependent file date-time structure
Filter
FilterStream
FindMatch
FixedVector< A >
FlattenHeightAction
FloatBinaryExprNode
FloatNode
FloatUnaryExprNode
FloorPlanResource
FloorPlanResource::Area
FlushStatsTask
FlyingVehicle
FlyingVehicle::JetActivation
FlyingVehicleData
FModFNTable
FogFeatGLSLFog
FogFeatHLSLFog
FogVolume
FontRenderBatcher
FontRenderBatcher::CharMarker
FontRenderBatcher::SheetMarker
ForcedMaterialMeshMgrBasically the same as RenderMeshMgr, but will override the material of the instance
ForceField
ForceField::IBSPLeafSolid
ForceField::IBSPNode
ForceField::Surface
FPSTracker
FrameAllocatorTemporary memory pool for per-frame allocations
FrameAllocatorMarkerHelper class to deal with FrameAllocator usage
FrameTemp< T >Class for temporary variables that you want to allocate easily using the FrameAllocator
FRangeValidatorFloating point min/max range validator
FreeListChunker< T >
FreeListChunkerUntyped
FrustrumCullerHelper class to perform efficient frustrum culling on bounding boxes
FrustumThis class implements a view frustum for use in culling scene objects and rendering the scene graph
FuncCallExprNode
FunctionDeclStmtNode
fxFoliageCulledList
fxFoliageItem
fxFoliageQuadrantNode
fxFoliageRenderList
fxFoliageReplicator
fxFoliageReplicator::tagFieldData
fxLight
fxLightData
fxShapeReplicatedStatic
fxShapeReplicator
fxShapeReplicator::tagFieldData
fxSunLight
GameBaseBase class for game objects which use datablocks, networking, are editable, and need to process ticks
GameBaseDataScriptable, demo-able datablock
GameConnection
GameConnection::GamePacketNotify
GGConnectInterface::GameInterfaceGameInterface is an abstract interface that games should implement if they want to use the GGConnectInterface helper code to communicate with the GGConnect framework
GameTSCtrl
GBitmap
GBitmap::Registration
GenericConstBufferThis class will be used by other const buffers and the material system
GenericConstBufferLayoutThis class describes a memory layout for a GenericConstBuffer
GenericConstBufferLayout::ParamDescDescribes the parameters we contain
GenOp
GFont
GFX360Device
GFX360TextureTarget
GFX360TilingScenario
GFXAdapter
GFXCardProfilerGraphics Card Profile
GFXCubemap
GFXD3D8CardProfiler
GFXD3D8Cubemap
GFXD3D8Device
GFXD3D8PrimitiveBuffer
GFXD3D8ShaderMgr
GFXD3D8StateBlock
GFXD3D8TextureManager
GFXD3D8TextureObject
GFXD3D8TextureTarget
GFXD3D8VertexBuffer
GFXD3D8WindowTarget
GFXD3D9CardProfiler
GFXD3D9Cubemap
GFXD3D9Device
GFXD3D9PrimitiveBuffer
GFXD3D9QueryFence
GFXD3D9Shader
GFXD3D9ShaderConstBuffer
GFXD3D9ShaderMgr
GFXD3D9StateBlock
GFXD3D9TextureManager
GFXD3D9TextureObject
GFXD3D9TextureTarget
GFXD3D9VertexBuffer
GFXD3D9WindowTarget
GFXDebugMarkerHelper class to deal with OS specific debug functionality
GFXDeviceGFXDevice is the TSE graphics interface layer
GFXDeviceStatistics
GFXDrawUtilHelper class containing utility functions for useful drawing routines (line, box, rect, billboard, text)
GFXFence
GFXGeneralFence
GFXGLAppleFence
GFXGLCardProfilerA 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::<name> and set it to false in GFXGLCardProfiler::setupCardCapabilities() Enclose your workaround code in if(GFX->getCardProfiler()->queryProfile("GL::Workaround::<name>")) { <workaround> } Remember to set the work around to true in the card profile script!
GFXGLCubemap
GFXGLDevice
GFXGLPrimitiveBufferThis is a primitive buffer (index buffer to GL users) which uses VBOs
GFXGLShader
GFXGLShaderConstBuffer
GFXGLShaderMgr
GFXGLStateBlock
GFXGLTextureManager
GFXGLTextureObject
GFXGLTextureTarget
GFXGLVertexBufferThis is a vertex buffer which uses GL_ARB_vertex_buffer_object
GFXGLWindowTarget
GFXInitInterface for tracking GFX adapters and initializing them into devices
GFXLightInfo
GFXLightMaterial
GFXLockedRectContains information on a locked region of a texture
GFXMaterialFeatureData
GFXNullDevice
GFXNullWindowTarget
GFXPCD3D9Device
GFXPrimitive
GFXPrimitiveBuffer
GFXPrimitiveBufferHandle
GFXResourceMixin for the purpose of tracking GFX resources owned by a GFXDevice
GFXSamplerStateDataAllows definition of sampler state via script, basically wraps a GFXSamplerStateDesc
GFXSamplerStateDesc
GFXShader
GFXShaderConstBufferGFXShaderConstBuffer is a collection of string/value pairs that are sent to a shader
GFXShaderConstDescInstances of this struct are returned GFXShaderConstBuffer
GFXShaderConstHandleThis is an opaque handle used by GFXShaderConstBuffer clients to set individual shader constants
GFXShaderMacroPassed to GFX for shader defines
GFXShaderMgr
GFXStateBlock
GFXStateBlockDataAllows definition of render state via script, basically wraps a GFXStateBlockDesc
GFXStateBlockDescGFXStateBlockDesc defines a render state, which is then used to create a GFXStateBlock instance
GFXTargetBase class for a target to which GFX can render
GFXTexHandle
GFXTextureManager
GFXTextureManager::CallbackData
GFXTextureObject
GFXTextureProfile
GFXTextureTargetA render target associated with one or more textures
GFXTransformSaverHelper class to store viewport and matrix stack state, and restore it later
GFXVertexBuffer
GFXVertexBufferHandle< T >
GFXVertexBufferHandleBase
GFXVertexColor
GFXVideoMode
GFXWindowTargetA render target associated with an OS window
GGMacViewGGMacView handles displaying content and responding to user input
GhostInfoInformation about a ghosted object
GjkCollisionState
GL::GLExtensionFlags
GL::GLExtensionPtrs
GlowBuffer
GL::GLXExtensionFlags
GridChunk
GridInfo
GridPoint
GridSquare
GroundCover
Gui3DMouseEvent
GuiArrayCtrlRenders a grid of cells
GuiAtlasMonitorCtrlA utility widget that displays what's going on inside of Atlas
GuiAtlasMonitorCtrl::TOCMonitorBookkeeping for a single TOC in the Atlas file we are monitoring
GuiAutoScrollCtrl
GuiAviBitmapCtrl
GuiBackgroundCtrlRenders a background, so you can have a backdrop for your GUI
GuiBitmapButtonCtrl------------------------------------- Bitmap Button Contrl Set 'bitmap' comsole field to base name of bitmaps to use
GuiBitmapButtonTextCtrl
GuiBitmapCtrlRenders a bitmap
GuiBubbleTextCtrl
GuiButtonBaseCtrl
GuiButtonCtrl
GuiCanvasA canvas on which rendering occurs
GuiCanvas::AccKeyMapAccelerator key map
GuiCheckBoxCtrl
GuiColorPickerCtrlGuiColorPickerCtrl
GuiConsole
GuiConsoleEditCtrl
GuiConsoleTextCtrl
GuiContainer
GuiControl
GuiControlArrayControl
GuiControlProfileA GuiControlProfile is used by every GuiObject and is akin to a datablock
GuiCursor
GuiDirectoryFileListCtrl
GuiDirectoryTreeCtrl
GuiDragAndDropControl
GuiDynamicCtrlArrayControl
GuiEditCtrl
GuiEventRepresents a single GUI event
GuiFileTreeCtrl
GuiFilterCtrl
GuiFormCtrl
GuiFrameSetCtrl
GuiFrameSetCtrl::FrameDetail
GuiGameListMenuCtrlA base class for cross platform menu controls that are gamepad friendly
GuiGameListMenuCtrl::RowInternal data representation of a single row in the control
GuiGameListMenuProfileA gui profile with additional fields specific to GuiGameListMenuCtrl
GuiGameListOptionsCtrlA control for showing pages of options that are gamepad friendly
GuiGameListOptionsCtrl::RowAn extension to the parent's row, adding the ability to keep a collection of options and track status related to them
GuiGameListOptionsProfileA gui profile with additional fields specific to GuiGameListOptionsCtrl
GuiGraphCtrl
GuiGraphCtrl::PlotInfo
GuiIconButtonCtrl------------------------------------- Icon Button Control Draws the bitmap within a normal button control
GuiImageList
GuiImageList::tag_TextureEntry
GuiInputCtrl
GuiInspector
GuiInspectorDatablockField
GuiInspectorDynamicField
GuiInspectorDynamicGroup
GuiInspectorField
GuiInspectorGroup
GuiInspectorTypeCheckBox
GuiInspectorTypeColor
GuiInspectorTypeColorF
GuiInspectorTypeColorI
GuiInspectorTypeEnum
GuiInspectorTypeFileName
GuiInspectorTypeGuiProfile
GuiInspectorTypeS32
GuiInspectorTypeString
GuiListBoxCtrl
GuiListBoxCtrl::LBItem
GuiMenuBackgroundCtrl
GuiMenuBar
GuiMenuBar::Menu
GuiMenuBar::MenuItem
GuiMenuTextListCtrl
GuiMessageVectorCtrlRender a MessageVector (chat HUD)
GuiMessageVectorCtrl::LineElement
GuiMessageVectorCtrl::LineWrappingDerived classes must keep this set of variables consistent if they use this classes onRender
GuiMessageVectorCtrl::LineWrapping::SEPair
GuiMessageVectorCtrl::SpecialMarkers
GuiMessageVectorCtrl::SpecialMarkers::Special
GuiMessageVectorCtrl::TextElement
GuiMLTextCtrl
GuiMLTextCtrl::Atom
GuiMLTextCtrl::Bitmap
GuiMLTextCtrl::BitmapRef
GuiMLTextCtrl::Font
GuiMLTextCtrl::Line
GuiMLTextCtrl::LineTag
GuiMLTextCtrl::Style
GuiMLTextCtrl::URL
GuiMLTextEditCtrl
GuiMouseEventCtrl
GuiObjectView
GuiPaneControlCollapsable pane control
GuiPanel
GuiPopUpBackgroundCtrl
GuiPopUpBackgroundCtrlEx
GuiPopUpMenuCtrl
GuiPopUpMenuCtrl::Entry
GuiPopUpMenuCtrl::Scheme
GuiPopUpMenuCtrlEx
GuiPopUpMenuCtrlEx::Entry
GuiPopUpMenuCtrlEx::Scheme
GuiPopupTextListCtrl
GuiPopupTextListCtrlEx
GuiProgressCtrl
GuiRadioCtrl
GuiRolloutCtrl
GuiScriptNotifyCtrl
GuiScrollCtrl
GuiSeparatorCtrlRenders a separator line with optional text
GuiSliderCtrl
GuiSplitContainer
GuiStackControlA stack of GUI controls
GuiSubmenuBackgroundCtrl
GuiTabBookCtrlTab Book Control for creation of tabbed dialogs
GuiTabBookCtrl::TabHeaderInfo
GuiTabPageCtrl
GuiTerrPreviewCtrl
GuiTextCtrl
GuiTextEditCtrl
GuiTextEditSliderCtrl
GuiTextListCtrl
GuiTextListCtrl::Entry
GuiTheoraCtrlPlay back a Theora video file
GuiTickCtrlThis Gui Control is designed to be subclassed to let people create controls which want to receive update ticks at a constant interval
GuiToggleButtonCtrl
GuiToolboxButtonCtrl
GuiTreeViewCtrl
GuiTreeViewCtrl::Item
GuiTreeViewCtrl::Item::InspectorTag
GuiTreeViewCtrl::Item::ScriptTag
GuiTSCtrl
GuiWindowCtrl
hash_multimap< T, Tinfo >
HashTable< Key, Value >A HashTable template class
HashTable< Key, Value >::_Iterator< U, E, M >
HashTable< Key, Value >::Node
HashTable< Key, Value >::Pair
Heightfield
fastdelegate::detail::horrible_union< OutputClass, InputClass >
HoverVehicle
HoverVehicle::JetActivation
HoverVehicleData
HTTPObject
IAtlasImageImportSourceInterface for image sources
ICallMethod
IClipMapImageCacheInterface for a clipmap image cache
IClipMapImageSourceInterface to fetch bits from an image source
IdGenerator
IfStmtNode
IGetSurfaceHelper
Dispatcher::IMessageListenerListener interface for objects that receive messages
InfiniteBitStreamThis class acts to provide an "infinitely extending" stream
Input
InputDevice
InputDevice::ObjInfo
InputEventInfoGeneric input event
InputManager
IntBinaryExprNode
Interior
Interior::AnimatedLight
Interior::ConvexHull
Interior::CoordBin
Interior::Edge
Interior::IBSPLeafSolid
Interior::IBSPNode
Interior::LightState
Interior::LightStateData
Interior::NullSurface
Interior::Portal
Interior::ReflectRenderNode
Interior::RenderNode
Interior::Surface
Interior::TexGenPlanes
Interior::TexMatrix
Interior::TriFan
Interior::VertexBufferTempIndexUsed to maintain point and normal relationship (which use dissimilar index lookups) for verts when building vertex buffer
Interior::Zone
Interior::ZoneReflectRNList
Interior::ZoneRNList
InteriorConvex
InteriorDict
InteriorDictEntry
InteriorInstance
InteriorLightPlugin
InteriorLMManager
InteriorLMManager::InstanceLMInfo
InteriorLMManager::InteriorLMInfo
InteriorPathFollower
InteriorPathFollower::WayPoint
InteriorResource
InteriorResTrigger
InteriorSimpleMesh
InteriorSimpleMesh::primitive
InteriorSubObject
InternalSlotAccessNode
InternalSlotDecl
IntNode
IntUnaryExprNode
IProcessInput
IRangeValidatorSigned integer min/max range validator
IRangeValidatorScaledScaled integer field validator
IRenderable3D
ISolid3D
Item
Item::StateDelta
ItemData
ITerrainInfoInterface for queries against the terrain dataset
ITickableThis interface allows you to let any object be ticked
ItrGameEntity
ItrPaddedPoint
IXAudio2VoiceCallback
JoinSessionTask
JournalJournaling System
Journal::FuncDecl
Journal::FuncRep< T >
Journal::FunctorFunctor base classes
Journal::FunctorDecl< T >Multiple argument function functor specialization
Journal::FunctorDecl< void(*)(A) >
Journal::FunctorDecl< void(*)(A, B) >
Journal::FunctorDecl< void(*)(A, B, C) >
Journal::FunctorDecl< void(*)(A, B, C, D) >
Journal::FunctorDecl< void(*)(A, B, C, D, E) >
Journal::FunctorDecl< void(*)(A, B, C, D, E, F) >
Journal::FunctorDecl< void(*)(A, B, C, D, E, F, G) >
Journal::FunctorDecl< void(*)(A, B, C, D, E, F, G, H) >
Journal::FunctorDecl< void(*)(A, B, C, D, E, F, G, H, I) >
Journal::FunctorDecl< void(*)(A, B, C, D, E, F, G, H, I, J) >
Journal::MethodDecl< T, U >
Journal::MethodDecl< T *, void(T::*)(A) >
Journal::MethodDecl< T *, void(T::*)(A, B) >
Journal::MethodDecl< T *, void(T::*)(A, B, C) >
Journal::MethodDecl< T *, void(T::*)(A, B, C, D) >
Journal::MethodDecl< T *, void(T::*)(A, B, C, D, E) >
Journal::MethodDecl< T *, void(T::*)(A, B, C, D, E, F) >
Journal::MethodDecl< T *, void(T::*)(A, B, C, D, E, F, G) >
Journal::MethodDecl< T *, void(T::*)(A, B, C, D, E, F, G, H) >
Journal::MethodDecl< T *, void(T::*)(A, B, C, D, E, F, G, H, I) >
Journal::MethodDecl< T *, void(T::*)(A, B, C, D, E, F, G, H, I, J) >
Journal::MethodRep< T >
JournaledSignal< void()>
JournaledSignal< void(A)>
JournaledSignal< void(A, B)>
JournaledSignal< void(A, B, C)>
JournaledSignal< void(A, B, C, D)>
JournaledSignal< void(A, B, C, D, E)>
JournaledSignal< void(A, B, C, D, E, F)>
JournaledSignal< void(A, B, C, D, E, F, G)>
JournaledSignal< void(A, B, C, D, E, F, G, H)>
JoystickAxisInfo
JoystickInputDevice
Platform::KeyboardInputExclusionDescription of a keyboard input we want to ignore
LangElement
LangFileClass for working with language files
LangTableLanguage file table
LBResultContainer
LeaderboardStats
LightInfo
LightInfoDual
LightInfoDualList
LightInfoList
LightManager
LightManagerInst< T >
LightManagerInstBase
LightmapFeatGLSLLightmap
LightmapFeatHLSLLightmap
Lightning
Lightning::Strike
Lightning::Thunder
LightningBolt
LightningBolt::Node
LightningBolt::NodeManager
LightningData
LightNormMapFeatGLSLLight Normal Map
LightNormMapFeatHLSLLight Normal Map
Torque::List< Type >A list template class
Torque::List< Type >::_Iterator< U, E >
Torque::List< Type >::Link
Torque::List< Type >::Node
Torque::List< Type >::PrivatePersist
LList< T >
LListNode< T >
LoadAchievementsTask
LoadLeaderboardTask
Platform::LocalTime
LoopStmtNode
LowerHeightAction
macApplication
MacCarbFont
MacCarbPlatState
MacCursorController
MacWindow
MacWindowManager
Map< Key, Value, Sequence >A Map template class
Marker
MatchJoinSettings
MatchSearchSettings
MatchSettings
Material
Material::StageData
MaterialList
MaterialManager
MaterialParameterHandleSimilar class to GFXShaderConsts, but this is to describe generic material parameters
MaterialParameters
Math
MatInstance
MatInstanceHook
MatInstParameters
MatrixF4x4 Matrix Class
Torque::Mem::MemDirectory
Torque::Mem::MemFileMem stdio file access
Torque::Mem::MemFileSystem
UnitTesting::MemoryTester
MemStream
MenuBar
MeshRenderInst
MessageBase class for messages
MessageForwarderForward messages from one queue to another
Dispatcher::MessageQueueInternal class for tracking message queues
MessageVectorStore a list of chat messages
MessageVector::MessageLine
MessageVector::SpectatorRef
MirrorSubObject
MissionArea
MissionAreaEditor
MissionMarker
MissionMarkerData
Torque::FS::MountSystem
Torque::FS::MountSystem::MountFS
Torque::FS::MountSystem::MountList
Move
MoveList
MoveManager
MRandomGeneratorBase class for random number generators
MRandomLCGLinear Congruential Method, the "minimal standard generator"
MRandomR250Fast, very good random numbers
MultiLine
MultiTypedChunkerThis class is similar to the Chunker<> class above
Mutex
MutexHandleHelper for simplifying mutex locking code
Namespace
Namespace::Entry
Namespace::Entry::CallbackUnion
NetPlatform-specific network operations
NetAddressGeneric network address
NetAsync
NetConnectionTorque network connection
NetConnection::GhostRefStructure to track ghost references in packets
NetConnection::GhostSaveStructure to track ghost-always objects and their ghost indices
NetConnection::NetRate
NetConnection::PacketNotifyStructure to track packets and what we sent over them
NetEventAn event to be sent over the network
NetEventNote
NetInterfaceNetInterface class
NetObjectSuperclass for ghostable networked objects
NetStringHandle
NetStringTable
NetStringTable::Entry
Noise2D
NSApplication
NSOpenGLView
NullSwizzle< T, mapLength >
ObjectBlockDecl
ObjectDeclNode
ObjectRenderInst
OPENALFNTABLE
OpenFileDialog
OpenFolderDialog
OpenGLDevice
OptimizedPolyListA concrete, renderable PolyList
OptimizedPolyList::Edge
OptimizedPolyList::FullPoly
OptimizedPolyList::Poly
OptimizedPolyList::TriangleLighting
OptimizedPolyList::Vertex
OrthoBoxConvex
OutlineSelectAction
PaintMaterialAction
ParamsDefThis is to provide common functionalty needed by vertex and pixel main defs
ParamsDefHLSL
Row
Particle
ParticleData
ParticleEmitter
ParticleEmitterData
ParticleEmitterNode
ParticleEmitterNodeData
PathA path!
Torque::PathFileSystem filename representation
PathCamera
PathCamera::StateDelta
PathCameraData
PathedInterior
PathedInteriorData
PathManager
PathManager::PathEntry
PathNode
PersistInfo
PersistInfo::MissionChunk
PersistInfo::PersistChunk
PhysicalZone
PixelParamsDefGLSL
PixelParamsDefHLSL
PixelSpecularGLSL
PixelSpecularHLSL
PlaneD
PlaneExtractorPolyListFill a Vector<PlaneF> with the planes from the geometry passed through this PolyList
PlaneF
PlaneTransformer
PlatformAssert
PlatformCursorController
PlatformCursorController::PlatformCursor
PlatformFont
PlatformFont::CharInfo
GGConnectInterface::PlatformInterfaceThe PlatformInterface is an abstract interface that should be implemented by your game engine
PlatformPopupMenuData
PlatformTimerPlatform-specific timer class
PlatformVideoInfo
PlatformVideoInfo::PVIAdapter
PlatformWindowAbstract representation of a native OS window
PlatformWindowManagerAbstract representation of a manager for native OS windows
Player
Player::ActionAnimation
Player::ArmAnimation
Player::ContactInfo
Player::Death
Player::Range
Player::StateDeltaClient interpolation/warp data
PlayerAchievements
PlayerData
PlayerData::ActionAnimation
PlayerData::ActionAnimationDefAnimation and other data intialized in onAdd
PlayerData::ActionAnimationDef::Vector
PlayerStats
Point2D2D high-precision point
Point2F2D floating-point point
Point2I2D integer point
Point3D
Point3F
Point3I3D integer point
Point4F4D floating-point point
Point4I4D integer point
Polyhedron
Polyhedron::Edge
Polytope
Polytope::Collision
Polytope::Edge
Polytope::Face
Polytope::StackElement
Polytope::Vertex
Polytope::Volume
PopupMenu
Torque::Posix::PosixDirectory
Torque::Posix::PosixFilePosix stdio file access
Torque::Posix::PosixFileSystem
Precipitation
PrecipitationDataPrecipitation datablock
ProcessEvent generation signal
ProcessedCustomMaterial
ProcessedDynamicLightMaterialThis processed material class is used for dynamic lighting
ProcessedFFMaterialFixed function rendering
ProcessedFFMaterial::FixedFuncFeatureData
ProcessedMaterialThis is an abstract base class which provides the external interface all subclasses must implement
ProcessedShaderMaterial
ProcessListList of ProcessObjects
ProcessMutex
ProcessObject
ProcessObject::Link
ProcessorProcessor info manager
ProcessRegisterCommandLineRegister a command line handling function To use this, declare a static var like this: static ProcessRegisterCommandLine sgCommandLine(HandleCommandLine);
ProcessRegisterInitRegister an initialization function To use this, declare a static var like this: static ProcessRegisterInit sgInit(InitFoo);
ProcessRegisterProcessingRegister a processing function To use this, declare a static var like this: static ProcessRegisterProcessing sgProcess(ProcessFoo);
ProcessRegisterShutdownRegister a shutdown function To use this, declare a static var like this: static ProcessRegisterShutdown sgShutdown(ShutdownFoo);
ProjectileBase class for all projectiles
ProjectileDataDatablock for projectiles. This class is the base class for all other projectiles
QoSPollStatus
QuadPatchQuadratic spline patch
QuadTreeTracerHelper class to perform a fast, recursive ray cast against a set of hierarchical bounding boxes
QuadTreeTracer::RayStackNode
QuadTreeTracer::StackNode
Quat16Compressed quaternion class
QuatF
QuitEvent
Raindrop
RaiseHeightAction
RawData
RayInfoExtension of the collision structure to allow use with raycasting
ReadStatsTask
RectClipper
RectD
RectF
RectI
RectSpacingI
RedBook
RedBookDevice
ReflectCubeFeatGLSLReflect Cubemap
ReflectCubeFeatHLSLReflect Cubemap
ReflectPlane
RenderBinManager
RenderBinManager::MainSortElem
RenderGlowMgr
RenderInst
RenderInstType
RenderMeshDynamicLightingMgr
RenderMeshMgr
RenderObjectMgr
RenderPassDataThis contains the common data needed to render a pass
RenderPassManager
RenderPoint
RenderRefractMgr
RenderTranslucentMgr
ResDictionaryResource Dictionary
ResizeBitStream
ResizeFilterStream
ResManagerA virtual file system for the storage and retrieval of ResourceObjects
ResManager::RegisteredExtension
Resource< T >
ResourceBase
ResourceBase::Header
ResourceHolder< T >
ResourceHolderBase
ResourceInstanceThe base class for all resources
ResourceManager
ResourceObjectWrapper around a ResourceInstance
ResourceOld< T >Wrapper class around a ResourceInstance subclass
ResourceRegisterLoadSignal< T >This template may be used to register a load signal as follows: static ResourceRegisterLoadSignal<T> sgAuto( staticLoadFunction );
ReturnStmtNode
ReturnType< R >
ReturnType< R(*)()>
ReturnType< R(*)(A)>
ReturnType< R(*)(A, B)>
ReturnType< R(*)(A, B, C)>
ReturnType< R(*)(A, B, C, D)>
ReturnType< R(*)(A, B, C, D, E)>
ReturnType< R(*)(A, B, C, D, E, F)>
ReturnType< R(*)(A, B, C, D, E, F, G)>
ReturnType< R(O::*)()>
ReturnType< R(O::*)(A)>
ReturnType< R(O::*)(A, B)>
ReturnType< R(O::*)(A, B, C)>
ReturnType< R(O::*)(A, B, C, D)>
ReturnType< R(O::*)(A, B, C, D, E)>
ReturnType< R(O::*)(A, B, C, D, E, F)>
ReturnType< R(O::*)(A, B, C, D, E, F, G)>
Rigid
RigidShape
RigidShape::StateDelta
RigidShapeData
RigidShapeData::Body
RuntimeClassRep< T >This class is to allow new types to be added, at run-time, to Torque
GGConnectInterface::RuntimeInterfaceThe RuntimeInterface is an abstract interface that should be implemented by your engine
SaveFileDialog
ScaleHeightAction
SceneGraph
SceneGraph::ZoneManager
SceneGraphData
SceneLighting
SceneLighting::ObjectProxyCreate a proxy for each object to store data
SceneLightingInterface
SceneObjectA 3D object
SceneObjectLightingPlugin
SceneObjectRefReference to a scene object
SceneRootRoot of scene graph
SceneStateThe SceneState describes the state of the scene being rendered
SceneState::FogBand
SceneState::InteriorListElem
SceneState::TransformPortalUsed to represent a portal which inserts a transformation into the scene
SceneState::ZoneState
ScreenShot
ScreenShotD3D
ScreenShotD3D8
ScriptCallbackHelperHelper class to interface with the console for script callbacks
ScriptMsgListenerScript accessible version of Dispatcher::IMessageListener
ScriptObject
SelectAction
Selection
SelectionBrush
SelfIlluminationFeatureGLSL
SelfIlluminationFeatureHLSL
Semaphore
ServerInfo
ServerProcessList
SetEmptyAction
SetHeightAction
SetMaterialGroupAction
SetMissionCRCEvent
SetModifiedAction
SFXALBuffer
SFXALDevice
SFXALVoice
SFXBufferThe buffer interface hides the details of how the device holds sound data for playback
SFXDescriptionThe SFXDescription defines how a sound should be played
SFXDevice
SFXDeviceInfo
SFXDSBuffer
SFXDSDeviceThe DirectSound device implementation exposes a couple of settings to script that you should be aware of:
SFXDSVoice
SFXEmitterThe SFXEmitter is used to place 2D or 3D sounds into a mission
SFXEnvironmentWarning: This class is non-functional and is only here to allow InteriorInstance to compile
SFXFMODBuffer
SFXFMODDevice
SFXFMODVoice
SFXListener
SFXNullBuffer
SFXNullDevice
SFXNullVoice
SFXOggResourceThe concrete sound resource for loading Ogg Vorbis audio data
SFXProfileThe SFXProfile is used to define a sound for playback
SFXProvider
SFXResourceThis is the base class for all sound file resources including streamed sound files
SFXSourceA source is a scriptable controller for all aspects of sound playback
SFXSystemThis class provides access to the sound system
SFXVoiceThe voice interface provides for playback of sound buffers and positioning of 3D sounds
SFXVorbisStreamA simple wrapper around OggVorbis_File which works with the Torque Stream classes
SFXWavResourceThe concrete sound resource for loading PCM Wave audio data
SFXXAudioBuffer
SFXXAudioDevice
SFXXAudioVoice
sgColorMap
sgDRLSurfaceChain
sgDRLSystem
sgDynamicLightCache
sgDynamicLightCacheData
sgFormatManager
sgGuiTexTestCtrl
sgInteriorLightPlugin
sgLightInfo
sgLightingModel
sgLightingModelAdvanced
sgLightingModelGLBase
sgLightingModelInverseSquare
sgLightingModelInverseSquareFastFalloff
sgLightingModelManager
sgLightingModelNearLinear
sgLightingModelNearLinearFastFalloff
sgLightingModelStock
sgLightManager
sgLightMapThe base class for generating mission level or real-time light maps for any sceneObject
sgLightMap::sgStaticMeshInfo
sgLightObjectThis class extends fxLight to provide mission level static light objects
sgLightObject::sgAnimateState
sgLightObjectDataThe datablock class for sgUniversalStaticLight
sgMatInstance
sgMatInstanceHook
sgMeshLightPlugin
sgMissionLightingFilter
sgMissionLightingFilterData
sgPlanarLightMapUsed to generate light maps on interiors
sgPlanarLightMap::sgLexel
sgPlanarLightMap::sgOccluder
sgPlanarLightMap::sgSmoothingTri
sgPlanarLightMap::sgSmoothingVert
sgRelightFilter
sgSceneLighting
sgSceneLightingProcessEvent
sgSceneObjectLightingPlugin
sgSceneObjectLightingPlugin::LightingInfo
sgShadowObjects
sgShadowObjects::sgObjectInfoObject info..
sgShadowObjects::sgStaticMeshTriUsed for storing static mesh geometry for fast shadow detection..
sgShadowProjector
sgShadowProjector::sgShadow
sgShadowSharedZBuffer
sgShadowTextureCache
sgShadowTextureEntryInfo
sgStatistics
sgTerrainLightMapUsed to generate terrain light maps
SGWinding
ShaderComponent
ShaderConnector
ShaderConnectorHLSL
ShaderConstHandles
ShaderData
ShaderDependency
ShaderFeature
ShaderFeature::Resources
ShaderFeatureGLSL
ShaderFeatureHLSL
ShaderGen
ShaderGenComponentFactoryAbstract factory for created (and initializating, if necessary) shader components
ShaderGenComponentFactoryGLSL
ShaderGenComponentFactoryHLSL
ShaderGenPrinterBase class used by shaderGen to be API agnostic
ShaderGenPrinterGLSL
ShaderGenPrinterHLSL
ShaderGenVarsShaderGenVars, predefined string names for variables that shadergen based shaders use, this avoids misspelling and string creation issues
ShaderIncludeDependency
ShaderMaterialParameterHandle
ShaderMaterialParameters
ShaderOp
ShaderRenderPassData
ShadowBase
ShadowCaster
ShadowCasterManager
ShadowVolumeBSPUsed to calculate shadows
ShadowVolumeBSP::SurfaceInfo
ShadowVolumeBSP::SVNode
ShadowVolumeBSP::SVPoly
ShapeBaseShapeBase is the renderable shape from which most of the scriptable objects are derived, including the player, vehicle and items classes
ShapeBase::CollisionTimeout
ShapeBase::MountedImageAn image mounted on a shapebase
ShapeBase::MountedImage::ImageEmitterRepresent the state of a specific particle emitter on the image
ShapeBase::MountInfoMounted objects
ShapeBase::Sound
ShapeBase::Thread
ShapeBaseConvex
ShapeBaseData
ShapeBaseImageData
ShapeBaseImageData::StateData
ShapeBaseImageData::StateData::Transition
Signal< bool()>
Signal< bool(A)>
Signal< bool(A, B)>
Signal< bool(A, B, C)>
Signal< bool(A, B, C, D)>
Signal< bool(A, B, C, D, E)>
Signal< bool(A, B, C, D, E, F)>
Signal< bool(A, B, C, D, E, F, G)>
Signal< bool(A, B, C, D, E, F, G, H)>
Signal< bool(A, B, C, D, E, F, G, H, I)>
Signal< bool(A, B, C, D, E, F, G, H, I, J)>
Signal< void()>
Signal< void(A)>
Signal< void(A, B)>
Signal< void(A, B, C)>
Signal< void(A, B, C, D)>
Signal< void(A, B, C, D, E)>
Signal< void(A, B, C, D, E, F)>
Signal< void(A, B, C, D, E, F, G)>
Signal< void(A, B, C, D, E, F, G, H)>
Signal< void(A, B, C, D, E, F, G, H, I)>
Signal< void(A, B, C, D, E, F, G, H, I, J)>
SignalBaseSignals (Multi-cast Delegates)
SignalBase::DelegateLink
SignalBaseT< Signature >
SignalBaseT< Signature >::DelegateLinkImpl
Sim2DAudioEvent
Sim3DAudioEvent
SimComponent
SimConsoleEventImplementation of schedule() function
SimConsoleThreadExecCallbackUsed by Con::threadSafeExecute()
SimConsoleThreadExecEvent
SimDataBlockRoot DataBlock class
SimDataBlockEvent
SimDataBlockGroup
SimEventRepresents a queued event in the sim
SimFieldDictionaryDictionary to keep track of dynamic fields on SimObject
SimFieldDictionary::Entry
SimFieldDictionaryIterator
SimGroupA group of SimObjects
SimGroupIterator
SimIdDictionaryMap of ID's to SimObjects
SimManagerNameDictionary
SimNameDictionaryMap of names to SimObjects
SimObjectBase class for objects involved in the simulation
SimObject::Notify
SimObjectListA vector of SimObjects
SimObjectPtr< T >Smart SimObject pointer
SimpleHashTable< T >
SimpleQueryListFor simple queries. Simply creates a vector of the objects
fastdelegate::detail::SimplifyMemFunc< N >
fastdelegate::detail::SimplifyMemFunc< SINGLE_MEMFUNCPTR_SIZE >
SimSetA set of SimObjects
SimSetIteratorIterator for use with SimSets
SimSetIterator::Entry
SimSetIterator::Stack
SimXMLDocument
Sky
SlotAccessNode
SlotAssignNode
SlotAssignOpNode
SlotDecl
SmoothHeightAction
SoftSelectAction
SparseArray< T >
SparseArray< T >::Node
SpawnSphere
Sphere
Sphere::Triangle
Sphere::TriangleMesh
SphereF
SphereMesh
SphereMesh::Triangle
SphereMesh::TriangleMesh
Splash
SplashData
SplashRing
SplashRingPoint
SplCtrlPtsClass for spline control points
SplinePatchBase class for spline patches
SquareStackNode
StandardMainLoopSupport class to simplify the process of writing a main loop for Torque apps
StartSessionTask
StateManager
StateManager::ClientCallbacks
StateManager::GameCallbacks
StateManager::HostCallbacks
StateManager::SPCallbacks
StaticNamedSingleton< T >Collection of statically registered named singletons
StaticShape
StaticShapeData
StdConsole
StdLibRuntimeInterface
StmtNodeRepresentation of a node for the scripting language parser
StormCloudData
StormFogData
StormFogVolume
StormInfo
StrcatExprNode
StrConstNode
StreamBase stream class for streaming data across a specific media
StreamObjectScript wrapper for the Stream class
StreqExprNode
String0-terminated array of characters
StringBufferUtility class to wrap string manipulation in a representation independent way
StringBuffer::RequestCounts
StringCase
StringNoCase
StringStackCore stack for interpreter operations
StrongObjectRefBase class for StrongRefBase strong reference pointers
StrongRefBaseBase 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)
StrongRefPtr< T >Reference counted object template pointer class Instances of this template class can be used as pointers to instances of StrongRefBase and its subclasses
StrongRefUnion< ExposedType >Union of an arbitrary type with a StrongRefBase
SunThis Sun object should support different types of lighting systems because of the lighting system createLightInfo factory method
Swizzle< T, mapLength >This class will swizzle 'sizeof( T )' length chunks of memory into different patterns which are user described
Platform::SystemInfo_struct
Platform::SystemInfo_struct::Processor
T3DSceneClient
T3DSceneComponent
T3DSolidSceneClient
TagDictionary
TagDictionary::TagEntry
TCPObject
TelnetConsoleTelnet admin console
TelnetConsole::TelnetClientRepresents a connection to the telnet console
TelnetDebuggerTelnet debug service implementation
TelnetDebugger::Breakpoint
TempAlloc< T >
Terraformer
TerrainAction
TerrainBlock
TerrainBlock::Material
TerrainChunk
TerrainConvex
TerrainEditor
TerrainFile
TerrainLightingPlugin
TerrainProxy
TerrainProxy::SquareStackNode
TerrainRender
TerrClipMapImageSource
TerrLightInfo
UnitTesting::TestRegistration< T >
UnitTesting::TestRegistry
UnitTesting::TestRun
TexAnimGLSLTex Anim
TexAnimHLSLTex Anim
Thread
ThreadManager
ThreadSafeQueue< T >A simple thread-safe queue
ThreadStoragePlatform independent per-thread storage class
TickCache
TickCacheEntry
Torque::Time64 bit time representation with ten microsecond resolution
Torque::Time::DateTime
Torque::Time::Tester
TimeManagerUtility class to fire journalled time-delta events at regular intervals
Tokenizer
TorqueGGCSignals
TorqueThreadStatic< T >
Transform3D
Transform3D::IDirtyListener
Transform3DInPlace
Trigger
TSCallback
TSDecalMeshDecals! The lovely detailing thingies, e.g
TSDrawPrimitive
TSIntegerSetThe standard mathmatical set, where there are no duplicates
TSLastDetailThis 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
TSMaterialListSpecialized material list for 3space objects
TSMesh
TSMeshLightPlugin
TSPartInstance
TSScaleClass to handle general scaling case
TSShapeTSShape stores generic data for a 3space model
TSShape::ConvexHullAccelerator
TSShape::DetailDetails are used for render detail selection
TSShape::IflMaterialIFL Materials are used to animate material lists -- i.e., run through a series of frames of a material
TSShape::NodeNodes hold the transforms in the shape's tree. They are the bones of the skeleton
TSShape::ObjectObjects hold renderable items (in particular meshes)
TSShape::ObjectStateDescribes state of an individual object
TSShape::SequenceA Sequence holds all the information necessary to perform a particular animation (sequence)
TSShape::TriggerWhen time on a sequence advances past a certain point, a trigger takes effect and changes one of the state variables to on or off
TSShapeAllocAlloc structure used in the reading/writing of shapes
TSShapeConstructorThis class allows an artist to export their animations for the model into the .dsq format
TSShapeInstanceAn instance of a 3space shape
TSShapeInstance::IflMaterialInstanceIFL objects ... controlled by animation but also can be controlled by user
TSShapeInstance::MeshObjectInstanceThese are set up by default based on shape data
TSShapeInstance::ObjectInstanceBase class for all renderable objects, including mesh objects and decal objects
TSShapeInstance::RenderData
TSShapeInstance::TSCallbackRecord
TSSkinMesh
TSSortedMeshTSSortedMesh is for meshes that need sorting (obviously)
TSSortedMesh::ClusterThis is a group of primitives that belong "together" in the rendering sequence
TSStatic
TSStaticConvex
TSStaticPolysoupConvex
TSThread3space animation thread
TSThread::TransitionDataIf in transition..
TSTransformStruct for encapsulating ts transform related static functions
TSTransform3D
TTagDerefNode
TTagExprNode
TTagSetStmtNode
TypeValidator
UInputManager
UndoAction
UndoManager
UndoScriptAction
UnitTesting::UnitMargin
UnitTesting::UnitTest
UnitTestComponentInterfaceThis is a class that will make it very easy for a component author to provide unit testing functionality from within an instantiated component
UnixCommandExecutor
UnixUtils
UseableSection
ValueWrapperInterface< T >This class is designed to wrap an existing class or type easily to allow a SimComponent to expose a property with custom processing code in an efficient and safe way
Var
VarNode
Vector< T >A dynamic array template class
VectorPtr< T >Template for vectors of pointers
VectorSet< T >
Vehicle
Vehicle::StateDelta
VehicleBlocker
VehicleData
VehicleData::Body
VertexParamsDefGLSL
VertexParamsDefHLSL
VertLightColorGLSLVertex lighting color
VertLightColorHLSLVertex lighting color
VertPixelConnectorGLSL
VertPositionGLSLVertex position
VertPositionHLSLVertex position
VisibilityFeatGLSLVisibility
VisibilityFeatHLSLVisibility
fastdelegate::detail::VoidToDefaultVoid< T >
fastdelegate::detail::VoidToDefaultVoid< void >
Platform::VolumeInformation
VolumeLight
WaterBlock
WaterBlock::WaterMatParams
WayPointTeam
WeakRefBaseBase class for objects which can be weakly referenced (i.e., reference goes away when object is destroyed)
WeakRefBase::WeakReferenceWeak reference to WeakRefBase
WeakRefPtr< T >Weak reference pointer class
WeakRefUnion< ExposedType >Union of an arbitrary type with a WeakRefBase
GL::WGLExtensionFlags
GL::WGLExtensionPtrs
WheeledVehicle
WheeledVehicle::Wheel
WheeledVehicle::Wheel::Surface
WheeledVehicleData
WheeledVehicleData::Wheel
WheeledVehicleSpring
WheeledVehicleTire
Win32CursorController
Torque::Win32::Win32Directory
Torque::Win32::Win32FileWin32 stdio file access
Torque::Win32::Win32FileSystem
Win32PlatState
Win32WindowImplementation of a window on Win32
Win32Window::Accelerator
Win32WindowManagerWin32 implementation of the window manager interface
WinConsole
WindEmitter
WindowInputGenerator
WinFont
WMIVideoInfo
WorldEditor
WorldEditor::ClassInfo
WorldEditor::ClassInfo::Entry
WorldEditor::CollisionInfo
WorldEditor::Selection
WorldEditor::SelectionState
WorldEditor::SelectionState::Entry
WorldEditor::StreamedObject
WriteAchievementTask
WriteStatsTask
x86UNIXFont
x86UNIXPlatformState
XB360Window
XB360WindowManager
XBBackgroundMusic
XBEHeader
XBESectionFlags
XBESectionHeader
XBGamepad
XBGamerProfile
XBInputDevice
XBLiveCommunicator
XBLiveMatchMaking
XBLiveQOS
XBLiveStats
XBLiveStatsGameData
XBLiveTask
XBLiveTaskProcessor
XBLiveVoice
XBLiveVoiceMessage
XBoxInputManager
XBoxPlatState
XBSections
XINPUT_CONTROLLER_STATE
XMessageBox
XMessageBoxButton
YYSTYPE
Zip::ZipArchiveClass for accessing Zip files
Zip::ZipArchive::ZipEntry
ZipCryptRStream
ZipObjectScript wrapper for Zip::ZipArchive
Zip::ZipStatFilterHelper class for tracking CRC and uncompressed size
ZipSubRStream
ZipSubWStream
Zip::ZipTempStream
ZoneVisDeterminer