|  | OGRE 14.3
    Object-Oriented Graphics Rendering Engine | 
| ►NOgre | |
| ►NBullet | |
| CCollisionListener | |
| CCollisionWorld | Simplified wrapper with automatic memory management | 
| CDebugDrawer | |
| CDynamicsWorld | Simplified wrapper with automatic memory management | 
| CRayResultCallback | |
| CRigidBodyState | A MotionState is Bullet's way of informing you about updates to an object | 
| ►NRTShader | |
| CAssignmentAtom | Shorthand for "lhs = rhs;" insted of using FFP_Assign(rhs, lhs) | 
| CAt | Shorthand for operator[] on preceding operand. e.g. myArray[p] | 
| CBinaryOpAtom | Shorthand for "dst = a OP b;" | 
| CBuiltinFunctionAtom | Shorthand for "dst = BUILTIN(args);" | 
| CConstParameter | Helper template which is the base for our ConstParameters | 
| CFFPTexturing | Texturing sub render state implementation of the Fixed Function Pipeline | 
| CFunction | A class that represents a shader based program function | 
| CFunctionAtom | A class that represents an atomic code section of shader based program function | 
| ►CFunctionInvocation | A class that represents function invocation code from shader based program function | 
| CFunctionInvocationCompare | Comparator function to be used for comparisons | 
| CFunctionInvocationLessThan | Comparator function to be used for sorting | 
| CFunctionStageRef | FFPShaderStage, part of a Function | 
| CHardwareSkinningFactory | A factory that enables creation of HardwareSkinning instances | 
| CIn | |
| CInOut | |
| CLayeredBlending | |
| COperand | A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields) | 
| COut | |
| CParameter | A class that represents a shader based program parameter | 
| CParameterFactory | Helper utility class that creates common parameters | 
| CProgram | A class that represents a shader based program | 
| CProgramManager | A singleton manager class that manages shader based programs | 
| CProgramSet | Container class for shader based programs | 
| CProgramWriter | Base class interface for shader program writers | 
| CProgramWriterManager | |
| CRenderState | This is a container class for sub render state class | 
| CSampleTextureAtom | Shorthand for "dst = texture(sampler, uv);" instead of using FFP_SampleTexture | 
| CSGScriptTranslator | This class responsible for translating core features of the RT Shader System for Ogre material scripts | 
| CShaderGenerator | Shader generator system main interface | 
| CSubRenderState | This class is the base interface of sub part from a shader based rendering pipeline | 
| CSubRenderStateAccessor | This class uses as accessor from a template SubRenderState to all of its instances that created based on it | 
| CSubRenderStateFactory | Abstract factory interface for creating SubRenderState implementation instances | 
| CTargetRenderState | This is the target render state | 
| CUniformParameter | Uniform parameter class | 
| ►NVolume | |
| CCacheSource | A caching Source | 
| CChunk | A single volume chunk mesh | 
| CChunkParameters | Parameters for loading the volume | 
| 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 | 
| CAbsolutePixelCountLodStrategy | |
| CAbstractNode | |
| CAffine3 | Transform specialization for 3D Affine - encapsulating a 3x4 Matrix | 
| ►CAlignedAllocator | STL compatible wrapper for AlignedMemory | 
| Crebind | |
| CAlignedMemory | Class to provide aligned memory allocate functionality | 
| 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 | 
| CAnimation | An animation sequence | 
| CAnimationContainer | An animation container interface, which allows generic access to sibling animations | 
| CAnimationControllerFunction | Predefined controller function for dealing with animation | 
| 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 | 
| CAntiPortal | AntiPortal datastructure for occlusion culling | 
| CAntiPortalFactory | Factory object for creating AntiPortal instances | 
| CAny | Variant type that can hold Any other type | 
| CAPKFileSystemArchiveFactory | |
| 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) | 
| ►CAssimpLoader | |
| COptions | |
| CAssimpPlugin | |
| CAtomAbstractNode | This is an abstract node which cannot be broken down further | 
| 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 | 
| CBaseInstanceBatchVTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) This implementation has the following advantages: | 
| 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 | 
| CBillboardParticleRenderer | Specialisation of ParticleSystemRenderer to render particles using a BillboardSet | 
| 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 | 
| CBitwise | Class for manipulating bit patterns | 
| CBone | A bone in a skeleton | 
| CBorderPanelOverlayElement | A specialisation of the PanelOverlayElement to provide a panel with a border | 
| CBorderRenderable | Class for rendering the border of a BorderPanelOverlayElement | 
| CBox | Structure used to define a box in a 3-D integer space | 
| CBoxEmitter | This emitter emits particles from a random location within a 3-dimensional box | 
| CBspIntersectionSceneQuery | BSP specialisation of IntersectionSceneQuery | 
| CBspLevel | Holds all the data associated with a Binary Space Parition (BSP) based indoor level | 
| ►CBspNode | Encapsulates a node in a BSP tree | 
| CBrush | |
| CBspRaySceneQuery | BSP specialisation of RaySceneQuery | 
| CBspSceneManager | Specialisation of the SceneManager class to deal with indoor scenes based on a BSP tree | 
| CBspSceneManagerFactory | Factory for BspSceneManager | 
| CBspSceneManagerPlugin | Plugin instance for BSPSceneManager | 
| CBspSceneNode | Specialisation of SceneNode for the BspSceneManager | 
| ►CCamera | A viewpoint from which the scene will be rendered | 
| CListener | Listener interface so you can be notified of Camera events | 
| CCapsule | 3D Line-Swept-Sphere class for intersection testing in Ogre3D Some algorithms based off code from the Wild Magic library by Dave Eberly | 
| CCgFxScriptLoader | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them | 
| CCgPlugin | Plugin instance for Cg Program Manager | 
| ►CCgProgram | Specialisation of HighLevelGpuProgram to provide support for nVidia's CG language | 
| CCmdArgs | Command object for setting compilation arguments | 
| CCmdProfiles | Command object for setting profiles | 
| CCgProgramFactory | Factory class for Cg programs | 
| CCodec | Abstract class that defines a 'codec' | 
| CColourBlendState | Describes the global blending factors for combining subsequent renders with the existing frame contents | 
| ►CColourFaderAffector | This affector modifies the colour of particles in flight | 
| 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 | |
| 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) | 
| ►CColourImageAffector | |
| CCmdImageAdjust | Command object for red adjust (see ParamCommand) | 
| ►CColourInterpolatorAffector | |
| CCmdColourAdjust | Command object for red adjust (see ParamCommand) | 
| CCmdTimeAdjust | Command object for red adjust (see ParamCommand) | 
| CColourValue | Class representing colour | 
| ►CCompositionPass | Object representing one pass or operation in a composition sequence | 
| CInputTex | Inputs (for material used for rendering the quad) | 
| CCompositionTargetPass | Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework | 
| ►CCompositionTechnique | Base composition technique, can be subclassed in plugins | 
| CTextureDefinition | Local texture definition | 
| CCompositor | Class representing a Compositor object | 
| CCompositorChain | Chain of compositor effects applying to one viewport | 
| ►CCompositorInstance | An instance of a Compositor object for one Viewport | 
| CListener | Provides an interface to "listen in" to to render system operations executed by this CompositorInstance | 
| CRenderSystemOperation | Specific render system operation | 
| CTargetOperation | Operation setup for a RenderTarget (collected) | 
| CCompositorLogic | Interface for compositor logics, which can be automatically binded to compositors, allowing per-compositor logic (such as attaching a relevant listener) to happen automatically | 
| CCompositorManager | Class for managing Compositor settings for Ogre | 
| CConcreteNode | |
| CConfigDialog | Defines the behaviour of an automatic renderer configuration dialog | 
| CConfigFile | Class for quickly loading settings from a text file | 
| CConfigOption | Packages the details of a configuration option | 
| 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 | 
| CCreateCompositorScriptCompilerEvent | |
| CCreateGpuProgramScriptCompilerEvent | |
| CCreateGpuSharedParametersScriptCompilerEvent | |
| CCreateMaterialScriptCompilerEvent | |
| CCreateParticleSystemScriptCompilerEvent | |
| CCustomCompositionPass | Interface for custom composition passes, allowing custom operations (in addition to the quad, scene and clear operations) in composition passes | 
| CCylinderEmitter | This emitter emits particles in a random direction from within a cylinder area, where the cylinder is oriented along the Z-axis | 
| CD3D11RenderSystem | Implementation of DirectX11 as a rendering system | 
| CD3D9RenderSystem | Implementation of DirectX9 as a rendering system | 
| CD3D9ResourceManager | |
| CDataStream | General purpose class used for encapsulating the reading and writing of data | 
| CDebugDrawer | Interface for visualising debugging the SceneManager state | 
| CDefaultAxisAlignedBoxSceneQuery | Default implementation of AxisAlignedBoxSceneQuery | 
| CDefaultDebugDrawer | |
| CDefaultHardwareBuffer | Specialisation of HardwareBuffer for emulation | 
| CDefaultHardwareBufferManager | DefaultHardwareBufferManager as a Singleton | 
| CDefaultHardwareBufferManagerBase | Specialisation of HardwareBufferManagerBase to emulate hardware buffers | 
| CDefaultIntersectionSceneQuery | Default implementation of IntersectionSceneQuery | 
| CDefaultPlaneBoundedVolumeListSceneQuery | Default implementation of PlaneBoundedVolumeListSceneQuery | 
| CDefaultRaySceneQuery | Default implementation of RaySceneQuery | 
| CDefaultShadowCameraSetup | Implements default shadow camera setup | 
| CDefaultSphereSceneQuery | Default implementation of SphereSceneQuery | 
| CDefaultTextureManager | Specialisation of TextureManager for offline processing. Cannot be used with an active RenderSystem | 
| CDefaultWorkQueue | Implementation of a general purpose request / response style background work queue | 
| CDefaultWorkQueueBase | Base for a general purpose task-based background work queue | 
| CDefaultZone | |
| CDefaultZoneFactory | |
| CDeflateStream | Stream which compresses / uncompresses data using the 'deflate' compression algorithm | 
| ►CDeflectorPlaneAffector | This affector defines a plane which deflects particles which collide with it | 
| CCmdBounce | Command object for bounce (see ParamCommand) | 
| CCmdPlaneNormal | Command object for plane normal (see ParamCommand) | 
| CCmdPlanePoint | Command object for plane point (see ParamCommand) | 
| CDegree | Wrapper class which indicates a given angle value is in Degrees | 
| CDepthBuffer | An abstract class that contains a depth/stencil buffer | 
| Cdeque | |
| ►CDirectionRandomiserAffector | This affector 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) | 
| 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 | 
| CDotSceneLoader | |
| CDotScenePlugin | |
| 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 | 
| ►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 | 
| CEllipsoidEmitter | Particle emitter which emits particles randomly from points inside an ellipsoid | 
| CEmbeddedZipArchiveFactory | Specialisation of ZipArchiveFactory for embedded Zip files | 
| CEntity | Defines an instance of a discrete, movable object based on a Mesh | 
| CEntityMaterialLodChangedEvent | Struct containing information about a material LOD change event for entities | 
| CEntityMeshLodChangedEvent | Struct containing information about a mesh LOD change event for entities | 
| 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 | |
| CExternalTextureSource | IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from | 
| CExternalTextureSourceManager | Singleton Class which handles the registering and control of texture plugins | 
| CFactoryObj | Abstract factory class | 
| 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 | 
| CFileSystemArchiveFactory | Specialisation of the ArchiveFactory to allow reading of files from filesystem folders / directories | 
| CFileSystemLayer | Provides methods to find out where the Ogre config files are stored and where logs and settings files should be written to | 
| 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 | 
| CFontManager | Manages Font resources, parsing .fontdef files and generally organising them | 
| 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 | 
| CFrameTimeControllerValue | Predefined controller value for getting the latest frame time | 
| CFreeImageCodec | |
| 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 | 
| CGL3PlusRenderSystem | Implementation of GL 3 as a rendering system | 
| CGLES2RenderSystem | Implementation of GL ES 2.x as a rendering system | 
| CGLRenderSystem | Implementation of GL as a rendering system | 
| CGLSLangPlugin | Plugin instance for Cg Program Manager | 
| CGLSLangProgram | Specialisation of HighLevelGpuProgram to provide support for the GLSLang compiler by Khronos | 
| CGLSLangProgramFactory | Factory class for GLSLang programs | 
| CGlyphInfo | Information about the position and size of a glyph in a texture | 
| 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 | 
| CGpuProgramFactory | Interface definition for factories of GpuProgram | 
| CGpuProgramManager | This ResourceManager manages GPU shader programs | 
| ►CGpuProgramParameters | Collects together the program parameters used for a GpuProgram | 
| CAutoConstantDefinition | Structure defining an auto constant that's available for use in a parameters object | 
| CAutoConstantEntry | Structure recording the use of an automatic parameter | 
| CGpuProgramUsage | This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit | 
| CGpuSharedParameters | A group of manually updated parameters that are shared between many parameter sets | 
| CGpuSharedParametersUsage | This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters | 
| CGrid2DPageStrategy | Page strategy which loads new pages based on a regular 2D grid | 
| CGrid2DPageStrategyData | Specialisation of PageStrategyData for Grid2DPageStrategy | 
| CGrid3DPageStrategy | Page strategy which loads new pages based on a regular 3D grid | 
| CGrid3DPageStrategyData | Specialisation of PageStrategyData for Grid3DPageStrategy | 
| 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 | 
| CHardwareOcclusionQuery | Query how many pixels have passed the per-fragment tests | 
| CHardwarePixelBuffer | Specialisation of HardwareBuffer for a pixel buffer | 
| CHardwareVertexBuffer | Specialisation of HardwareBuffer for a vertex buffer | 
| CHighLevelGpuProgram | Abstract base class representing a high-level program (a vertex or fragment program) | 
| ►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) | 
| CIlluminationPass | Struct recording a pass which can be used for a specific illumination stage | 
| CImage | Class representing an image file | 
| CImageCodec | Codec specialized in images | 
| CImGuiOverlay | Ogre's integrated support for Dear ImGui | 
| CImportAbstractNode | This abstract node represents an import statement | 
| CIndexData | Summary class collecting together index data source information | 
| CInstanceBatch | InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived to implement different instancing techniques (InstanceManager::InstancingTechnique) OGRE wasn't truly thought for instancing | 
| CInstanceBatchHW | This is technique requires true instancing hardware support | 
| CInstanceBatchHW_VTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instancing | 
| CInstanceBatchShader | This is the same technique the old InstancedGeometry implementation used (with improvements) | 
| CInstanceBatchVTF | |
| CInstancedEntity | |
| CInstanceManager | This is the main starting point for the new instancing system | 
| 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 | |
| CIShader | |
| 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 > | |
| CItemIdentityException | |
| CIteratorWrapper | Basefunctionality for IteratorWrappers | 
| CKeyFrame | A key frame in an animation sequence defined by an AnimationTrack | 
| CLayerBlendModeEx | Class which manages blending of both colour and alpha components | 
| CLight | Representation of a dynamic light source in the scene | 
| CLinearControllerFunction | Predefined controller function based on linear function interpolation | 
| ►CLinearForceAffector | This affector applies a force vector to all particles to modify their trajectory | 
| CCmdForceApp | Command object for force application (see ParamCommand) | 
| CCmdForceVector | Command object for force vector (see ParamCommand) | 
| CLinkedSkeletonAnimationSource | Link to another skeleton to share animations | 
| CLiSPSMShadowCameraSetup | Implements the Light Space Perspective Shadow Mapping Algorithm [WSP04] | 
| Clist | |
| ►CLod0Stripifier | |
| CRemapInfo | |
| CLodCollapseCost | |
| CLodCollapseCostCurvature | |
| CLodCollapseCostOutside | |
| CLodCollapseCostProfiler | |
| CLodCollapseCostQuadric | |
| CLodCollapser | |
| ►CLodConfig | |
| CAdvanced | |
| CLodConfigSerializer | |
| ►CLodData | |
| CEdge | |
| CIndexBufferInfo | |
| CIndexBufferPointer | |
| CLine | |
| CTriangle | |
| CVertex | |
| CVertexEqual | Equality function for UniqueVertexSet | 
| CVertexHash | Hash function for UniqueVertexSet | 
| CLodInputProvider | |
| CLodLevel | Structure for automatic Lod configuration | 
| CLodListener | A interface class defining a listener which can be used to receive notifications of LOD events | 
| CLodOutputProvider | |
| 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 | 
| CLodWorkQueueInjectorListener | |
| ►CLog | Log class for writing debug/log data to files | 
| ►CStream | Stream object which targets a log | 
| CFlush | Simple type to indicate a flush of the stream to the log | 
| CLogListener | |
| CLogManager | The log manager handles the creation and retrieval of logs for the application | 
| ►CManualObject | Class providing a much simplified interface to generating manual objects with custom geometry | 
| CManualObjectSection | Built, renderable section of geometry | 
| CManualResourceLoader | Interface describing a manual resource loader | 
| Cmap | |
| CMapIterator | Concrete IteratorWrapper for nonconst access to the underlying key-value container | 
| CMapIteratorWrapper | Prepared IteratorWrapper for key-value container | 
| CMaterial | Class encapsulates rendering properties of an object | 
| ►CMaterialManager | Class for managing Material settings for Ogre | 
| CListener | Listener on any general material events | 
| ►CMaterialSerializer | Class for serializing Materials to a .material script | 
| CListener | Class that allows listening in on the various stages of material serialization process | 
| ►CMath | Class to provide access to common mathematical functions | 
| CRandomValueProvider | This class is used to provide an external random value provider | 
| CMatrix3 | A 3x3 matrix which can represent rotations around axes | 
| CMatrix4 | Transform specialization for projective - encapsulating a 4x4 Matrix | 
| CMemoryDataStream | Common subclass of DataStream for handling data from chunks of memory | 
| CMesh | Resource holding data about 3D mesh | 
| CMeshLodGenerator | |
| 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 | 
| CMeshSerializerListener | This class allows users to hook into the mesh loading process and modify references within the mesh as they are loading | 
| CMetalRenderSystem | |
| ►CMovableObject | Abstract class defining a movable object in a scene | 
| CListener | Listener which gets called back on MovableObject events | 
| CMovableObjectFactory | Interface definition for a factory class which produces a certain kind of MovableObject, and can be registered with Root in order to allow all clients to produce new instances of this object, integrated with the standard Ogre processing | 
| CMovableObjectLodChangedEvent | Struct containing information about a LOD change event for movable objects | 
| CMovablePlane | Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply | 
| Cmultimap | |
| CMultiRenderTarget | This class represents a render target that renders to multiple RenderTextures at once | 
| CNameGenerator | Utility class to generate a sequentially numbered series of names | 
| ►CNode | Class representing a general-purpose node an articulated scene graph | 
| CListener | Listener which gets called back on Node events | 
| 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 | 
| CObjectAbstractNode | This specific abstract node represents a script object | 
| COctree | Octree datastructure for managing scene nodes | 
| COctreeAxisAlignedBoxSceneQuery | Octree implementation of AxisAlignedBoxSceneQuery | 
| COctreeCamera | Specialized viewpoint from which an Octree can be rendered | 
| COctreeIntersectionSceneQuery | Octree implementation of IntersectionSceneQuery | 
| COctreeNode | Specialized SceneNode that is customized for working within an Octree | 
| COctreePlaneBoundedVolumeListSceneQuery | Octree implementation of PlaneBoundedVolumeListSceneQuery | 
| COctreePlugin | Plugin instance for Octree Manager | 
| COctreeRaySceneQuery | Octree implementation of RaySceneQuery | 
| COctreeSceneManager | Specialized SceneManager that divides the geometry into an octree in order to facilitate spatial queries | 
| COctreeSceneManagerFactory | Factory for OctreeSceneManager | 
| COctreeSphereSceneQuery | Octree implementation of SphereSceneQuery | 
| COctreeZone | |
| COctreeZoneData | |
| COctreeZoneFactory | Factory for OctreeZone | 
| COctreeZonePlugin | Plugin instance for OctreeZone | 
| COptimisedUtil | Utility class for provides optimised functions | 
| 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 | 
| 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 | 
| CPanelOverlayElement | OverlayElement representing a flat, single-material (or transparent) panel which can contain other elements | 
| CParamDictionary | Class to hold a dictionary of parameters for a single class | 
| CParameterDef | |
| CParticle | Class representing a single particle instance | 
| CParticleAffector | Abstract class defining the interface to be implemented by particle affectors | 
| CParticleAffectorFactory | Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses | 
| CParticleEmitter | Abstract class defining the interface to be implemented by particle emitters | 
| CParticleEmitterFactory | Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses | 
| CParticleFXPlugin | Plugin instance for ParticleFX Manager | 
| CParticleSystem | Class defining particle system based special effects | 
| CParticleSystemManager | Manages particle systems, particle system scripts (templates) and the available emitter & affector factories | 
| CParticleSystemRenderer | Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances | 
| ►CPass | Class defining a single pass of a Technique (of a Material): a single rendering call | 
| CHashFunc | Definition of a functor for calculating the hashcode of a Pass | 
| CPassthroughControllerFunction | Predefined controller function which just passes through the original source directly to dest | 
| CPatchMesh | Patch specialisation of Mesh | 
| CPatchSurface | A surface which is defined by curves of some kind to form a patch, e.g | 
| CPCPlane | Portal Culling Plane | 
| CPCZAxisAlignedBoxSceneQuery | PCZ implementation of AxisAlignedBoxSceneQuery | 
| CPCZCamera | Specialized viewpoint from which an PCZone Scene can be rendered | 
| CPCZFrustum | Specialized frustum shaped culling volume that has culling planes created from portals | 
| CPCZIntersectionSceneQuery | PCZ implementation of IntersectionSceneQuery | 
| CPCZLight | Specialized version of Ogre::Light which caches which zones the light affects | 
| CPCZLightFactory | Factory object for creating PCZLight instances | 
| CPCZone | Portal-Connected Zone datastructure for managing scene nodes | 
| CPCZoneFactory | Factory for PCZones | 
| CPCZoneFactoryManager | |
| CPCZPlaneBoundedVolumeListSceneQuery | PCZ implementation of PlaneBoundedVolumeListSceneQuery | 
| CPCZPlugin | Plugin instance for PCZ Manager | 
| CPCZRaySceneQuery | PCZ implementation of RaySceneQuery | 
| CPCZSceneManager | Specialized SceneManager that uses Portal-Connected-Zones to divide the scene spatially | 
| CPCZSceneManagerFactory | Factory for PCZSceneManager | 
| CPCZSceneNode | The PCZSceneNode is an extension used to store zone information and provide additional functionality for a given Ogre::SceneNode | 
| CPCZSphereSceneQuery | PCZ implementation of SphereSceneQuery | 
| CPixelBox | A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory | 
| CPixelCountLodStrategyBase | Abstract base class for level of detail strategy based on pixel count approximations from bounding sphere projection | 
| CPixelUtil | Some utility functions for packing and unpacking pixel data | 
| 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 | This emitter emits particles from a single point, which is it’s position | 
| CPolygon | The class represents a polygon in 3D space | 
| CPool | Template class describing a simple pool of items | 
| CPortal | Portal datastructure for connecting zones | 
| CPortalBase | PortalBase - Base class to Portal and AntiPortal classes | 
| CPortalBaseFactory | Factory object for creating Portal instances | 
| CPortalFactory | Factory object for creating Portal instances | 
| CPose | A pose is a linked set of vertex offsets applying to one set of vertex data | 
| 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 | 
| CPSSMShadowCameraSetup | Parallel Split Shadow Map (PSSM) shadow camera setup | 
| CQuake3Level | Support for loading and extracting data from a Quake3 level file | 
| ►CQuake3Shader | Class for recording Quake3 shaders | 
| CPass | |
| CQuake3ShaderManager | Class for managing Quake3 custom shaders | 
| CQuaternion | Implementation of a Quaternion, i.e | 
| CQueuedRenderableCollection | Lowest level collection of renderables | 
| CQueuedRenderableVisitor | Visitor interface for items in a QueuedRenderableCollection | 
| CRadian | Wrapper class which indicates a given angle value is in Radians | 
| 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 | 
| 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 specific render queue and depth settings, like RENDER_QUEUE_BACKGROUND and 'depth_write off' for backdrops, and RENDER_QUEUE_OVERLAY and 'depth_check off' for fullscreen quads | 
| CRegionSceneQuery | Abstract class defining a query which returns single results from a region | 
| ►CRenderable | Abstract class defining the interface all renderable objects must implement | 
| CVisitor | Visitor object that can be used to iterate over a collection of Renderable instances abstractly | 
| CRenderablePass | Struct associating a single Pass with a single Renderable | 
| CRenderingAPIException | |
| CRenderObjectListener | Abstract interface which classes must implement if they wish to receive events from the scene manager when single object is about to be rendered | 
| CRenderOperation | 'New' rendering operation using vertex buffers | 
| CRenderPriorityGroup | Collection of renderables by priority | 
| ►CRenderQueue | Class to manage the scene object rendering queue | 
| CRenderableListener | Class to listen in on items being added to the render queue | 
| CRenderQueueGroup | A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same time to the renderer | 
| 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 | 
| CRenderSystemCapabilities | This class stores the capabilities of the graphics card | 
| CRenderSystemCapabilitiesManager | Class for managing RenderSystemCapabilities database for Ogre | 
| CRenderSystemCapabilitiesSerializer | Class for serializing RenderSystemCapabilities to / from a .rendercaps script | 
| ►CRenderTarget | A 'canvas' which can receive the results of a rendering operation | 
| CFrameStats | |
| CRenderTargetEvent | Struct containing information about a RenderTarget event | 
| CRenderTargetListener | A interface class defining a listener which can be used to receive notifications of RenderTarget events | 
| CRenderTargetViewportEvent | Struct containing information about a RenderTarget Viewport-specific event | 
| CRenderTexture | This class represents a RenderTarget that renders to a Texture | 
| CRenderToVertexBuffer | An object which renders geometry to a vertex | 
| CRenderWindow | Manages the target rendering window | 
| CRenderWindowDescription | Render window creation parameters | 
| ►CResource | Abstract class representing a loadable resource | 
| CListener | |
| CResourceBackgroundQueue | This class is used to perform Resource operations in a background thread | 
| CResourceGroupListener | This 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 | This class allows users to override resource loading behavior | 
| ►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 | 
| CRibbonTrail | Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances | 
| ►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) | 
| CRoot | The root class of the Ogre system | 
| ►CRotationAffector | This affector rotates particles in flight | 
| 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 | 
| CRotationalSpline | This class interpolates orientations (rotations) along a spline using derivatives of quaternions | 
| CRsImageCodec | |
| CRuntimeAssertionException | |
| ►CSampler | Class which determines how a TextureUnitState accesses data from a Texture | 
| CUVWAddressingMode | Texture addressing mode for each texture coordinate | 
| ►CScaleAffector | This affector scales particles in flight | 
| CCmdScaleAdjust | Command object for scale adjust (see ParamCommand) | 
| CScaleControllerFunction | Predefined controller function which simply scales an input to an output value | 
| ►CSceneManager | Manages the organisation and rendering of a 'scene': a collection of objects and potentially world geometry | 
| CListener | Class that allows listening in on the various stages of SceneManager processing, so that custom behaviour can be implemented from outside | 
| CRenderContext | |
| CSceneMgrQueuedRenderableVisitor | Inner helper class to implement the visitor pattern for rendering objects in a queue | 
| CSkyBoxGenParameters | |
| CSkyDomeGenParameters | |
| CSkyPlaneGenParameters | |
| CSceneManagerFactory | Class which will create instances of a given SceneManager | 
| CSceneNode | Class representing a node in the scene graph | 
| CSceneQuery | A class for performing queries on a scene | 
| CSceneQueryListener | This optional class allows you to receive per-result callbacks from SceneQuery executions instead of a single set of consolidated results | 
| CSceneQueryResult | Holds the results of a scene query | 
| CScreenRatioPixelCountLodStrategy | |
| CScriptCompiler | This is the main class for the compiler | 
| 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 | 
| CScriptLoader | Abstract class defining the interface used by classes which wish to perform script loading to define instances of whatever they manage | 
| CScriptTranslator | This class translates script AST (abstract syntax tree) into Ogre resources | 
| CScriptTranslatorManager | The ScriptTranslatorManager manages the lifetime and access to script translators | 
| CSegment | 3D Line Segment class for intersection testing in Ogre3D | 
| CSerializer | Generic class for serialising data to / from binary stream-based files | 
| Cset | |
| CShadowCameraSetup | This class allows you to plug in new ways to define the camera setup when rendering and projecting shadow textures | 
| CShadowCaster | This class defines the interface that must be implemented by shadow casters | 
| CShadowRenderable | Class which represents the renderable aspects of a set of shadow volume faces | 
| CShadowTextureConfig | Structure containing the configuration for one shadow texture | 
| CShadowTextureListener | |
| CSharedPtr | |
| CSimplePageContentCollection | Specialisation of PageContentCollection which just provides a simple list of PageContent instances | 
| CSimplePageContentCollectionFactory | Factory class for SimplePageContentCollection | 
| CSimpleParamCommand | Generic ParamCommand implementation stores pointers to the class getter and setter functions | 
| CSimpleParamCommand< _Class, const String &, getter, setter > | Specialization for strings | 
| CSimpleRenderable | Simple implementation of MovableObject and Renderable for single-part custom objects | 
| CSimpleSpline | A very simple spline class which implements the Catmull-Rom class of splines | 
| CSingleton | Template class for creating single-instance global classes | 
| CSkeleton | A collection of Bone objects used to animate a skinned mesh | 
| CSkeletonInstance | A SkeletonInstance is a single instance of a Skeleton used by a world object | 
| CSkeletonManager | Handles the management of skeleton resources | 
| CSkeletonSerializer | Class for serialising skeleton data to/from an OGRE .skeleton file | 
| 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 | |
| CSPFMNone | |
| CSphere | A sphere primitive, mostly used for bounds checking | 
| CSphereSceneQuery | Specialises the SceneQuery class for querying within a sphere | 
| CStaticCache | Template version of cache based on static array | 
| CStaticFaceGroup | Collects a group of static i.e | 
| ►CStaticGeometry | Pre-transforms and batches up meshes for efficient use as static geometry in a scene | 
| CGeometryBucket | A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored | 
| CLODBucket | A LODBucket is a collection of smaller buckets with the same LOD | 
| CMaterialBucket | A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same LOD) | 
| COptimisedSubMeshGeometry | Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances | 
| CQueuedGeometry | Structure recording a queued geometry for low level builds | 
| CQueuedSubMesh | Structure recording a queued submesh for the build | 
| CRegion | The details of a topological region which is the highest level of partitioning for this class | 
| CSubMeshLodGeometryLink | Saved link between SubMesh at a LOD and vertex/index data May point to original or optimised geometry | 
| CSTBIImageCodec | |
| CStencilState | Describes the stencil buffer operation | 
| ►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 | 
| 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 | 
| ►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 | 
| ►CTerrain | The main containing class for a chunk of terrain | 
| CDefaultGpuBufferAllocator | Standard implementation of a buffer allocator which re-uses buffers | 
| CGpuBufferAllocator | Interface used to by the Terrain instance to allocate GPU buffers | 
| CImportData | Structure encapsulating import data that you may use to bootstrap the terrain without loading from a native data stream | 
| CLayerInstance | An instance of a layer, with specific texture names | 
| CTerrainAutoUpdateLod | Terrain automatic LOD loading | 
| CTerrainAutoUpdateLodByDistance | Class implementing TerrainAutoUpdateLod interface | 
| CTerrainAutoUpdateLodFactory | |
| CTerrainGlobalOptions | Options class which just stores default options for the terrain | 
| ►CTerrainGroup | Helper class to assist you in managing multiple terrain instances that are connected to each other | 
| CRayResult | Result from a terrain ray intersection with the terrain group | 
| CTerrainSlot | Slot for a terrain instance, together with its definition | 
| CTerrainSlotDefinition | Definition of how to populate a 'slot' in the terrain group | 
| CTerrainLayerBlendMap | Class exposing an interface to a blend map for a given layer | 
| CTerrainLayerSampler | Description of a sampler that will be used with each layer | 
| ►CTerrainLodManager | Terrain LOD data manager | 
| CLoadLodRequest | |
| CLodInfo | |
| ►CTerrainMaterialGenerator | Class that provides functionality to generate materials for use with a terrain | 
| CProfile | |
| ►CTerrainMaterialGeneratorA | A TerrainMaterialGenerator which can cope with normal mapped, specular mapped terrain | 
| CSM2Profile | Shader model 2 profile target | 
| ►CTerrainPagedWorldSection | A world section which includes paged terrain | 
| CTerrainDefiner | |
| CTerrainPaging | This class is the 'core' class for paging terrain, that will integrate with the larger paging system and provide the appropriate utility classes required | 
| ►CTerrainQuadTreeNode | A node in a quad tree used to store a patch of terrain | 
| CLodLevel | |
| CTexCoordModifierControllerValue | Predefined controller value for getting / setting a texture coordinate modifications (scales and translates) | 
| CTextAreaOverlayElement | This class implements an overlay element which contains simple unformatted text | 
| CTexture | Abstract class representing a Texture resource | 
| CTextureAnimatorAffector | This affector makes it possible to have an animated texture for each individual particle | 
| CTextureAnimatorAffectorFactory | Factory class for TextureAnimatorAffector | 
| CTextureFrameControllerValue | Predefined controller value for getting / setting the frame number of a texture layer | 
| CTextureManager | Class for loading & managing textures | 
| ►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 | 
| CTimeIndex | Time index object used to search keyframe at the given position | 
| CTimer | Timer class | 
| CTinyRenderSystem | Software rasterizer Implementation as a rendering system | 
| CTransformBase | Class encapsulating a standard 4x4 homogeneous matrix | 
| CTransformBaseReal | |
| CTransformKeyFrame | Specialised KeyFrame which stores a full transform | 
| CTRect | |
| CUnimplementedException | Template struct which creates a distinct type for each exception code | 
| CUserObjectBindings | Class that provides convenient interface to establish a linkage between custom user application objects and Ogre core classes | 
| CVariableAccessAbstractNode | This abstract node represents a variable assignment | 
| CVector | Standard N-dimensional vector | 
| Cvector | |
| CVectorBase | Helper class to implement legacy API. Notably x, y, z access | 
| CVectorBase< 2, Real > | |
| CVectorBase< 3, Real > | |
| CVectorBase< 4, Real > | |
| 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 | 
| CVertexAnimationTrack | Specialised AnimationTrack for dealing with changing vertex position information | 
| CVertexBoneAssignment | 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 | Collects together all the vertex-related information used to render geometry | 
| CHardwareAnimationData | Struct used to hold hardware morph / pose vertex data information | 
| 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 | 
| CViewPoint | Structure for holding a position & orientation pair | 
| ►CViewport | An abstraction of a viewport, i.e., a rendering region on a render target | 
| CListener | Listener interface so you can be notified of Viewport changes | 
| CVisibleObjectsBoundsInfo | Structure collecting together information about the visible objects that have been discovered in a scene | 
| CVulkanRenderSystem | |
| CWaveformControllerFunction | Predefined controller function based on a waveform | 
| CWireBoundingBox | Allows the rendering of a wireframe bounding box | 
| ►CWorkQueue | Interface to a general purpose task-basedbackground work queue | 
| CRequest | General purpose request structure | 
| CResponse | General purpose response structure | 
| CWorldFragment | Represents part of the world geometry that is a result of a SceneQuery | 
| CZipArchiveFactory | Specialisation to allow reading of files from a zip format source archive | 
| CZoneData | |
| ►NOgreBites | |
| CAdvancedRenderControls | |
| CApplicationContextBase | Base class responsible for setting up a common context for applications | 
| CApplicationContextQt | Specialization for connecting with Qt | 
| CAxisEvent | |
| CButton | Basic button class | 
| CButtonEvent | |
| CCameraMan | Utility class for controlling the camera in samples | 
| CCheckBox | Basic check box widget | 
| CDecorWidget | Custom, decorative widget created from a template | 
| CEvent | |
| CImGuiInputListener | |
| CInputListener | Return values of the callbacks are ignored by ApplicationContext however they can be used to control event propagation in a hierarchy | 
| CInputListenerChain | Chain of multiple InputListeners that acts as a single InputListener | 
| CKeyboardEvent | |
| CKeysym | |
| CLabel | Basic label widget | 
| CMouseButtonEvent | |
| CMouseMotionEvent | |
| CMouseWheelEvent | |
| CNativeWindowPair | Link between a renderwindow and a platform specific window | 
| CParamsPanel | Basic parameters panel widget | 
| CProgressBar | Basic progress bar widget | 
| CSelectMenu | Basic selection menu widget | 
| CSeparator | Basic separator widget | 
| CSGTechniqueResolverListener | Default implementation of a Listener to use with the Ogre::RTShader system | 
| CSlider | Basic slider widget | 
| CStaticPluginLoader | Utility class for loading the plugins statically | 
| CTextBox | Scrollable text box widget | 
| CTextInputEvent | |
| CTouchFingerEvent | |
| CTrayListener | Listener class for responding to tray events | 
| CTrayManager | Main class to manage a cursor, backdrop, trays and widgets | 
| CWidget | Abstract base class for all widgets | 
| CWindowEventListener | Callback class used to send out window events to client app | 
| CWindowEventUtilities | Utility class to handle Window Messages | 
| CaiMatrix4x4t | |
| Cbsp_brush_t | |
| Cbsp_brushside_t | |
| Cbsp_face_t | |
| Cbsp_header_t | |
| Cbsp_leaf_t | |
| Cbsp_lump_entry_t | |
| Cbsp_model_t | |
| Cbsp_node_t | |
| Cbsp_plane_t | |
| Cbsp_shader_t | |
| Cbsp_vertex_t | |
| Cbsp_vis_t |