Class List

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

[detail level 1234]

►NOgre
►NEmitterCommands
CCmdAngle	Command object for ParticleEmitter - see ParamCommand
CCmdColour	Command object for particle emitter - see ParamCommand
CCmdColourRangeEnd	Command object for particle emitter - see ParamCommand
CCmdColourRangeStart	Command object for particle emitter - see ParamCommand
CCmdDirection	Command object for particle emitter - see ParamCommand
CCmdDirPositionRef	Command object for particle emitter - see ParamCommand
CCmdDuration	Command object for particle emitter - see ParamCommand
CCmdEmissionRate	Command object for particle emitter - see ParamCommand
CCmdEmittedEmitter	Command object for particle emitter - see ParamCommand
CCmdMaxDuration	Command object for particle emitter - see ParamCommand
CCmdMaxRepeatDelay	Command object for particle emitter - see ParamCommand
CCmdMaxTTL	Command object for particle emitter - see ParamCommand
CCmdMaxVelocity	Command object for particle emitter - see ParamCommand
CCmdMinDuration	Command object for particle emitter - see ParamCommand
CCmdMinRepeatDelay	Command object for particle emitter - see ParamCommand
CCmdMinTTL	Command object for particle emitter - see ParamCommand
CCmdMinVelocity	Command object for particle emitter - see ParamCommand
CCmdName	Command object for particle emitter - see ParamCommand
CCmdPosition	Command object for particle emitter - see ParamCommand
CCmdRepeatDelay	Command object for particle emitter - see ParamCommand
CCmdTTL	Command object for particle emitter - see ParamCommand
CCmdUp	Command object for particle emitter - see ParamCommand
CCmdVelocity	Command object for particle emitter - see ParamCommand
►NRTShader
CCGProgramProcessor	CG Language program processor class
CCGProgramWriter	CG target language writer implementation
CCompareUniformByName
CConstParameter	Helper template which is the base for our ConstParameters
CDualQuaternionSkinning	Implement a sub render state which performs dual quaternion hardware skinning
CFFPAlphaTest	A factory that enables creation of LayeredBlending instances
CFFPAlphaTestFactory
CFFPColour	Colour sub render state implementation of the Fixed Function Pipeline
CFFPColourFactory	A factory that enables creation of FFPColour instances
CFFPFog	Fog sub render state implementation of the Fixed Function Pipeline
CFFPFogFactory	A factory that enables creation of FFPFog instances
CFFPLighting	Lighting sub render state implementation of the Fixed Function Pipeline
CFFPLightingFactory	A factory that enables creation of FFPLighting instances
CFFPRenderStateBuilder	Fixed Function Pipeline render state builder
CFFPTexturing	Texturing sub render state implementation of the Fixed Function Pipeline
CFFPTexturingFactory	A factory that enables creation of FFPTexturing instances
CFFPTransform	Transform sub render state implementation of the Fixed Function Pipeline
CFFPTransformFactory	A factory that enables creation of FFPTransform instances
CFunction	A class that represents a shader based program function
CFunctionAtom	A class that represents an atomic code section of shader based program function
►CFunctionInvocation	A class that represents function invocation code from shader based program function
CFunctionInvocationCompare	Comparator function to be used for comparisons
CFunctionInvocationLessThan	Comparator function to be used for sorting
CGLSLESProgramProcessor	GLSL ES Language program processor class
CGLSLESProgramWriter	GLSL ES target language writer implementation
CGLSLProgramProcessor	GLSL Language program processor class
CGLSLProgramWriter	GLSL target language writer implementation
►CHardwareSkinning	Implement a sub render state which performs hardware skinning
CSkinningData
CHardwareSkinningFactory	A factory that enables creation of HardwareSkinning instances
CHardwareSkinningTechnique	Implement a sub render state which performs hardware skinning
CHLSLProgramProcessor	CG Language program processor class
CHLSLProgramWriter	HLSL target language writer implementation
CIntegratedPSSM3	Integrated PSSM shadow receiver with 3 splits sub render state implementation
CIntegratedPSSM3Factory	A factory that enables creation of IntegratedPSSM3 instances
►CLayeredBlending	Texturing sub render state implementation of layered blending
CTextureBlend
CLayeredBlendingFactory	A factory that enables creation of LayeredBlending instances
CLinearSkinning	Implement a sub render state which performs hardware skinning
CNormalMapLighting	Normal Map Lighting extension sub render state implementation
CNormalMapLightingFactory	A factory that enables creation of NormalMapLighting instances
COperand	A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields)
CParameter	A class that represents a shader based program parameter
CParameterFactory	Helper utility class that creates common parameters
CPerPixelLighting	Per pixel Lighting extension sub render state implementation
CPerPixelLightingFactory	A factory that enables creation of PerPixelLighting instances
CProgram	A class that represents a shader based program
CProgramManager	A singleton manager class that manages shader based programs
CProgramProcessor	A class that provides extra processing services on CPU based programs
CProgramSet	Container class for shader based programs
CProgramWriter	Base class interface for shader program writers
CProgramWriterFactory	Interface definition for factories of ShaderProgramWriter
CProgramWriterManager
CRenderState	This is a container class for sub render state class
CSGMaterialSerializerListener	This class responsible for translating core features of the RT Shader System for Ogre material scripts
CSGScriptTranslator	This class responsible for translating core features of the RT Shader System for Ogre material scripts
CShaderGenerator	Shader generator system main interface
CShaderProgramWriterCGFactory	CG program writer factory implementation
CShaderProgramWriterGLSLESFactory	GLSL ES program writer factory implementation
CShaderProgramWriterGLSLFactory	GLSL program writer factory implementation
CShaderProgramWriterHLSLFactory	HLSL program writer factory implementation
CSubRenderState	This class is the base interface of sub part from a shader based rendering pipeline
CSubRenderStateAccessor	This class uses as accessor from a template SubRenderState to all of its instances that created based on it
CSubRenderStateFactory	Abstract factory interface for creating SubRenderState implementation instances
CTargetRenderState	This is the target render state
CTextureAtlasRecord
CTextureAtlasSampler	Implements texture atlas sampling
►CTextureAtlasSamplerFactory	A factory that enables creation of TextureAtlasSampler instances
CTextureAtlasAttib
CTriplanarTexturing	Triplanar Texturing
CTriplanarTexturingFactory	A factory that enables creation of TriplanarMapping instances
CUniformParameter	Uniform parameter class
►Nv1
►NOverlayElementCommands
CCmdCaption	Command object for OverlayElement - see ParamCommand
CCmdHeight	Command object for OverlayElement - see ParamCommand
CCmdHorizontalAlign	Command object for OverlayElement - see ParamCommand
CCmdLeft	Command object for OverlayElement - see ParamCommand
CCmdMaterial	Command object for OverlayElement - see ParamCommand
CCmdMetricsMode	Command object for OverlayElement - see ParamCommand
CCmdTop	Command object for OverlayElement - see ParamCommand
CCmdVerticalAlign	Command object for OverlayElement - see ParamCommand
CCmdVisible	Command object for OverlayElement - see ParamCommand
CCmdWidth	Command object for OverlayElement - see ParamCommand
CAnimation	An animation sequence
CAnimationContainer	An animation container interface, which allows generic access to sibling animations
CAnimationState	Represents the state of an animation and the weight of its influence
CAnimationStateControllerValue	ControllerValue wrapper class for AnimationState
CAnimationStateSet	Class encapsulating a set of AnimationState objects
►CAnimationTrack	A 'track' in an animation sequence, i.e
CListener	Listener allowing you to override certain behaviour of a track, for example to drive animation procedurally
CBaseInstanceBatchVTF	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
CBillboard	A billboard is a primitive which always faces the camera in every frame
►CBillboardChain	Allows the rendering of a chain of connected billboards
CElement	Contains the data of an element of the BillboardChain
CBillboardChainFactory	Factory object for creating BillboardChain instances
►CBillboardParticleRenderer	Specialisation of ParticleSystemRenderer to render particles using a BillboardSet
CCmdAccurateFacing	Command object for accurate facing(see ParamCommand)
CCmdBillboardOrigin	Command object for billboard origin (see ParamCommand)
CCmdBillboardRotationType	Command object for billboard rotation type (see ParamCommand)
CCmdBillboardType	Command object for billboard type (see ParamCommand)
CCmdCommonDirection	Command object for common direction (see ParamCommand)
CCmdCommonUpVector	Command object for common up-vector (see ParamCommand)
CCmdPointRendering	Command object for point rendering (see ParamCommand)
CBillboardParticleRendererFactory	Factory class for BillboardParticleRenderer
CBillboardSet	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
CBillboardSetFactory	Factory object for creating BillboardSet instances
►CBorderPanelOverlayElement	A specialisation of the PanelOverlayElement to provide a panel with a border
CCmdBorderBottomLeftUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CCmdBorderBottomRightUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CCmdBorderBottomUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CCmdBorderLeftUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CCmdBorderMaterial	Command object for specifying the Material for the border (see ParamCommand)
CCmdBorderRightUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CCmdBorderSize	Command object for specifying border sizes (see ParamCommand)
CCmdBorderTopLeftUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CCmdBorderTopRightUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CCmdBorderTopUV	Command object for specifying texture coordinates for the border (see ParamCommand)
CBorderPanelOverlayElementFactory	Factory for creating BorderPanelOverlayElement instances
CBorderRenderable	Class for rendering the border of a BorderPanelOverlayElement
CCbDrawCall
CCbDrawCallIndexed
CCbDrawCallStrip
CCbRenderOp
CCbStartV1LegacyRendering
CD3D11DepthPixelBuffer
CD3D11HardwareBuffer	Base implementation of a D3D11 buffer, dealing with all the common aspects
CD3D11HardwareBufferManager	D3D11HardwareBufferManagerBase as a Singleton
CD3D11HardwareBufferManagerBase	Implementation of HardwareBufferManager for D3D11
CD3D11HardwareIndexBuffer
CD3D11HardwarePixelBuffer
CD3D11HardwareUniformBuffer	Specialisation of HardwareBuffer for D3D11
CD3D11HardwareVertexBuffer	Specialisation of HardwareVertexBuffer for D3D11
CD3D11NullPixelBuffer
CD3D11RenderToVertexBuffer	An object which renders geometry to a vertex
CDefaultHardwareBufferManager	DefaultHardwareBufferManager as a Singleton
CDefaultHardwareBufferManagerBase	Specialisation of HardwareBufferManagerBase to emulate hardware buffers
CDefaultHardwareCounterBuffer	Specialisation of HardwareCounterBuffer for emulation
CDefaultHardwareIndexBuffer	Specialisation of HardwareIndexBuffer for emulation
CDefaultHardwareUniformBuffer	Specialisation of HardwareUniformBuffer for emulation
CDefaultHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for emulation
►CEdgeData	This class contains the information required to describe the edge connectivity of a given set of vertices and indexes
CEdge	Edge data
CEdgeGroup	A group of edges sharing the same vertex data
CTriangle	Basic triangle structure
CEdgeListBuilder	General utility class for building edge lists for geometry
CEntity	Defines an instance of a discrete, movable object based on a Mesh
CEntityFactory	Factory object for creating Entity instances
CGL3PlusDefaultHardwareBufferManager	GL3PlusDefaultHardwareBufferManagerBase as a Singleton
CGL3PlusDefaultHardwareBufferManagerBase	Specialisation of HardwareBufferManager to emulate hardware buffers
CGL3PlusDefaultHardwareCounterBuffer	Specialisation of HardwareCounterBuffer for emulation
CGL3PlusDefaultHardwareIndexBuffer	Specialisation of HardwareIndexBuffer for emulation
CGL3PlusDefaultHardwareUniformBuffer	Specialisation of HardwareUniformBuffer for emulation
CGL3PlusDefaultHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for emulation
CGL3PlusHardwareBufferManager	GL3PlusHardwareBufferManagerBase as a Singleton
CGL3PlusHardwareBufferManagerBase	Implementation of HardwareBufferManager for OpenGL
CGL3PlusHardwareCounterBuffer	Specialisation of HardwareCounterBuffer for OpenGL
CGL3PlusHardwareIndexBuffer
CGL3PlusHardwarePixelBuffer
CGL3PlusHardwareShaderStorageBuffer	Specialisation of HardwareUniformBuffer for the OpenGL Shader Storage Buffer
CGL3PlusHardwareUniformBuffer	Specialisation of HardwareUniformBuffer for OpenGL
CGL3PlusHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for OpenGL
CGL3PlusRenderBuffer	Renderbuffer surface
CGL3PlusRenderToVertexBuffer	An object which renders geometry to a vertex
CGL3PlusTextureBuffer	Texture surface
CGLES2DefaultHardwareBufferManager	GLES2DefaultHardwareBufferManagerBase as a Singleton
CGLES2DefaultHardwareBufferManagerBase	Specialisation of HardwareBufferManager to emulate hardware buffers
CGLES2DefaultHardwareIndexBuffer	Specialisation of HardwareIndexBuffer for emulation
CGLES2DefaultHardwareUniformBuffer	Specialisation of HardwareUniformBuffer for emulation
CGLES2DefaultHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for emulation
CGLES2HardwareBufferManager	GLES2HardwareBufferManagerBase as a Singleton
CGLES2HardwareBufferManagerBase	Implementation of HardwareBufferManager for OpenGL ES
CGLES2HardwareIndexBuffer
CGLES2HardwarePixelBuffer
CGLES2HardwareUniformBuffer	Specialisation of HardwareUniformBuffer for OpenGL
CGLES2HardwareVertexBuffer	Specialisation of HardwareVertexBuffer for OpenGL ES
CGLES2RenderBuffer	Renderbuffer surface
CGLES2RenderToVertexBuffer
CGLES2TextureBuffer	Texture surface
CHardwareBuffer	Abstract class defining common features of hardware buffers
CHardwareBufferLicensee	Abstract interface representing a 'licensee' of a hardware buffer copy
CHardwareBufferLockGuard	Locking helper
CHardwareBufferManager	Singleton wrapper for hardware buffer manager
CHardwareBufferManagerBase	Base definition of a hardware buffer manager
CHardwareCounterBuffer	Specialisation of HardwareBuffer for a counter buffer
CHardwareCounterBufferSharedPtr	Shared pointer implementation used to share counter buffers
CHardwareIndexBuffer	Specialisation of HardwareBuffer for vertex index buffers, still abstract
CHardwareIndexBufferSharedPtr	Shared pointer implementation used to share index buffers
CHardwarePixelBuffer	Specialisation of HardwareBuffer for a pixel buffer
CHardwarePixelBufferSharedPtr	Shared pointer implementation used to share pixel buffers
CHardwareUniformBuffer	Specialisation of HardwareBuffer for a uniform buffer
CHardwareUniformBufferSharedPtr	Shared pointer implementation used to share uniform buffers
CHardwareVertexBuffer	Specialisation of HardwareBuffer for a vertex buffer
CHardwareVertexBufferSharedPtr	Shared pointer implementation used to share vertex buffers
CIndexData	Summary class collecting together index data source information
CInstanceBatch	InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived to implement different instancing techniques (
CInstanceBatchHW	This is technique requires true instancing hardware support
CInstanceBatchHW_VTF	Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instancing
CInstanceBatchShader	This is the same technique the old "InstancedGeometry" implementation used (with improvements)
CInstanceBatchVTF
CInstancedEntity
CInstanceManager	This is the main starting point for the new instancing system
CInstanceManagerCmp
CKeyFrame	A key frame in an animation sequence defined by an AnimationTrack
CLinkedSkeletonAnimationSource	Link to another skeleton to share animations
►CManualObject	Class providing a much simplified interface to generating manual objects with custom geometry
CManualObjectSection	Built, renderable section of geometry
CManualObjectFactory	Factory object for creating ManualObject instances
CMesh	Resource holding data about 3D mesh
CMeshLodUsage	A way of recording the way each LODs is recorded this Mesh
CMeshManager	Handles the management of mesh resources
CMeshSerializer	Class for serialising mesh data to/from an OGRE .mesh file
CMeshSerializerImpl	Internal implementation of Mesh reading / writing for the latest version of the .mesh format
CMeshSerializerImpl_v1_1	Class for providing backwards-compatibility for loading version 1.1 of the .mesh format
CMeshSerializerImpl_v1_10	Class for providing backwards-compatibility for loading version 1.10 of the .mesh format
CMeshSerializerImpl_v1_2	Class for providing backwards-compatibility for loading version 1.2 of the .mesh format
CMeshSerializerImpl_v1_3	Class for providing backwards-compatibility for loading version 1.3 of the .mesh format
CMeshSerializerImpl_v1_4	Class for providing backwards-compatibility for loading version 1.4 of the .mesh format
CMeshSerializerImpl_v1_41	Class for providing backwards-compatibility for loading version 1.41 of the .mesh format
CMeshSerializerImpl_v1_8	Class for providing backwards-compatibility for loading version 1.8 of the .mesh format
CMeshSerializerListener
CMetalHardwareBufferCommon	Common buffer operations for most v1 buffer interfaces used in Metal This implementation treats: Ignores STATIC and DYNAMIC bit in buffers Lack of WRITE_ONLY and DISCARDABLE buffer puts it in slowest path
CMetalHardwareBufferManager	MetalHardwareBufferManagerBase as a Singleton
CMetalHardwareBufferManagerBase	Implementation of HardwareBufferManager for Metal
CMetalHardwareIndexBuffer	Specialisation of HardwareIndexBuffer for Metal
CMetalHardwarePixelBuffer
CMetalHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for Metal
CMetalNullPixelBuffer
CMetalTextureBuffer	Texture surface
CNodeAnimationTrack	Specialised AnimationTrack for dealing with node transforms
CNULLHardwarePixelBuffer
CNumericAnimationTrack	Specialised AnimationTrack for dealing with generic animable values
CNumericKeyFrame	Specialised KeyFrame which stores any numeric value
COldBone	A bone in a skeleton
►COldNode	Class representing a general-purpose OldNode an articulated scene graph
CListener	Listener which gets called back on OldNode events
COldNodeAnimationTrack	Specialised AnimationTrack for dealing with node transforms
COldSkeletonInstance	A OldSkeletonInstance is a single instance of a Skeleton used by a world object
COldSkeletonManager	Handles the management of skeleton resources
COverlay	Represents a layer which is rendered on top of the 'normal' scene contents
COverlayContainer	A 2D element which contains other OverlayElement instances
COverlayElement	Abstract definition of a 2D element to be displayed in an Overlay
COverlayElementFactory	Defines the interface which all components wishing to supply OverlayElement subclasses must implement
COverlayManager	Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them
COverlayProfileSessionListener	Concrete impl
COverlaySystem	This class simplify initialization / finalization of the overlay system
►CPanelOverlayElement	OverlayElement representing a flat, single-material (or transparent) panel which can contain other elements
CCmdTiling	Command object for specifying tiling (see ParamCommand)
CCmdTransparent	Command object for specifying transparency (see ParamCommand)
CCmdUVCoords	Command object for specifying UV coordinates (see ParamCommand)
CPanelOverlayElementFactory	Factory for creating PanelOverlayElement instances
CPatchMesh	Patch specialisation of Mesh
CPatchSurface	A surface which is defined by curves of some kind to form a patch, e.g
CPose	A pose is a linked set of vertex offsets applying to one set of vertex data
CPrefabFactory	A factory class that can create various mesh prefabs
CRectangle2D	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 'depth_write off' materials
CRectangle2DFactory	Factory object for creating Entity instances
CRenderOperation	'New' rendering operation using vertex buffers
CRenderToVertexBuffer
CRibbonTrail	Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances
CRibbonTrailFactory	Factory object for creating RibbonTrail instances
CSimpleRenderable	Simple implementation of MovableObject and Renderable for single-part custom objects
CSkeleton	A collection of OldBone objects used to animate a skinned mesh
CSkeletonSerializer	Class for serialising skeleton data to/from an OGRE .skeleton file
►CStaticGeometry	Pre-transforms and batches up meshes for efficient use as static geometry in a scene
CGeometryBucket	A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored
CLODBucket	A LODBucket is a collection of smaller buckets with the same LOD
CMaterialBucket	A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same LOD)
COptimisedSubMeshGeometry	Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances
CQueuedGeometry	Structure recording a queued geometry for low level builds
CQueuedSubMesh	Structure recording a queued submesh for the build
CRegion	The details of a topological region which is the highest level of partitioning for this class
CSubMeshLodGeometryLink	Saved link between SubMesh at a LOD and vertex/index data May point to original or optimised geometry
CSubEntity	Utility class which defines the sub-parts of an Entity
CSubMesh	Defines a part of a complete mesh
CTagPoint	A tagged point on a skeleton, which can be used to attach entities to on specific other entities
►CTangentSpaceCalc	Class for calculating a tangent space basis
CIndexRemap	Information about a remapped index
CResult	The result of having built a tangent space basis
CTempBlendedBufferInfo	Structure for recording the use of temporary blend buffers
►CTextAreaOverlayElement	This class implements an overlay element which contains simple unformatted text
CCmdAlignment	Command object for setting the alignment
CCmdCaption	Command object for setting the caption
CCmdCharHeight	Command object for setting the char height
CCmdColour	Command object for setting the constant colour
CCmdColourBottom	Command object for setting the bottom colour
CCmdColourTop	Command object for setting the top colour
CCmdFontName	Command object for setting the caption
CCmdSpaceWidth	Command object for setting the width of a space
CTextAreaOverlayElementFactory	Factory for creating TextAreaOverlayElement instances
CTimeIndex	Time index object used to search keyframe at the given position
CTransformKeyFrame	Specialised KeyFrame which stores a full transform
CVertexAnimationTrack	Specialised AnimationTrack for dealing with changing vertex position information
CVertexBoneAssignment_s	Records the assignment of a single vertex to a single bone with the corresponding weight
CVertexBufferBinding	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
CVertexCacheProfiler	Vertex cache profiler
►CVertexData	Summary class collecting together vertex source information
CHardwareAnimationData	Struct used to hold hardware morph / pose vertex data information
CReadRequests
CVertexDeclaration	This class declares the format of a set of vertex inputs, which can be issued to the rendering API through a RenderOperation
CVertexElement	This class declares the usage of a single vertex buffer as a component of a complete VertexDeclaration
CVertexMorphKeyFrame	Specialised KeyFrame which stores absolute vertex positions for a complete buffer, designed to be interpolated with other keys in the same track
►CVertexPoseKeyFrame	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
CPoseRef	Reference to a pose at a given influence level
►CVertexShadowMapHelper
CGeometry
CWireBoundingBox	Allows the rendering of a wireframe bounding box
►NVolume
CCacheSource	A caching Source
CChunk	A single volume chunk mesh
CChunkHandler	Handles the WorkQueue management of the chunks
CChunkParameters	Parameters for loading the volume
CChunkRequest	Data being passed around while loading
CChunkTreeSharedData	Internal shared values of the chunks which are equal in the whole tree
CCSGCubeSource	A not rotated cube
CCSGDifferenceSource	Builds the difference between two sources
CCSGIntersectionSource	Builds the intersection between two sources
CCSGNegateSource	Negates the given volume
CCSGNoiseSource
CCSGOperationSource	Abstract operation volume source holding two sources as operants
CCSGPlaneSource	A plane
CCSGScaleSource	Scales the given volume source
CCSGSphereSource	A sphere
CCSGUnarySource	Source which does a unary operation to another one
CCSGUnionSource	Builds the union between two sources
CDualCell	To store the generated dual cells in a vector
CDualGridGenerator	Class for the generation of the DualGrid
CGridSource	A volume source from a discrete 3d grid
CHalfFloatGridSource	A volume source from a 16 Bit float 3D grid capable of loading volume serializations
CIsoSurface	Abstract IsoSurface
CIsoSurfaceMC	Marching Cubes implementation like at http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/
CMeshBuilder	Class to build up a mesh with vertices and indices
CMeshBuilderCallback	Callback class when the user needs information about the triangles of chunks of a LOD level
COctreeNode	A node in the volume octree
COctreeNodeSplitPolicy	The class deciding on whether to split an octree node or not when building the octree
CSimplexNoise	Simplex Noise ported from public domain Java Implementation http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java Thanks Stefan Gustavson!
CSource	Abstract class defining the density function
CTextureSource	A volume source from a 3D texture
CVertex	Lightweight struct to represent a mesh vertex
C_ConfigOption	Packages the details of a configuration option
CAabb	AoS (array of structures) version of ArrayAabb
CAbsolutePixelCountLodStrategy
CAbstractNode
CActiveActorData
CAlignedMemory	Class to provide aligned memory allocate functionality
CAllocatedObject	Superclass for all objects that wish to use custom memory allocators when their new / delete operators are called
CAndroidEGLContext
CAndroidEGLSupport
CAndroidEGLWindow
CAndroidLogListener
CAngle	Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAngleUnit
CAnimableObject	Defines an interface to classes which have one or more AnimableValue instances to expose
CAnimableValue	Defines an object property which is animable, i.e
CAnimationControllerFunction	Predefined controller function for dealing with animation
CAntiPortal	AntiPortal datastructure for occlusion culling
CAntiPortalFactory	Factory object for creating AntiPortal instances
CAny	Variant type that can hold Any other type
CAnyNumeric	Specialised Any class which has built in arithmetic operators, but can hold only types which support operator +,-,* and /
CAPKFileSystemArchive
CAPKFileSystemArchiveFactory
CAPKZipArchiveFactory
CArchive	Archive-handling class
CArchiveFactory	Abstract factory class, archive codec plugins can register concrete subclasses of this
CArchiveManager	This class manages the available ArchiveFactory plugins
►CAreaEmitter	Particle emitter which emits particles randomly from points inside an area (box, sphere, ellipsoid whatever subclasses choose to be)
CCmdDepth	Command object for area emitter size (see ParamCommand)
CCmdHeight	Command object for area emitter size (see ParamCommand)
CCmdWidth	Command object for area emitter size (see ParamCommand)
CArrayAabb	Cache-friendly array of Aabb represented as a SoA array
CArrayActorPlane	Actors are defined by a plane and a rectangle that limits that plane
CArrayMatrix4	Cache-friendly container of 4x4 matrices represented as a SoA array
CArrayMatrixAf4x3	Cache-friendly container of AFFINE 4x4 matrices represented as a SoA array
►CArrayMemoryManager	Abstract memory manager for managing large chunks of contiguous memory, optimized for SoA (Structure of Arrays) implementations
CRebaseListener	When mUsedMemory >= mMaxMemory (that is, we've exhausted all our preallocated memory) ArrayMemoryManager will proceed to reallocate all memory
CArrayQuaternion	Cache-friendly array of Quaternion represented as a SoA array
CArrayRay
CArraySphere	Cache-friendly array of Sphere represented as a SoA array
CArrayVector3	Cache-friendly array of 3-dimensional represented as a SoA array
CASTCCodec	Codec specialized in loading ASTC (ARM Adaptive Scalable Texture Compression) images
CAsyncTicket	In Ogre 2.0 data structures, reading data from GPU back to CPU is asynchronous
CAtomAbstractNode	This is an abstract node which cannot be broken down further
CAtomicObject
CAtomicScalar
CAutoParamDataSource	This utility class is used to hold the information used to generate the matrices and other information required to automatically populate GpuProgramParameters
CAxisAlignedBox	A 3D box aligned with the x/y/z axes
CAxisAlignedBoxSceneQuery	Specialises the SceneQuery class for querying within an axis aligned box
CBackgroundProcessResult	Encapsulates the result of a background queue request
CBarrier	A barrier is a synchronization mechanism where multiple threads wait until all of them have reached the barrier sync point before continuing
CBasicBlock
CBitwise	Class for manipulating bit patterns
CBone	Class representing a Bone in the join hierarchy of a skeleton
CBoneArrayMemoryManager	Implementation to create the Transform variables needed by Bones
CBoneMemoryManager	Wrap-around class that contains multiple ArrayMemoryManager, one per hierarchy depth
CBoneTransform	Represents the transform of a single object, arranged in SoA (Structure of Arrays)
CBooleanMask4
CBoundUav
CBox	Structure used to define a box in a 3-D integer space
CBoxEmitter	Particle emitter which emits particles randomly from points inside a box
CBoxEmitterFactory	Factory class for particle emitter of type "Box"
CBspIntersectionSceneQuery	BSP specialisation of IntersectionSceneQuery
CBspLevel	Holds all the data associated with a Binary Space Parition (BSP) based indoor level
►CBspNode	Encapsulates a node in a BSP tree
CBrush
CBspRaySceneQuery	BSP specialisation of RaySceneQuery
CBspResourceManager	Manages the locating and loading of BSP-based indoor levels
CBspSceneManager	Specialisation of the SceneManager class to deal with indoor scenes based on a BSP tree
CBspSceneManagerFactory	Factory for BspSceneManager
CBspSceneManagerPlugin	Plugin instance for BSPSceneManager
CBspSceneNode	Specialisation of SceneNode for the BspSceneManager
CBufferInterface	Most (if not all) buffers, can be treated with the same code
CBufferPacked
CBuildLightListRequest
CBuiltinScriptTranslatorManager	This class manages the builtin translators
CBySkeletonDef
►CCamera	A viewpoint from which the scene will be rendered
CListener	Listener interface so you can be notified of Camera events
CCapsule
CCbBase
CCbDrawCall
CCbDrawCallIndexed
CCbDrawCallStrip
CCbDrawIndexed
CCbDrawStrip
CCbIndirectBuffer
Ccbitset32	This is similar to std::bitset, except waaay less bloat
CcbitsetN
CCbLowLevelMaterial
CCbPipelineStateObject
CCbShaderBuffer
CCbSharedDraw
CCbTexture
CCbTextureDisableFrom
CCbVao
CCgFxScriptLoader	Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them
CCgPlugin	Plugin instance for Cg Program Manager
►CCgProgram	Specialisation of HighLevelGpuProgram to provide support for nVidia's CG language
CCmdArgs	Command object for setting compilation arguments
CCmdEntryPoint	Command object for setting entry point
CCmdProfiles	Command object for setting profiles
CCgProgramFactory	Factory class for Cg programs
CCocoaContext
CCocoaWindow
►CCodec	Abstract class that defines a 'codec'
CCodecData
►CColourFaderAffector	This plugin subclass of ParticleAffector allows you to alter the colour of particles
CCmdAlphaAdjust	Command object for alpha adjust (see ParamCommand)
CCmdBlueAdjust	Command object for blue adjust (see ParamCommand)
CCmdGreenAdjust	Command object for green adjust (see ParamCommand)
CCmdRedAdjust	Command object for red adjust (see ParamCommand)
►CColourFaderAffector2	This plugin subclass of ParticleAffector allows you to alter the colour of particles
CCmdAlphaAdjust1	Command object for alpha adjust (see ParamCommand)
CCmdAlphaAdjust2	Command object for alpha adjust (see ParamCommand)
CCmdBlueAdjust1	Command object for blue adjust (see ParamCommand)
CCmdBlueAdjust2	Command object for blue adjust (see ParamCommand)
CCmdGreenAdjust1	Command object for green adjust (see ParamCommand)
CCmdGreenAdjust2	Command object for green adjust (see ParamCommand)
CCmdRedAdjust1	Command object for red adjust (see ParamCommand)
CCmdRedAdjust2	Command object for red adjust (see ParamCommand)
CCmdStateChange	Command object for alpha adjust (see ParamCommand)
CColourFaderAffectorFactory	Factory class for ColourFaderAffector
CColourFaderAffectorFactory2	Factory class for ColourFaderAffector
►CColourImageAffector
CCmdImageAdjust	Command object for red adjust (see ParamCommand)
CColourImageAffectorFactory	Factory class for ColourImageAffector
►CColourInterpolatorAffector
CCmdColourAdjust	Command object for red adjust (see ParamCommand)
CCmdTimeAdjust	Command object for red adjust (see ParamCommand)
CColourInterpolatorAffectorFactory	Factory class for ColourInterpolatorAffector
CColourValue	Class representing colour
CCommandBuffer	Command Buffer implementation
CCompositorChannel	A channel in the compositor transports textures between nodes
CCompositorManager2	Main system for managing Render Targets through the use of nodes
CCompositorNamedBuffer
CCompositorNode	Compositor nodes are the core subject of compositing
CCompositorNodeDef	Compositor nodes are the core subject of compositing
CCompositorNodeTranslator
CCompositorPass	Abstract class for compositor passes
CCompositorPassClear	Implementation of CompositorPass This implementation will clear the RenderTarget using the parameters from definition (rectangle area, which buffers, what values, etc)
CCompositorPassClearDef
CCompositorPassCompute	Implementation of CompositorPass This implementation will render a fullscreen triangle/quad to the RenderTarget using the parameters from definition (rectangle area, whether triangle or quad pass, whether to include frustum corners, etc)
►CCompositorPassComputeDef
CBufferSource
CComputeTextureSource
►CCompositorPassDef	Interface to abstract all types of pass definitions (
CUavDependency
CCompositorPassDepthCopy	Implementation of CompositorPass This implementation will copy one DepthBuffer to another DepthBuffer from two RTs
CCompositorPassDepthCopyDef
CCompositorPassMipmap	Implementation of CompositorPass This implementation will Mipmap the texture used by this RenderTarget
CCompositorPassMipmapDef
CCompositorPassProvider	Base class that users can derive from in order to implement custom passes for the compositor
CCompositorPassQuad	Implementation of CompositorPass This implementation will render a fullscreen triangle/quad to the RenderTarget using the parameters from definition (rectangle area, whether triangle or quad pass, whether to include frustum corners, etc)
►CCompositorPassQuadDef
CQuadTextureSource
CCompositorPassScene	Implementation of CompositorPass This implementation will perform main rendering, selecting several parameters (like viewport's visibility mask, first and last render queue to render) it will render the main scene
CCompositorPassSceneDef
CCompositorPassStencil	Implementation of CompositorPass This implementation will clear the RenderTarget using the parameters from definition (rectangle area, which buffers, what values, etc)
CCompositorPassStencilDef
CCompositorPassTranslator
CCompositorPassUav	Implementation of CompositorPass This implementation will set UAVs
►CCompositorPassUavDef
CBufferSource
CTextureSource
CCompositorShadowMapRepeatTranslator
CCompositorShadowMapTargetTranslator
CCompositorShadowMapTargetTypeTranslator
CCompositorShadowNode	Shadow Nodes are special nodes (not to be confused with
CCompositorShadowNodeDef	Shadow Nodes are special nodes (not to be confused with
CCompositorShadowNodeTranslator
CCompositorTargetDef
CCompositorTargetTranslator
CCompositorTexture
CCompositorTextureBaseTranslator
CCompositorWorkspace	A compositor workspace is the main interface to render into an RT, be it a RenderWindow or an RTT (Render Texture Target)
►CCompositorWorkspaceDef	@See CompositorWorkspace
CChannelRoute
CCompositorWorkspaceListener
CCompositorWorkspaceTranslator
►CComPtr
CSafeBoolHelper
CComputeProperty
CConcreteNode
CConfigDialog	Defines the behaviour of an automatic renderer configuration dialog
CConfigFile	Class for quickly loading settings from a text file
CConstBufferPacked	Represents constant buffers (also known as Uniform Buffers in GL)
►CConstBufferPool	Maintains a pool of buffers grouped by hash ID
CBufferPool
CExtraBufferParams
CConstBufferPoolUser
CConstMapIterator	Concrete IteratorWrapper for const access to the underlying key-value container
CConstMapRange	Predefined type
CConstVectorIterator	Concrete IteratorWrapper for const access to the underlying container
CConstVectorRange	Predefined type
CController	Instances of this class 'control' the value of another object in the system
CControllerFunction	Subclasses of this class are responsible for performing a function on an input value for a Controller
CControllerManager	Class for managing Controller instances
CControllerValue	Can either be used as an input or output value
CConvexBody	Holds a solid representation of a convex body
CCPreprocessor	This is a simplistic C/C++-like preprocessor
CCreateCompositorScriptCompilerEvent
CCreateGpuProgramScriptCompilerEvent
CCreateGpuSharedParametersScriptCompilerEvent
CCreateHighLevelGpuProgramScriptCompilerEvent
CCreateMaterialScriptCompilerEvent
CCreateParticleSystemScriptCompilerEvent
CCubemapProbe
CCullFrustumRequest	All variables are read-only for the worker threads
CCustomCompositionPass	Interface for custom composition passes, allowing custom operations (in addition to the quad, scene and clear operations) in composition passes
CCylinderEmitter	Particle emitter which emits particles randomly from points inside a cylinder
CCylinderEmitterFactory	Factory class for particle emitter of type "Cylinder"
CD3D11AsyncTicket
CD3D11BufferInterface	For D3D11, most (if not all) buffers, can be treated with the same code
CD3D11BufferInterfaceBase	For D3D11, most (if not all) buffers, can be treated with the same code
CD3D11CompatBufferInterface	In D3D11, const buffers can't be bound by offset
CD3D11ConstBufferPacked
CD3D11DepthBuffer
CD3D11DepthTexture
CD3D11DepthTextureTarget
CD3D11Device
CD3D11DeviceResource	Represents a Direct3D rendering resource
CD3D11DeviceResourceManager	Singleton that is used to propagate device state changed notifications
CD3D11Driver
CD3D11DriverList
CD3D11DynamicBuffer	D3D11 doesn't support mapping the same buffer twice even if the regions don't overlap
CD3D11GpuProgramManager
CD3D11HardwareOcclusionQuery	This is a class that is the DirectX9 implementation of hardware occlusion testing
CD3D11HlmsPso	@See HlmsPso
►CD3D11HLSLProgram	Specialization of HighLevelGpuProgram to provide support for D3D11 High-Level Shader Language (HLSL)
CCmdColumnMajorMatrices	Command object for setting matrix packing in column-major order
CCmdEnableBackwardsCompatibility	Command object for setting backwards compatibility
CCmdEntryPoint	Command object for setting entry point
CCmdPreprocessorDefines	Command object for setting macro defines
CCmdTarget	Command object for setting target assembler
CD3D11HLSLProgramFactory	Factory class for D3D11 HLSL programs
CD3D11Mappings
CD3D11MultiRenderTarget
CD3D11NullTexture
CD3D11NullTextureTarget
CD3D11PixelFormatToShaderType
CD3D11Plugin	Plugin instance for D3D11 Manager
CD3D11RenderSystem	Implementation of DirectX11 as a rendering system
CD3D11RenderTexture	RenderTexture implementation for D3D11
CD3D11RenderWindowBase
CD3D11RenderWindowSwapChainBased
CD3D11StagingBuffer	NOTE FOR D3D12 PORTING: The GL3Plus implementation should be used as reference, since it is much lower level than this implementation for D3D11
CD3D11StereoDriverAMD	Virtual interface of the stereo driver
CD3D11StereoDriverBridge	Bridge interface from the render system to the stereo driver
CD3D11StereoDriverImpl	Virtual interface of the stereo driver
CD3D11StereoDriverNVIDIA	Interface of the NVIDIA stereo driver
CD3D11TexBufferPacked
CD3D11Texture
CD3D11TextureManager
CD3D11UavBufferPacked
►CD3D11VaoManager
CBlock
CStrideChanger
CD3D11VertexArrayObject
CD3D11VertexArrayObjectShared
CD3D11VideoMode
CD3D11VideoModeList
CD3D9DepthBuffer
CD3D9Device	High level interface of Direct3D9 Device
CD3D9DeviceManager	Device manager interface
CD3D9Driver
CD3D9DriverList
CD3D9GpuFragmentProgram	Direct3D implementation of low-level fragment programs
►CD3D9GpuProgram	Direct3D implementation of a few things common to low-level vertex & fragment programs
CCmdColumnMajorMatrices	Command object for setting matrix packing in column-major order
CCmdExternalMicrocode	Command object for getting/setting external micro code (void*)
CD3D9GpuProgramManager
CD3D9GpuVertexProgram	Direct3D implementation of low-level vertex programs
CD3D9HardwareBufferManager	D3D9HardwareBufferManagerBase as a Singleton
CD3D9HardwareBufferManagerBase	Implementation of HardwareBufferManager for D3D9
CD3D9HardwareIndexBuffer
CD3D9HardwareOcclusionQuery	This is a class that is the DirectX9 implementation of hardware occlusion testing
CD3D9HardwarePixelBuffer
CD3D9HardwareVertexBuffer	Specialisation of HardwareVertexBuffer for D3D9
►CD3D9HLSLProgram	Specialisation of HighLevelGpuProgram to provide support for D3D9 High-Level Shader Language (HLSL)
CCmdAssemblerCode	Command object for getting/setting assembler code
CCmdBackwardsCompatibility	Command object for enabling backwards compatibility
CCmdColumnMajorMatrices	Command object for setting matrix packing in column-major order
CCmdEntryPoint	Command object for setting entry point
CCmdMicrocode	Command object for getting/setting micro code
CCmdOptimisation	Command object for setting optimisation level
CCmdPreprocessorDefines	Command object for setting macro defines
CCmdTarget	Command object for setting target assembler
CD3D9HLSLProgramFactory	Factory class for D3D9 HLSL programs
CD3D9Mappings
CD3D9MultiRenderTarget
CD3D9Plugin	Plugin instance for D3D9 Manager
CD3D9RenderSystem	Implementation of DirectX9 as a rendering system
CD3D9RenderTexture	RenderTexture implementation for D3D9
CD3D9RenderWindow
CD3D9Resource	Represents a Direct3D rendering resource
CD3D9ResourceManager
CD3D9StereoDriverAMD	Virtual interface of the stereo driver
CD3D9StereoDriverBridge	Bridge interface from the render system to the stereo driver
CD3D9StereoDriverImpl	Virtual interface of the stereo driver
CD3D9StereoDriverNVIDIA	Interface of the NVIDIA stereo driver
CD3D9Texture
CD3D9TextureManager
CD3D9VertexDeclaration	Specialisation of VertexDeclaration for D3D9
CD3D9VideoMode
CD3D9VideoModeList
CDataStream	General purpose class used for encapsulating the reading and writing of data
CDDSCodec	Codec specialized in loading DDS (Direct Draw Surface) images
CDecal	Decals can have diffuse, normal map, and emissive on top of regular objects
CDecalFactory
CDefaultAxisAlignedBoxSceneQuery	Default implementation of AxisAlignedBoxSceneQuery
CDefaultIntersectionSceneQuery	Default implementation of IntersectionSceneQuery
CDefaultPlaneBoundedVolumeListSceneQuery	Default implementation of PlaneBoundedVolumeListSceneQuery
CDefaultRaySceneQuery	Default implementation of RaySceneQuery
CDefaultSceneFormatListener	Default implementation that prevents a SceneNode from being exported if the only attached objects
CDefaultSceneManager	Default scene manager
CDefaultSceneManagerFactory	Factory for default scene manager
CDefaultShadowCameraSetup	Implements default shadow camera setup
CDefaultSphereSceneQuery	Default implementation of SphereSceneQuery
CDefaultWorkQueue	Implementation of a general purpose request / response style background work queue
CDefaultWorkQueueBase	Base for a general purpose request / response style background work queue
CDefaultZone
CDefaultZoneFactory
CDeflateStream	Stream which compresses / uncompresses data using the 'deflate' compression algorithm
►CDeflectorPlaneAffector	This class defines a ParticleAffector which deflects particles
CCmdBounce	Command object for bounce (see ParamCommand)
CCmdPlaneNormal	Command object for plane normal (see ParamCommand)
CCmdPlanePoint	Command object for plane point (see ParamCommand)
CDeflectorPlaneAffectorFactory	Factory class for DeflectorPlaneAffector
CDegree	Wrapper class which indicates a given angle value is in Degrees
CDepthBuffer	An abstract class that contains a depth/stencil buffer
Cdeque
►CDirectionRandomiserAffector	This class defines a ParticleAffector which applies randomness to the movement of the particles
CCmdKeepVelocity	Command object for keep_velocity (see ParamCommand)
CCmdRandomness	Command object for randomness (see ParamCommand)
CCmdScope	Command object for scope (see ParamCommand)
CDirectionRandomiserAffectorFactory	Factory class for DirectionRandomiserAffector
CDistanceLodBoxStrategy	Level of detail strategy based on distance from camera to an object's bounding box
CDistanceLodSphereStrategy	Level of detail strategy based on distance from camera to an object's bounding sphere
CDistanceLodStrategyBase	Level of detail strategy based on distance from camera
CDriverVersion	DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the current GPU driver
CDualQuaternion	Implementation of a dual quaternion, i.e
CDynLib	Resource holding data about a dynamic library
CDynLibManager	Manager for Dynamic-loading Libraries
CEGLContext
CEGLSupport
CEGLWindow
CEllipsoidEmitter	Particle emitter which emits particles randomly from points inside an ellipsoid
CEllipsoidEmitterFactory	Factory class for particle emitter of type "Ellipsoid"
CEmbeddedZipArchiveFactory	Specialisation of ZipArchiveFactory for embedded Zip files
CEmscriptenEGLContext
CEmscriptenEGLSupport
CEmscriptenEGLWindow
CEntityMaterialLodChangedEvent	Struct containing information about a material LOD change event for entities
CEntityMeshLodChangedEvent	Struct containing information about a mesh LOD change event for entities
CErrorDialog	Class for displaying the error dialog if Ogre fails badly
CETCCodec	Codec specialized in loading ETC (Ericsson Texture Compression) images
CException	When thrown, provides information about an error that has occurred inside the engine
CExceptionFactory	Class implementing dispatch methods in order to construct by-value exceptions of a derived type based just on an exception code
CEXRCodec	Codec specialized in loading OpenEXR high dynamic range images
►CExternalTextureSource	IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from
CCmdFPS
CCmdInputFileName
CCmdPlayMode
CCmdTecPassState
CExternalTextureSourceManager	Singleton Class which handles the registering and control of texture plugins
CFactoryObj	Abstract factory class
CFastArray	Lightweight implementation of std::vector
CFileHandleDataStream	Common subclass of DataStream for handling data from C-style file handles
CFileInfo	Information about a file/directory within the archive will be returned using a FileInfo struct
CFileNotFoundException
CFileStreamDataStream	Common subclass of DataStream for handling data from std::basic_istream
CFileSystemArchive	Specialisation of the Archive class to allow reading of files from filesystem folders / directories
CFileSystemArchiveFactory	Specialisation of ArchiveFactory for FileSystem files
CFileSystemLayer	Provides methods to find out where the Ogre config files are stored and where logs and settings files should be written to
CFilterKernel
CFilterSeparableKernel
CFloatGpuParameterControllerValue	Predefined controller value for setting a single floating- point value in a constant parameter of a vertex or fragment program
CFocusedShadowCameraSetup	Implements the uniform shadow mapping algorithm in focused mode
►CFont	Class representing a font in the system
CGlyphInfo	Information about the position and size of a glyph in a texture
CFontManager	Manages Font resources, parsing .fontdef files and generally organising them
CForward3D	Forward3D
CForwardClustered	Implementation of Clustered Forward Shading
►CForwardPlusBase	ForwardPlusBase
CCachedGridBuffer
CFrameEvent	Struct containing information about a frame event
CFrameListener	A interface class defining a listener which can be used to receive notifications of frame events
CFrameStats	All return values are either in milliseconds or frames per second; but they're internally stored in microseconds
CFrameTimeControllerValue	Predefined controller value for getting the latest frame time
CFreeImageCodec	Codec specialized in images loaded using FreeImage
CFreeOnDestructor	Helper class to that will free the pointer on the destructor
CFrustum	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
CGL3PlusAsyncTicket
CGL3PlusBufferInterface	For GL3+, most (if not all) buffers, can be treated with the same code
CGL3PlusConstBufferPacked
CGL3PlusContext	Class that encapsulates an GL context
CGL3PlusDepthBuffer
CGL3PlusDepthTexture
CGL3PlusDepthTextureTarget
CGL3PlusDynamicBuffer	GL3+ doesn't support mapping the same buffer twice even if the regions don't overlap
CGL3PlusFBOManager	Factory for GL Frame Buffer Objects, and related things
CGL3PlusFBOMultiRenderTarget	MultiRenderTarget for OpenGL
CGL3PlusFBORenderTexture	RenderTexture for GL FBO
CGL3PlusFrameBufferObject	Frame Buffer Object abstraction
CGL3PlusHardwareOcclusionQuery	This is a class that is the base class of the query class for hardware occlusion
CGL3PlusHlmsPso	@See HlmsPso
CGL3PlusMultiSourceVertexBufferPool
CGL3PlusNullTexture
CGL3PlusNullTextureTarget
CGL3PlusOldVertexArrayObject	Specialisation of VertexDeclaration for OpenGL Vertex Array Object usage
CGL3PlusPixelFormatToShaderType
CGL3PlusPixelUtil	Class to do pixel format mapping between GL and OGRE
CGL3PlusPlugin	Plugin instance for GL3Plus Manager
CGL3PlusRenderSystem	Implementation of GL 3 as a rendering system
CGL3PlusRenderTexture	Base class for GL Render Textures
CGL3PlusRTTManager	Manager/factory for RenderTextures
CGL3PlusStagingBuffer	A staging buffer is a buffer that resides on the GPU and be written to/from both CPU & GPU However the access in both cases is limited
CGL3PlusSupport
CGL3PlusSurfaceDesc	GL surface descriptor
CGL3PlusTexBufferEmulatedPacked
CGL3PlusTexBufferPacked
CGL3PlusTexture
CGL3PlusTextureManager	GL3Plus-specific implementation of a TextureManager
CGL3PlusUavBufferPacked
►CGL3PlusVaoManager
CBlock
CStrideChanger
CGL3PlusVertexArrayObject
CGLAtomicCounterReference	Structure used to keep track of named atomic counter uniforms in the linked program object
CGLES2AsyncTicket
CGLES2BufferInterface	For GL3+, most (if not all) buffers, can be treated with the same code
CGLES2ConstBufferPacked
CGLES2Context	Class that encapsulates an GL context
CGLES2DepthBuffer
CGLES2DepthTexture
CGLES2DepthTextureTarget
CGLES2DynamicBuffer	GL3+ doesn't support mapping the same buffer twice even if the regions don't overlap
CGLES2FBOManager	Factory for GL ES 2 Frame Buffer Objects, and related things
CGLES2FBOMultiRenderTarget	MultiRenderTarget for GL ES 2.x
CGLES2FBORenderTexture	RenderTexture for GL ES 2 FBO
CGLES2FrameBufferObject	Frame Buffer Object abstraction
CGLES2GpuProgramManager
CGLES2HardwareOcclusionQuery
CGLES2HlmsPso	@See HlmsPso
CGLES2HlmsSamplerblock	A sampler block contains settings that go hand in hand with a texture, and thus are common to many textures
CGLES2MultiSourceVertexBufferPool
CGLES2NullTexture
CGLES2NullTextureTarget
CGLES2OldVertexArrayObject	Specialisation of VertexDeclaration for OpenGL ES 2 Vertex Array Object usage
CGLES2PixelFormatToShaderType
CGLES2PixelUtil	Class to do pixel format mapping between GL and OGRE
CGLES2Plugin	Plugin instance for GL ES 2 Manager
CGLES2RenderSystem	Implementation of GL ES 2.x as a rendering system
CGLES2RenderTexture	Base class for GL Render Textures
CGLES2RTTManager	Manager/factory for RenderTextures
CGLES2StagingBuffer	A staging buffer is a buffer that resides on the GPU and be written to/from both CPU & GPU However the access in both cases is limited
CGLES2Support
CGLES2SurfaceDesc	GL surface descriptor
CGLES2TexBufferEmulatedPacked
CGLES2Texture
CGLES2TextureManager	GL ES-specific implementation of a TextureManager
►CGLES2VaoManager
CBlock
CStrideChanger
CGLES2VertexArrayObject
►CGLSLESCgProgram	Specialisation of HighLevelGpuProgram to provide support for CG
CCmdEntryPoint	Command object for setting entry point
CCmdProfiles	Command object for setting profiles
CGLSLESCgProgramFactory	Factory class for GLSL ES programs
CGLSLESLinkProgram	C++ encapsulation of GLSL ES Program Object
CGLSLESLinkProgramManager	Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL ES has one program object that represents the active vertex and fragment shader objects during a rendering state
CGLSLESProgramCommon	C++ encapsulation of GLSL ES Program Object
CGLSLESProgramManagerCommon	Ogre assumes that there are separate programs to deal with but GLSL ES has one program object that represents the active shader objects during a rendering state
CGLSLESProgramPipeline	Specialisation of GLSLESProgramCommon to provide support for separable programs via the Open GL program pipeline
CGLSLESProgramPipelineManager	Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL ES has one program pipeline object that represents the active vertex and fragment program objects during a rendering state
►CGLSLESShader	Specialisation of HighLevelGpuProgram to encapsulate shader objects obtained from compiled shaders written in the OpenGL Shader Language (GLSL ES) for OpenGL ES 2.0
CCmdOptimisation	Command object for running the GLSL optimiser
CCmdPreprocessorDefines	Command object for setting macro defines
CGLSLESShaderFactory	Factory class for GLSL ES programs
CGLSLMonolithicProgram	Model of OpenGL program object created using the glLinkProgram method of linking
CGLSLMonolithicProgramManager	Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL has one program object that represents the active vertex and fragment shader objects during a rendering state
CGLSLProgram	C++ encapsulation of GLSL program object
CGLSLProgramManager	Ogre assumes that there are separate programs to deal with but GLSL has one program object that represents the active shader objects during a rendering state
CGLSLSeparableProgram	Specialisation of GLSLProgram to provide support for separable programs via the OpenGL program pipeline
CGLSLSeparableProgramManager	Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL has one program pipeline object that represents the active vertex and fragment program objects during a rendering state
►CGLSLShader	Specialisation of HighLevelGpuProgram to encapsulate shader objects obtained from compiled shaders written in the OpenGL Shader Language (GLSL)
CCmdAttach	Command object for attaching another GLSL Program
CCmdColumnMajorMatrices	Command object for setting matrix packing in column-major order
CCmdInputOperationType	Command object for setting the input operation type (geometry shader only)
CCmdMaxOutputVertices	Command object for setting the maximum output vertices (geometry shader only)
CCmdOutputOperationType	Command object for setting the output operation type (geometry shader only)
CCmdPreprocessorDefines	Command object for setting macro defines
CGLSLShaderFactory	Factory class for GLSL shaders
CGLSLShaderManager
CGLUniformReference	Structure used to keep track of named uniforms in the linked program object
CGLXContext
CGLXGLSupport
CGLXUtils
CGLXWindow
CGpuConstantDefinition	Information about predefined program constants
CGpuLogicalBufferStruct	Container struct to allow params to safely & update shared list of logical buffer assignments
CGpuLogicalIndexUse	Structure recording the use of a physical buffer by a logical parameter index
CGpuNamedConstants	Struct collecting together the information for named constants
CGpuNamedConstantsSerializer	Simple class for loading / saving GpuNamedConstants
CGpuProgram	Defines a program which runs on the GPU such as a vertex or fragment program
►CGpuProgramManager
CHash
►CGpuProgramParameters	Collects together the program parameters used for a GpuProgram
CAutoConstantDefinition	Structure defining an auto constant that's available for use in a parameters object
CAutoConstantEntry	Structure recording the use of an automatic parameter
CGpuProgramTranslator
CGpuProgramUsage	This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit
CGpuResource
CGpuSharedParameters	Definition of container that holds the current bool constants
CGpuSharedParametersUsage	This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters
CGrid2DPageStrategy	Page strategy which loads new pages based on a regular 2D grid
CGrid2DPageStrategyData	Specialisation of PageStrategyData for Grid2DPageStrategy
CGrid3DPageStrategy	Page strategy which loads new pages based on a regular 3D grid
CGrid3DPageStrategyData	Specialisation of PageStrategyData for Grid3DPageStrategy
CGTKGLSupport	GL support in a GTK window
CGTKWindow
CHardwareOcclusionQuery	This is a abstract class that that provides the interface for the query class for hardware occlusion
CHashedVector	A hashed vector
►CHighLevelGpuProgram	Abstract base class representing a high-level program (a vertex or fragment program)
CCmdEnableIncludeHeader	Command object for enabling include in shaders
CHighLevelGpuProgramFactory	Interface definition for factories of HighLevelGpuProgram
CHighLevelGpuProgramManager	This ResourceManager manages high-level vertex and fragment programs
►CHlms	HLMS stands for "High Level Material System"
CDatablockEntry
CLibrary
CHlmsBasePieces
CHlmsBaseProp	These are "default" or "Base" properties common to many implementations and thus defined here
CHlmsBits
CHlmsBlendblock	A blend block contains settings that rarely change, and thus are common to many materials
CHlmsBufferManager	Managing constant and texture buffers for sending shader parameters is a very similar process to most Hlms implementations using them
CHlmsCache
CHlmsCompute	HLMS implementation that handles compute shaders
CHlmsComputeJob
CHlmsComputePso
CHlmsDatablock	An hlms datablock contains individual information about a specific material
►CHlmsDiskCache	This class allows saving the current state of an Hlms to disk: both its compiled shaders with source and the generated PSOs
CCache
CPso
CSourceCode
►CHlmsJson	HLMS stands for "High Level Material System"
CNamedBlocks
CHlmsJsonCompute	HLMS stands for "High Level Material System"
CHlmsJsonListener
CHlmsJsonPbs
CHlmsJsonUnlit
CHlmsListener	Listener that can be hooked to an Hlms implementation for extending it with custom code
CHlmsLowLevel	This is an HLMS implementation that acts as proxy to use the Material system from Ogre 1.9 The older material system is data-driven (thanks to AutoParamDataSource) compared to HLMS where the user needs to write its own implementation in C++ (or modify an exisiting one)
CHlmsLowLevelDatablock	Contains information needed by the UI (2D) for OpenGL ES 2.0
CHlmsMacroblock	A macro block contains settings that will rarely change, and thus are common to many materials
CHlmsManager	HLMS stands for "High Level Material System"
CHlmsPassPso	IT'S MEMBERS MUST BE KEPT POD (Otherwise HlmsPso needs to be modified)
CHlmsPbs	Physically based shading implementation specfically designed for OpenGL 3+, D3D11 and other RenderSystems which support uniform buffers
CHlmsPbsDatablock	Contains information needed by PBS (Physically Based Shading) for OpenGL 3+ & D3D11+
CHlmsPbsMobile	Physically based shading implementation specfically designed for OpenGL ES 2.0 and other RenderSystems which do not support uniform buffers
CHlmsPbsMobileDatablock	Contains information needed by PBS (Physically Based Shading) for OpenGL ES 2.0
CHlmsProperty
CHlmsPso	Defines a PipelineStateObject as required by Vulkan, Metal & DX12
CHlmsPsoProp
CHlmsSamplerblock	A sampler block contains settings that go hand in hand with a texture, and thus are common to many textures
CHlmsTextureExportListener
►CHlmsTextureManager	HLMS Texture Manager manages textures in the way HLMS expects
CDefaultTextureParameters
CMetadataCacheEntry
CTextureLocation
CThreshold	Textures whose size are less or equal to minTextureSize (without considering mipmaps) will have their maxTexturesPerArray clamped to the value given in this threshold structure
►CHlmsTexturePack
CTextureEntry
CHlmsTranslator
CHlmsUnlit	Implementation without lighting or skeletal animation specfically designed for OpenGL 3+, D3D11 and other RenderSystems which support uniform buffers
CHlmsUnlitDatablock	Contains information needed by PBS (Physically Based Shading) for OpenGL 3+ & D3D11+
CHlmsUnlitMobile	User Interface (2D) implementation specfically designed for OpenGL ES 2.0 and other RenderSystems which do not support uniform buffers
►CHlmsUnlitMobileDatablock	Contains information needed by the UI (2D) for OpenGL ES 2.0
CUvAtlasParams
►CHollowEllipsoidEmitter	Particle emitter which emits particles randomly from points inside a hollow ellipsoid
CCmdInnerX	Command object for inner size (see ParamCommand)
CCmdInnerY	Command object for inner size (see ParamCommand)
CCmdInnerZ	Command object for inner size (see ParamCommand)
CHollowEllipsoidEmitterFactory	Factory class for particle emitter of type "HollowEllipsoid"
CId	Usage: OGRE_NEW SceneNode( Id::generateNewId< Node >() )
CIdObject
CIdString	Hashed string
CImage	Class representing an image file
►CImageCodec	Codec specialized in images
CImageData	Codec return class for images
CImportAbstractNode	This abstract node represents an import statement
CIndexBufferPacked
CIndirectBufferPacked	Represents Indirect buffers for storing draw call commands
CInstanceBatchCullRequest
►CInstantRadiosity
CAreaOfInterest	Areas of Interest are defined by both AABB and distance (can be 0)
CInternalErrorException
CIntersectionSceneQuery	Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another
CIntersectionSceneQueryListener	Alternative listener class for dealing with IntersectionSceneQuery
CIntersectionSceneQueryResult	Holds the results of an intersection scene query (pair values)
CInvalidCallException
CInvalidParametersException
CInvalidStateException
CIOException
CIrradianceVolume
CisPodLike
CisPodLike< bool >
CisPodLike< char >
CisPodLike< double >
CisPodLike< float >
CisPodLike< int >
CisPodLike< long >
CisPodLike< short >
CisPodLike< signed char >
CisPodLike< std::pair< T, U > >
CisPodLike< T * >
CisPodLike< unsigned >
CisPodLike< unsigned char >
CisPodLike< unsigned long >
CisPodLike< unsigned short >
CItem	Defines an instance of a discrete, movable object based on a Mesh
CItemFactory	FItemy object for creating Item instances
CItemIdentityException
Citerator_range	Base for an iterator_range
CIteratorWrapper	Basefunctionality for IteratorWrappers
CKeyFrameRig
CKfTransform	Holds the transform of a KeyFrame (which is part of an animation)
CKfTransformArrayMemoryManager	Implementation to create the KfTransform variables needed by SkeletonTrack @See SkeletonAnimationDef and
CLayerBlendModeEx	Class which manages blending of both colour and alpha components
CLight	Representation of a dynamic light source in the scene
CLightClosest	Used as the light list, sorted
CLightFactory	Factory object for creating Light instances
CLightListInfo	Holds all lights in SoA after being culled over all frustums
CLightweightMutex	A lightweight mutex is a synchronization mechanism, very similar to a regular mutex
CLinearControllerFunction	Predefined controller function based on linear function interpolation
►CLinearForceAffector	This class defines a ParticleAffector which applies a linear force to particles in a system
CCmdForceApp	Command object for force application (see ParamCommand)
CCmdForceVector	Command object for force vector (see ParamCommand)
CLinearForceAffectorFactory	Factory class for LinearForceAffector
CLinearResampler
CLinearResampler_Byte
CLinearResampler_Float32
Clist
►CLod0Stripifier
CRemapInfo
CLodCollapseCost
CLodCollapseCostCurvature
CLodCollapseCostOutside
CLodCollapseCostProfiler
CLodCollapseCostQuadric
CLodCollapser
►CLodConfig
CAdvanced
CLodConfigSerializer
►CLodData
CEdge
CIndexBufferInfo
CIndexBufferPointer
CTriangle
CVertex
CVertexEqual
CVertexHash
CLodIndexBuffer	Thread-safe buffer for storing Hardware index buffer
►CLodInputBuffer	Data representing all required information from a Mesh. Used by LodInputProviderBuffer
CSubmesh
CLodInputProvider
CLodInputProviderBuffer
CLodInputProviderMesh
CLodLevel	Structure for automatic Lod configuration
CLodListener	A interface class defining a listener which can be used to receive notifications of LOD events
►CLodOutputBuffer	Data representing the output of the Mesh reduction. Used by LodOutputProviderBuffer
CSubmesh
CLodOutputProvider
CLodOutputProviderBuffer
CLodOutputProviderCompressedBuffer
CLodOutputProviderCompressedMesh
CLodOutputProviderMesh
CLodOutsideMarker	This class will mark vertices of a mesh, which are visible from far away (from outside)
CLodStrategy	Strategy for determining level of detail
CLodStrategyManager	Manager for LOD strategies
CLodVertexBuffer	Thread-safe buffer for storing Hardware vertex buffer
CLodWorkQueueInjector	Injects the output of a request to the mesh in a thread safe way
CLodWorkQueueInjectorListener
CLodWorkQueueRequest
CLodWorkQueueWorker	Processes requests
►CLog
►CStream	Stream object which targets a log
CFlush	Simple type to indicate a flush of the stream to the log
CLogListener
CLogManager	The log manager handles the creation and retrieval of logs for the application
CLowLevelProp
CLwConstString
►CLwString	This is a Light-weight string wrapper around the C string interface
CFloat
►CManualObject
CManualObjectSection	Built, renderable section of geometry
CManualObjectFactory	Factory object for creating ManualObject instances
CManualResourceLoader	Interface describing a manual resource loader
Cmap
CMapIterator	Concrete IteratorWrapper for nonconst access to the underlying key-value container
CMapIteratorWrapper	Prepared IteratorWrapper for key-value container
CMapRange	Predefined type
CMaterial	Class encapsulates rendering properties of an object
►CMaterialManager	Class for managing Material settings for Ogre
CListener	Listener on any general material events
CMaterialScriptProgramDefinition	Struct for holding a program definition which is in progress
►CMaterialSerializer	Class for serializing Materials to / from a .material script
CListener	Class that allows listening in on the various stages of material serialization process
CMaterialTranslator
►CMath	Class to provide access to common mathematical functions
CRandomValueProvider	This class is used to provide an external random value provider
CMathlibC
CMatrix3	A 3x3 matrix which can represent rotations around axes
CMatrix4	Class encapsulating a standard 4x4 homogeneous matrix
CMemoryDataStream	Common subclass of DataStream for handling data from chunks of memory
CMesh	Resource holding data about 3D mesh
CMeshLodGenerator
CMeshManager	Handles the management of mesh resources
CMeshSerializer	Class for serialising mesh data to/from an OGRE .mesh file
CMeshSerializerImpl	Internal implementation of Mesh reading / writing for the latest version of the .mesh format
CMeshSerializerImpl_v2_1_R0
CMeshSerializerImpl_v2_1_R1
CMeshSerializerListener
CMetalAsyncTicket
CMetalBufferInterface	For Metal, all buffers can be treated with the same code
CMetalConstBufferPacked
CMetalDepthBuffer
CMetalDepthTexture
CMetalDepthTextureTarget
CMetalDevice
CMetalDiscardBuffer
►CMetalDiscardBufferManager	Metal doesn't support "DISCARD" like D3D9/D3D11 (and OpenGL but often it's broken) where we requested to map a write-only buffer and the API would discard the previous contents (thus allowing us to avoid a stall until the GPU is done with the region)
CUnsafeBlock
CMetalDynamicBuffer	Metal doesn't "map"
CMetalGpuProgramManager
CMetalHlmsPso	@See HlmsPso
CMetalMappings
CMetalMultiRenderTarget
CMetalMultiSourceVertexBufferPool
CMetalNullTexture
CMetalNullTextureTarget
CMetalPixelFormatToShaderType
CMetalPlugin	Plugin instance for Metal Manager
►CMetalProgram	Specialisation of HighLevelGpuProgram to provide support for Metal Shader Language
CCmdEntryPoint	Command object for setting entry point
CCmdPreprocessorDefines	Command object for setting macro defines
CCmdShaderReflectionPairHint	Command object for setting vertex shader pair
CMetalProgramFactory	Factory class for Metal programs
CMetalRenderSystem	Implementation of Metal as a rendering system
CMetalRenderTargetCommon
CMetalRenderTexture
CMetalRenderWindow
CMetalStagingBuffer	A staging buffer is a buffer that resides on the GPU and be written to/from both CPU & GPU However the access in both cases is limited
CMetalTexBufferPacked
CMetalTexture
CMetalTextureManager
CMetalUavBufferPacked
►CMetalVaoManager
CBlock
CStrideChanger
►CMovableObject	Abstract class defining a movable object in a scene
CListener	Listener which gets called back on MovableObject events
CMovableObjectFactory	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
CMovableObjectLodChangedEvent	Struct containing information about a LOD change event for movable objects
CMovablePlane	Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply
Cmultimap
CMultiRenderTarget	This class represents a render target that renders to multiple RenderTextures at once
CMultiSourceVertexBufferPool	Vertex Array Objects do not need to change when: The same (internal) vertex buffer is still bound
CNaClGLContext
CNaClGLSupport
CNaClWindow
CNameGenerator	Utility class to generate a sequentially numbered series of names
CNearestResampler
CNoAddRefRelease
►CNode	Class representing a general-purpose node an articulated scene graph
CListener	Listener which gets called back on Node events
CNodeArrayMemoryManager	Implementation to create the Transform variables needed by Nodes & SceneNodes
CNodeMemoryManager	Wrap-around class that contains multiple ArrayMemoryManager, one per hierarchy depth
CNULLAsyncTicket
CNULLBufferInterface	For GL3+, most (if not all) buffers, can be treated with the same code
CNULLConstBufferPacked
CNullEntity
CNULLMultiSourceVertexBufferPool
CNULLPixelFormatToShaderType
CNULLPlugin	Plugin instance for NULL Manager
CNULLRenderSystem	Implementation of NULL as a rendering system
CNULLRenderTexture
CNULLRenderWindow
CNULLStagingBuffer	A staging buffer is a buffer that resides on the GPU and be written to/from both CPU & GPU However the access in both cases is limited
CNULLTexBufferPacked
CNULLTexture
CNULLTextureManager
CNULLUavBufferPacked
►CNULLVaoManager
CBlock
CStrideChanger
CNULLVertexArrayObject
CNumericSolver	Provides numeric solvers for Ogre
CObjectAbstractNode	This specific abstract node represents a script object
CObjectData	Represents the transform of a single object, arranged in SoA (Structure of Arrays)
CObjectDataArrayMemoryManager	Implementation to create the ObjectData variables needed by MovableObjects
CObjectMemoryManager	Wrap-around class that contains multiple ArrayMemoryManager, one per render queue
COctree	Octree datastructure for managing scene nodes
COctreeAxisAlignedBoxSceneQuery	Octree implementation of AxisAlignedBoxSceneQuery
COctreeCamera	Specialized viewpoint from which an Octree can be rendered
COctreeIntersectionSceneQuery	Octree implementation of IntersectionSceneQuery
COctreeNode	Specialized SceneNode that is customized for working within an Octree
COctreePlaneBoundedVolumeListSceneQuery	Octree implementation of PlaneBoundedVolumeListSceneQuery
COctreePlugin	Plugin instance for Octree Manager
COctreeRaySceneQuery	Octree implementation of RaySceneQuery
COctreeSceneManager	Specialized SceneManager that divides the geometry into an octree in order to facilitate spatial queries
COctreeSceneManagerFactory	Factory for OctreeSceneManager
COctreeSphereSceneQuery	Octree implementation of SphereSceneQuery
COctreeZone
COctreeZoneData
COctreeZoneFactory	Factory for OctreeZone
COctreeZonePlugin	Plugin instance for OctreeZone
COfflineProfiler	Simple profiler that will produce a CSV file for offline analysis once dumpProfileResults is called
COGREWidget
COITDCodec	Codec specialized in loading OITD (Ogre Internal Texture Dump) format
COptimisedUtil	Utility class for provides optimised functions
COSXGL3PlusSupport
CPackedTexture	Used by JSON serialization, but can also be used outside of it
CPage	Page class
CPageContent	Interface definition for a unit of content within a page
CPageContentCollection	Definition of the interface for a collection of PageContent instances
CPageContentCollectionFactory	Define the interface to a factory class that will create subclasses of PageContentCollection
CPageContentFactory	Define the interface to a factory class that will create subclasses of PageContent
CPagedWorld	This class represents a collection of pages which make up a world
CPagedWorldSection	Represents a section of the PagedWorld which uses a given PageStrategy, and which is made up of a generally localised set of Page instances
CPagedWorldSectionFactory	A factory class for creating types of world section
CPageManager	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
CPageProvider	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
CPageStrategy	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
CPageStrategyData	Abstract marker class representing the data held against the PagedWorldSection which is specifically used by the PageStrategy
CParallaxCorrectedCubemap
CParamCommand	Abstract class which is command object which gets/sets parameters
CParamDictionary	Class to hold a dictionary of parameters for a single class
CParameterDef	Definition of a parameter supported by a StringInterface class, for introspection
CParticle	Class representing a single particle instance
CParticleAffector	Abstract class defining the interface to be implemented by particle affectors
CParticleAffectorFactory	Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses
CParticleAffectorTranslator
CParticleEmitter	Abstract class defining the interface to be implemented by particle emitters
CParticleEmitterFactory	Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses
CParticleEmitterTranslator
CParticleFXPlugin	Plugin instance for ParticleFX Manager
CParticleIterator	Convenience class to make it easy to step through all particles in a ParticleSystem
►CParticleSystem	Class defining particle system based special effects
CCmdCull	Command object for cull_each (see ParamCommand)
CCmdEmittedEmitterQuota	Command object for emittedEmitterQuota (see ParamCommand)
CCmdHeight	Command object for particle_height (see ParamCommand)
CCmdIterationInterval	Command object for iteration interval(see ParamCommand)
CCmdLocalSpace	Command object for local space (see ParamCommand)
CCmdMaterial	Command object for material (see ParamCommand)
CCmdNonvisibleTimeout	Command object for nonvisible timeout (see ParamCommand)
CCmdQuota	Command object for quota (see ParamCommand)
CCmdRenderer	Command object for renderer (see ParamCommand)
CCmdSorted	Command object for sorting (see ParamCommand)
CCmdWidth	Command object for particle_width (see ParamCommand)
CParticleSystemFactory	Factory object for creating ParticleSystem instances
CParticleSystemManager	Manages particle systems, particle system scripts (templates) and the available emitter & affector factories
CParticleSystemRenderer	Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances
CParticleSystemRendererFactory	Abstract class definition of a factory object for ParticleSystemRenderer
CParticleSystemTranslator
CParticleVisualData	Abstract class containing any additional data required to be associated with a particle to perform the required rendering
CPass	Class defining a single pass of a Technique (of a Material), i.e
CPassthroughControllerFunction	Predefined controller function which just passes through the original source directly to dest
CPassTranslator
CPbsBakedTexture
CPbsMobileProperty
CPbsMobileShaderCreationData
CPbsProperty
CPbsUvAtlasParams
CPCPlane
CPCZAxisAlignedBoxSceneQuery	PCZ implementation of AxisAlignedBoxSceneQuery
CPCZCamera	Specialized viewpoint from which an PCZone Scene can be rendered
CPCZFrustum	Specialized frustum shaped culling volume that has culling planes created from portals
CPCZIntersectionSceneQuery	PCZ implementation of IntersectionSceneQuery
CPCZLight	Specialized version of Ogre::Light which caches which zones the light affects
CPCZLightFactory	Factory object for creating PCZLight instances
CPCZone	Portal-Connected Zone datastructure for managing scene nodes
CPCZoneFactory	Factory for PCZones
CPCZoneFactoryManager
CPCZPlaneBoundedVolumeListSceneQuery	PCZ implementation of PlaneBoundedVolumeListSceneQuery
CPCZPlugin	Plugin instance for PCZ Manager
CPCZRaySceneQuery	PCZ implementation of RaySceneQuery
CPCZSceneManager	Specialized SceneManager that uses Portal-Connected-Zones to divide the scene spatially
CPCZSceneManagerFactory	Factory for PCZSceneManager
CPCZSceneNode
CPCZSphereSceneQuery	PCZ implementation of SphereSceneQuery
CPixelBox
CPixelCountLodStrategyBase	Abstract base class for level of detail strategy based on pixel count approximations from bounding sphere projection
CPixelFormatDescription	A record that describes a pixel format in detail
CPixelFormatToShaderType
CPixelUtil	Some utility functions for packing and unpacking pixel data
CPlanarReflectionActor
►CPlanarReflections	Planar Reflections can be used with both Unlit and PBS, but they're setup differently
CTrackedRenderable
CPlane	Defines a plane in 3D space
CPlaneBoundedVolume	Represents a convex volume bounded by planes
CPlaneBoundedVolumeListSceneQuery	Specialises the SceneQuery class for querying within a plane-bounded volume
CPlaneOptimalShadowCameraSetup	Implements the plane optimal shadow camera algorithm
CPlatformInformation	Class which provides the run-time platform information Ogre runs on
CPlugin	Class defining a generic OGRE plugin
CPointEmitter	Particle emitter which emits particles from a single point
CPointEmitterFactory	Factory class for particle emitter of type "Point"
CPolygon	The class represents a polygon in 3D space
CPool	Template class describing a simple pool of items
CPortal	Portal datastructure for connecting zones
CPortalBase	PortalBase - Base class to Portal and AntiPortal classes
CPortalBaseFactory	Factory object for creating Portal instances
CPortalFactory	Factory object for creating Portal instances
CPreApplyTextureAliasesScriptCompilerEvent
CProcessNameExclusionScriptCompilerEvent
CProcessResourceNameScriptCompilerEvent
CProfile	An individual profile that will be processed by the Profiler
CProfiledEdge
CProfileFrame	Represents the total timing information of a profile since profiles can be called more than once each frame
CProfileHistory	Represents a history of each profile during the duration of the app
CProfileInstance	Represents an individual profile call
CProfiler	The profiler allows you to measure the performance of your code
CProfileSessionListener	ProfileSessionListener should be used to visualize profile results
CProperty	Property instance with passthrough calls to a given object
CPropertyAbstractNode	This abstract node represents a script property
CPropertyBase	Base interface for an instance of a property
CPropertyDef	Definition of a property of an object
CPropertySet	Defines a complete set of properties for a single object instance
CPropertyValue	A simple structure designed just as a holder of property values between the instances of objects they might target
CPsoCacheHelper	Utility class to cache PSOs
CPSSMShadowCameraSetup	Parallel Split Shadow Map (PSSM) shadow camera setup
CPVRTCCodec	Codec specialized in loading PVRTC (PowerVR) images
CQuake3Level	Support for loading and extracting data from a Quake3 level file
►CQuake3Shader	Class for recording Quake3 shaders
CPass
CQuake3ShaderManager	Class for managing Quake3 custom shaders
CQuaternion	Implementation of a Quaternion, i.e
CQueuedRenderable
CRadian	Wrapper class which indicates a given angle value is in Radians
CRadixSort	Class for performing a radix sort (fast comparison-less sort based on byte value) on various standard STL containers
CRawSimdUniquePtr	Similar to std::unique_ptr, but: Uses a custom allocator (OGRE_MALLOC_SIMD) Pointers must be really unique (RESTRICT_ALIAS modifier is used!) To access the pointer, use get(); instead of using this container directly The purpose of this container is to enclose a raw pointer while avoiding breaking the rule of 3 when copying
CRay	Representation of a ray in space, i.e
CRaySceneQuery	Specialises the SceneQuery class for querying along a ray
CRaySceneQueryListener	Alternative listener class for dealing with RaySceneQuery
CRaySceneQueryResultEntry	This struct allows a single comparison of result data no matter what the type
CRegionSceneQuery	Abstract class defining a query which returns single results from a region
CRenderable	Abstract class defining the interface all renderable objects must implement
CRenderableAnimated
CRenderingAPIException
CRenderObjectListener	Abstract interface which classes must implement if they wish to receive events from the scene manager when single object is about to be rendered
CRenderQueue	Enumeration of queue groups, by which the application may group queued renderables so that they are rendered together with events in between
CRenderQueueListener	Abstract interface which classes must implement if they wish to receive events from the render queue
►CRenderSystem	Defines the functionality of a 3D API
CListener	Defines a listener on the custom events that this render system can raise
CRenderSystemContext
CRenderSystemCapabilities	Singleton class for storing the capabilities of the graphics card
CRenderSystemCapabilitiesManager	Class for managing RenderSystemCapabilities database for Ogre
CRenderSystemCapabilitiesSerializer	Class for serializing RenderSystemCapabilities to / from a .rendercaps script
►CRenderTarget	A 'canvas' which can receive the results of a rendering operation
CFrameStats
CImpl	RenderSystem specific interface for a RenderTarget; this should be subclassed by RenderSystems
CRenderTargetEvent	Struct containing information about a RenderTarget event
CRenderTargetListener	A interface class defining a listener which can be used to receive notifications of RenderTarget events
CRenderTargetViewportEvent	Struct containing information about a RenderTarget Viewport-specific event
CRenderTexture	This class represents a RenderTarget that renders to a Texture
CRenderWindow	Manages the target rendering window
CRenderWindowDescription	Render window creation parameters
►CResource	Abstract class representing a loadable resource (e.g
CListener
►CResourceBackgroundQueue	This class is used to perform Resource operations in a background thread
CListener	This abstract listener interface lets you get notifications of completed background processes instead of having to poll ticket statuses
CResourceGroupListener	This abstract class defines an interface which is called back during resource group loading to indicate the progress of the load
►CResourceGroupManager	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
CResourceDeclaration	Nested struct defining a resource declaration
CResourceLocation	Resource location entry
CResourceLoadingListener
►CResourceManager	Defines a generic resource handler
CResourcePool	Definition of a pool of resources, which users can use to reuse similar resources many times without destroying and recreating them
CResourceTransition
►CRingEmitter	Particle emitter which emits particles randomly from points inside a ring (e.g
CCmdInnerX	Command object for inner size (see ParamCommand)
CCmdInnerY	Command object for inner size (see ParamCommand)
CRingEmitterFactory	Factory class for particle emitter of type "Ring"
CRoot	The root class of the Ogre system
►CRotationAffector	This plugin subclass of ParticleAffector allows you to alter the rotation of particles
CCmdRotationRangeEnd	Command object for particle emitter - see ParamCommand
CCmdRotationRangeStart	Command object for particle emitter - see ParamCommand
CCmdRotationSpeedRangeEnd	Command object for particle emitter - see ParamCommand
CCmdRotationSpeedRangeStart	Command object for particle emitter - see ParamCommand
CRotationAffectorFactory	Factory class for RotationAffector
CRotationalSpline	This class interpolates orientations (rotations) along a spline using derivatives of quaternions
CRqBits
CRuntimeAssertionException
►CScaleAffector	This plugin subclass of ParticleAffector allows you to alter the scale of particles
CCmdScaleAdjust	Command object for scale adjust (see ParamCommand)
CScaleAffectorFactory	Factory class for ScaleAffector
CScaleControllerFunction	Predefined controller function which simply scales an input to an output value
CSceneFormatBase
CSceneFormatExporter
CSceneFormatImporter
CSceneFormatListener	Override this listener if you want to filter which objects get exported
►CSceneManager	Manages the organisation and rendering of a 'scene' i.e
CListener	Class that allows listening in on the various stages of SceneManager processing, so that custom behaviour can be implemented from outside
CRenderContext
CSkyBoxGenParameters
CSkyDomeGenParameters
CSkyPlaneGenParameters
CSceneManagerEnumerator	Enumerates the SceneManager classes available to applications
CSceneManagerFactory	Class which will create instances of a given SceneManager
CSceneManagerMetaData	Structure containing information about a scene manager
CSceneNode	Class representing a node in the scene graph
►CSceneQuery	A class for performing queries on a scene
CWorldFragment	Represents part of the world geometry that is a result of a SceneQuery
CSceneQueryListener	This optional class allows you to receive per-result callbacks from SceneQuery executions instead of a single set of consolidated results
CSceneQueryResult	Holds the results of a scene query
CScreenRatioPixelCountLodStrategy
►CScriptCompiler	This is the main class for the compiler
CError
CScriptCompilerEvent	This struct is a base class for events which can be thrown by the compilers and caught by subscribers
CScriptCompilerListener	This is a listener for the compiler
CScriptCompilerManager	Manages threaded compilation of scripts
CScriptLexer
CScriptLoader	Abstract class defining the interface used by classes which wish to perform script loading to define instances of whatever they manage
CScriptParser
CScriptToken	This struct represents a token, which is an ID'd lexeme from the parsing input stream
CScriptTranslator	This class translates script AST (abstract syntax tree) into Ogre resources
CScriptTranslatorManager	The ScriptTranslatorManager manages the lifetime and access to script translators
CSDLGLSupport
CSDLWindow
CSegment
CSerializer	Generic class for serialising data to / from binary stream-based files
Cset
►CShaderParams	The purpose of this class is to contain a set of both auto and manual parameters that may apply to multiple shaders; without having the shader to be created first (the drawback of GpuProgramParameters)
CAutoParam
CManualParam
CParam
CShadowCameraSetup	This class allows you to plug in new ways to define the camera setup when rendering and projecting shadow textures
►CShadowNodeHelper
CResolution
CShadowParam
CShadowTextureDefinition	Local texture definition
CShadowVolumeExtrudeProgram	Static class containing source for vertex programs for extruding shadow volumes
CSharedParamsTranslator
CSharedPtr	Reference-counted shared pointer, used for objects where implicit destruction is required
CSharedPtrInfo
CSharedPtrInfoDelete
CSharedPtrInfoDeleteT
CSharedPtrInfoFree
CSharedPtrInfoNone
CSimpleMatrix4	Simple wrap up to load an AoS matrix 4x4 using SSE
CSimpleMatrixAf4x3	Simple wrap up to load an AoS matrix 4x3 using SSE
CSimplePageContentCollection	Specialisation of PageContentCollection which just provides a simple list of PageContent instances
CSimplePageContentCollectionFactory	Factory class for SimplePageContentCollection
CSimpleSpline	A very simple spline class which implements the Catmull-Rom class of splines
CSingleton	Template class for creating single-instance global classes
CSkeletonAnimation	Represents the instance of a Skeletal animation based on its definition
CSkeletonAnimationDef
CSkeletonAnimManager	This is how the Skeleton system works in 2.0: There is one BoneMemoryManager per skeleton
►CSkeletonDef
CBoneData
CDepthLevelInfo
CSkeletonInstance	Instance of a Skeleton, main external interface for retrieving bone positions and applying animations
CSkeletonManager	Handles the management of skeleton resources
CSkeletonTrack
CSmallVector	SmallVector - This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small
CSmallVector< T, 0 >	Specialize SmallVector at N=0
CSmallVectorBase	SmallVectorBase - This is all the non-templated stuff common to all SmallVectors
CSmallVectorImpl	SmallVectorImpl - This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter
CSmallVectorTemplateBase	SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's
CSmallVectorTemplateBase< T, true >	SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's
CSmallVectorTemplateCommon
CSphere	A sphere primitive, mostly used for bounds checking
CSphereSceneQuery	Specialises the SceneQuery class for querying within a sphere
►CStagingBuffer	A staging buffer is a buffer that resides on the GPU and be written to/from both CPU & GPU However the access in both cases is limited
CDestination
CStaticCache	Template version of cache based on static array
CStaticFaceGroup	Collects a group of static i.e
CSTBIImageCodec	Codec specialized in images loaded using stbi (https://github.com/nothings/stb)
CStencilParams
CStencilStateOp
►CSTLAllocator
Crebind	Standard rebind mechanism
CSTLAllocatorBase	Wrapper class for operating as an STL container allocator
CSTLAllocatorBase< const T >
►CStreamSerialiser	Utility class providing helper methods for reading / writing structured data held in a DataStream
CChunk	Definition of a chunk of data in a file
CStringConverter	Class for converting the core Ogre data types to/from Strings
CStringInterface	Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers
CStringUtil	Utility class for manipulating Strings
CSubItem	Utility class which defines the sub-parts of an Item
►CSubMesh	Defines a part of a complete mesh
CSourceData
CSubStringRef
CTagPoint	TagPoints are like SceneNodes, that can be children of a Bone
►CTechnique	Class representing an approach to rendering this particular Material
CGPUDeviceNameRule	Rule controlling whether technique is deemed supported based on GPU device name
CGPUVendorRule	Rule controlling whether technique is deemed supported based on GPU vendor
CTechniqueTranslator
►CTerrain	The main containing class for a chunk of terrain
CDefaultGpuBufferAllocator	Standard implementation of a buffer allocator which re-uses buffers
CGpuBufferAllocator	Interface used to by the Terrain instance to allocate GPU buffers
CImportData	Structure encapsulating import data that you may use to bootstrap the terrain without loading from a native data stream
CLayerInstance	An instance of a layer, with specific texture names
CTerrainAutoUpdateLod	Terrain automatic LOD loading
CTerrainAutoUpdateLodByDistance	Class implementing TerrainAutoUpdateLod interface
CTerrainAutoUpdateLodFactory
CTerrainGlobalOptions	Options class which just stores default options for the terrain
►CTerrainGroup	Helper class to assist you in managing multiple terrain instances that are connected to each other
CRayResult	Result from a terrain ray intersection with the terrain group
CTerrainSlot	Slot for a terrain instance, together with its definition
CTerrainSlotDefinition	Definition of how to populate a 'slot' in the terrain group
CTerrainLayerBlendMap	Class exposing an interface to a blend map for a given layer
CTerrainLayerDeclaration	The definition of the information each layer will contain in this terrain
CTerrainLayerSampler	Description of a sampler that will be used with each layer
CTerrainLayerSamplerElement	Information about one element of a sampler / texture within a layer
►CTerrainLodManager	Terrain LOD data manager
CLoadLodRequest
CLodInfo
►CTerrainMaterialGenerator	Class that provides functionality to generate materials for use with a terrain
CProfile	Inner class which should also be subclassed to provide profile-specific material generation
►CTerrainMaterialGeneratorA	A TerrainMaterialGenerator which can cope with normal mapped, specular mapped terrain
CSM2Profile	Shader model 2 profile target
►CTerrainPagedWorldSection	A world section which includes paged terrain
CTerrainDefiner
CTerrainPaging	This class is the 'core' class for paging terrain, that will integrate with the larger paging system and provide the appropriate utility classes required
►CTerrainQuadTreeNode	A node in a quad tree used to store a patch of terrain
CLodLevel
CTexBufferPacked	Represents Texture buffers (also known as tbuffers in D3D11)
CTexCoordModifierControllerValue	Predefined controller value for getting / setting a texture coordinate modifications (scales and translates)
CTexture	Abstract class representing a Texture resource
CTextureAnimationControllerValue	Predefined controller value for getting / setting a texture coordinate modifications (scales and translates)
►CTextureDefinitionBase	Centralized class for dealing with declarations of textures in Node & Workspace definitions
CBufferDefinition
CTextureDefinition	Local texture definition
CTextureFrameControllerValue	Predefined controller value for getting / setting the frame number of a texture layer
CTextureManager	Class for loading & managing textures
CTextureSourceTranslator
►CTextureUnitState	Class representing the state of a single texture unit during a Pass of a Technique, of a Material
CTextureEffect	Internal structure defining a texture effect
CTextureUnitTranslator
CThreadHandle
CThreadLocalPtr
CThreads
CTimer	Timer class
CTransform	Represents the transform of a single object, arranged in SoA (Structure of Arrays)
CTRect
CUavBufferPacked	Represents UAV buffers (also known as SSBOs in OpenGL) Uav buffers are supported in DX10/DX10.1 hardware (with up to date drivers)
►CUnifiedHighLevelGpuProgram	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
CCmdDelegate	Command object for setting delegate (can set more than once)
CUnifiedHighLevelGpuProgramFactory	Factory class for Unified programs
CUniformScalableTask	A uniform task is a highly parallelizable task that can be divided in many threads where all threads take near the same amount of time to perform
CUnimplementedException	Template struct which creates a distinct type for each exception code
CUnlitBakedTexture
CUnlitMobileProp
►CUnlitProperty
CDiffuseMapPtr
Cunordered_map
Cunordered_multimap
Cunordered_multiset
Cunordered_set
CUpdateLodRequest
CUpdateTransformRequest
CUserObjectBindings	Class that provides convenient interface to establish a linkage between custom user application objects and Ogre core classes
CVaoManager
CVariableAccessAbstractNode	This abstract node represents a variable assignment
Cvector
CVector2	Standard 2-dimensional vector
CVector3	Standard 3-dimensional vector
CVector4	4-dimensional homogeneous vector
CVectorIterator	Concrete IteratorWrapper for nonconst access to the underlying container
CVectorIteratorWrapper	Prepared IteratorWrapper for container like std::vector
CVectorRange	Predefined type
CVectorSet	VectorSet is basically a helper to use a vector as a small set container
►CVertexArrayObject	Vertex array objects (Vaos) are immutable objects that describe a combination of vertex buffers and index buffer with a given operation type
CReadRequests
CVertexBoneAssignment	Records the assignment of a single vertex to a single bone with the corresponding weight.
CVertexBufferPacked
CVertexElement2
CVertexShadowMapHelper
CViewPoint	Structure for holding a position & orientation pair
CViewport	An abstraction of a viewport, i.e
CWaveformControllerFunction	Predefined controller function based on a waveform
CWin32Context
CWin32EGLContext
CWin32EGLSupport
CWin32EGLWindow
CWin32GLSupport
CWin32Window
CWindowEventListener
CWindowEventUtilities
CWireAabb	Helper class to display the Aabb of a MovableObject as lines
CWireAabbFactory	Factory object for creating WireAabb instances
►CWorkQueue	Interface to a general purpose request / response style background work queue
CRequest	General purpose request structure
CRequestHandler	Interface definition for a handler of requests
CResponse	General purpose response structure
CResponseHandler	Interface definition for a handler of responses
CX11EGLContext
CX11EGLSupport
CX11EGLWindow
CZipArchive	Specialisation of the Archive class to allow reading of files from a zip format source archive
CZipArchiveFactory	Specialisation of ArchiveFactory for Zip files
CZipDataStream	Specialisation of DataStream to handle streaming data from zip archives
CZoneData
►Nrapidjson
CGenericDocument
CGenericValue
CMemoryPoolAllocator
CUTF8
C_finddata_t
Cbsp_brush_t
Cbsp_brushside_t
Cbsp_face_t
Cbsp_header_t
Cbsp_leaf_t
Cbsp_lump_entry_t
Cbsp_model_t
Cbsp_node_t
Cbsp_plane_t
Cbsp_shader_t
Cbsp_vertex_t
Cbsp_vis_t
CCocoaWindowDelegate
CDisplay
CNotPointerAtom
COgreGL3PlusView
COgreGL3PlusWindow
COgreMetalView
COgreView
COgreWindow
CRotation
CStrangeData
CVisual
CXClientMessageEvent
CXClientMessageEventData
CXErrorEvent
CXEvent
CXRRScreenConfiguration
CXRRScreenSize
CXSetWindowAttributes
CXSizeHints
CXTextProperty
CXVisualInfo
CXWindowAttributes
CXWMHints