Namespace List

Here is a list of all namespaces with brief descriptions:

[detail level 1234]

►NOgre	BswapNN may be defined as macros in <sys/endian.h> or <sys/bswap.h>
NAssert
NBakedDescriptorSets
NCommonTextureTypes
NCopyEncTransitionMode
NCubemapSide
NDefaultMipmapGen
NDescBindingTypes
►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
NGpuPageOutStrategy
NGpuResidency
NLampConeType
NLampHorizType
NLoadAction
NMsaaPatterns
NParticleRotationType
NParticleType
NPbsBrdf
NPixelFormatDataTypes
NPrefabRootLayout
NResidencyMask
NResourceAccess
NResourceLayout
NSceneFlags
NStoreAction
NSubmissionType
►NTextureFilter
CFilterBase
CGenerateHwMipmaps
CGenerateSwMipmaps
CLeaveChannelR
CPremultiplyAlpha
CPrepareForNormalMapping
NTextureFlags
NTextureSourceType
NTextureTypes
►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
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)
CCmdTextureSlices	Command object for TextureSlices (see ParamCommand)
CCmdTextureStacks	Command object for TextureStacks (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
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
CD3D11HardwareVertexBuffer	Specialisation of HardwareVertexBuffer for D3D11
CDefaultHardwareBufferManager	DefaultHardwareBufferManager as a Singleton
CDefaultHardwareBufferManagerBase	Specialisation of HardwareBufferManagerBase to emulate hardware buffers
CDefaultHardwareIndexBuffer	Specialisation of HardwareIndexBuffer 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
CGL3PlusDefaultHardwareIndexBuffer	Specialisation of HardwareIndexBuffer for emulation
CGL3PlusDefaultHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for emulation
CGL3PlusHardwareBufferManager	GL3PlusHardwareBufferManagerBase as a Singleton
CGL3PlusHardwareBufferManagerBase	Implementation of HardwareBufferManager for OpenGL
CGL3PlusHardwareIndexBuffer
CGL3PlusHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for OpenGL
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
CHardwareIndexBuffer	Specialisation of HardwareBuffer for vertex index buffers, still abstract
CHardwareIndexBufferSharedPtr	Shared pointer implementation used to share index 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
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
CMetalHardwareVertexBuffer	Specialisation of HardwareVertexBuffer for Metal
CNodeAnimationTrack	Specialised AnimationTrack for dealing with node transforms
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
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
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
CVulkanHardwareBufferCommon
CVulkanHardwareBufferManager
CVulkanHardwareBufferManagerBase
CVulkanHardwareIndexBuffer
CVulkanHardwareVertexBuffer
CWireBoundingBox	Allows the rendering of a wireframe bounding box
NVisibilityFlags
►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
NVoxelizerJobSetting
C_ConfigOption	Packages the details of a configuration option
CAabb	AoS (array of structures) version of ArrayAabb
CAbiCookie
CAbsolutePixelCountLodStrategy	The AbsolutePixelCountLodStrategy class LOD strategy that works like ScreenRatioPixelCountLodStrategy, but in range [-width * height;0] instead of [-1.0;0.0]
CAbstractNode
CActiveActorData
CAlignedMemory	Class to provide aligned memory allocate functionality
CAndroidEGLContext
CAndroidEGLSupport
CAndroidEGLWindow
CAndroidJniProvider
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
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)
CAreaEmitter2	Particle emitter which emits particles randomly from points inside an area (box, sphere, ellipsoid whatever subclasses choose to be)
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
CArrayPlane
CArrayQuaternion	Cache-friendly array of Quaternion represented as a SoA array
CArrayRay
CArraySphere	Cache-friendly array of Sphere represented as a SoA array
CArrayVector2	Cache-friendly array of 2-dimensional represented as a SoA array
CArrayVector3	Cache-friendly array of 3-dimensional represented as a SoA array
CArrayVector4	Cache-friendly array of 4-dimensional represented as a SoA array
CASTCCodec	Codec specialized in loading ASTC (ARM Adaptive Scalable Texture Compression) images
►CAsyncTextureTicket	In Ogre 2.2 reading data from GPU back to CPU is asynchronous
CDelayedDownload
CAsyncTicket	In Ogre 2.0 data structures, reading data from GPU back to CPU is asynchronous
CAtmosphereComponent
►CAtmosphereNpr	Non-physically-based-render (NPR) Atmosphere solution
CPreset
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
CBarrierSolver
CBasicBlock
CBillboard	Basic Billboard holder that belongs to a ParticleSystemDef
CBillboardSet	A BillboardSet is just a ParticleSystemDef directly exposed to the user but without emitters, affectors and time to live
Cbitset64	See cbitset64
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
CBoxEmitter2	Particle emitter which emits particles randomly from points inside a box
CBoxEmitterFactory	Factory class for particle emitter of type "Box"
CBoxEmitterFactory2
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
CCamerasInProgress	Struct that holds a number of cameras used in the current rendering pass
CCbBase
CCbDrawCall
CCbDrawCallIndexed
CCbDrawCallStrip
CCbDrawIndexed
CCbDrawStrip
CCbIndirectBuffer
Ccbitset32	This is similar to std::bitset, except waaay less bloat
Ccbitset64	This is similar to std::bitset, except waaay less bloat
CcbitsetN
CCbLowLevelMaterial
CCbPipelineStateObject
CCbSamplers
CCbShaderBuffer
CCbSharedDraw
CCbTexture
CCbTextures
CCbVao
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)
CColourFaderAffector2FX2	This plugin subclass of ParticleAffector allows you to alter the colour of particles
CColourFaderAffector2FX2Factory
CColourFaderAffectorFactory	Factory class for ColourFaderAffector
CColourFaderAffectorFactory2	Factory class for ColourFaderAffector
CColourFaderAffectorFX2	This plugin subclass of ParticleAffector allows you to alter the colour of particles
CColourFaderAffectorFX2Factory
►CColourImageAffector
CCmdImageAdjust	Command object for red adjust (see ParamCommand)
CColourImageAffector2
CColourImageAffectorFactory	Factory class for ColourImageAffector
CColourImageAffectorFactory2
►CColourInterpolatorAffector
CCmdColourAdjust	Command object for red adjust (see ParamCommand)
CCmdTimeAdjust	Command object for red adjust (see ParamCommand)
CColourInterpolatorAffector2
CColourInterpolatorAffectorFactory	Factory class for ColourInterpolatorAffector
CColourInterpolatorAffectorFactory2
CColourValue	Class representing colour
CCommandBuffer	Command Buffer implementation
CCompositorLoadActionTranslator
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 (see CompositorPassType):
CUavDependency
CViewportRect
CCompositorPassDepthCopy	Implementation of CompositorPass This implementation will copy one DepthBuffer to another DepthBuffer from two RTs
CCompositorPassDepthCopyDef
CCompositorPassIblSpecular	Implementation of CompositorPass This implementation will generate IblSpeculars for the specified texture
CCompositorPassIblSpecularDef
CCompositorPassMipmap	Implementation of CompositorPass This implementation will generate mipmaps for the specified texture
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
CCompositorPassShadows	CompositorPassShadows This class enables force-updating multiple shadow nodes in batch in its own pass
CCompositorPassShadowsDef
CCompositorPassStencil	Implementation of CompositorPass This implementation will clear the RenderTarget using the parameters from definition (rectangle area, which buffers, what values, etc)
CCompositorPassStencilDef
CCompositorPassTargetBarrier
CCompositorPassTargetBarrierDef
CCompositorPassTranslator
CCompositorPassUav	Implementation of CompositorPass This implementation will set UAVs
►CCompositorPassUavDef
CBufferSource
CTextureSource
CCompositorPassWarmUp	Implementation of CompositorPass
CCompositorPassWarmUpDef
CCompositorRenderTargetViewTranslator
CCompositorShadowMapRepeatTranslator
CCompositorShadowMapTargetTranslator
CCompositorShadowMapTargetTypeTranslator
CCompositorShadowNode	Shadow Nodes are special nodes (not to be confused with CompositorNode) that are only used for rendering shadow maps
CCompositorShadowNodeDef	Shadow Nodes are special nodes (not to be confused with
CCompositorShadowNodeTranslator
CCompositorStoreActionTranslator
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
CChannelRoute
CCompositorWorkspaceListener
CCompositorWorkspaceTranslator
CComPtr
CComputeProperty
CComputeTools
CConcentricShadowCamera	Implements the concentric shadow mapping algorithm
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
CConstVectorIterator	Concrete IteratorWrapper for const access to the underlying container
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
CCullFrustumPreparedData
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
CCylinderEmitter2	Particle emitter which emits particles randomly from points inside a cylinder
CCylinderEmitterFactory	Factory class for particle emitter of type "Cylinder"
CCylinderEmitterFactory2
CD3D11AmdExtension
CD3D11AsyncTextureTicket	See AsyncTextureTicket
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
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
CD3D11FrameBufferDescValue
CD3D11GpuProgramManager
CD3D11HardwareOcclusionQuery	This is a class that is the DirectX9 implementation of hardware occlusion testing
CD3D11HlmsPso	We cache some conversion values here to avoid doing it every time we set the Pso
►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
CD3D11PixelFormatToShaderType
CD3D11Plugin	Plugin instance for D3D11 Manager
CD3D11ReadOnlyBufferPacked
CD3D11RenderPassDescriptor	D3D11 will share groups of ID3D11RenderTargetView all D3D11RenderPassDescriptor that share the same RTV setup
CD3D11RenderSystem	Implementation of DirectX11 as a rendering system
CD3D11StagingBuffer	NOTE FOR D3D12 PORTING: The GL3Plus implementation should be used as reference, since it is much lower level than this implementation for D3D11
CD3D11StagingTexture
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
CD3D11TextureGpu
CD3D11TextureGpuManager
CD3D11TextureGpuRenderTarget
CD3D11TextureGpuWindow
CD3D11UavBufferPacked
►CD3D11VaoManager
CBlock
CStrideChanger
CD3D11VendorExtension
CD3D11VertexArrayObject
CD3D11VertexArrayObjectShared
CD3D11VideoMode
CD3D11VideoModeList
CD3D11Window
CD3D11WindowSwapChainBased
CDataStream	General purpose class used for encapsulating the reading and writing of data
CDDSCodec2	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
CDefaultTextureGpuManagerListener	This is a Default implementation of TextureGpuManagerListener based on heuristics
CDefaultWorkQueue	Implementation of a general purpose request / response style background work queue
CDefaultWorkQueueBase	Base for a general purpose request / response style background work queue
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)
CDeflectorPlaneAffector2	This class defines a ParticleAffector which deflects particles
CDeflectorPlaneAffectorFactory	Factory class for DeflectorPlaneAffector
CDeflectorPlaneAffectorFactory2
CDegree	Wrapper class which indicates a given angle value is in Degrees
CDeleteOnDestructor
CDepthBuffer	An abstract class that contains a depth/stencil buffer
CDescBindingRange
CDescriptorSetSampler	Descriptor sets describe what samplers should be bound together in one place
CDescriptorSetTexture	Descriptor sets describe what textures should be bound together in one place
►CDescriptorSetTexture2
CBufferSlot
CSlot
CTextureSlot
►CDescriptorSetUav	Descriptor sets describe what uavs should be bound together in one place
CBufferSlot
CSlot
CTextureSlot
►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)
CDirectionRandomiserAffector2	This class defines a ParticleAffector which applies randomness to the movement of the particles
CDirectionRandomiserAffectorFactory	Factory class for DirectionRandomiserAffector
CDirectionRandomiserAffectorFactory2
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
CEGLGLSupport
CEglPBufferContext
►CEglPBufferSupport
CDeviceData
CEglPBufferWindow	PBuffer implementation of EGL When supported, PBuffer is a surface-less implementation of OpenGL
CEGLSupport
CEGLWindow
CEllipsoidEmitter	Particle emitter which emits particles randomly from points inside an ellipsoid
CEllipsoidEmitter2	Particle emitter which emits particles randomly from points inside an ellipsoid
CEllipsoidEmitterFactory	Factory class for particle emitter of type "Ellipsoid"
CEllipsoidEmitterFactory2
CEmbeddedZipArchiveFactory	Specialisation of ZipArchiveFactory for embedded Zip files
CEmittedParticle
CEmitterDefData	EmitterDefData are per ParticleSystemDef
CEmitterInstanceData	EmitterInstanceData are per ParticleSystem
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
Cfloat2
Cfloat4
Cfloat4x3
Cfloat4x4
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
CFrameBufferDescKey
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 returned values are either in seconds or frames per second
CFrameTimeControllerValue	Predefined controller value for getting the latest frame time
CFreeImageCodec2	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
CGL3PlusAsyncTextureTicket	See AsyncTextureTicket
CGL3PlusAsyncTicket
CGL3PlusBufferInterface	For GL3+, most (if not all) buffers, can be treated with the same code
CGL3PlusConstBufferPacked
CGL3PlusContext	Class that encapsulates an GL context
CGL3PlusDescriptorSetTexture2
CGL3PlusDynamicBuffer	GL3+ doesn't support mapping the same buffer twice even if the regions don't overlap
CGL3PlusFrameBufferDescValue
CGL3PlusHardwareOcclusionQuery	This is a class that is the base class of the query class for hardware occlusion
CGL3PlusHlmsPso	We cache some conversion values here to avoid doing it every time we set the Pso
CGL3PlusMappings
CGL3PlusOldVertexArrayObject	Specialisation of VertexDeclaration for OpenGL Vertex Array Object usage
CGL3PlusPixelFormatToShaderType
CGL3PlusPlugin	Plugin instance for GL3Plus Manager
CGL3PlusReadOnlyBufferEmulatedPacked
CGL3PlusReadOnlyTexBufferPacked
CGL3PlusReadOnlyUavBufferPacked
CGL3PlusRenderPassDescriptor	GL3+ will share FBO handles between all GL3PlusRenderPassDescriptor that share the same FBO setup
CGL3PlusRenderSystem	Implementation of GL 3 as a rendering system
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
CGL3PlusStagingTexture
CGL3PlusSupport
CGL3PlusTexBufferEmulatedPacked
CGL3PlusTexBufferPacked
CGL3PlusTextureGpu
CGL3PlusTextureGpuHeadlessWindow
CGL3PlusTextureGpuManager
CGL3PlusTextureGpuRenderTarget
CGL3PlusTextureGpuWindow
CGL3PlusUavBufferPacked
►CGL3PlusVaoManager
CBlock
CStrideChanger
CGL3PlusVertexArrayObject
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	An abstract class that contains a depth/stencil buffer.
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	We cache some conversion values here to avoid doing it every time we set the Pso
CGLES2HlmsSamplerblock	A sampler block contains settings that go hand in hand with a texture, and thus are common to many textures
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
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
►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
CGlSwitchableSupport
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
CGpuProgramParameters_AutoConstantEntry	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
CGpuTrackedResource
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
CHardwareOcclusionQuery	This is a abstract class that that provides the interface for the query class for hardware occlusion
CHashedVector	A hashed vector
CHiddenAreaMeshVrGenerator
CHiddenAreaVrSettings
►CHighLevelGpuProgram	Abstract base class representing a high-level program (a vertex or fragment program)
CCmdEnableIncludeHeader	Command object for enabling include in shaders
CCmdUseHlmsParser	Command object for using Hlms parser
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"
CDatablockCustomPieceFile
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
CDatablockCustomPiecesCache
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+
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
►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+
►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)
CHollowEllipsoidEmitter2	Particle emitter which emits particles randomly from points inside a hollow ellipsoid
CHollowEllipsoidEmitterFactory	Factory class for particle emitter of type "HollowEllipsoid"
CHollowEllipsoidEmitterFactory2
CId	Usage: OGRE_NEW SceneNode( Id::generateNewId< Node >() )
CIdObject
CIdString	Hashed string
CIesLoader
CIfdProbeVisualizer
CImage2	Class representing an image file
►CImageCodec2	Codec specialized in images
CImageData2	Codec return class for images
CImportAbstractNode	This abstract node represents an import statement
CIndexBufferPacked
CIndirectBufferPacked	Represents Indirect buffers for storing draw call commands
►CInstantRadiosity
CAreaOfInterest	Areas of Interest are defined by both AABB and distance (can be 0)
CInternalCubemapProbe	This class is internal and should not be interfaced directly by users
CInternalCubemapProbeFactory
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
CIrradianceField	Implements an Irradiance Field with Depth, inspired on DDGI
CIrradianceFieldRaster	Implements IrradianceField, but generating results via cubemap rasterization
CIrradianceFieldSettings
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
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 SkeletonTrack
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
CLightProfiles
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)
CLinearForceAffector2	This class defines a ParticleAffector which applies a linear force to particles in a system
CLinearForceAffectorFactory	Factory class for LinearForceAffector
CLinearForceAffectorFactory2
CLod0Stripifier
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
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
CDouble
CFloat
►CManualObject
CManualObjectSection	Built, renderable section of geometry
CManualObjectFactory	Factory object for creating ManualObject instances
CManualResourceLoader	Interface describing a manual resource loader
CMapIterator	Concrete IteratorWrapper for nonconst access to the underlying key-value container
CMapIteratorWrapper	Prepared IteratorWrapper for key-value container
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
CMetalAsyncTextureTicket	See AsyncTextureTicket
CMetalAsyncTicket
CMetalBufferInterface	For Metal, all buffers can be treated with the same code
CMetalBufferRegion
CMetalConstBufferPacked
CMetalDescriptorSetTexture
CMetalDevice
CMetalDeviceItem
CMetalDeviceList
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"
CMetalFrameBufferDescValue
CMetalGpuProgramManager
CMetalHlmsPso
CMetalMappings
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
CMetalReadOnlyBufferPacked
CMetalRenderPassDescriptor
CMetalRenderSystem	Implementation of Metal as a rendering system
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
CMetalStagingTexture
CMetalTexBufferPacked	In Metal, Tex and ReadOnly buffers are exactly the same, thus we derive from ReadOnlyBufferPacked to cover both at once
CMetalTexRegion
CMetalTextureGpu
CMetalTextureGpuManager
CMetalTextureGpuRenderTarget
CMetalTextureGpuWindow
CMetalUavBufferPacked
►CMetalVaoManager
CBlock
CStrideChanger
CMetalWindow
►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
CNameGenerator	Utility class to generate a sequentially numbered series of names
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
CNULLAsyncTextureTicket	See AsyncTextureTicket
CNULLAsyncTicket
CNULLBufferInterface	For GL3+, most (if not all) buffers, can be treated with the same code
CNULLConstBufferPacked
CNullEntity
CNULLPixelFormatToShaderType
CNULLPlugin	Plugin instance for NULL Manager
CNULLReadOnlyBufferPacked
CNULLRenderSystem	Implementation of NULL as a rendering system
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
CNULLStagingTexture
CNULLTexBufferPacked
CNULLTextureGpu
CNULLTextureGpuManager
CNULLTextureGpuRenderTarget
CNULLUavBufferPacked
►CNULLVaoManager
CBlock
CStrideChanger
CNULLVertexArrayObject
CNULLWindow
CNumericSolver	Provides numeric solvers for Ogre
►CObjCmdBuffer
CCmd
CExceptionThrown
CNotifyDataIsReady
COutOfDateCache
CTransitionToLoaded
CUploadFromStagingTex
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
COfflineProfiler	Simple profiler that will produce a CSV file for offline analysis once dumpProfileResults is called
COGRE_HLMS_TEXTURE_BASE_CLASS	This is not a regular header, therefore it has no include guards
COITDCodec	Codec specialized in loading OITD (Ogre Internal Texture Dump) format
COptimisedUtil	Utility class for provides optimised functions
COSXGL3PlusSupport
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
CParallaxCorrectedCubemapAuto	Per-Pixel reflection probes
CParallaxCorrectedCubemapAutoListener
CParallaxCorrectedCubemapBase
►CParallelHlmsCompileQueue
CRequest
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
CParticleAffector2	Affectors are per ParticleSystemDef
CParticleAffectorFactory	Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses
CParticleAffectorFactory2	Abstract class defining the interface to be implemented by creators of ParticleAffector2 subclasses
CParticleAffectorTranslator
CParticleAffectorTranslator2
CParticleCpuData
CParticleEmitter	Abstract class defining the interface to be implemented by particle emitters
CParticleEmitterDefDataFactory	Abstract class defining the interface to be implemented by creators of EmitterDefData subclasses
CParticleEmitterFactory	Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses
CParticleEmitterTranslator
CParticleEmitterTranslator2
CParticleFX2Plugin	Plugin instance for ParticleFX2 Manager
CParticleFXPlugin	Plugin instance for ParticleFX Manager
CParticleGpuData
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)
CParticleSystem2
CParticleSystem2Factory	Object for creating ParticleSystem2 instances
CParticleSystemDef	A ParticleSystemDef does not form part of the scene
CParticleSystemFactory	Factory object for creating ParticleSystem instances
CParticleSystemManager	Manages particle systems, particle system scripts (templates) and the available emitter & affector factories
CParticleSystemManager2
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
CParticleSystemTranslator2
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
CPbsProperty
CPccPerPixelGridPlacement	Placing multiple PCC probes by hand can be difficult and even error prone
CPixelCountLodStrategyBase	Abstract base class for level of detail strategy based on pixel count approximations from bounding sphere projection
CPixelFormatGpuUtils	The pixel format used for images, textures, and render surfaces
CPixelFormatToShaderType
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
CPointEmitter2
CPointEmitterFactory	Factory class for particle emitter of type "Point"
CPointEmitterFactory2
CPolygon	The class represents a polygon in 3D space
CPool	Template class describing a simple pool of items
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
CQuaternion	Implementation of a Quaternion, i.e
CQueuedRenderable
CRadialDensityMask
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
CRasterParams
CRawSimdUniquePtr	Similar to std::unique_ptr, but:
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
CReadOnlyBufferPacked	Represents the best way to access read-only data
CRectangle2D
CRectangle2DFactory	Factory object for creating Entity instances
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
CRenderingMetrics
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
CRenderPassColourTarget
CRenderPassDepthTarget
CRenderPassDescriptor
CRenderPassStencilTarget
CRenderPassTargetBase
CRenderQueue	Class to manage the scene object rendering queue
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
CPipelineCachePrefixHeader	When serializing pipeline cache data to the file, we use a header that is filled with enough information to be able to validate the data, with the pipeline cache data following immediately afterwards
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
CRenderTargetViewDef
CRenderTargetViewEntry
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
CResourceStatus
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)
CRingEmitter2	Particle emitter which emits particles randomly from points inside a ring (e.g
CRingEmitterFactory	Factory class for particle emitter of type "Ring"
CRingEmitterFactory2
CRoot	The root class of the Ogre system
►CRootLayout	The RootLayout class
CArrayDesc
►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
CRotationAffector2	This plugin subclass of ParticleAffector allows you to alter the rotation of particles
CRotationAffectorFactory	Factory class for RotationAffector
CRotationAffectorFactory2
CRotationalSpline	This class interpolates orientations (rotations) along a spline using derivatives of quaternions
CRqBits
CRuntimeAssertionException
CSampleDescription	Opaque struct that holds effective FSAA (MSAA, CSAA, etc.) mode
►CScaleAffector	This plugin subclass of ParticleAffector allows you to alter the scale of particles
CCmdMultiplyMode
CCmdScaleAdjust	Command object for scale adjust (see ParamCommand)
CScaleAffector2	This plugin subclass of ParticleAffector allows you to alter the scale of particles
CScaleAffectorFactory	Factory class for ScaleAffector
CScaleAffectorFactory2
CScaleControllerFunction	Predefined controller function which simply scales an input to an output value
►CScaleInterpolatorAffector
CCmdScaleAdjust	Command object for red adjust (see ParamCommand)
CCmdTimeAdjust	Command object for red adjust (see ParamCommand)
CScaleInterpolatorAffector2
CScaleInterpolatorAffectorFactory	Factory class for ScaleInterpolatorAffector
CScaleInterpolatorAffectorFactory2
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
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
CScopedLock
CScreenRatioPixelCountLodStrategy	The ScreenRatioPixelCountLodStrategy class Implement a strategy which calculates LOD ratios based on coverage in screen ratios in the range [-1.0; 0.0] where -1.0 means the object is covering the whole screen and 0 covering almost nothing in the screen (very tiny)
►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
CSemaphore	Implements a semaphore
CSerializer	Generic class for serialising data to / from binary stream-based files
►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
CManualParamEx
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
CSharedParamsTranslator
CSharedPtr
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
CSPFMDeleteT
CSphere	A sphere primitive, mostly used for bounds checking
CSphereSceneQuery	Specialises the SceneQuery class for querying within a sphere
CStackVector	Compact implementation similar to std::array
►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
CStagingTexture	A StagingTexture is an intermediate texture that can be read and be written from both CPU & GPU
CStagingTextureBufferImpl	This implementation can be used by all RenderSystem APIs except D3D11, which is why this implementation is part of OgreMain
CStagingTextureManager
CStaticCache	Template version of cache based on static array
CSTBIImageCodec	Codec specialized in images loaded using stbi (https://github.com/nothings/stb)
CStdList
CStdMap
CStdMultiMap
CStdUnorderedSet
CStdVector
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
CTexBufferPacked	Represents Texture buffers (also known as tbuffers in D3D11)
CTexCoordModifierControllerValue	Predefined controller value for getting / setting a texture coordinate modifications (scales and translates)
CTextureAnimationControllerValue	Predefined controller value for getting / setting a texture coordinate modifications (scales and translates)
CTextureBox	For cubemaps, the face is in sliceStart, (see CubemapSide::CubemapSide) For cubemap arrays, the cubemaps are addressed as sliceStart * 6
►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
CTextureGpu
CTextureGpuListener
►CTextureGpuManager	This class manages all textures (i.e
CBudgetEntry	Specifies the minimum squared resolution & number of slices to keep around all the for time StagingTextures
CMetadataCacheEntry
CResourceEntry
CTextureGpuManagerListener
CTexturePool
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
Ctype4
CUavBufferPacked	Represents UAV buffers (also known as SSBOs in OpenGL) Uav buffers are supported in DX10/DX10.1 hardware (with up to date drivers)
Cuint4
►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
►CUnlitProperty
CDiffuseMapPtr
CUpdateLodRequest
CUpdateTransformRequest
CUserObjectBindings	Class that provides convenient interface to establish a linkage between custom user application objects and Ogre core classes
►CVaoManager
CMemoryStatsEntry
CVariableAccessAbstractNode	This abstract node represents a variable assignment
CVctCascadedVoxelizer	This class manages multiple cascades of Voxels and each cascade can be composed of VctImageVoxelizer
CVctCascadeSetting	Contains VctLighting settings about each cascade that cannot be set by setting them directly via VctCascadedVoxelizer::getVctLighting
CVctImageVoxelizer	The image voxelizer aims to be faster than VctImageVoxelizer for the whole scene by following a different approach:
CVctLighting
►CVctMaterial
CDatablockConversionResult
CVctVoxelizer	The voxelizer consists in several stages
CVctVoxelizerSourceBase	This class contains shared functionality between voxelizer; and is used by VctLighting to source its voxel data to generate GI
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
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.
►CVertexBufferDownloadHelper	Ogre currently does not support deinterleaved vertex buffers
CDownloadData
CVertexBufferPacked
CVertexElement2
CVertexElementSemanticFull
CVertexFormatWarmUpStorage	The purpose of this class is to trigger shader compilations on demand (e.g
CVertexShadowMapHelper
CVerticesRemapInfo
CViewPoint	Structure for holding a position & orientation pair
CViewport	An abstraction of a viewport, i.e
►CVoxelizedMeshCache	Uses a VctVoxelizer to convert a single mesh made up of triangles into a voxel 3D texture representation
CVoxelizedMesh
CVoxelizerBucket
CVoxelVisualizer
CVrData
CVulkanAndroidSupport
CVulkanAndroidWindow
CVulkanAsyncTextureTicket	See AsyncTextureTicket
CVulkanAsyncTicket
CVulkanBufferInterface
CVulkanCache
CVulkanConstantDefinitionBindingParam
CVulkanConstBufferPacked
CVulkanDelayed_vkDestroyBufferView
CVulkanDelayed_vkDestroyFramebuffer
CVulkanDelayed_vkDestroyImage
CVulkanDelayed_vkDestroyImageView
CVulkanDelayed_vkDestroyPipeline
CVulkanDelayed_vkDestroyRenderPass
CVulkanDelayed_vkDestroySampler
CVulkanDelayed_vkDestroyShaderModule
CVulkanDelayedFuncBase
CVulkanDescriptorPool	The VulkanDescriptorPool class A VulkanDescriptorPool manages the pool of a single set (i.e
CVulkanDescriptorSetSampler
CVulkanDescriptorSetTexture
CVulkanDescriptorSetTexture2
CVulkanDescriptorSetUav
►CVulkanDevice
CExtraVkFeatures
CSelectedQueue
CVulkanDeviceResource	Represents a Vulkan device depended rendering resource
CVulkanDeviceResourceManager	Singleton that is used to propagate device state changed notifications
CVulkanDiscardBuffer
►CVulkanDiscardBufferManager	Vulkan 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
CVulkanDynamicBuffer	Vulkan maps per pool, thus mapping the same pool twice is a common occurrence
CVulkanExternalDevice	Use it to pass an external device
CVulkanExternalInstance	Use it to pass an external instance
CVulkanFlushOnlyDescValue
CVulkanFrameBufferDescKey
CVulkanFrameBufferDescValue
CVulkanGlobalBindingTable	This table holds an emulation of D3D11/Metal style of resource binding
CVulkanGpuProgramManager
CVulkanHlmsPso
CVulkanInstance	We need the ability to re-enumerate devices to handle physical device removing, that requires fresh VkInstance instance, as otherwise Vulkan returns obsolete physical devices list
CVulkanMappings
CVulkanPhysicalDevice
CVulkanPixelFormatToShaderType
CVulkanPlugin	Plugin instance for Vulkan Manager
►CVulkanProgram	Specialisation of HighLevelGpuProgram to provide support for Vulkan Shader Language
CCmdPreprocessorDefines	Command object for setting macro defines
CVulkanProgramFactory	Factory class for Vulkan programs
►CVulkanQueue
CPerFrameData
CVulkanRawBuffer	Provides a simple interface similar to that of MTLBuffer
CVulkanReadOnlyBufferPacked
CVulkanRenderPassDescriptor
CVulkanRenderSystem	Implementation of Vulkan as a rendering system
CVulkanResourceTransition
CVulkanRootLayout
CVulkanStagingBuffer	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
CVulkanStagingTexture
CVulkanSupport
CVulkanTexBufferPacked
CVulkanTextureGpu
CVulkanTextureGpuManager
CVulkanTextureGpuRenderTarget
CVulkanTextureGpuWindow
CVulkanUavBufferPacked
►CVulkanVaoManager
CBlock
CDirtyBlock
CStrideChanger
CVulkanWin32Support
CVulkanWin32Window
CVulkanWindow
CVulkanWindowNull
CVulkanWindowSwapChainBased
CVulkanXcbSupport
CVulkanXcbWindow
CWaitableEvent	A WaitableEvent is useful in the scenario of a singler consumer, multiple producers The consumer will wait until any of the producers wake it up to consume the work
CWarmUpHelper
CWaveformControllerFunction	Predefined controller function based on a waveform
CWin32Context
CWin32EGLContext
CWin32EGLSupport
CWin32EGLWindow
CWin32GLSupport
CWin32Window
CWindow
CWindowEventListener
CWindowEventUtilities
CWireAabb	Helper class to display the Aabb of a MovableObject as lines
CWireAabbFactory	Factory object for creating WireAabb instances
CWorkarounds
►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
NProfileSampleFlags
►Nrapidjson
CGenericDocument
CGenericValue
CMemoryPoolAllocator
CUTF8
►Nstd
Chash< Ogre::SharedPtr< T > >