Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

Ogre |
EmitterCommands |
CmdAngle | Command object for ParticleEmitter - see ParamCommand
CmdColour | Command object for particle emitter - see ParamCommand
CmdColourRangeEnd | Command object for particle emitter - see ParamCommand
CmdColourRangeStart | Command object for particle emitter - see ParamCommand
CmdDirection | Command object for particle emitter - see ParamCommand
CmdDirPositionRef | Command object for particle emitter - see ParamCommand
CmdDuration | Command object for particle emitter - see ParamCommand
CmdEmissionRate | Command object for particle emitter - see ParamCommand
CmdEmittedEmitter | Command object for particle emitter - see ParamCommand
CmdMaxDuration | Command object for particle emitter - see ParamCommand
CmdMaxRepeatDelay | Command object for particle emitter - see ParamCommand
CmdMaxTTL | Command object for particle emitter - see ParamCommand
CmdMaxVelocity | Command object for particle emitter - see ParamCommand
CmdMinDuration | Command object for particle emitter - see ParamCommand
CmdMinRepeatDelay | Command object for particle emitter - see ParamCommand
CmdMinTTL | Command object for particle emitter - see ParamCommand
CmdMinVelocity | Command object for particle emitter - see ParamCommand
CmdName | Command object for particle emitter - see ParamCommand
CmdPosition | Command object for particle emitter - see ParamCommand
CmdRepeatDelay | Command object for particle emitter - see ParamCommand
CmdTTL | Command object for particle emitter - see ParamCommand
CmdUp | Command object for particle emitter - see ParamCommand
CmdVelocity | Command object for particle emitter - see ParamCommand
OverlayElementCommands |
CmdCaption | Command object for OverlayElement - see ParamCommand
CmdHeight | Command object for OverlayElement - see ParamCommand
CmdHorizontalAlign | Command object for OverlayElement - see ParamCommand
CmdLeft | Command object for OverlayElement - see ParamCommand
CmdMaterial | Command object for OverlayElement - see ParamCommand
CmdMetricsMode | Command object for OverlayElement - see ParamCommand
CmdTop | Command object for OverlayElement - see ParamCommand
CmdVerticalAlign | Command object for OverlayElement - see ParamCommand
CmdVisible | Command object for OverlayElement - see ParamCommand
CmdWidth | Command object for OverlayElement - see ParamCommand
RTShader |
CGProgramProcessor | CG Language program processor class
CGProgramWriter | CG target language writer implementation
ConstParameter | Helper template which is the base for our ConstParameters
Function | A class that represents a shader based program function
FunctionAtom | A class that represents an atomic code section of shader based program function
FunctionInvocation | A class that represents function invocation code from shader based program function
FunctionInvocationCompare | Comparator function to be used for comparisons
FunctionInvocationLessThan | Comparator function to be used for sorting
GLSLESProgramProcessor | GLSL ES Language program processor class
GLSLESProgramWriter | GLSL ES target language writer implementation
GLSLProgramProcessor | GLSL Language program processor class
GLSLProgramWriter | GLSL target language writer implementation
HLSLProgramProcessor | CG Language program processor class
HLSLProgramWriter | HLSL target language writer implementation
Operand | A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields)
Parameter | A class that represents a shader based program parameter
ParameterFactory | Helper utility class that creates common parameters
Program | A class that represents a shader based program
ProgramManager | A singleton manager class that manages shader based programs
ProgramProcessor | A class that provides extra processing services on CPU based programs
MergeCombination |
MergeParameter |
ProgramSet | Container class for shader based programs
ProgramWriter | Base class interface for shader program writers
ProgramWriterFactory | Interface definition for factories of ShaderProgramWriter
ProgramWriterManager |
RenderState | This is a container class for sub render state class
SGMaterialSerializerListener | This class responsible for translating core features of the RT Shader System for Ogre material scripts
SGScriptTranslator | This class responsible for translating core features of the RT Shader System for Ogre material scripts
ShaderGenerator | Shader generator system main interface
MatGroupPair_less |
SGMaterial | Shader generator material wrapper class
SGPass | Shader generator pass wrapper class
SGRenderObjectListener | Shader generator RenderObjectListener sub class
SGSceneManagerListener | Shader generator scene manager sub class
SGScheme | Shader generator scheme class
SGScriptTranslatorManager | Shader generator ScriptTranslatorManager sub class
SGTechnique | Shader generator technique wrapper class
ShaderProgramWriterCGFactory | CG program writer factory implementation
ShaderProgramWriterGLSLESFactory | GLSL ES program writer factory implementation
ShaderProgramWriterGLSLFactory | GLSL program writer factory implementation
ShaderProgramWriterHLSLFactory | HLSL program writer factory implementation
SubRenderState | This class is the base interface of sub part from a shader based rendering pipeline
SubRenderStateAccessor | This class uses as accessor from a template SubRenderState to all of its instances that created based on it
SubRenderStateFactory | Abstract factory interface for creating SubRenderState implementation instances
TargetRenderState | This is the target render state
UniformParameter | Uniform parameter class
Volume |
CacheSource | A caching Source
Chunk | A single volume chunk mesh
ChunkHandler | Handles the WorkQueue management of the chunks
ChunkParameters | Parameters for loading the volume
ChunkRequest | Data being passed around while loading
ChunkTreeSharedData | Internal shared values of the chunks which are equal in the whole tree
CSGCubeSource | A not rotated cube
CSGDifferenceSource | Builds the difference between two sources
CSGIntersectionSource | Builds the intersection between two sources
CSGNegateSource | Negates the given volume
CSGNoiseSource |
CSGOperationSource | Abstract operation volume source holding two sources as operants
CSGPlaneSource | A plane
CSGScaleSource | Scales the given volume source
CSGSphereSource | A sphere
CSGUnarySource | Source which does a unary operation to another one
CSGUnionSource | Builds the union between two sources
DualCell | To store the generated dual cells in a vector
DualGridGenerator | Class for the generation of the DualGrid
GridSource | A volume source from a discrete 3d grid
HalfFloatGridSource | A volume source from a 16 Bit float 3D grid capable of loading volume serializations
IsoSurface | Abstract IsoSurface
IsoSurfaceMC | Marching Cubes implementation like at http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/
MeshBuilder | Class to build up a mesh with vertices and indices
MeshBuilderCallback | Callback class when the user needs information about the triangles of chunks of a LOD level
OctreeNode | A node in the volume octree
OctreeNodeSplitPolicy | The class deciding on whether to split an octree node or not when building the octree
SimplexNoise | Simplex Noise ported from public domain Java Implementation http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java Thanks Stefan Gustavson!
Source | Abstract class defining the density function
TextureSource | A volume source from a 3D texture
Vertex | Lightweight struct to represent a mesh vertex
_ConfigOption | Packages the details of a configuration option
AbsolutePixelCountLodStrategy |
AbstractNode |
AlignedMemory | Class to provide aligned memory allocate functionality
AllocatedObject | Superclass for all objects that wish to use custom memory allocators when their new / delete operators are called
AndroidLogListener |
Angle | Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAngleUnit
AnimableObject | Defines an interface to classes which have one or more AnimableValue instances to expose
AnimableValue | Defines an object property which is animable, i.e
Animation | An animation sequence
AnimationContainer | An animation container interface, which allows generic access to sibling animations
AnimationControllerFunction | Predefined controller function for dealing with animation
AnimationState | Represents the state of an animation and the weight of its influence
AnimationStateControllerValue | ControllerValue wrapper class for AnimationState
AnimationStateSet | Class encapsulating a set of AnimationState objects
AnimationTrack | A 'track' in an animation sequence, i.e
Listener | Listener allowing you to override certain behaviour of a track, for example to drive animation procedurally
Any | Variant type that can hold Any other type
holder |
placeholder |
AnyNumeric | Specialised Any class which has built in arithmetic operators, but can hold only types which support operator +,-,* and /
numholder |
numplaceholder |
APKFileSystemArchive |
APKFileSystemArchiveFactory |
APKZipArchiveFactory |
Archive | Archive-handling class
ArchiveFactory | Abstract factory class, archive codec plugins can register concrete subclasses of this
ArchiveManager | This class manages the available ArchiveFactory plugins
AtomAbstractNode | This is an abstract node which cannot be broken down further
AtomicObject |
AtomicScalar |
AutoParamDataSource | This utility class is used to hold the information used to generate the matrices and other information required to automatically populate GpuProgramParameters
AxisAlignedBox | A 3D box aligned with the x/y/z axes
AxisAlignedBoxSceneQuery | Specialises the SceneQuery class for querying within an axis aligned box
BackgroundProcessResult | Encapsulates the result of a background queue request
BaseInstanceBatchVTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) This implementation has the following advantages: Supports huge amount of instances per batch Supports skinning even with huge ammounts of instances per batch Doesn't need shader constants registers
Billboard | A billboard is a primitive which always faces the camera in every frame
BillboardChain | Allows the rendering of a chain of connected billboards
ChainSegment | Simple struct defining a chain segment by referencing a subset of the preallocated buffer (which will be mMaxElementsPerChain * mChainCount long), by it's chain index, and a head and tail value which describe the current chain
Element | Contains the data of an element of the BillboardChain
BillboardChainFactory | Factory object for creating BillboardChain instances
BillboardParticleRenderer | Specialisation of ParticleSystemRenderer to render particles using a BillboardSet
CmdAccurateFacing | Command object for accurate facing(see ParamCommand)
CmdBillboardOrigin | Command object for billboard origin (see ParamCommand)
CmdBillboardRotationType | Command object for billboard rotation type (see ParamCommand)
CmdBillboardType | Command object for billboard type (see ParamCommand)
CmdCommonDirection | Command object for common direction (see ParamCommand)
CmdCommonUpVector | Command object for common up-vector (see ParamCommand)
CmdPointRendering | Command object for point rendering (see ParamCommand)
BillboardParticleRendererFactory | Factory class for BillboardParticleRenderer
BillboardSet | A collection of billboards (faces which are always facing the given direction) with the same (default) dimensions, material and which are fairly close proximity to each other
SortByDirectionFunctor | Sort by direction functor
SortByDistanceFunctor | Sort by distance functor
BillboardSetFactory | Factory object for creating BillboardSet instances
Bitwise | Class for manipulating bit patterns
Bone | A bone in a skeleton
BorderPanelOverlayElement | A specialisation of the PanelOverlayElement to provide a panel with a border
CellUV |
CmdBorderBottomLeftUV | Command object for specifying texture coordinates for the border (see ParamCommand)
CmdBorderBottomRightUV | Command object for specifying texture coordinates for the border (see ParamCommand)
CmdBorderBottomUV | Command object for specifying texture coordinates for the border (see ParamCommand)
CmdBorderLeftUV | Command object for specifying texture coordinates for the border (see ParamCommand)
CmdBorderMaterial | Command object for specifying the Material for the border (see ParamCommand)
CmdBorderRightUV | Command object for specifying texture coordinates for the border (see ParamCommand)
CmdBorderSize | Command object for specifying border sizes (see ParamCommand)
CmdBorderTopLeftUV | Command object for specifying texture coordinates for the border (see ParamCommand)
CmdBorderTopRightUV | Command object for specifying texture coordinates for the border (see ParamCommand)
CmdBorderTopUV | Command object for specifying texture coordinates for the border (see ParamCommand)
BorderPanelOverlayElementFactory | Factory for creating BorderPanelOverlayElement instances
BorderRenderable | Class for rendering the border of a BorderPanelOverlayElement
Box | Structure used to define a box in a 3-D integer space
BuiltinScriptTranslatorManager | This class manages the builtin translators
Camera | A viewpoint from which the scene will be rendered
Listener | Listener interface so you can be notified of Camera events
CategorisedAlignAllocPolicy |
CategorisedAllocPolicy |
Codec | Abstract class that defines a 'codec'
CodecData |
ColourValue | Class representing colour
CompositionPass | Object representing one pass or operation in a composition sequence
InputTex | Inputs (for material used for rendering the quad)
CompositionPassTranslator |
CompositionTargetPass | Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework
CompositionTargetPassTranslator |
CompositionTechnique | Base composition technique, can be subclassed in plugins
TextureDefinition | Local texture definition
CompositionTechniqueTranslator |
Compositor | Class representing a Compositor object
CompositorChain | Chain of compositor effects applying to one viewport
RQListener | Render queue listener used to set up rendering events
CompositorInstance | An instance of a Compositor object for one Viewport
Listener | Provides an interface to "listen in" to to render system operations executed by this CompositorInstance
RenderSystemOperation | Specific render system operation
TargetOperation | Operation setup for a RenderTarget (collected)
CompositorLogic | Interface for compositor logics, which can be automatically binded to compositors, allowing per-compositor logic (such as attaching a relevant listener) to happen automatically
CompositorManager | Class for managing Compositor settings for Ogre
TextureDef |
TextureDefLess |
CompositorTranslator |
ConcreteNode |
ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog
ConfigFile | Class for quickly loading settings from a text file
ConstMapIterator | Concrete IteratorWrapper for const access to the underlying key-value container
ConstMapRange | Predefined type
ConstVectorIterator | Concrete IteratorWrapper for const access to the underlying container
ConstVectorRange | Predefined type
Controller | Instances of this class 'control' the value of another object in the system
ControllerFunction | Subclasses of this class are responsible for performing a function on an input value for a Controller
ControllerManager | Class for managing Controller instances
ControllerValue | Can either be used as an input or output value
ConvexBody | Holds a solid representation of a convex body
CreateCompositorScriptCompilerEvent |
CreateGpuProgramScriptCompilerEvent |
CreateGpuSharedParametersScriptCompilerEvent |
CreateHighLevelGpuProgramScriptCompilerEvent |
CreateMaterialScriptCompilerEvent |
CreateParticleSystemScriptCompilerEvent |
CustomCompositionPass | Interface for custom composition passes, allowing custom operations (in addition to the quad, scene and clear operations) in composition passes
DataStream | General purpose class used for encapsulating the reading and writing of data
DDSCodec | Codec specialized in loading DDS (Direct Draw Surface) images
DefaultAxisAlignedBoxSceneQuery | Default implementation of AxisAlignedBoxSceneQuery
DefaultHardwareBufferManager | DefaultHardwareBufferManager as a Singleton
DefaultHardwareBufferManagerBase | Specialisation of HardwareBufferManagerBase to emulate hardware buffers
DefaultHardwareCounterBuffer | Specialisation of HardwareCounterBuffer for emulation
DefaultHardwareIndexBuffer | Specialisation of HardwareIndexBuffer for emulation
DefaultHardwareUniformBuffer | Specialisation of HardwareUniformBuffer for emulation
DefaultHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for emulation
DefaultIntersectionSceneQuery | Default implementation of IntersectionSceneQuery
DefaultPlaneBoundedVolumeListSceneQuery | Default implementation of PlaneBoundedVolumeListSceneQuery
DefaultRaySceneQuery | Default implementation of RaySceneQuery
DefaultSceneManager | Default scene manager
DefaultSceneManagerFactory | Factory for default scene manager
DefaultShadowCameraSetup | Implements default shadow camera setup
DefaultSphereSceneQuery | Default implementation of SphereSceneQuery
DefaultWorkQueue | Implementation of a general purpose request / response style background work queue
DefaultWorkQueueBase | Base for a general purpose request / response style background work queue
OGRE_THREAD_WORKER_INHERIT | Thread function
RequestHandlerHolder | Intermediate structure to hold a pointer to a request handler which provides insurance against the handler itself being disconnected while the list remains unchanged
DeflateStream | Stream which compresses / uncompresses data using the 'deflate' compression algorithm
Degree | Wrapper class which indicates a given angle value is in Degrees
DepthBuffer | An abstract class that contains a depth/stencil buffer
deque |
DistanceLodBoxStrategy | Level of detail strategy based on distance from camera to an object's bounding box
DistanceLodSphereStrategy | Level of detail strategy based on distance from camera to an object's bounding sphere
DistanceLodStrategy | Level of detail strategy based on distance from camera
DriverVersion | DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the current GPU driver
DualQuaternion | Implementation of a dual quaternion, i.e
DynLib | Resource holding data about a dynamic library
DynLibManager | Manager for Dynamic-loading Libraries
EdgeData | This class contains the information required to describe the edge connectivity of a given set of vertices and indexes
Edge | Edge data
EdgeGroup | A group of edges sharing the same vertex data
Triangle | Basic triangle structure
EdgeListBuilder | General utility class for building edge lists for geometry
CommonVertex | A vertex can actually represent several vertices in the final model, because vertices along texture seams etc will have been duplicated
Geometry | A set of indexed geometry data
geometryLess | Comparator for sorting geometries by vertex set
vectorLess | Comparator for unique vertex list
EmbeddedZipArchiveFactory | Specialisation of ZipArchiveFactory for embedded Zip files
Entity | Defines an instance of a discrete, movable object based on a Mesh
EntityShadowRenderable | Nested class to allow entity shadows
EntityFactory | Factory object for creating Entity instances
EntityMaterialLodChangedEvent | Struct containing information about a material LOD change event for entities
EntityMeshLodChangedEvent | Struct containing information about a mesh LOD change event for entities
ErrorDialog | Class for displaying the error dialog if Ogre fails badly
ETCCodec | Codec specialized in loading ETC (Ericsson Texture Compression) images
Exception | When thrown, provides information about an error that has occurred inside the engine
ExceptionCodeType | Template struct which creates a distinct type for each exception code
ExceptionFactory | Class implementing dispatch methods in order to construct by-value exceptions of a derived type based just on an exception code
ExternalTextureSource | IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from
CmdFPS |
CmdInputFileName |
CmdPlayMode |
CmdTecPassState |
ExternalTextureSourceManager | Singleton Class which handles the registering and control of texture plugins
FactoryObj | Abstract factory class
FileHandleDataStream | Common subclass of DataStream for handling data from C-style file handles
FileInfo | Information about a file/directory within the archive will be returned using a FileInfo struct
FileNotFoundException |
FileStreamDataStream | Common subclass of DataStream for handling data from std::basic_istream
FileSystemArchive | Specialisation of the Archive class to allow reading of files from filesystem folders / directories
FileSystemArchiveFactory | Specialisation of ArchiveFactory for FileSystem files
FileSystemLayer | Provides methods to find out where the Ogre config files are stored and where logs and settings files should be written to
FloatGpuParameterControllerValue | Predefined controller value for setting a single floating- point value in a constant parameter of a vertex or fragment program
FocusedShadowCameraSetup | Implements the uniform shadow mapping algorithm in focused mode
PointListBody | Internal class holding a point list representation of a convex body
Font | Class representing a font in the system
CmdCharSpacer |
CmdCodePoints | Command object for Font - see ParamCommand
CmdResolution | Command object for Font - see ParamCommand
CmdSize | Command object for Font - see ParamCommand
CmdSource | Command object for Font - see ParamCommand
CmdType | Command object for Font - see ParamCommand
GlyphInfo | Information about the position and size of a glyph in a texture
FontManager | Manages Font resources, parsing .fontdef files and generally organising them
FrameEvent | Struct containing information about a frame event
FrameListener | A interface class defining a listener which can be used to receive notifications of frame events
FrameTimeControllerValue | Predefined controller value for getting the latest frame time
FreeImageCodec | Codec specialized in images loaded using FreeImage
Frustum | A frustum represents a pyramid, capped at the near and far end which is used to represent either a visible area or a projection area
GpuConstantDefinition | Information about predefined program constants
GpuLogicalBufferStruct | Container struct to allow params to safely & update shared list of logical buffer assignments
GpuLogicalIndexUse | Structure recording the use of a physical buffer by a logical parameter index
GpuNamedConstants | Struct collecting together the information for named constants
GpuNamedConstantsSerializer | Simple class for loading / saving GpuNamedConstants
GpuProgram | Defines a program which runs on the GPU such as a vertex or fragment program
CmdAdjacency |
CmdManualNamedConstsFile |
CmdMorph |
CmdPose |
CmdSkeletal |
CmdSyntax |
CmdType | Command object - see ParamCommand
CmdVTF |
GpuProgramManager |
GpuProgramParameters | Collects together the program parameters used for a GpuProgram
AutoConstantDefinition | Structure defining an auto constant that's available for use in a parameters object
AutoConstantEntry | Structure recording the use of an automatic parameter
GpuProgramTranslator |
GpuProgramUsage | This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit
GpuSharedParameters | A group of manually updated parameters that are shared between many parameter sets
GpuSharedParametersUsage | This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters
CopyDataEntry |
Grid2DPageStrategy | Page strategy which loads new pages based on a regular 2D grid
Grid2DPageStrategyData | Specialisation of PageStrategyData for Grid2DPageStrategy
Grid3DPageStrategy | Page strategy which loads new pages based on a regular 3D grid
Grid3DPageStrategyData | Specialisation of PageStrategyData for Grid3DPageStrategy
HardwareBuffer | Abstract class defining common features of hardware buffers
HardwareBufferLicensee | Abstract interface representing a 'licensee' of a hardware buffer copy
HardwareBufferLockGuard | Locking helper
HardwareBufferManager | Singleton wrapper for hardware buffer manager
HardwareBufferManagerBase | Base definition of a hardware buffer manager
VertexBufferLicense | Struct holding details of a license to use a temporary shared buffer
HardwareCounterBuffer | Specialisation of HardwareBuffer for a counter buffer
HardwareCounterBufferSharedPtr | Shared pointer implementation used to share counter buffers
HardwareIndexBuffer | Specialisation of HardwareBuffer for vertex index buffers, still abstract
HardwareIndexBufferSharedPtr | Shared pointer implementation used to share index buffers
HardwareOcclusionQuery | This is a abstract class that that provides the interface for the query class for hardware occlusion
HardwarePixelBuffer | Specialisation of HardwareBuffer for a pixel buffer
HardwarePixelBufferSharedPtr | Shared pointer implementation used to share pixel buffers
HardwareUniformBuffer | Specialisation of HardwareBuffer for a uniform buffer
HardwareUniformBufferSharedPtr | Shared pointer implementation used to share uniform buffers
HardwareVertexBuffer | Specialisation of HardwareBuffer for a vertex buffer
HardwareVertexBufferSharedPtr | Shared pointer implementation used to share vertex buffers
HashedVector | A hashed vector
HighLevelGpuProgram | Abstract base class representing a high-level program (a vertex or fragment program)
HighLevelGpuProgramFactory | Interface definition for factories of HighLevelGpuProgram
HighLevelGpuProgramManager | This ResourceManager manages high-level vertex and fragment programs
IlluminationPass | Struct recording a pass which can be used for a specific illumination stage
Image | Class representing an image file
ImageCodec | Codec specialized in images
ImageData | Codec return class for images
ImportAbstractNode | This abstract node represents an import statement
IndexData | Summary class collecting together index data source information
InstanceBatch | InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived to implement different instancing techniques (
InstanceBatchHW | This is technique requires true instancing hardware support
InstanceBatchHW_VTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instancing
InstanceBatchShader | This is the same technique the old "InstancedGeometry" implementation used (with improvements)
InstanceBatchVTF |
InstancedEntity |
InstancedGeometry | Pre-transforms and batches up meshes for efficient use as instanced geometry in a scene
BatchInstance | The details of a topological BatchInstance which is the highest level of partitioning for this class
GeometryBucket | A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored
InstancedObject |
LODBucket | A LODBucket is a collection of smaller buckets with the same LOD
MaterialBucket | A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same LOD)
OptimisedSubMeshGeometry | Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances
QueuedGeometry | Structure recording a queued geometry for low level builds
QueuedSubMesh | Structure recording a queued submesh for the build
SubMeshLodGeometryLink | Saved link between SubMesh at a LOD and vertex/index data May point to original or optimised geometry
InstanceManager | This is the main starting point for the new instancing system
BatchSettings |
InternalErrorException |
IntersectionSceneQuery | Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another
IntersectionSceneQueryListener | Alternative listener class for dealing with IntersectionSceneQuery
IntersectionSceneQueryResult | Holds the results of an intersection scene query (pair values)
InvalidParametersException |
InvalidStateException |
IOException |
isPodLike |
isPodLike< bool > |
isPodLike< char > |
isPodLike< double > |
isPodLike< float > |
isPodLike< int > |
isPodLike< long > |
isPodLike< short > |
isPodLike< signed char > |
isPodLike< std::pair< T, U > > |
isPodLike< T * > |
isPodLike< unsigned > |
isPodLike< unsigned char > |
isPodLike< unsigned long > |
isPodLike< unsigned short > |
ItemIdentityException |
iterator_range | Base for an iterator_range
IteratorWrapper | Basefunctionality for IteratorWrappers
KeyFrame | A key frame in an animation sequence defined by an AnimationTrack
LayerBlendModeEx | Class which manages blending of both colour and alpha components
Light | Representation of a dynamic light source in the scene
LightFactory | Factory object for creating Light instances
LinearResampler |
LinearResampler_Byte |
LinearResampler_Float32 |
LinkedSkeletonAnimationSource | Link to another skeleton to share animations
LiSPSMShadowCameraSetup | Implements the Light Space Perspective Shadow Mapping Algorithm
list |
LodConfig |
LodLevel | Structure for automatic LOD configuration
LodListener | A interface class defining a listener which can be used to receive notifications of LOD events
LodStrategy | Strategy for determining level of detail
LodStrategyManager | Manager for LOD strategies
Log |
Stream | Stream object which targets a log
Flush | Simple type to indicate a flush of the stream to the log
LogListener |
LogManager | The log manager handles the creation and retrieval of logs for the application
ManualObject | Class providing a much simplified interface to generating manual objects with custom geometry
ManualObjectSection | Built, renderable section of geometry
ManualObjectSectionShadowRenderable | Nested class to allow shadows
TempVertex | Temporary vertex structure
ManualObjectFactory | Factory object for creating ManualObject instances
ManualResourceLoader | Interface describing a manual resource loader
map |
MapIterator | Concrete IteratorWrapper for nonconst access to the underlying key-value container
MapIteratorWrapper | Prepared IteratorWrapper for key-value container
MapRange | Predefined type
Material | Class encapsulates rendering properties of an object
MaterialManager | Class for managing Material settings for Ogre
Listener | Listener on any general material events
MaterialScriptContext | Struct for holding the script context while parsing
MaterialScriptProgramDefinition | Struct for holding a program definition which is in progress
MaterialSerializer | Class for serializing Materials to / from a .material script
Listener | Class that allows listening in on the various stages of material serialization process
MaterialTranslator |
Math | Class to provide access to common mathematical functions
RandomValueProvider | This class is used to provide an external random value provider
Matrix3 | A 3x3 matrix which can represent rotations around axes
Matrix4 | Class encapsulating a standard 4x4 homogeneous matrix
MemoryDataStream | Common subclass of DataStream for handling data from chunks of memory
Mesh | Resource holding data about 3D mesh
MeshLodUsage | A way of recording the way each LODs is recorded this Mesh
MeshManager | Handles the management of mesh resources
MeshBuildParams | Saved parameters used to (re)build a manual mesh built by this class
MeshSerializer | Class for serialising mesh data to/from an OGRE .mesh file
MeshVersionData |
MeshSerializerImpl | Internal implementation of Mesh reading / writing for the latest version of the .mesh format
MeshSerializerImpl_v1_1 | Class for providing backwards-compatibility for loading version 1.1 of the .mesh format
MeshSerializerImpl_v1_2 | Class for providing backwards-compatibility for loading version 1.2 of the .mesh format
MeshSerializerImpl_v1_3 | Class for providing backwards-compatibility for loading version 1.3 of the .mesh format
MeshSerializerImpl_v1_4 | Class for providing backwards-compatibility for loading version 1.4 of the .mesh format
MeshSerializerImpl_v1_41 | Class for providing backwards-compatibility for loading version 1.41 of the .mesh format
MeshSerializerListener |
MovableObject | Abstract class defining a movable object in a scene
Listener | Listener which gets called back on MovableObject events
MovableObjectFactory | Interface definition for a factory class which produces a certain kind of MovableObject, and can be registered with Root in order to allow all clients to produce new instances of this object, integrated with the standard Ogre processing
MovableObjectLodChangedEvent | Struct containing information about a LOD change event for movable objects
MovablePlane | Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply
multimap |
MultiRenderTarget | This class represents a render target that renders to multiple RenderTextures at once
NameGenerator | Utility class to generate a sequentially numbered series of names
NearestResampler |
NedAlignedAllocPolicy | An allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at a given boundary (which should be a power of 2)
NedAllocImpl | Non-templated utility class just to hide nedmalloc
NedAllocPolicy | An allocation policy for use with AllocatedObject and STLAllocator
NedPoolingAlignedPolicy | An allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at a given boundary (which should be a power of 2)
NedPoolingImpl | Non-templated utility class just to hide nedmalloc
NedPoolingPolicy | An allocation policy for use with AllocatedObject and STLAllocator
Node | Class representing a general-purpose node an articulated scene graph
DebugRenderable | Inner class for displaying debug renderable for Node
Listener | Listener which gets called back on Node events
NodeAnimationTrack | Specialised AnimationTrack for dealing with node transforms
Splines |
NumericAnimationTrack | Specialised AnimationTrack for dealing with generic animable values
NumericKeyFrame | Specialised KeyFrame which stores any numeric value
NumericSolver | Provides numeric solvers for Ogre
ObjectAbstractNode | This specific abstract node represents a script object
OptimisedUtil | Utility class for provides optimised functions
Overlay | Represents a layer which is rendered on top of the 'normal' scene contents
OverlayContainer | A 2D element which contains other OverlayElement instances
OverlayElement | Abstract definition of a 2D element to be displayed in an Overlay
OverlayElementFactory | Defines the interface which all components wishing to supply OverlayElement subclasses must implement
OverlayManager | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them
OverlayProfileSessionListener | Concrete impl
OverlaySystem | This class simplify initialization / finalization of the overlay system
Page | Page class
PageData |
PageRequest | Structure for holding background page requests
PageResponse |
PageContent | Interface definition for a unit of content within a page
PageContentCollection | Definition of the interface for a collection of PageContent instances
PageContentCollectionFactory | Define the interface to a factory class that will create subclasses of PageContentCollection
PageContentFactory | Define the interface to a factory class that will create subclasses of PageContent
PagedWorld | This class represents a collection of pages which make up a world
PagedWorldSection | Represents a section of the PagedWorld which uses a given PageStrategy, and which is made up of a generally localised set of Page instances
PagedWorldSectionFactory | A factory class for creating types of world section
PageManager | The PageManager is the entry point through which you load all PagedWorld instances, and the place where PageStrategy instances and factory classes are registered to customise the paging behaviour
EventRouter |
PageProvider | Abstract class that can be implemented by the user application to provide a way to retrieve or generate page data from a source of their choosing
PageStrategy | Defines the interface to a strategy class which is responsible for deciding when Page instances are requested for addition and removal from the paging system
PageStrategyData | Abstract marker class representing the data held against the PagedWorldSection which is specifically used by the PageStrategy
PanelOverlayElement | OverlayElement representing a flat, single-material (or transparent) panel which can contain other elements
CmdTiling | Command object for specifying tiling (see ParamCommand)
CmdTransparent | Command object for specifying transparency (see ParamCommand)
CmdUVCoords | Command object for specifying UV coordinates (see ParamCommand)
PanelOverlayElementFactory | Factory for creating PanelOverlayElement instances
ParamCommand | Abstract class which is command object which gets/sets parameters
ParamDictionary | Class to hold a dictionary of parameters for a single class
ParameterDef | Definition of a parameter supported by a StringInterface class, for introspection
Particle | Class representing a single particle instance
ParticleAffector | Abstract class defining the interface to be implemented by particle affectors
ParticleAffectorFactory | Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses
ParticleAffectorTranslator |
ParticleEmitter | Abstract class defining the interface to be implemented by particle emitters
ParticleEmitterFactory | Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses
ParticleEmitterTranslator |
ParticleIterator | Convenience class to make it easy to step through all particles in a ParticleSystem
ParticleSystem | Class defining particle system based special effects
CmdCull | Command object for cull_each (see ParamCommand)
CmdEmittedEmitterQuota | Command object for emittedEmitterQuota (see ParamCommand)
CmdHeight | Command object for particle_height (see ParamCommand)
CmdIterationInterval | Command object for iteration interval(see ParamCommand)
CmdLocalSpace | Command object for local space (see ParamCommand)
CmdMaterial | Command object for material (see ParamCommand)
CmdNonvisibleTimeout | Command object for nonvisible timeout (see ParamCommand)
CmdQuota | Command object for quota (see ParamCommand)
CmdRenderer | Command object for renderer (see ParamCommand)
CmdSorted | Command object for sorting (see ParamCommand)
CmdWidth | Command object for particle_width (see ParamCommand)
SortByDirectionFunctor | Sort by direction functor
SortByDistanceFunctor | Sort by distance functor
ParticleSystemFactory | Factory object for creating ParticleSystem instances
ParticleSystemManager | Manages particle systems, particle system scripts (templates) and the available emitter & affector factories
ParticleSystemRenderer | Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances
ParticleSystemRendererFactory | Abstract class definition of a factory object for ParticleSystemRenderer
ParticleSystemTranslator |
ParticleVisualData | Abstract class containing any additional data required to be associated with a particle to perform the required rendering
Pass | Class defining a single pass of a Technique (of a Material), i.e
HashFunc | Definition of a functor for calculating the hashcode of a Pass
PassthroughControllerFunction | Predefined controller function which just passes through the original source directly to dest
PassTranslator |
PatchMesh | Patch specialisation of Mesh
PatchSurface | A surface which is defined by curves of some kind to form a patch, e.g
PixelBox | A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory
PixelCountLodStrategy | Abstract base class for level of detail strategy based on pixel count approximations from bounding sphere projection
PixelFormatDescription | A record that describes a pixel format in detail
PixelUtil | Some utility functions for packing and unpacking pixel data
Plane | Defines a plane in 3D space
PlaneBoundedVolume | Represents a convex volume bounded by planes
PlaneBoundedVolumeListSceneQuery | Specialises the SceneQuery class for querying within a plane-bounded volume
PlaneOptimalShadowCameraSetup | Implements the plane optimal shadow camera algorithm
PlatformInformation | Class which provides the run-time platform information Ogre runs on
Plugin | Class defining a generic OGRE plugin
PMGenRequest | Request data structure
IndexBuffer |
SubmeshInfo |
VertexBuffer |
PMInjector | Injects the output of a request to the mesh in a thread safe way
PMInjectorListener |
PMWorker | Processes requests
Polygon | The class represents a polygon in 3D space
Pool | Template class describing a simple pool of items
Pose | A pose is a linked set of vertex offsets applying to one set of vertex data
PreApplyTextureAliasesScriptCompilerEvent |
PrefabFactory | A factory class that can create various mesh prefabs
ProcessNameExclusionScriptCompilerEvent |
ProcessResourceNameScriptCompilerEvent |
Profile | An individual profile that will be processed by the Profiler
ProfileFrame | Represents the total timing information of a profile since profiles can be called more than once each frame
ProfileHistory | Represents a history of each profile during the duration of the app
ProfileInstance | Represents an individual profile call
Profiler | The profiler allows you to measure the performance of your code
ProfileSessionListener | ProfileSessionListener should be used to visualize profile results
ProgressiveMeshGenerator | Improved version of ProgressiveMesh
IndexBufferPointer |
PMCollapsedEdge |
PMEdge |
PMIndexBufferInfo |
PMTriangle |
PMVertex |
PMVertexEqual |
PMVertexHash |
VectorSet |
ProgressiveMeshGeneratorBase |
Property | Property instance with passthrough calls to a given object
PropertyAbstractNode | This abstract node represents a script property
PropertyBase | Base interface for an instance of a property
PropertyDef | Definition of a property of an object
PropertySet | Defines a complete set of properties for a single object instance
PropertyValue | A simple structure designed just as a holder of property values between the instances of objects they might target
PSSMShadowCameraSetup | Parallel Split Shadow Map (PSSM) shadow camera setup
PVRTCCodec | Codec specialized in loading PVRTC (PowerVR) images
Quaternion | Implementation of a Quaternion, i.e
QueuedProgressiveMeshGenerator | Creates a request for the worker
QueuedRenderableCollection | Lowest level collection of renderables
DepthSortDescendingLess | Comparator to order objects by descending camera distance
PassGroupLess | Comparator to order pass groups
RadixSortFunctorDistance | Functor for descending sort value 2 for radix sort (distance)
RadixSortFunctorPass | Functor for accessing sort value 1 for radix sort (Pass)
QueuedRenderableVisitor | Visitor interface for items in a QueuedRenderableCollection
Radian | Wrapper class which indicates a given angle value is in Radians
RadixSort | Class for performing a radix sort (fast comparison-less sort based on byte value) on various standard STL containers
SortEntry |
Ray | Representation of a ray in space, i.e
RaySceneQuery | Specialises the SceneQuery class for querying along a ray
RaySceneQueryListener | Alternative listener class for dealing with RaySceneQuery
RaySceneQueryResultEntry | This struct allows a single comparison of result data no matter what the type
Rectangle2D | Allows the rendering of a simple 2D rectangle This class renders a simple 2D rectangle; this rectangle has no depth and therefore is best used with specific render queue and depth settings, like RENDER_QUEUE_BACKGROUND and 'depth_write off' for backdrops, and RENDER_QUEUE_OVERLAY and 'depth_check off' for fullscreen quads
RegionSceneQuery | Abstract class defining a query which returns single results from a region
Renderable | Abstract class defining the interface all renderable objects must implement
RenderSystemData | An internal class that should be used only by a render system for internal use
Visitor | Visitor object that can be used to iterate over a collection of Renderable instances abstractly
RenderablePass | Struct associating a single Pass with a single Renderable
RenderingAPIException |
RenderObjectListener | Abstract interface which classes must implement if they wish to receive events from the scene manager when single object is about to be rendered
RenderOperation | 'New' rendering operation using vertex buffers
RenderPriorityGroup | Collection of renderables by priority
RenderQueue | Class to manage the scene object rendering queue
RenderableListener | Class to listen in on items being added to the render queue
RenderQueueGroup | A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same time to the renderer
RenderQueueInvocation | Class representing the invocation of queue groups in a RenderQueue
RenderQueueInvocationSequence | Class to hold a linear sequence of RenderQueueInvocation objects
RenderQueueListener | Abstract interface which classes must implement if they wish to receive events from the render queue
RenderSystem | Defines the functionality of a 3D API
Listener | Defines a listener on the custom events that this render system can raise
RenderSystemContext |
RenderSystemCapabilities | Singleton class for storing the capabilities of the graphics card
RenderSystemCapabilitiesManager | Class for managing RenderSystemCapabilities database for Ogre
RenderSystemCapabilitiesSerializer | Class for serializing RenderSystemCapabilities to / from a .rendercaps script
RenderTarget | A 'canvas' which can receive the results of a rendering operation
FrameStats |
Impl | RenderSystem specific interface for a RenderTarget; this should be subclassed by RenderSystems
RenderTargetEvent | Struct containing information about a RenderTarget event
RenderTargetListener | A interface class defining a listener which can be used to receive notifications of RenderTarget events
RenderTargetViewportEvent | Struct containing information about a RenderTarget Viewport-specific event
RenderTexture | This class represents a RenderTarget that renders to a Texture
RenderToVertexBuffer | An object which renders geometry to a vertex
RenderWindow | Manages the target rendering window
RenderWindowDescription | Render window creation parameters
Resource | Abstract class representing a loadable resource (e.g
Listener |
ResourceBackgroundQueue | This class is used to perform Resource operations in a background thread
Listener | This abstract listener interface lets you get notifications of completed background processes instead of having to poll ticket statuses
ResourceRequest | Encapsulates a queued request for the background queue
ResourceResponse | Struct that holds details of queued notifications
ResourceGroupListener | This abstract class defines an interface which is called back during resource group loading to indicate the progress of the load
ResourceGroupManager | This singleton class manages the list of resource groups, and notifying the various resource managers of their obligations to load / unload resources in a group
ResourceDeclaration | Nested struct defining a resource declaration
ResourceGroup | Resource group entry
ResourceLocation | Resource location entry
ResourceLoadingListener |
ResourceManager | Defines a generic resource handler
ResourcePool | Definition of a pool of resources, which users can use to reuse similar resources many times without destroying and recreating them
RibbonTrail | Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances
RibbonTrailFactory | Factory object for creating RibbonTrail instances
Root | The root class of the Ogre system
RotationalSpline | This class interpolates orientations (rotations) along a spline using derivatives of quaternions
RuntimeAssertionException |
ScaleControllerFunction | Predefined controller function which simply scales an input to an output value
SceneManager | Manages the organisation and rendering of a 'scene' i.e
LightClippingInfo | Struct for caching light clipping information for re-use in a frame
LightInfo | Cached light information, used to tracking light's changes
lightLess | Comparator for sorting lights relative to a point
lightsForShadowTextureLess | Default sorting routine which sorts lights which cast shadows to the front of a list, sub-sorting by distance
Listener | Class that allows listening in on the various stages of SceneManager processing, so that custom behaviour can be implemented from outside
materialLess | Comparator for material map, for sorting materials into render order (e.g
MovableObjectCollection | Simple structure to hold MovableObject map and a mutex to go with it
RenderContext |
SceneMgrQueuedRenderableVisitor | Inner helper class to implement the visitor pattern for rendering objects in a queue
ShadowCasterSceneQueryListener | Inner class to use as callback for shadow caster scene query
SkyBoxGenParameters |
SkyDomeGenParameters |
SkyPlaneGenParameters |
SceneManagerEnumerator | Enumerates the SceneManager classes available to applications
SceneManagerFactory | Class which will create instances of a given SceneManager
SceneManagerMetaData | Structure containing information about a scene manager
SceneNode | Class representing a node in the scene graph
SceneQuery | A class for performing queries on a scene
WorldFragment | Represents part of the world geometry that is a result of a SceneQuery
SceneQueryListener | This optional class allows you to receive per-result callbacks from SceneQuery executions instead of a single set of consolidated results
SceneQueryResult | Holds the results of a scene query
ScreenRatioPixelCountLodStrategy |
ScriptCompiler | This is the main class for the compiler
AbstractTreeBuilder |
Error |
ScriptCompilerEvent | This struct is a base class for events which can be thrown by the compilers and caught by subscribers
ScriptCompilerListener | This is a listener for the compiler
ScriptCompilerManager | Manages threaded compilation of scripts
ScriptLexer |
ScriptLoader | Abstract class defining the interface used by classes which wish to perform script loading to define instances of whatever they manage
ScriptParser |
ScriptToken | This struct represents a token, which is an ID'd lexeme from the parsing input stream
ScriptTranslator | This class translates script AST (abstract syntax tree) into Ogre resources
ScriptTranslatorManager | The ScriptTranslatorManager manages the lifetime and access to script translators
Serializer | Generic class for serialising data to / from binary stream-based files
set |
ShadowCameraSetup | This class allows you to plug in new ways to define the camera setup when rendering and projecting shadow textures
ShadowCaster | This class defines the interface that must be implemented by shadow casters
ShadowRenderable | Class which represents the renderable aspects of a set of shadow volume faces
ShadowTextureConfig | Structure containing the configuration for one shadow texture
ShadowTextureManager | Class to manage the available shadow textures which may be shared between many SceneManager instances if formats agree
ShadowVolumeExtrudeProgram | Static class containing source for vertex programs for extruding shadow volumes
SharedParamsTranslator |
SharedPtr | Reference-counted shared pointer, used for objects where implicit destruction is required
SharedPtrInfo |
SharedPtrInfoDelete |
SharedPtrInfoDeleteT |
SharedPtrInfoFree |
SimplePageContentCollection | Specialisation of PageContentCollection which just provides a simple list of PageContent instances
SimplePageContentCollectionFactory | Factory class for SimplePageContentCollection
SimpleRenderable | Simple implementation of MovableObject and Renderable for single-part custom objects
SimpleSpline | A very simple spline class which implements the Catmull-Rom class of splines
Singleton | Template class for creating single-instance global classes
Skeleton | A collection of Bone objects used to animate a skinned mesh
SkeletonInstance | A SkeletonInstance is a single instance of a Skeleton used by a world object
SkeletonManager | Handles the management of skeleton resources
SkeletonSerializer | Class for serialising skeleton data to/from an OGRE .skeleton file
SmallVector | SmallVector - This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small
SmallVector< T, 0 > | Specialize SmallVector at N=0
SmallVectorBase | SmallVectorBase - This is all the non-templated stuff common to all SmallVectors
U |
SmallVectorImpl | SmallVectorImpl - This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter
SmallVectorTemplateBase | SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's
SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's
SmallVectorTemplateCommon |
Sphere | A sphere primitive, mostly used for bounds checking
SphereSceneQuery | Specialises the SceneQuery class for querying within a sphere
StaticCache | Template version of cache based on static array
StaticFaceGroup | Collects a group of static i.e
StaticGeometry | Pre-transforms and batches up meshes for efficient use as static geometry in a scene
GeometryBucket | A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored
LODBucket | A LODBucket is a collection of smaller buckets with the same LOD
LODShadowRenderable | Nested class to allow shadows
MaterialBucket | A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same LOD)
OptimisedSubMeshGeometry | Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances
QueuedGeometry | Structure recording a queued geometry for low level builds
QueuedSubMesh | Structure recording a queued submesh for the build
Region | The details of a topological region which is the highest level of partitioning for this class
SubMeshLodGeometryLink | Saved link between SubMesh at a LOD and vertex/index data May point to original or optimised geometry
StdAlignedAllocPolicy | A "standard" allocation policy for use with AllocatedObject and STLAllocator, which aligns memory at a given boundary (which should be a power of 2)
StdAllocPolicy | A "standard" allocation policy for use with AllocatedObject and STLAllocator
STLAllocator |
rebind | Standard rebind mechanism
STLAllocatorBase | Wrapper class for operating as an STL container allocator
STLAllocatorBase< const T > |
StreamSerialiser | Utility class providing helper methods for reading / writing structured data held in a DataStream
Chunk | Definition of a chunk of data in a file
StringConverter | Class for converting the core Ogre data types to/from Strings
StringInterface | Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers
StringUtil | Utility class for manipulating Strings
SubEntity | Utility class which defines the sub-parts of an Entity
SubMesh | Defines a part of a complete mesh
TagPoint | A tagged point on a skeleton, which can be used to attach entities to on specific other entities
TangentSpaceCalc | Class for calculating a tangent space basis
IndexRemap | Information about a remapped index
Result | The result of having built a tangent space basis
VertexInfo |
Technique | Class representing an approach to rendering this particular Material
GPUDeviceNameRule | Rule controlling whether technique is deemed supported based on GPU device name
GPUVendorRule | Rule controlling whether technique is deemed supported based on GPU vendor
TechniqueTranslator |
TempBlendedBufferInfo | Structure for recording the use of temporary blend buffers
Terrain | The main containing class for a chunk of terrain
DefaultGpuBufferAllocator | Standard implementation of a buffer allocator which re-uses buffers
DerivedDataRequest | A data holder for communicating with the background derived data update
DerivedDataResponse | A data holder for communicating with the background derived data update
GenerateMaterialRequest | A data holder for communicating with the background GetMaterial
GpuBufferAllocator | Interface used to by the Terrain instance to allocate GPU buffers
ImportData | Structure encapsulating import data that you may use to bootstrap the terrain without loading from a native data stream
LayerInstance | An instance of a layer, with specific texture names
TerrainAutoUpdateLod | Terrain automatic LOD loading
TerrainAutoUpdateLodByDistance | Class implementing TerrainAutoUpdateLod interface
TerrainAutoUpdateLodFactory |
TerrainGlobalOptions | Options class which just stores default options for the terrain
TerrainGroup | Helper class to assist you in managing multiple terrain instances that are connected to each other
LoadRequest | Structure for holding the load request
RayResult | Result from a terrain ray intersection with the terrain group
TerrainSlot | Slot for a terrain instance, together with its definition
TerrainSlotDefinition | Definition of how to populate a 'slot' in the terrain group
TerrainLayerBlendMap | Class exposing an interface to a blend map for a given layer
TerrainLayerDeclaration | The definition of the information each layer will contain in this terrain
TerrainLayerSampler | Description of a sampler that will be used with each layer
TerrainLayerSamplerElement | Information about one element of a sampler / texture within a layer
TerrainLodManager | Terrain LOD data manager
LoadLodRequest |
LodInfo |
TerrainMaterialGenerator | Class that provides functionality to generate materials for use with a terrain
Profile | Inner class which should also be subclassed to provide profile-specific material generation
TerrainMaterialGeneratorA | A TerrainMaterialGenerator which can cope with normal mapped, specular mapped terrain
SM2Profile | Shader model 2 profile target
ShaderHelper | Interface definition for helper class to generate shaders
ShaderHelperCg | Utility class to help with generating shaders for Cg / HLSL
ShaderHelperGLSL | Utility class to help with generating shaders for GLSL
ShaderHelperGLSLES | Utility class to help with generating shaders for GLSL ES
ShaderHelperHLSL |
TerrainPagedWorldSection | A world section which includes paged terrain
TerrainDefiner |
TerrainPaging | This class is the 'core' class for paging terrain, that will integrate with the larger paging system and provide the appropriate utility classes required
SectionFactory |
TerrainQuadTreeNode | A node in a quad tree used to store a patch of terrain
LodLevel |
Movable | MovableObject implementation to provide the hook to the scene
Rend | Hook to the render queue
VertexDataRecord |
TexCoordModifierControllerValue | Predefined controller value for getting / setting a texture coordinate modifications (scales and translates)
TextAreaOverlayElement | This class implements an overlay element which contains simple unformatted text
CmdAlignment | Command object for setting the alignment
CmdCaption | Command object for setting the caption
CmdCharHeight | Command object for setting the char height
CmdColour | Command object for setting the constant colour
CmdColourBottom | Command object for setting the bottom colour
CmdColourTop | Command object for setting the top colour
CmdFontName | Command object for setting the caption
CmdSpaceWidth | Command object for setting the width of a space
TextAreaOverlayElementFactory | Factory for creating TextAreaOverlayElement instances
Texture | Abstract class representing a Texture resource
TextureFrameControllerValue | Predefined controller value for getting / setting the frame number of a texture layer
TextureManager | Class for loading & managing textures
TextureSourceTranslator |
TextureUnitState | Class representing the state of a single texture unit during a Pass of a Technique, of a Material
TextureEffect | Internal structure defining a texture effect
UVWAddressingMode | Texture addressing mode for each texture coordinate
TextureUnitTranslator |
TimeIndex | Time index object used to search keyframe at the given position
Timer | Timer class
TransformKeyFrame | Specialised KeyFrame which stores a full transform
TRect |
UnifiedHighLevelGpuProgram | Specialisation of HighLevelGpuProgram which just delegates its implementation to one other high level program, allowing a single program definition to represent one supported program from a number of options
CmdDelegate | Command object for setting delegate (can set more than once)
UnifiedHighLevelGpuProgramFactory | Factory class for Unified programs
UnimplementedException |
UserObjectBindings | Class that provides convenient interface to establish a linkage between custom user application objects and Ogre core classes
Attributes | Internal class that uses as data storage container
VariableAccessAbstractNode | This abstract node represents a variable assignment
vector |
Vector2 | Standard 2-dimensional vector
Vector3 | Standard 3-dimensional vector
Vector4 | 4-dimensional homogeneous vector
VectorIterator | Concrete IteratorWrapper for nonconst access to the underlying container
VectorIteratorWrapper | Prepared IteratorWrapper for container like std::vector
VectorRange | Predefined type
VertexAnimationTrack | Specialised AnimationTrack for dealing with changing vertex position information
VertexBoneAssignment_s | Records the assignment of a single vertex to a single bone with the corresponding weight
VertexBufferBinding | Records the state of all the vertex buffer bindings required to provide a vertex declaration with the input data it needs for the vertex elements
VertexCacheProfiler | Vertex cache profiler
VertexData | Summary class collecting together vertex source information
HardwareAnimationData | Struct used to hold hardware morph / pose vertex data information
VertexDeclaration | This class declares the format of a set of vertex inputs, which can be issued to the rendering API through a RenderOperation
VertexElement | This class declares the usage of a single vertex buffer as a component of a complete VertexDeclaration
VertexMorphKeyFrame | Specialised KeyFrame which stores absolute vertex positions for a complete buffer, designed to be interpolated with other keys in the same track
VertexPoseKeyFrame | Specialised KeyFrame which references a Mesh::Pose at a certain influence level, which stores offsets for a subset of the vertices in a buffer to provide a blendable pose
PoseRef | Reference to a pose at a given influence level
ViewPoint | Structure for holding a position & orientation pair
Viewport | An abstraction of a viewport, i.e
Listener | Listener interface so you can be notified of Viewport changes
VisibleObjectsBoundsInfo | Structure collecting together information about the visible objects that have been discovered in a scene
WaveformControllerFunction | Predefined controller function based on a waveform
WindowEventListener |
WindowEventUtilities |
WireBoundingBox | Allows the rendering of a wireframe bounding box
WorkQueue | Interface to a general purpose request / response style background work queue
Request | General purpose request structure
RequestHandler | Interface definition for a handler of requests
Response | General purpose response structure
ResponseHandler | Interface definition for a handler of responses
ZipArchive | Specialisation of the Archive class to allow reading of files from a zip format source archive
ZipArchiveFactory | Specialisation of ArchiveFactory for Zip files
ZipDataStream | Specialisation of DataStream to handle streaming data from zip archives
_finddata_t |
OgreView |
OgreWindow |

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.