 |
OGRE
1.12.10
Object-Oriented Graphics Rendering Engine
|
|
OGRE
1.12.10
Object-Oriented Graphics Rendering Engine
|
| NAssimp | |
| ►NOgre | |
| ►NGLSL | |
| CGLSLLinkProgram | C++ encapsulation of GLSL Program Object |
| CGLSLLinkProgramManager | |
| CGLSLProgram | |
| CGLSLProgramFactory | Factory class for GLSL programs |
| NGLSLES | |
| ►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 |
| ►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;" |
| CCGProgramProcessor | CG Language program processor class |
| CCGProgramWriter | CG target language writer implementation |
| CConstParameter | Helper template which is the base for our ConstParameters |
| CDualQuaternionSkinning | Implement a sub render state which performs dual quaternion hardware skinning |
| CFFPAlphaTest | A factory that enables creation of LayeredBlending instances |
| CFFPAlphaTestFactory | |
| CFFPColour | Colour sub render state implementation of the Fixed Function Pipeline |
| CFFPColourFactory | A factory that enables creation of FFPColour instances |
| CFFPFog | Fog sub render state implementation of the Fixed Function Pipeline |
| CFFPFogFactory | A factory that enables creation of FFPFog instances |
| CFFPLighting | Lighting sub render state implementation of the Fixed Function Pipeline |
| CFFPLightingFactory | A factory that enables creation of FFPLighting instances |
| CFFPRenderStateBuilder | Fixed Function Pipeline render state builder |
| CFFPTexturing | Texturing sub render state implementation of the Fixed Function Pipeline |
| CFFPTexturingFactory | A factory that enables creation of FFPTexturing instances |
| CFFPTransform | Transform sub render state implementation of the Fixed Function Pipeline |
| CFFPTransformFactory | A factory that enables creation of FFPTransform instances |
| CFunction | A class that represents a shader based program function |
| CFunctionAtom | A class that represents an atomic code section of shader based program function |
| ►CFunctionInvocation | A class that represents function invocation code from shader based program function |
| CFunctionInvocationCompare | Comparator function to be used for comparisons |
| CFunctionInvocationLessThan | Comparator function to be used for sorting |
| CFunctionStageRef | FFPShaderStage, part of a Function |
| CGBuffer | Transform sub render state implementation of writing to GBuffers |
| CGBufferFactory | A factory that enables creation of GBuffer instances |
| CGLSLESProgramProcessor | GLSL ES Language program processor class |
| CGLSLESProgramWriter | GLSL ES target language writer implementation |
| CGLSLProgramProcessor | GLSL Language program processor class |
| CGLSLProgramWriter | GLSL target language writer implementation |
| ►CHardwareSkinning | Implement a sub render state which performs hardware skinning |
| CSkinningData | |
| CHardwareSkinningFactory | A factory that enables creation of HardwareSkinning instances |
| CHardwareSkinningTechnique | Implement a sub render state which performs hardware skinning |
| CHLSLProgramProcessor | CG Language program processor class |
| CHLSLProgramWriter | HLSL target language writer implementation |
| CIn | |
| CInOut | |
| CIntegratedPSSM3 | Integrated PSSM shadow receiver with 3 splits sub render state implementation |
| CIntegratedPSSM3Factory | A factory that enables creation of IntegratedPSSM3 instances |
| ►CLayeredBlending | Texturing sub render state implementation of layered blending |
| CTextureBlend | |
| CLayeredBlendingFactory | A factory that enables creation of LayeredBlending instances |
| CLinearSkinning | Implement a sub render state which performs hardware skinning |
| CNormalMapLighting | Normal Map Lighting extension sub render state implementation |
| CNormalMapLightingFactory | A factory that enables creation of NormalMapLighting instances |
| COperand | A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields) |
| COut | |
| CParameter | A class that represents a shader based program parameter |
| CParameterFactory | Helper utility class that creates common parameters |
| CPerPixelLighting | Per pixel Lighting extension sub render state implementation |
| CPerPixelLightingFactory | A factory that enables creation of PerPixelLighting instances |
| CProgram | A class that represents a shader based program |
| CProgramManager | A singleton manager class that manages shader based programs |
| CProgramProcessor | A class that provides extra processing services on CPU based programs |
| CProgramSet | Container class for shader based programs |
| CProgramWriter | Base class interface for shader program writers |
| CProgramWriterFactory | Interface definition for factories of ShaderProgramWriter |
| CProgramWriterManager | |
| CRenderState | This is a container class for sub render state class |
| CSampleTextureAtom | Shorthand for "dst = texture(sampler, uv);" instead of using FFP_SampleTexture |
| CSGMaterialSerializerListener | This class responsible for translating core features of the RT Shader System for Ogre material scripts |
| CSGScriptTranslator | This class responsible for translating core features of the RT Shader System for Ogre material scripts |
| CShaderGenerator | Shader generator system main interface |
| CShaderProgramWriterCGFactory | CG program writer factory implementation |
| CShaderProgramWriterGLSLESFactory | GLSL ES program writer factory implementation |
| CShaderProgramWriterGLSLFactory | GLSL program writer factory implementation |
| CShaderProgramWriterHLSLFactory | HLSL program writer factory implementation |
| CSubRenderState | This class is the base interface of sub part from a shader based rendering pipeline |
| CSubRenderStateAccessor | This class uses as accessor from a template SubRenderState to all of its instances that created based on it |
| CSubRenderStateFactory | Abstract factory interface for creating SubRenderState implementation instances |
| CTargetRenderState | This is the target render state |
| CTextureAtlasRecord | |
| CTextureAtlasSampler | Implements texture atlas sampling |
| ►CTextureAtlasSamplerFactory | A factory that enables creation of TextureAtlasSampler instances |
| CTextureAtlasAttib | |
| CTriplanarTexturing | Triplanar Texturing |
| CTriplanarTexturingFactory | A factory that enables creation of TriplanarMapping instances |
| CUniformParameter | Uniform parameter class |
| ►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 |
| 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 |
| CAnyNumeric | Specialised Any class which has built in arithmetic operators, but can hold only types which support operator +,-,* and / |
| 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 | |
| CASTCCodec | Codec specialized in loading ASTC (ARM Adaptive Scalable Texture Compression) images |
| 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 |
| CBackgroundProcessResult | Encapsulates the result of a background queue request |
| CBaseInstanceBatchVTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) This implementation has the following advantages: Supports huge amount of instances per batch Supports skinning even with huge ammounts of instances per batch Doesn't need shader constants registers |
| CBillboard | A billboard is a primitive which always faces the camera in every frame |
| ►CBillboardChain | Allows the rendering of a chain of connected billboards |
| CElement | Contains the data of an element of the BillboardChain |
| CBillboardChainFactory | Factory object for creating BillboardChain instances |
| ►CBillboardParticleRenderer | Specialisation of ParticleSystemRenderer to render particles using a BillboardSet |
| CCmdAccurateFacing | Command object for accurate facing(see ParamCommand) |
| CCmdBillboardOrigin | Command object for billboard origin (see ParamCommand) |
| CCmdBillboardRotationType | Command object for billboard rotation type (see ParamCommand) |
| CCmdBillboardType | Command object for billboard type (see ParamCommand) |
| CCmdCommonDirection | Command object for common direction (see ParamCommand) |
| CCmdCommonUpVector | Command object for common up-vector (see ParamCommand) |
| CCmdPointRendering | Command object for point rendering (see ParamCommand) |
| CBillboardParticleRendererFactory | Factory class for BillboardParticleRenderer |
| CBillboardSet | A collection of billboards (faces which are always facing the given direction) with the same (default) dimensions, material and which are fairly close proximity to each other |
| CBillboardSetFactory | Factory object for creating BillboardSet instances |
| 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 |
| 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 |
| CBox | Structure used to define a box in a 3-D integer space |
| CBoxEmitter | Particle emitter which emits particles randomly from points inside a box |
| CBoxEmitterFactory | Factory class for particle emitter of type "Box" |
| CBspIntersectionSceneQuery | BSP specialisation of IntersectionSceneQuery |
| CBspLevel | Holds all the data associated with a Binary Space Parition (BSP) based indoor level |
| ►CBspNode | Encapsulates a node in a BSP tree |
| CBrush | |
| CBspRaySceneQuery | BSP specialisation of RaySceneQuery |
| CBspSceneLoader | Manages the locating and loading of BSP-based indoor levels |
| CBspSceneManager | Specialisation of the SceneManager class to deal with indoor scenes based on a BSP tree |
| CBspSceneManagerFactory | Factory for BspSceneManager |
| CBspSceneManagerPlugin | Plugin instance for BSPSceneManager |
| CBspSceneNode | Specialisation of SceneNode for the BspSceneManager |
| ►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 |
| CCmdEntryPoint | Command object for setting entry point |
| CCmdProfiles | Command object for setting profiles |
| CCgProgramFactory | Factory class for Cg programs |
| ►CCodec | Abstract class that defines a 'codec' |
| CCodecData | |
| CColourBlendState | Describes the global blending factors for combining subsequent renders with the existing frame contents |
| ►CColourFaderAffector | This plugin subclass of ParticleAffector allows you to alter the colour of particles |
| CCmdAlphaAdjust | Command object for alpha adjust (see ParamCommand) |
| CCmdBlueAdjust | Command object for blue adjust (see ParamCommand) |
| CCmdGreenAdjust | Command object for green adjust (see ParamCommand) |
| CCmdRedAdjust | Command object for red adjust (see ParamCommand) |
| ►CColourFaderAffector2 | This plugin subclass of ParticleAffector allows you to alter the colour of particles |
| CCmdAlphaAdjust1 | Command object for alpha adjust (see ParamCommand) |
| CCmdAlphaAdjust2 | Command object for alpha adjust (see ParamCommand) |
| CCmdBlueAdjust1 | Command object for blue adjust (see ParamCommand) |
| CCmdBlueAdjust2 | Command object for blue adjust (see ParamCommand) |
| CCmdGreenAdjust1 | Command object for green adjust (see ParamCommand) |
| CCmdGreenAdjust2 | Command object for green adjust (see ParamCommand) |
| CCmdRedAdjust1 | Command object for red adjust (see ParamCommand) |
| CCmdRedAdjust2 | Command object for red adjust (see ParamCommand) |
| CCmdStateChange | Command object for alpha adjust (see ParamCommand) |
| CColourFaderAffectorFactory | Factory class for ColourFaderAffector |
| CColourFaderAffectorFactory2 | Factory class for ColourFaderAffector |
| ►CColourImageAffector | |
| CCmdImageAdjust | Command object for red adjust (see ParamCommand) |
| CColourImageAffectorFactory | Factory class for ColourImageAffector |
| ►CColourInterpolatorAffector | |
| CCmdColourAdjust | Command object for red adjust (see ParamCommand) |
| CCmdTimeAdjust | Command object for red adjust (see ParamCommand) |
| CColourInterpolatorAffectorFactory | Factory class for ColourInterpolatorAffector |
| CColourValue | Class representing colour |
| ►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 |
| ►CComPtr | |
| CSafeBoolHelper | |
| 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 |
| CCPreprocessor | This is a simplistic C/C++-like preprocessor |
| CCreateCompositorScriptCompilerEvent | |
| CCreateGpuProgramScriptCompilerEvent | |
| CCreateGpuSharedParametersScriptCompilerEvent | |
| CCreateHighLevelGpuProgramScriptCompilerEvent | |
| CCreateMaterialScriptCompilerEvent | |
| CCreateParticleSystemScriptCompilerEvent | |
| CCustomCompositionPass | Interface for custom composition passes, allowing custom operations (in addition to the quad, scene and clear operations) in composition passes |
| CCylinderEmitter | Particle emitter which emits particles randomly from points inside a cylinder |
| CCylinderEmitterFactory | Factory class for particle emitter of type "Cylinder" |
| CD3D11DepthBuffer | |
| CD3D11Device | |
| CD3D11DeviceResource | Represents a Direct3D rendering resource |
| CD3D11DeviceResourceManager | Singleton that is used to propagate device state changed notifications |
| CD3D11Driver | |
| CD3D11DriverList | |
| CD3D11HardwareBuffer | Base implementation of a D3D11 buffer, dealing with all the common aspects |
| CD3D11HardwareBufferManager | Implementation of HardwareBufferManager for D3D11 |
| CD3D11HardwareIndexBuffer | |
| CD3D11HardwareOcclusionQuery | This is a class that is the DirectX9 implementation of hardware occlusion testing |
| CD3D11HardwarePixelBuffer | |
| CD3D11HardwareUniformBuffer | Specialisation of HardwareBuffer for D3D11 |
| CD3D11HardwareVertexBuffer | Specialisation of HardwareVertexBuffer for D3D11 |
| ►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 |
| CCmdTarget | Command object for setting target assembler |
| CD3D11HLSLProgramFactory | Factory class for D3D11 HLSL programs |
| CD3D11Mappings | |
| CD3D11MultiRenderTarget | |
| CD3D11Plugin | Plugin instance for D3D11 Manager |
| CD3D11RenderingAPIException | |
| CD3D11RenderSystem | Implementation of DirectX11 as a rendering system |
| CD3D11RenderTarget | |
| CD3D11RenderTexture | RenderTexture implementation for D3D11 |
| CD3D11RenderToVertexBuffer | An object which renders geometry to a vertex |
| CD3D11RenderWindowBase | |
| CD3D11RenderWindowSwapChainBased | |
| CD3D11Sampler | |
| 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 |
| CD3D11Texture | Specialisation of Texture for D3D11 |
| CD3D11TextureManager | |
| CD3D11VertexDeclaration | Specialisation of VertexDeclaration for D3D11 |
| CD3D11VideoMode | |
| CD3D11VideoModeList | |
| CD3D9DepthBuffer | |
| CD3D9Device | High level interface of Direct3D9 Device |
| CD3D9DeviceManager | Device manager interface |
| CD3D9Driver | |
| CD3D9DriverList | |
| CD3D9GpuFragmentProgram | Direct3D implementation of low-level fragment programs |
| ►CD3D9GpuProgram | Direct3D implementation of a few things common to low-level vertex & fragment programs |
| CCmdColumnMajorMatrices | Command object for setting matrix packing in column-major order |
| CCmdExternalMicrocode | Command object for getting/setting external micro code (void*) |
| CD3D9GpuProgramManager | |
| CD3D9GpuVertexProgram | Direct3D implementation of low-level vertex programs |
| CD3D9HardwareBufferManager | Implementation of HardwareBufferManager for D3D9 |
| CD3D9HardwareIndexBuffer | |
| CD3D9HardwareOcclusionQuery | This is a class that is the DirectX9 implementation of hardware occlusion testing |
| CD3D9HardwarePixelBuffer | |
| CD3D9HardwareVertexBuffer | Specialisation of HardwareVertexBuffer for D3D9 |
| ►CD3D9HLSLProgram | Specialisation of HighLevelGpuProgram to provide support for D3D9 High-Level Shader Language (HLSL) |
| CCmdAssemblerCode | Command object for getting/setting assembler code |
| CCmdBackwardsCompatibility | Command object for enabling backwards compatibility |
| CCmdColumnMajorMatrices | Command object for setting matrix packing in column-major order |
| CCmdEntryPoint | Command object for setting entry point |
| CCmdMicrocode | Command object for getting/setting micro code |
| CCmdOptimisation | Command object for setting optimisation level |
| CCmdTarget | Command object for setting target assembler |
| CD3D9HLSLProgramFactory | Factory class for D3D9 HLSL programs |
| CD3D9Mappings | |
| CD3D9MultiRenderTarget | |
| CD3D9Plugin | Plugin instance for D3D9 Manager |
| CD3D9RenderSystem | Implementation of DirectX9 as a rendering system |
| CD3D9RenderTexture | RenderTexture implementation for D3D9 |
| CD3D9RenderWindow | |
| CD3D9Resource | Represents a Direct3D rendering resource |
| CD3D9ResourceManager | |
| CD3D9StereoDriverAMD | Virtual interface of the stereo driver |
| CD3D9StereoDriverBridge | Bridge interface from the render system to the stereo driver |
| CD3D9StereoDriverImpl | Virtual interface of the stereo driver |
| CD3D9StereoDriverNVIDIA | Interface of the NVIDIA stereo driver |
| CD3D9Texture | |
| CD3D9TextureManager | |
| CD3D9VertexDeclaration | Specialisation of VertexDeclaration for D3D9 |
| CD3D9VideoMode | |
| CD3D9VideoModeList | |
| CDataStream | General purpose class used for encapsulating the reading and writing of data |
| CDDSCodec | Codec specialized in loading DDS (Direct Draw Surface) images |
| CDebugDrawer | Interface for visualising debugging the SceneManager state |
| CDefaultAxisAlignedBoxSceneQuery | Default implementation of AxisAlignedBoxSceneQuery |
| CDefaultDebugDrawer | |
| CDefaultHardwareBufferManager | DefaultHardwareBufferManager as a Singleton |
| CDefaultHardwareBufferManagerBase | Specialisation of HardwareBufferManagerBase to emulate hardware buffers |
| CDefaultHardwareIndexBuffer | Specialisation of HardwareIndexBuffer for emulation |
| CDefaultHardwareUniformBuffer | Specialisation of HardwareUniformBuffer for emulation |
| CDefaultHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for emulation |
| CDefaultIntersectionSceneQuery | Default implementation of IntersectionSceneQuery |
| CDefaultPlaneBoundedVolumeListSceneQuery | Default implementation of PlaneBoundedVolumeListSceneQuery |
| CDefaultProperties | |
| CDefaultRaySceneQuery | Default implementation of RaySceneQuery |
| CDefaultSceneManager | Default scene manager |
| CDefaultSceneManagerFactory | Factory for default scene manager |
| 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 |
| CDefaultWorkQueueBase | Base for a general purpose request / response style background work queue |
| CDefaultZone | |
| CDefaultZoneFactory | |
| CDeflateStream | Stream which compresses / uncompresses data using the 'deflate' compression algorithm |
| ►CDeflectorPlaneAffector | This class defines a ParticleAffector which deflects particles |
| CCmdBounce | Command object for bounce (see ParamCommand) |
| CCmdPlaneNormal | Command object for plane normal (see ParamCommand) |
| CCmdPlanePoint | Command object for plane point (see ParamCommand) |
| CDeflectorPlaneAffectorFactory | Factory class for DeflectorPlaneAffector |
| CDegree | Wrapper class which indicates a given angle value is in Degrees |
| CDepthBuffer | An abstract class that contains a depth/stencil buffer |
| Cdeque | |
| ►CDirectionRandomiserAffector | This class defines a ParticleAffector which applies randomness to the movement of the particles |
| CCmdKeepVelocity | Command object for keep_velocity (see ParamCommand) |
| CCmdRandomness | Command object for randomness (see ParamCommand) |
| CCmdScope | Command object for scope (see ParamCommand) |
| CDirectionRandomiserAffectorFactory | Factory class for DirectionRandomiserAffector |
| CDistanceLodBoxStrategy | Level of detail strategy based on distance from camera to an object's bounding box |
| CDistanceLodSphereStrategy | Level of detail strategy based on distance from camera to an object's bounding sphere |
| CDistanceLodStrategyBase | Level of detail strategy based on distance from camera |
| 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 |
| CElementTranslator | [font_translator] |
| CEllipsoidEmitter | Particle emitter which emits particles randomly from points inside an ellipsoid |
| CEllipsoidEmitterFactory | Factory class for particle emitter of type "Ellipsoid" |
| CEmbeddedZipArchiveFactory | Specialisation of ZipArchiveFactory for embedded Zip files |
| CEntity | Defines an instance of a discrete, movable object based on a Mesh |
| CEntityFactory | Factory object for creating Entity instances |
| CEntityMaterialLodChangedEvent | Struct containing information about a material LOD change event for entities |
| CEntityMeshLodChangedEvent | Struct containing information about a mesh LOD change event for entities |
| 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 | |
| ►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 |
| 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 |
| CGlyphInfo | Information about the position and size of a glyph in a texture |
| CFontManager | Manages Font resources, parsing .fontdef files and generally organising them |
| CFontTranslator | [font_translator] |
| 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 | |
| CFreeImagePlugin | |
| 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 |
| CGL3PlusDepthBuffer | |
| CGL3PlusFBOManager | Factory for GL Frame Buffer Objects, and related things |
| CGL3PlusFBOMultiRenderTarget | MultiRenderTarget for OpenGL |
| CGL3PlusFBORenderTexture | RenderTexture for GL FBO |
| CGL3PlusFrameBufferObject | Frame Buffer Object abstraction |
| CGL3PlusHardwareBuffer | |
| CGL3PlusHardwareBufferManager | Implementation of HardwareBufferManager for OpenGL |
| CGL3PlusHardwareIndexBuffer | |
| CGL3PlusHardwareOcclusionQuery | This is a class that is the base class of the query class for hardware occlusion |
| CGL3PlusHardwarePixelBuffer | |
| CGL3PlusHardwareUniformBuffer | Specialisation of HardwareUniformBuffer for OpenGL |
| CGL3PlusHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for OpenGL |
| CGL3PlusPixelUtil | Class to do pixel format mapping between GL and OGRE |
| CGL3PlusPlugin | Plugin instance for GL3Plus Manager |
| CGL3PlusRenderBuffer | Renderbuffer surface |
| CGL3PlusRenderSystem | Implementation of GL 3 as a rendering system |
| CGL3PlusRenderToVertexBuffer | An object which renders geometry to a vertex |
| CGL3PlusSampler | |
| CGL3PlusStateCacheManager | |
| CGL3PlusTexture | |
| CGL3PlusTextureBuffer | Texture surface |
| CGL3PlusTextureManager | GL3Plus-specific implementation of a TextureManager |
| CGLArbGpuProgram | Specialisation of the GL low-level program for ARB programs |
| CGLAtomicCounterReference | Structure used to keep track of named atomic counter uniforms in the linked program object |
| CGLContext | Class that encapsulates an GL context |
| CGLCopyingRenderTexture | |
| CGLCopyingRTTManager | Simple, copying manager/factory for RenderTextures |
| CGLDepthBuffer | |
| CGLDepthBufferCommon | OpenGL supports 3 different methods: FBO, pbuffer & Copy |
| CGLES2DepthBuffer | |
| 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 |
| CGLES2HardwareBuffer | |
| CGLES2HardwareBufferManager | Implementation of HardwareBufferManager for OpenGL ES |
| CGLES2HardwareIndexBuffer | |
| CGLES2HardwareOcclusionQuery | |
| CGLES2HardwarePixelBuffer | |
| CGLES2HardwareUniformBuffer | Specialisation of HardwareUniformBuffer for OpenGL |
| CGLES2HardwareVertexBuffer | Specialisation of HardwareVertexBuffer for OpenGL ES |
| CGLES2PixelUtil | Class to do pixel format mapping between GL and OGRE |
| CGLES2Plugin | Plugin instance for GL ES 2 Manager |
| CGLES2RenderBuffer | Renderbuffer surface |
| CGLES2RenderSystem | Implementation of GL ES 2.x as a rendering system |
| CGLES2RenderToVertexBuffer | |
| CGLES2StateCacheManager | |
| CGLES2Texture | |
| CGLES2TextureBuffer | Texture surface |
| CGLES2TextureManager | GL ES-specific implementation of a TextureManager |
| CGLFBOManager | Factory for GL Frame Buffer Objects, and related things |
| CGLFBOMultiRenderTarget | MultiRenderTarget for GL |
| CGLFBORenderTexture | RenderTexture for GL FBO |
| CGLFrameBufferObject | Frame Buffer Object abstraction |
| CGLFrameBufferObjectCommon | Frame Buffer Object abstraction |
| CGLGpuNvparseProgram | |
| CGLGpuProgram | Generalised low-level GL program, can be applied to multiple types (eg ARB and NV) |
| CGLGpuProgramBase | |
| CGLGpuProgramManager | |
| CGLHardwareBufferManager | Implementation of HardwareBufferManager for OpenGL |
| CGLHardwareIndexBuffer | |
| CGLHardwareOcclusionQuery | This is a class that is the base class of the query class for hardware occlusion |
| CGLHardwarePixelBuffer | |
| CGLHardwarePixelBufferCommon | |
| CGLHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for OpenGL |
| CGLNativeSupport | |
| CGLPBRenderTexture | |
| CGLPBRTTManager | Manager for rendertextures and PBuffers (offscreen rendering contexts) |
| CGLPBuffer | An off-screen rendering context |
| CGLPixelUtil | Class to do pixel format mapping between GL and OGRE |
| CGLPlugin | Plugin instance for GL Manager |
| CGLRenderBuffer | Renderbuffer surface |
| CGLRenderSystem | Implementation of GL as a rendering system |
| ►CGLRenderSystemCommon | |
| CVideoMode | |
| CGLRenderTarget | |
| CGLRenderTexture | Base class for GL Render Textures |
| CGLRenderToVertexBuffer | |
| CGLRTTManager | Manager/factory for RenderTextures |
| ►CGLSLESCgProgram | Specialisation of HighLevelGpuProgram to provide support for CG |
| CCmdEntryPoint | Command object for setting entry point |
| CCmdProfiles | Command object for setting profiles |
| CGLSLESCgProgramFactory | Factory class for GLSL ES programs |
| CGLSLESLinkProgram | C++ encapsulation of GLSL ES Program Object |
| ►CGLSLESProgram | |
| CCmdOptimisation | Command object for running the GLSL optimiser |
| CGLSLESProgramCommon | C++ encapsulation of GLSL ES Program Object |
| CGLSLESProgramFactory | Factory class for GLSL ES programs |
| CGLSLESProgramManager | 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 |
| CGLSLESProgramPipeline | Specialisation of HighLevelGpuProgram to provide support for OpenGL Shader Language (GLSL ES) for OpenGL ES 2.0 |
| CGLSLMonolithicProgram | Model of OpenGL program object created using the glLinkProgram method of linking |
| CGLSLProgram | C++ encapsulation of GLSL program object |
| CGLSLProgramCommon | |
| CGLSLProgramManager | 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 |
| CGLSLProgramManagerCommon | Ogre assumes that there are separate programs to deal with but GLSL has one program object that represents the active shader objects during a rendering state |
| CGLSLSeparableProgram | Specialisation of GLSLProgram to provide support for separable programs via the OpenGL program pipeline |
| CGLSLShader | |
| ►CGLSLShaderCommon | Specialisation of HighLevelGpuProgram to provide support for OpenGL Shader Language (GLSL) |
| CCmdAttach | Command object for attaching another GLSL Program |
| CCmdColumnMajorMatrices | Command object for setting matrix packing in column-major order |
| CGLSLShaderFactory | Factory class for GLSL shaders |
| CGLStateCacheManager | |
| CGLStateCacheManagerCommon | An in memory cache of the OpenGL state |
| CGLSurfaceDesc | GL surface descriptor |
| CGLTexture | |
| CGLTextureBuffer | Texture surface |
| CGLTextureCommon | |
| CGLTextureManager | GL-specific implementation of a TextureManager |
| CGLUniformCache | An in memory cache of the OpenGL uniforms |
| CGLUniformReference | Structure used to keep track of named uniforms in the linked program object |
| CGLVertexArrayObject | Specialisation of VertexDeclaration for OpenGL Vertex Array Object usage |
| CGLWindow | |
| 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 | |
| ►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 | This is a abstract class that that provides the interface for the query class for hardware occlusion |
| CHardwarePixelBuffer | Specialisation of HardwareBuffer for a pixel buffer |
| CHardwareUniformBuffer | Specialisation of HardwareBuffer for a uniform buffer |
| CHardwareVertexBuffer | Specialisation of HardwareBuffer for a vertex buffer |
| CHashedVector | A hashed vector |
| CHighLevelGpuProgram | Abstract base class representing a high-level program (a vertex or fragment program) |
| CHighLevelGpuProgramFactory | Interface definition for factories of HighLevelGpuProgram |
| CHighLevelGpuProgramManager | This ResourceManager manages high-level vertex and fragment programs |
| CHlmsDatablock | |
| CHlmsManager | |
| CHlmsMaterialBase | |
| ►CHollowEllipsoidEmitter | Particle emitter which emits particles randomly from points inside a hollow ellipsoid |
| CCmdInnerX | Command object for inner size (see ParamCommand) |
| CCmdInnerY | Command object for inner size (see ParamCommand) |
| CCmdInnerZ | Command object for inner size (see ParamCommand) |
| CHollowEllipsoidEmitterFactory | Factory class for particle emitter of type "HollowEllipsoid" |
| CId | Usage: OGRE_NEW SceneNode( Id::generateNewId< Node >() ) |
| CIdObject | |
| CIdString | Hashed string |
| 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 |
| CImageData | Codec return class for images |
| CImGuiOverlay | |
| 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 ( |
| 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 | |
| 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 |
| CLightFactory | Factory object for creating Light instances |
| CLinearControllerFunction | Predefined controller function based on linear function interpolation |
| ►CLinearForceAffector | This class defines a ParticleAffector which applies a linear force to particles in a system |
| CCmdForceApp | Command object for force application (see ParamCommand) |
| CCmdForceVector | Command object for force vector (see ParamCommand) |
| CLinearForceAffectorFactory | Factory class for LinearForceAffector |
| CLinkedSkeletonAnimationSource | Link to another skeleton to share animations |
| CLiSPSMShadowCameraSetup | Implements the Light Space Perspective Shadow Mapping Algorithm |
| Clist | |
| ►CLod0Stripifier | |
| CRemapInfo | |
| CLodCollapseCost | |
| CLodCollapseCostCurvature | |
| CLodCollapseCostOutside | |
| CLodCollapseCostProfiler | |
| CLodCollapseCostQuadric | |
| CLodCollapser | |
| ►CLodConfig | |
| CAdvanced | |
| CLodConfigSerializer | |
| ►CLodData | |
| CEdge | |
| CIndexBufferInfo | |
| CIndexBufferPointer | |
| CTriangle | |
| CVertex | |
| CVertexEqual | Equality function for UniqueVertexSet |
| CVertexHash | Hash function for UniqueVertexSet |
| CLodIndexBuffer | Thread-safe buffer for storing Hardware index buffer |
| ►CLodInputBuffer | Data representing all required information from a Mesh. Used by LodInputProviderBuffer |
| CSubmesh | |
| CLodInputProvider | |
| CLodInputProviderBuffer | |
| CLodInputProviderMesh | |
| CLodLevel | Structure for automatic Lod configuration |
| CLodListener | A interface class defining a listener which can be used to receive notifications of LOD events |
| ►CLodOutputBuffer | Data representing the output of the Mesh reduction. Used by LodOutputProviderBuffer |
| CSubmesh | |
| CLodOutputProvider | |
| CLodOutputProviderBuffer | |
| CLodOutputProviderCompressedBuffer | |
| CLodOutputProviderCompressedMesh | |
| CLodOutputProviderMesh | |
| CLodOutsideMarker | This class will mark vertices of a mesh, which are visible from far away (from outside) |
| CLodStrategy | Strategy for determining level of detail |
| CLodStrategyManager | Manager for LOD strategies |
| CLodVertexBuffer | Thread-safe buffer for storing Hardware vertex buffer |
| CLodWorkQueueInjector | Injects the output of a request to the mesh in a thread safe way |
| CLodWorkQueueInjectorListener | |
| CLodWorkQueueRequest | |
| CLodWorkQueueWorker | Processes requests |
| ►CLog | |
| ►CStream | Stream object which targets a log |
| CFlush | Simple type to indicate a flush of the stream to the log |
| CLogListener | |
| CLogManager | The log manager handles the creation and retrieval of logs for the application |
| ►CManualObject | Class providing a much simplified interface to generating manual objects with custom geometry |
| CManualObjectSection | Built, renderable section of geometry |
| CManualObjectSectionShadowRenderable | Nested class to allow shadows |
| CManualObjectFactory | Factory object for creating ManualObject instances |
| CManualResourceLoader | Interface describing a manual resource loader |
| Cmap | |
| CMapIterator | Concrete IteratorWrapper for nonconst access to the underlying key-value container |
| CMapIteratorWrapper | Prepared IteratorWrapper for key-value container |
| 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 | |
| CMetalDepthBuffer | |
| CMetalDepthPixelBuffer | |
| CMetalDepthTexture | |
| CMetalDepthTextureTarget | |
| CMetalDevice | |
| CMetalDiscardBuffer | |
| ►CMetalDiscardBufferManager | Metal doesn't support "DISCARD" like D3D9/D3D11 (and OpenGL but often it's broken) where we requested to map a write-only buffer and the API would discard the previous contents (thus allowing us to avoid a stall until the GPU is done with the region) |
| CBlock | |
| CUnsafeBlock | |
| 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 | Implementation of HardwareBufferManager for Metal |
| CMetalHardwareIndexBuffer | Specialisation of HardwareIndexBuffer for Metal |
| CMetalHardwarePixelBuffer | |
| CMetalHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for Metal |
| CMetalMappings | |
| CMetalMultiRenderTarget | |
| CMetalPlugin | Plugin instance for Metal Manager |
| ►CMetalProgram | Specialisation of HighLevelGpuProgram to provide support for Metal Shader Language |
| CCmdEntryPoint | Command object for setting entry point |
| CCmdShaderReflectionPairHint | Command object for setting vertex shader pair |
| CMetalProgramFactory | Factory class for Metal programs |
| CMetalRenderSystem | Implementation of Metal as a rendering system |
| CMetalRenderTargetCommon | |
| CMetalRenderTexture | |
| CMetalRenderWindow | |
| CMetalSampler | |
| 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 |
| CMetalTexture | |
| CMetalTextureBuffer | Texture surface |
| CMetalTextureManager | |
| ►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 |
| CNoAddRefRelease | |
| ►CNode | Class representing a general-purpose node an articulated scene graph |
| CDebugRenderable | Inner class for displaying debug renderable for Node |
| 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 |
| CNumericSolver | Provides numeric solvers for Ogre |
| 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 |
| COverlayTranslator | |
| COverlayTranslatorManager | |
| 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 |
| 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 |
| CParamDictionary | Class to hold a dictionary of parameters for a single class |
| CParameterDef | Definition of a parameter supported by a StringInterface class, for introspection |
| CParticle | Class representing a single particle instance |
| CParticleAffector | Abstract class defining the interface to be implemented by particle affectors |
| CParticleAffectorFactory | Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses |
| 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 |
| CParticleIterator | |
| ►CParticleSystem | Class defining particle system based special effects |
| CCmdCull | Command object for cull_each (see ParamCommand) |
| CCmdEmittedEmitterQuota | Command object for emittedEmitterQuota (see ParamCommand) |
| CCmdHeight | Command object for particle_height (see ParamCommand) |
| CCmdIterationInterval | Command object for iteration interval(see ParamCommand) |
| CCmdLocalSpace | Command object for local space (see ParamCommand) |
| CCmdMaterial | Command object for material (see ParamCommand) |
| CCmdNonvisibleTimeout | Command object for nonvisible timeout (see ParamCommand) |
| CCmdQuota | Command object for quota (see ParamCommand) |
| CCmdRenderer | Command object for renderer (see ParamCommand) |
| CCmdSorted | Command object for sorting (see ParamCommand) |
| CCmdWidth | Command object for particle_width (see ParamCommand) |
| CParticleSystemFactory | Factory object for creating ParticleSystem instances |
| CParticleSystemManager | Manages particle systems, particle system scripts (templates) and the available emitter & affector factories |
| CParticleSystemRenderer | Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances |
| CParticleSystemRendererFactory | Abstract class definition of a factory object for ParticleSystemRenderer |
| CParticleVisualData | |
| ►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 |
| ►CPbsMaterial | |
| CTextureAddressing | |
| 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 | Particle emitter which emits particles from a single point |
| CPointEmitterFactory | Factory class for particle emitter of type "Point" |
| CPolygon | The class represents a polygon in 3D space |
| CPool | Template class describing a simple pool of items |
| CPortal | Portal datastructure for connecting zones |
| CPortalBase | PortalBase - Base class to Portal and AntiPortal classes |
| CPortalBaseFactory | Factory object for creating Portal instances |
| CPortalFactory | Factory object for creating Portal instances |
| CPose | A pose is a linked set of vertex offsets applying to one set of vertex data |
| 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 |
| ►CPropertyMap | |
| CProperty | |
| 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 |
| CPVRTCCodec | Codec specialized in loading PVRTC (PowerVR) images |
| CQuake3Level | Support for loading and extracting data from a Quake3 level file |
| ►CQuake3Shader | Class for recording Quake3 shaders |
| CPass | |
| CQuake3ShaderManager | Class for managing Quake3 custom shaders |
| CQuaternion | Implementation of a Quaternion, i.e |
| 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 |
| CRadixSort | Class for performing a radix sort (fast comparison-less sort based on byte value) on various standard STL containers |
| 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 |
| CRenderSystemData | |
| 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 |
| CRenderQueueInvocation | Class representing the invocation of queue groups in a RenderQueue |
| CRenderQueueInvocationSequence | Class to hold a linear sequence of RenderQueueInvocation objects |
| CRenderQueueListener | Abstract interface which classes must implement if they wish to receive events from the render queue |
| ►CRenderSystem | Defines the functionality of a 3D API |
| CListener | Defines a listener on the custom events that this render system can raise |
| CRenderSystemContext | Dummy structure for render system contexts - implementing RenderSystems can extend as needed |
| 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 | |
| CImpl | RenderSystem specific interface for a RenderTarget; this should be subclassed by RenderSystems |
| CRenderTargetEvent | Struct containing information about a RenderTarget event |
| CRenderTargetListener | A interface class defining a listener which can be used to receive notifications of RenderTarget events |
| CRenderTargetViewportEvent | Struct containing information about a RenderTarget Viewport-specific event |
| CRenderTexture | This class represents a RenderTarget that renders to a Texture |
| 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 |
| CListener | This abstract listener interface lets you get notifications of completed background processes instead of having to poll ticket statuses |
| 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 |
| CRibbonTrailFactory | Factory object for creating RibbonTrail 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) |
| CRingEmitterFactory | Factory class for particle emitter of type "Ring" |
| CRoot | The root class of the Ogre system |
| ►CRotationAffector | This plugin subclass of ParticleAffector allows you to alter the rotation of particles |
| CCmdRotationRangeEnd | Command object for particle emitter - see ParamCommand |
| CCmdRotationRangeStart | Command object for particle emitter - see ParamCommand |
| CCmdRotationSpeedRangeEnd | Command object for particle emitter - see ParamCommand |
| CCmdRotationSpeedRangeStart | Command object for particle emitter - see ParamCommand |
| CRotationAffectorFactory | Factory class for RotationAffector |
| CRotationalSpline | This class interpolates orientations (rotations) along a spline using derivatives of quaternions |
| CRuntimeAssertionException | |
| ►CSampler | Class which determines how a TextureUnitState accesses data from a Texture |
| CUVWAddressingMode | Texture addressing mode for each texture coordinate |
| ►CScaleAffector | This plugin subclass of ParticleAffector allows you to alter the scale of particles |
| CCmdScaleAdjust | Command object for scale adjust (see ParamCommand) |
| CScaleAffectorFactory | Factory class for ScaleAffector |
| CScaleControllerFunction | Predefined controller function which simply scales an input to an output value |
| CSceneLoader | Abstract class for loading scenes from a file (DataStream) |
| CSceneLoaderManager | |
| ►CSceneManager | Manages the organisation and rendering of a 'scene': a collection of objects and potentially world geometry |
| ClightLess | Comparator for sorting lights relative to a point |
| CListener | Class that allows listening in on the various stages of SceneManager processing, so that custom behaviour can be implemented from outside |
| CmaterialLess | Comparator for material map, for sorting materials into render order (e.g |
| CRenderContext | |
| CSceneMgrQueuedRenderableVisitor | Inner helper class to implement the visitor pattern for rendering objects in a queue |
| CSkyBoxGenParameters | |
| CSkyDomeGenParameters | |
| CSkyPlaneGenParameters | |
| CSceneManagerEnumerator | Enumerates the SceneManager classes available to applications |
| CSceneManagerFactory | Class which will create instances of a given SceneManager |
| CSceneManagerMetaData | Structure containing information about a scene manager |
| CSceneNode | Class representing a node in the scene graph |
| ►CSceneQuery | A class for performing queries on a scene |
| CWorldFragment | Represents part of the world geometry that is a result of a SceneQuery |
| CSceneQueryListener | This optional class allows you to receive per-result callbacks from SceneQuery executions instead of a single set of consolidated results |
| CSceneQueryResult | Holds the results of a scene query |
| CScreenRatioPixelCountLodStrategy | |
| CScriptCompiler | This is the main class for the compiler |
| 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 | |
| CShaderGenerator | |
| CShaderHelper | Interface definition for helper class to generate shaders |
| CShaderHelperGLSL | Utility class to help with generating shaders for unified GLSL |
| CShaderManager | |
| CShaderPiecesManager | |
| CShaderTemplate | |
| 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 |
| CSharedPtr | |
| CSimplePageContentCollection | Specialisation of PageContentCollection which just provides a simple list of PageContent instances |
| CSimplePageContentCollectionFactory | Factory class for SimplePageContentCollection |
| 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 |
| CSPIRVShader | |
| CSPIRVShaderFactory | |
| 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 | |
| CSTBIPlugin | |
| 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 |
| CTempBlendedBufferInfo | Structure for recording the use of temporary blend buffers |
| ►CTerrain | The main containing class for a chunk of terrain |
| CDefaultGpuBufferAllocator | Standard implementation of a buffer allocator which re-uses buffers |
| CGpuBufferAllocator | Interface used to by the Terrain instance to allocate GPU buffers |
| CImportData | Structure encapsulating import data that you may use to bootstrap the terrain without loading from a native data stream |
| CLayerInstance | An instance of a layer, with specific texture names |
| CTerrainAutoUpdateLod | Terrain automatic LOD loading |
| CTerrainAutoUpdateLodByDistance | Class implementing TerrainAutoUpdateLod interface |
| CTerrainAutoUpdateLodFactory | |
| CTerrainGlobalOptions | Options class which just stores default options for the terrain |
| ►CTerrainGroup | Helper class to assist you in managing multiple terrain instances that are connected to each other |
| CRayResult | Result from a terrain ray intersection with the terrain group |
| CTerrainSlot | Slot for a terrain instance, together with its definition |
| CTerrainSlotDefinition | Definition of how to populate a 'slot' in the terrain group |
| CTerrainLayerBlendMap | Class exposing an interface to a blend map for a given layer |
| CTerrainLayerDeclaration | The definition of the information each layer will contain in this terrain |
| CTerrainLayerSampler | Description of a sampler that will be used with each layer |
| CTerrainLayerSamplerElement | Information about one element of a sampler / texture within a layer |
| ►CTerrainLodManager | Terrain LOD data manager |
| CLoadLodRequest | |
| CLodInfo | |
| ►CTerrainMaterialGenerator | Class that provides functionality to generate materials for use with a terrain |
| CProfile | Inner class which should also be subclassed to provide profile-specific material generation |
| ►CTerrainMaterialGeneratorA | A TerrainMaterialGenerator which can cope with normal mapped, specular mapped terrain |
| CSM2Profile | Shader model 2 profile target |
| ►CTerrainPagedWorldSection | A world section which includes paged terrain |
| CTerrainDefiner | |
| CTerrainPaging | This class is the 'core' class for paging terrain, that will integrate with the larger paging system and provide the appropriate utility classes required |
| ►CTerrainQuadTreeNode | A node in a quad tree used to store a patch of terrain |
| CLodLevel | |
| 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 |
| 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 |
| CTexture | Abstract class representing a Texture resource |
| 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 |
| CTransformBase | Class encapsulating a standard 4x4 homogeneous matrix |
| CTransformBaseReal | |
| CTransformKeyFrame | Specialised KeyFrame which stores a full transform |
| CTRect | |
| ►CUnifiedHighLevelGpuProgram | Specialisation of HighLevelGpuProgram which just delegates its implementation to one other GpuProgram, 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 |
| 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_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 | 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 |
| 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 |
| CWaveformControllerFunction | Predefined controller function based on a waveform |
| CWireBoundingBox | Allows the rendering of a wireframe bounding box |
| ►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 |
| 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 |
| CButton | Basic button class |
| CCameraMan | Utility class for controlling the camera in samples |
| CCheckBox | Basic check box widget |
| CConfigDialog | |
| 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 | This class demonstrates basic usage of the 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 |
| Npugi | |
| Nstd |
1.9.1