| ►CAbstractNodeAlloc |  | 
| ►COgre::AbstractNode |  | 
| COgre::AtomAbstractNode | This is an abstract node which cannot be broken down further | 
| COgre::ImportAbstractNode | This abstract node represents an import statement | 
| COgre::ObjectAbstractNode | This specific abstract node represents a script object | 
| COgre::PropertyAbstractNode | This abstract node represents a script property | 
| COgre::VariableAccessAbstractNode | This abstract node represents a variable assignment | 
| CaiMatrix4x4t< TReal > |  | 
| ►CAnimableAlloc |  | 
| COgre::AnimableValue | Defines an object property which is animable, i.e | 
| ►CAnimationAlloc |  | 
| COgre::Animation | An animation sequence | 
| COgre::AnimationState | Represents the state of an animation and the weight of its influence | 
| COgre::AnimationStateSet | Class encapsulating a set of AnimationState objects | 
| ►COgre::AnimationTrack | A 'track' in an animation sequence, i.e | 
| COgre::NodeAnimationTrack | Specialised AnimationTrack for dealing with node transforms | 
| COgre::NumericAnimationTrack | Specialised AnimationTrack for dealing with generic animable values | 
| COgre::VertexAnimationTrack | Specialised AnimationTrack for dealing with changing vertex position information | 
| ►COgre::KeyFrame | A key frame in an animation sequence defined by an AnimationTrack | 
| COgre::NumericKeyFrame | Specialised KeyFrame which stores any numeric value | 
| COgre::TransformKeyFrame | Specialised KeyFrame which stores a full transform | 
| COgre::VertexMorphKeyFrame | Specialised KeyFrame which stores absolute vertex positions for a complete buffer, designed to be interpolated with other keys in the same track | 
| COgre::VertexPoseKeyFrame | Specialised KeyFrame which references a Mesh::Pose at a certain influence level, which stores offsets for a subset of the vertices in a buffer to provide a blendable pose | 
| COgre::Pose | A pose is a linked set of vertex offsets applying to one set of vertex data | 
| ►CArchiveAlloc |  | 
| COgre::Archive | Archive-handling class | 
| ►COgre::ArchiveFactory | Abstract factory class, archive codec plugins can register concrete subclasses of this | 
| COgre::APKFileSystemArchiveFactory |  | 
| COgre::FileSystemArchiveFactory | Specialisation of the ArchiveFactory to allow reading of files from filesystem folders / directories | 
| ►COgre::ZipArchiveFactory | Specialisation to allow reading of files from a zip format source archive | 
| COgre::EmbeddedZipArchiveFactory | Specialisation of ZipArchiveFactory for embedded Zip files | 
| COgre::ArchiveManager | This class manages the available ArchiveFactory plugins | 
| ►CBatchedGeometryAlloc |  | 
| COgre::StaticGeometry | Pre-transforms and batches up meshes for efficient use as static geometry in a scene | 
| COgre::StaticGeometry::GeometryBucket | A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored | 
| COgre::StaticGeometry::LODBucket | A LODBucket is a collection of smaller buckets with the same LOD | 
| COgre::StaticGeometry::MaterialBucket | A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same LOD) | 
| COgre::StaticGeometry::OptimisedSubMeshGeometry | Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances | 
| COgre::StaticGeometry::QueuedGeometry | Structure recording a queued geometry for low level builds | 
| COgre::StaticGeometry::QueuedSubMesh | Structure recording a queued submesh for the build | 
| 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 |  | 
| ►CbtIDebugDraw |  | 
| COgre::Bullet::DebugDrawer |  | 
| ►CbtMotionState |  | 
| COgre::Bullet::RigidBodyState | A MotionState is Bullet's way of informing you about updates to an object | 
| ►CBufferAlloc |  | 
| ►COgre::HardwareBuffer | Abstract class defining common features of hardware buffers | 
| COgre::DefaultHardwareBuffer | Specialisation of HardwareBuffer for emulation | 
| COgre::HardwareIndexBuffer | Specialisation of HardwareBuffer for vertex index buffers, still abstract | 
| COgre::HardwarePixelBuffer | Specialisation of HardwareBuffer for a pixel buffer | 
| COgre::HardwareVertexBuffer | Specialisation of HardwareBuffer for a vertex buffer | 
| ►COgre::HardwareBufferManagerBase | Base definition of a hardware buffer manager | 
| COgre::DefaultHardwareBufferManagerBase | Specialisation of HardwareBufferManagerBase to emulate hardware buffers | 
| ►COgre::HardwareBufferManager | Singleton wrapper for hardware buffer manager | 
| COgre::DefaultHardwareBufferManager | DefaultHardwareBufferManager as a Singleton | 
| COgre::VertexCacheProfiler | Vertex cache profiler | 
| ►CCodecAlloc |  | 
| ►COgre::Codec | Abstract class that defines a 'codec' | 
| ►COgre::ImageCodec | Codec specialized in images | 
| COgre::EXRCodec |  | 
| COgre::FreeImageCodec |  | 
| COgre::RsImageCodec |  | 
| COgre::STBIImageCodec |  | 
| ►CCompositorInstAlloc |  | 
| COgre::CompositionPass | Object representing one pass or operation in a composition sequence | 
| COgre::CompositionTargetPass | Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework | 
| COgre::CompositionTechnique | Base composition technique, can be subclassed in plugins | 
| COgre::CompositionTechnique::TextureDefinition | Local texture definition | 
| COgre::CompositorChain | Chain of compositor effects applying to one viewport | 
| COgre::CompositorInstance | An instance of a Compositor object for one Viewport | 
| COgre::CompositorInstance::RenderSystemOperation | Specific render system operation | 
| ►CConfigAlloc |  | 
| COgre::ConfigFile | Class for quickly loading settings from a text file | 
| ►CControllerAlloc |  | 
| COgre::Controller< float > |  | 
| ►COgre::ControllerFunction< float > |  | 
| COgre::AnimationControllerFunction | Predefined controller function for dealing with animation | 
| COgre::LinearControllerFunction | Predefined controller function based on linear function interpolation | 
| COgre::PassthroughControllerFunction | Predefined controller function which just passes through the original source directly to dest | 
| COgre::ScaleControllerFunction | Predefined controller function which simply scales an input to an output value | 
| COgre::WaveformControllerFunction | Predefined controller function based on a waveform | 
| ►COgre::ControllerValue< float > |  | 
| COgre::AnimationStateControllerValue | ControllerValue wrapper class for AnimationState | 
| COgre::FloatGpuParameterControllerValue | Predefined controller value for setting a single floating- point value in a constant parameter of a vertex or fragment program | 
| COgre::FrameTimeControllerValue | Predefined controller value for getting the latest frame time | 
| COgre::TexCoordModifierControllerValue | Predefined controller value for getting / setting a texture coordinate modifications (scales and translates) | 
| COgre::TextureFrameControllerValue | Predefined controller value for getting / setting the frame number of a texture layer | 
| COgre::Controller< T > | Instances of this class 'control' the value of another object in the system | 
| COgre::ControllerFunction< T > | Subclasses of this class are responsible for performing a function on an input value for a Controller | 
| COgre::ControllerManager | Class for managing Controller instances | 
| COgre::ControllerValue< T > | Can either be used as an input or output value | 
| ►CD3D11DeviceResourceManager |  | 
| COgre::D3D11RenderSystem | Implementation of DirectX11 as a rendering system | 
| ►CDynLibAlloc |  | 
| COgre::DynLib | Resource holding data about a dynamic library | 
| COgre::DynLibManager | Manager for Dynamic-loading Libraries | 
| ►CEdgeDataAlloc |  | 
| COgre::EdgeData | This class contains the information required to describe the edge connectivity of a given set of vertices and indexes | 
| ►CFactoryAlloc |  | 
| ►COgre::GpuProgramFactory | Interface definition for factories of GpuProgram | 
| COgre::CgProgramFactory | Factory class for Cg programs | 
| COgre::GLSLangProgramFactory | Factory class for GLSLang programs | 
| COgre::InstanceManager | This is the main starting point for the new instancing system | 
| ►CFileSystemLayerAlloc |  | 
| COgre::FileSystemLayer | Provides methods to find out where the Ogre config files are stored and where logs and settings files should be written to | 
| ►CFXAlloc |  | 
| COgre::Billboard | A billboard is a primitive which always faces the camera in every frame | 
| ►COgre::Particle | Class representing a single particle instance | 
| ►COgre::ParticleEmitter | Abstract class defining the interface to be implemented by particle emitters | 
| ►COgre::AreaEmitter | Particle emitter which emits particles randomly from points inside an area (box, sphere, ellipsoid whatever subclasses choose to be) | 
| COgre::BoxEmitter | This emitter emits particles from a random location within a 3-dimensional box | 
| COgre::CylinderEmitter | This emitter emits particles in a random direction from within a cylinder area, where the cylinder is oriented along the Z-axis | 
| ►COgre::EllipsoidEmitter | Particle emitter which emits particles randomly from points inside an ellipsoid | 
| COgre::HollowEllipsoidEmitter | Particle emitter which emits particles randomly from points inside a hollow ellipsoid | 
| COgre::RingEmitter | Particle emitter which emits particles randomly from points inside a ring (e.g | 
| COgre::PointEmitter | This emitter emits particles from a single point, which is it’s position | 
| ►COgre::ParticleAffector | Abstract class defining the interface to be implemented by particle affectors | 
| COgre::ColourFaderAffector | This affector modifies the colour of particles in flight | 
| COgre::ColourFaderAffector2 |  | 
| COgre::ColourImageAffector |  | 
| COgre::ColourInterpolatorAffector |  | 
| COgre::DeflectorPlaneAffector | This affector defines a plane which deflects particles which collide with it | 
| COgre::DirectionRandomiserAffector | This affector applies randomness to the movement of the particles | 
| COgre::LinearForceAffector | This affector applies a force vector to all particles to modify their trajectory | 
| COgre::RotationAffector | This affector rotates particles in flight | 
| COgre::ScaleAffector | This affector scales particles in flight | 
| COgre::TextureAnimatorAffector | This affector makes it possible to have an animated texture for each individual particle | 
| ►COgre::ParticleAffectorFactory | Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses | 
| COgre::TextureAnimatorAffectorFactory | Factory class for TextureAnimatorAffector | 
| COgre::ParticleEmitterFactory | Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses | 
| ►COgre::ParticleSystemRenderer | Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances | 
| COgre::BillboardParticleRenderer | Specialisation of ParticleSystemRenderer to render particles using a BillboardSet | 
| ►CGeneralAllocatedObject |  | 
| COgre::UserObjectBindings | Class that provides convenient interface to establish a linkage between custom user application objects and Ogre core classes | 
| ►CGLRenderSystemCommon |  | 
| COgre::GL3PlusRenderSystem | Implementation of GL 3 as a rendering system | 
| COgre::GLES2RenderSystem | Implementation of GL ES 2.x as a rendering system | 
| COgre::GLRenderSystem | Implementation of GL as a rendering system | 
| ►CGpuParamsAlloc |  | 
| COgre::GpuLogicalBufferStruct | Container struct to allow params to safely & update shared list of logical buffer assignments | 
| COgre::GpuNamedConstants | Struct collecting together the information for named constants | 
| COgre::GpuProgramParameters | Collects together the program parameters used for a GpuProgram | 
| COgre::GpuSharedParameters | A group of manually updated parameters that are shared between many parameter sets | 
| COgre::GpuSharedParametersUsage | This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters | 
| ►CImageAlloc |  | 
| COgre::Image | Class representing an image file | 
| COgre::PixelBox | A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory | 
| ►CIndexDataAlloc |  | 
| COgre::IndexData | Summary class collecting together index data source information | 
| ►CLodAlloc |  | 
| ►COgre::LodStrategy | Strategy for determining level of detail | 
| ►COgre::DistanceLodStrategyBase | Level of detail strategy based on distance from camera | 
| COgre::DistanceLodBoxStrategy | Level of detail strategy based on distance from camera to an object's bounding box | 
| COgre::DistanceLodSphereStrategy | Level of detail strategy based on distance from camera to an object's bounding sphere | 
| ►COgre::PixelCountLodStrategyBase | Abstract base class for level of detail strategy based on pixel count approximations from bounding sphere projection | 
| COgre::AbsolutePixelCountLodStrategy |  | 
| COgre::ScreenRatioPixelCountLodStrategy |  | 
| COgre::LodStrategyManager | Manager for LOD strategies | 
| ►CLogAlloc |  | 
| COgre::Log | Log class for writing debug/log data to files | 
| COgre::LogManager | The log manager handles the creation and retrieval of logs for the application | 
| ►CMovableAlloc |  | 
| COgre::ManualObject::ManualObjectSection | Built, renderable section of geometry | 
| ►COgre::MovableObject | Abstract class defining a movable object in a scene | 
| ►COgre::BillboardChain | Allows the rendering of a chain of connected billboards | 
| COgre::RibbonTrail | Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances | 
| COgre::BillboardSet | A collection of billboards (faces which are always facing the given direction) with the same (default) dimensions, material and which are fairly close proximity to each other | 
| COgre::Entity | Defines an instance of a discrete, movable object based on a Mesh | 
| ►COgre::Frustum | A frustum represents a pyramid, capped at the near and far end which is used to represent either a visible area or a projection area | 
| ►COgre::Camera | A viewpoint from which the scene will be rendered | 
| COgre::OctreeCamera | Specialized viewpoint from which an Octree can be rendered | 
| COgre::PCZCamera | Specialized viewpoint from which an PCZone Scene can be rendered | 
| ►COgre::InstanceBatch | 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 | 
| ►COgre::BaseInstanceBatchVTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) This implementation has the following advantages: | 
| COgre::InstanceBatchHW_VTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instancing | 
| COgre::InstanceBatchVTF |  | 
| COgre::InstanceBatchHW | This is technique requires true instancing hardware support | 
| COgre::InstanceBatchShader | This is the same technique the old InstancedGeometry implementation used (with improvements) | 
| COgre::InstancedEntity |  | 
| ►COgre::Light | Representation of a dynamic light source in the scene | 
| COgre::PCZLight | Specialized version of Ogre::Light which caches which zones the light affects | 
| COgre::ManualObject | Class providing a much simplified interface to generating manual objects with custom geometry | 
| COgre::MovablePlane | Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply | 
| COgre::ParticleSystem | Class defining particle system based special effects | 
| ►COgre::PortalBase | PortalBase - Base class to Portal and AntiPortal classes | 
| COgre::AntiPortal | AntiPortal datastructure for occlusion culling | 
| COgre::Portal | Portal datastructure for connecting zones | 
| ►COgre::SimpleRenderable | Simple implementation of MovableObject and Renderable for single-part custom objects | 
| COgre::Rectangle2D | Allows the rendering of a simple 2D rectangle This class renders a simple 2D rectangle; this rectangle has no depth and therefore is best used with specific render queue and depth settings, like RENDER_QUEUE_BACKGROUND and 'depth_write off' for backdrops, and RENDER_QUEUE_OVERLAY and 'depth_check off' for fullscreen quads | 
| COgre::Volume::Chunk | A single volume chunk mesh | 
| COgre::WireBoundingBox | Allows the rendering of a wireframe bounding box | 
| COgre::StaticGeometry::Region | The details of a topological region which is the highest level of partitioning for this class | 
| COgre::TerrainQuadTreeNode | A node in a quad tree used to store a patch of terrain | 
| ►COgre::MovableObjectFactory | Interface definition for a factory class which produces a certain kind of MovableObject, and can be registered with Root in order to allow all clients to produce new instances of this object, integrated with the standard Ogre processing | 
| COgre::PCZLightFactory | Factory object for creating PCZLight instances | 
| ►COgre::PortalBaseFactory | Factory object for creating Portal instances | 
| COgre::AntiPortalFactory | Factory object for creating AntiPortal instances | 
| COgre::PortalFactory | Factory object for creating Portal instances | 
| ►CNodeAlloc |  | 
| COgre::BspNode | Encapsulates a node in a BSP tree | 
| ►COgre::Node | Class representing a general-purpose node an articulated scene graph | 
| ►COgre::Bone | A bone in a skeleton | 
| COgre::TagPoint | A tagged point on a skeleton, which can be used to attach entities to on specific other entities | 
| ►COgre::SceneNode | Class representing a node in the scene graph | 
| COgre::BspSceneNode | Specialisation of SceneNode for the BspSceneManager | 
| COgre::OctreeNode | Specialized SceneNode that is customized for working within an Octree | 
| COgre::PCZSceneNode | The PCZSceneNode is an extension used to store zone information and provide additional functionality for a given Ogre::SceneNode | 
| COgre::Octree | Octree datastructure for managing scene nodes | 
| COgre::AlignedAllocator< T, Alignment >::rebind< Other > |  | 
| COgre::AlignedMemory | Class to provide aligned memory allocate functionality | 
| COgre::Angle | Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAngleUnit | 
| ►COgre::AnimableObject | Defines an interface to classes which have one or more AnimableValue instances to expose | 
| COgre::MovableObject | Abstract class defining a movable object in a scene | 
| ►COgre::AnimationContainer | An animation container interface, which allows generic access to sibling animations | 
| ►COgre::Mesh | Resource holding data about 3D mesh | 
| COgre::PatchMesh | Patch specialisation of Mesh | 
| ►COgre::SceneManager | Manages the organisation and rendering of a 'scene': a collection of objects and potentially world geometry | 
| COgre::BspSceneManager | Specialisation of the SceneManager class to deal with indoor scenes based on a BSP tree | 
| COgre::OctreeSceneManager | Specialized SceneManager that divides the geometry into an octree in order to facilitate spatial queries | 
| COgre::PCZSceneManager | Specialized SceneManager that uses Portal-Connected-Zones to divide the scene spatially | 
| ►COgre::Skeleton | A collection of Bone objects used to animate a skinned mesh | 
| COgre::SkeletonInstance | A SkeletonInstance is a single instance of a Skeleton used by a world object | 
| COgre::AnimationTrack::Listener | Listener allowing you to override certain behaviour of a track, for example to drive animation procedurally | 
| COgre::Any | Variant type that can hold Any other type | 
| COgre::AssimpLoader |  | 
| COgre::AssimpLoader::Options |  | 
| COgre::AxisAlignedBox | A 3D box aligned with the x/y/z axes | 
| COgre::BillboardChain::Element | Contains the data of an element of the BillboardChain | 
| COgre::Bitwise | Class for manipulating bit patterns | 
| ►COgre::Box | Structure used to define a box in a 3-D integer space | 
| COgre::PixelBox | A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory | 
| COgre::BspNode::Brush |  | 
| COgre::Bullet::CollisionListener |  | 
| ►COgre::Bullet::CollisionWorld | Simplified wrapper with automatic memory management | 
| COgre::Bullet::DynamicsWorld | Simplified wrapper with automatic memory management | 
| COgre::Bullet::RayResultCallback |  | 
| COgre::Camera::Listener | Listener interface so you can be notified of Camera events | 
| COgre::Capsule | 3D Line-Swept-Sphere class for intersection testing in Ogre3D Some algorithms based off code from the Wild Magic library by Dave Eberly | 
| COgre::ColourBlendState | Describes the global blending factors for combining subsequent renders with the existing frame contents | 
| COgre::ColourValue | Class representing colour | 
| COgre::CompositionPass::InputTex | Inputs (for material used for rendering the quad) | 
| COgre::CompositorInstance::Listener | Provides an interface to "listen in" to to render system operations executed by this CompositorInstance | 
| COgre::CompositorInstance::TargetOperation | Operation setup for a RenderTarget (collected) | 
| COgre::CompositorLogic | Interface for compositor logics, which can be automatically binded to compositors, allowing per-compositor logic (such as attaching a relevant listener) to happen automatically | 
| COgre::ConfigOption | Packages the details of a configuration option | 
| COgre::ConvexBody | Holds a solid representation of a convex body | 
| COgre::CustomCompositionPass | Interface for custom composition passes, allowing custom operations (in addition to the quad, scene and clear operations) in composition passes | 
| COgre::Degree | Wrapper class which indicates a given angle value is in Degrees | 
| COgre::deque< T > |  | 
| COgre::DotSceneLoader |  | 
| COgre::DriverVersion | DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the current GPU driver | 
| COgre::DualQuaternion | Implementation of a dual quaternion, i.e | 
| COgre::EdgeData::Edge | Edge data | 
| COgre::EdgeData::EdgeGroup | A group of edges sharing the same vertex data | 
| COgre::EdgeData::Triangle | Basic triangle structure | 
| COgre::EdgeListBuilder | General utility class for building edge lists for geometry | 
| COgre::EntityMaterialLodChangedEvent | Struct containing information about a material LOD change event for entities | 
| COgre::EntityMeshLodChangedEvent | Struct containing information about a mesh LOD change event for entities | 
| COgre::ExceptionFactory | Class implementing dispatch methods in order to construct by-value exceptions of a derived type based just on an exception code | 
| COgre::FactoryObj< T > | Abstract factory class | 
| ►COgre::FactoryObj< Archive > |  | 
| COgre::ArchiveFactory | Abstract factory class, archive codec plugins can register concrete subclasses of this | 
| ►COgre::FactoryObj< ParticleSystemRenderer > |  | 
| COgre::BillboardParticleRendererFactory | Factory class for BillboardParticleRenderer | 
| COgre::FileInfo | Information about a file/directory within the archive will be returned using a FileInfo struct | 
| COgre::FrameEvent | Struct containing information about a frame event | 
| ►COgre::FrameListener | A interface class defining a listener which can be used to receive notifications of frame events | 
| COgre::FrameTimeControllerValue | Predefined controller value for getting the latest frame time | 
| COgre::Volume::Chunk | A single volume chunk mesh | 
| ►COgreBites::ApplicationContextBase | Base class responsible for setting up a common context for applications | 
| COgreBites::ApplicationContextQt | Specialization for connecting with Qt | 
| COgre::GlyphInfo | Information about the position and size of a glyph in a texture | 
| COgre::GpuConstantDefinition | Information about predefined program constants | 
| COgre::GpuLogicalIndexUse | Structure recording the use of a physical buffer by a logical parameter index | 
| COgre::GpuProgramParameters::AutoConstantDefinition | Structure defining an auto constant that's available for use in a parameters object | 
| COgre::GpuProgramParameters::AutoConstantEntry | Structure recording the use of an automatic parameter | 
| COgre::HardwareBufferLicensee | Abstract interface representing a 'licensee' of a hardware buffer copy | 
| COgre::HardwareBufferLockGuard | Locking helper | 
| ►COgre::IntersectionSceneQueryListener | Alternative listener class for dealing with IntersectionSceneQuery | 
| ►COgre::IntersectionSceneQuery | Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another | 
| ►COgre::DefaultIntersectionSceneQuery | Default implementation of IntersectionSceneQuery | 
| COgre::BspIntersectionSceneQuery | BSP specialisation of IntersectionSceneQuery | 
| COgre::OctreeIntersectionSceneQuery | Octree implementation of IntersectionSceneQuery | 
| COgre::PCZIntersectionSceneQuery | PCZ implementation of IntersectionSceneQuery | 
| COgre::IShader |  | 
| COgre::isPodLike< T > |  | 
| COgre::isPodLike< bool > |  | 
| COgre::isPodLike< char > |  | 
| COgre::isPodLike< double > |  | 
| COgre::isPodLike< float > |  | 
| COgre::isPodLike< int > |  | 
| COgre::isPodLike< long > |  | 
| COgre::isPodLike< short > |  | 
| COgre::isPodLike< signed char > |  | 
| COgre::isPodLike< std::pair< T, U > > |  | 
| COgre::isPodLike< T * > |  | 
| COgre::isPodLike< unsigned > |  | 
| COgre::isPodLike< unsigned char > |  | 
| COgre::isPodLike< unsigned long > |  | 
| COgre::isPodLike< unsigned short > |  | 
| COgre::IteratorWrapper< T, IteratorType, ValType > | Basefunctionality for IteratorWrappers | 
| ►COgre::IteratorWrapper< T, IteratorType, T::mapped_type > |  | 
| ►COgre::MapIteratorWrapper< T, IteratorType > | Prepared IteratorWrapper for key-value container | 
| COgre::ConstMapIterator< NodeTrackList > |  | 
| COgre::ConstMapIterator< NumericTrackList > |  | 
| COgre::ConstMapIterator< VertexTrackList > |  | 
| COgre::ConstMapIterator< AnimationStateMap > |  | 
| COgre::ConstMapIterator< GpuConstantDefinitionMap > |  | 
| COgre::ConstMapIterator< InstanceBatchMap > |  | 
| COgre::ConstMapIterator< VertexOffsetMap > |  | 
| COgre::ConstMapIterator< NormalsMap > |  | 
| COgre::ConstMapIterator< PriorityMap > |  | 
| COgre::ConstMapIterator< MovableObjectFactoryMap > |  | 
| COgre::ConstMapIterator< TerrainSlotMap > |  | 
| COgre::MapIterator< AnimationStateMap > |  | 
| COgre::MapIterator< ArchiveMap > |  | 
| COgre::MapIterator< SettingsMultiMap > |  | 
| COgre::MapIterator< SettingsBySection > |  | 
| COgre::MapIterator< VertexBoneAssignmentList > |  | 
| COgre::MapIterator< ParticleAffectorFactoryMap > |  | 
| COgre::MapIterator< ParticleEmitterFactoryMap > |  | 
| COgre::MapIterator< ParticleSystemRendererFactoryMap > |  | 
| COgre::MapIterator< ParticleTemplateMap > |  | 
| COgre::MapIterator< VertexOffsetMap > |  | 
| COgre::MapIterator< NormalsMap > |  | 
| COgre::MapIterator< PriorityMap > |  | 
| COgre::MapIterator< ResourceManagerMap > |  | 
| COgre::MapIterator< ResourceHandleMap > |  | 
| COgre::MapIterator< CameraList > |  | 
| COgre::MapIterator< AnimationList > |  | 
| COgre::MapIterator< MovableObjectMap > |  | 
| COgre::MapIterator< MaterialBucketMap > |  | 
| COgre::MapIterator< RegionMap > |  | 
| COgre::MapIterator< ChildMap > |  | 
| COgre::MapIterator< ChildContainerMap > |  | 
| COgre::MapIterator< OverlayMap > |  | 
| COgre::MapIterator< TerrainSlotMap > |  | 
| COgre::MapIterator< PCZoneFactoryMap > |  | 
| COgre::MapIterator< ZoneMap > |  | 
| ►COgre::IteratorWrapper< T, IteratorType, T::value_type > |  | 
| ►COgre::VectorIteratorWrapper< T, IteratorType > | Prepared IteratorWrapper for container like std::vector | 
| COgre::ConstVectorIterator< EnabledAnimationStateList > |  | 
| COgre::ConstVectorIterator< InstanceBatchVec > |  | 
| COgre::ConstVectorIterator< PoseRefList > |  | 
| COgre::ConstVectorIterator< LodValueList > |  | 
| COgre::ConstVectorIterator< PoseList > |  | 
| COgre::ConstVectorIterator< ChildNodeMap > |  | 
| COgre::ConstVectorIterator< TextureUnitStates > |  | 
| COgre::ConstVectorIterator< NodeList > |  | 
| COgre::ConstVectorIterator< ShadowTextureConfigList > |  | 
| COgre::ConstVectorIterator< ObjectMap > |  | 
| COgre::ConstVectorIterator< LinkedSkeletonAnimSourceList > |  | 
| COgre::ConstVectorIterator< GPUVendorRuleList > |  | 
| COgre::ConstVectorIterator< GPUDeviceNameRuleList > |  | 
| COgre::VectorIterator< Passes > |  | 
| COgre::VectorIterator< TargetPasses > |  | 
| COgre::VectorIterator< TextureDefinitions > |  | 
| COgre::VectorIterator< Techniques > |  | 
| COgre::VectorIterator< Instances > |  | 
| COgre::VectorIterator< TextureList > |  | 
| COgre::VectorIterator< ChildObjectList > |  | 
| COgre::VectorIterator< PoseRefList > |  | 
| COgre::VectorIterator< SubMeshList > |  | 
| COgre::VectorIterator< PoseList > |  | 
| COgre::VectorIterator< ChildNodeMap > |  | 
| COgre::VectorIterator< TextureUnitStates > |  | 
| COgre::VectorIterator< ObjectMap > |  | 
| COgre::VectorIterator< ShadowRenderableList > |  | 
| COgre::VectorIterator< BoneList > |  | 
| COgre::VectorIterator< GeometryBucketList > |  | 
| COgre::VectorIterator< LODBucketList > |  | 
| COgre::VectorIterator< IlluminationPassList > |  | 
| ►COgre::IteratorWrapper< T, T::const_iterator, T::mapped_type > |  | 
| ►COgre::MapIteratorWrapper< T, T::const_iterator > |  | 
| COgre::ConstMapIterator< T > | Concrete IteratorWrapper for const access to the underlying key-value container | 
| ►COgre::IteratorWrapper< T, T::const_iterator, T::value_type > |  | 
| ►COgre::VectorIteratorWrapper< T, T::const_iterator > |  | 
| COgre::ConstVectorIterator< T > | Concrete IteratorWrapper for const access to the underlying container | 
| ►COgre::IteratorWrapper< T, T::iterator, T::mapped_type > |  | 
| ►COgre::MapIteratorWrapper< T, T::iterator > |  | 
| COgre::MapIterator< T > | Concrete IteratorWrapper for nonconst access to the underlying key-value container | 
| ►COgre::IteratorWrapper< T, T::iterator, T::value_type > |  | 
| ►COgre::VectorIteratorWrapper< T, T::iterator > |  | 
| COgre::VectorIterator< T > | Concrete IteratorWrapper for nonconst access to the underlying container | 
| COgre::LayerBlendModeEx | Class which manages blending of both colour and alpha components | 
| COgre::LinkedSkeletonAnimationSource | Link to another skeleton to share animations | 
| COgre::list< T > |  | 
| COgre::Lod0Stripifier |  | 
| COgre::Lod0Stripifier::RemapInfo |  | 
| ►COgre::LodCollapseCost |  | 
| COgre::LodCollapseCostCurvature |  | 
| COgre::LodCollapseCostOutside |  | 
| COgre::LodCollapseCostProfiler |  | 
| COgre::LodCollapseCostQuadric |  | 
| COgre::LodCollapser |  | 
| COgre::LodConfig |  | 
| COgre::LodConfig::Advanced |  | 
| COgre::LodData |  | 
| COgre::LodData::Edge |  | 
| COgre::LodData::IndexBufferInfo |  | 
| COgre::LodData::IndexBufferPointer |  | 
| COgre::LodData::Line |  | 
| COgre::LodData::Triangle |  | 
| COgre::LodData::Vertex |  | 
| COgre::LodData::VertexEqual | Equality function for UniqueVertexSet | 
| COgre::LodData::VertexHash | Hash function for UniqueVertexSet | 
| COgre::LodInputProvider |  | 
| COgre::LodLevel | Structure for automatic Lod configuration | 
| COgre::LodListener | A interface class defining a listener which can be used to receive notifications of LOD events | 
| COgre::LodOutputProvider |  | 
| COgre::LodOutsideMarker | This class will mark vertices of a mesh, which are visible from far away (from outside) | 
| COgre::LodWorkQueueInjectorListener |  | 
| COgre::Log::Stream | Stream object which targets a log | 
| COgre::Log::Stream::Flush | Simple type to indicate a flush of the stream to the log | 
| COgre::LogListener |  | 
| ►COgre::ManualResourceLoader | Interface describing a manual resource loader | 
| COgre::Font | Class representing a font in the system | 
| COgre::map< K, V, P > |  | 
| ►COgre::MaterialManager::Listener | Listener on any general material events | 
| COgreBites::SGTechniqueResolverListener | Default implementation of a Listener to use with the Ogre::RTShader system | 
| COgre::MaterialSerializer::Listener | Class that allows listening in on the various stages of material serialization process | 
| COgre::Math | Class to provide access to common mathematical functions | 
| COgre::Math::RandomValueProvider | This class is used to provide an external random value provider | 
| COgre::Matrix3 | A 3x3 matrix which can represent rotations around axes | 
| COgre::MeshLodUsage | A way of recording the way each LODs is recorded this Mesh | 
| COgre::MeshSerializerListener | This class allows users to hook into the mesh loading process and modify references within the mesh as they are loading | 
| COgre::MovableObject::Listener | Listener which gets called back on MovableObject events | 
| COgre::MovableObjectLodChangedEvent | Struct containing information about a LOD change event for movable objects | 
| COgre::multimap< K, V, P > |  | 
| COgre::NameGenerator | Utility class to generate a sequentially numbered series of names | 
| ►COgre::Node::Listener | Listener which gets called back on Node events | 
| COgre::RibbonTrail | Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances | 
| COgre::OptimisedUtil | Utility class for provides optimised functions | 
| COgre::Page | Page class | 
| COgre::PageProvider | Abstract class that can be implemented by the user application to provide a way to retrieve or generate page data from a source of their choosing | 
| ►COgre::ParamCommand | Abstract class which is command object which gets/sets parameters | 
| COgre::SimpleParamCommand< _Class, const String &, getter, setter > | Specialization for strings | 
| COgre::AreaEmitter::CmdDepth | Command object for area emitter size (see ParamCommand) | 
| COgre::AreaEmitter::CmdHeight | Command object for area emitter size (see ParamCommand) | 
| COgre::AreaEmitter::CmdWidth | Command object for area emitter size (see ParamCommand) | 
| COgre::CgProgram::CmdArgs | Command object for setting compilation arguments | 
| COgre::CgProgram::CmdProfiles | Command object for setting profiles | 
| COgre::ColourFaderAffector2::CmdAlphaAdjust1 | Command object for alpha adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdAlphaAdjust2 | Command object for alpha adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdBlueAdjust1 | Command object for blue adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdBlueAdjust2 | Command object for blue adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdGreenAdjust1 | Command object for green adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdGreenAdjust2 | Command object for green adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdRedAdjust1 | Command object for red adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdRedAdjust2 | Command object for red adjust (see ParamCommand) | 
| COgre::ColourFaderAffector2::CmdStateChange | Command object for alpha adjust (see ParamCommand) | 
| COgre::ColourFaderAffector::CmdAlphaAdjust | Command object for alpha adjust (see ParamCommand) | 
| COgre::ColourFaderAffector::CmdBlueAdjust | Command object for blue adjust (see ParamCommand) | 
| COgre::ColourFaderAffector::CmdGreenAdjust | Command object for green adjust (see ParamCommand) | 
| COgre::ColourFaderAffector::CmdRedAdjust | Command object for red adjust (see ParamCommand) | 
| COgre::ColourImageAffector::CmdImageAdjust | Command object for red adjust (see ParamCommand) | 
| COgre::ColourInterpolatorAffector::CmdColourAdjust | Command object for red adjust (see ParamCommand) | 
| COgre::ColourInterpolatorAffector::CmdTimeAdjust | Command object for red adjust (see ParamCommand) | 
| COgre::DeflectorPlaneAffector::CmdBounce | Command object for bounce (see ParamCommand) | 
| COgre::DeflectorPlaneAffector::CmdPlaneNormal | Command object for plane normal (see ParamCommand) | 
| COgre::DeflectorPlaneAffector::CmdPlanePoint | Command object for plane point (see ParamCommand) | 
| COgre::DirectionRandomiserAffector::CmdKeepVelocity | Command object for keep_velocity (see ParamCommand) | 
| COgre::DirectionRandomiserAffector::CmdRandomness | Command object for randomness (see ParamCommand) | 
| COgre::DirectionRandomiserAffector::CmdScope | Command object for scope (see ParamCommand) | 
| COgre::HollowEllipsoidEmitter::CmdInnerX | Command object for inner size (see ParamCommand) | 
| COgre::HollowEllipsoidEmitter::CmdInnerY | Command object for inner size (see ParamCommand) | 
| COgre::HollowEllipsoidEmitter::CmdInnerZ | Command object for inner size (see ParamCommand) | 
| COgre::LinearForceAffector::CmdForceApp | Command object for force application (see ParamCommand) | 
| COgre::LinearForceAffector::CmdForceVector | Command object for force vector (see ParamCommand) | 
| COgre::RingEmitter::CmdInnerX | Command object for inner size (see ParamCommand) | 
| COgre::RingEmitter::CmdInnerY | Command object for inner size (see ParamCommand) | 
| COgre::RotationAffector::CmdRotationRangeEnd | Command object for particle emitter - see ParamCommand | 
| COgre::RotationAffector::CmdRotationRangeStart | Command object for particle emitter - see ParamCommand | 
| COgre::RotationAffector::CmdRotationSpeedRangeEnd | Command object for particle emitter - see ParamCommand | 
| COgre::RotationAffector::CmdRotationSpeedRangeStart | Command object for particle emitter - see ParamCommand | 
| COgre::ScaleAffector::CmdScaleAdjust | Command object for scale adjust (see ParamCommand) | 
| COgre::SimpleParamCommand< _Class, Param, getter, setter > | Generic ParamCommand implementation stores pointers to the class getter and setter functions | 
| COgre::SimpleParamCommand< _Class, const String &, getter, setter > | Specialization for strings | 
| COgre::ParamDictionary | Class to hold a dictionary of parameters for a single class | 
| COgre::ParameterDef |  | 
| COgre::Pass::HashFunc | Definition of a functor for calculating the hashcode of a Pass | 
| COgre::PCZFrustum | Specialized frustum shaped culling volume that has culling planes created from portals | 
| COgre::PixelUtil | Some utility functions for packing and unpacking pixel data | 
| ►COgre::Plane | Defines a plane in 3D space | 
| COgre::MovablePlane | Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply | 
| COgre::PCPlane | Portal Culling Plane | 
| COgre::PlaneBoundedVolume | Represents a convex volume bounded by planes | 
| COgre::PlatformInformation | Class which provides the run-time platform information Ogre runs on | 
| COgre::Polygon | The class represents a polygon in 3D space | 
| COgre::Pool< T > | Template class describing a simple pool of items | 
| ►COgre::Pool< ResourcePtr > |  | 
| COgre::ResourceManager::ResourcePool | Definition of a pool of resources, which users can use to reuse similar resources many times without destroying and recreating them | 
| COgre::ProfiledEdge |  | 
| COgre::ProfileFrame | Represents the total timing information of a profile since profiles can be called more than once each frame | 
| COgre::ProfileHistory | Represents a history of each profile during the duration of the app | 
| ►COgre::ProfileSessionListener | ProfileSessionListener should be used to visualize profile results | 
| COgre::OverlayProfileSessionListener | Concrete impl | 
| COgre::PropertyValue | A simple structure designed just as a holder of property values between the instances of objects they might target | 
| COgre::Quake3Shader::Pass |  | 
| COgre::Quaternion | Implementation of a Quaternion, i.e | 
| ►COgre::QueuedRenderableVisitor | Visitor interface for items in a QueuedRenderableCollection | 
| COgre::SceneManager::SceneMgrQueuedRenderableVisitor | Inner helper class to implement the visitor pattern for rendering objects in a queue | 
| COgre::Radian | Wrapper class which indicates a given angle value is in Radians | 
| COgre::Ray | Representation of a ray in space, i.e | 
| ►COgre::RaySceneQueryListener | Alternative listener class for dealing with RaySceneQuery | 
| ►COgre::RaySceneQuery | Specialises the SceneQuery class for querying along a ray | 
| ►COgre::DefaultRaySceneQuery | Default implementation of RaySceneQuery | 
| COgre::BspRaySceneQuery | BSP specialisation of RaySceneQuery | 
| COgre::OctreeRaySceneQuery | Octree implementation of RaySceneQuery | 
| COgre::PCZRaySceneQuery | PCZ implementation of RaySceneQuery | 
| COgre::RaySceneQueryResultEntry | This struct allows a single comparison of result data no matter what the type | 
| ►COgre::Renderable | Abstract class defining the interface all renderable objects must implement | 
| COgre::BillboardChain | Allows the rendering of a chain of connected billboards | 
| COgre::BillboardSet | A collection of billboards (faces which are always facing the given direction) with the same (default) dimensions, material and which are fairly close proximity to each other | 
| COgre::BorderRenderable | Class for rendering the border of a BorderPanelOverlayElement | 
| COgre::BspLevel | Holds all the data associated with a Binary Space Parition (BSP) based indoor level | 
| COgre::InstanceBatch | 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 | 
| COgre::ManualObject::ManualObjectSection | Built, renderable section of geometry | 
| ►COgre::OverlayElement | Abstract definition of a 2D element to be displayed in an Overlay | 
| ►COgre::OverlayContainer | A 2D element which contains other OverlayElement instances | 
| ►COgre::PanelOverlayElement | OverlayElement representing a flat, single-material (or transparent) panel which can contain other elements | 
| COgre::BorderPanelOverlayElement | A specialisation of the PanelOverlayElement to provide a panel with a border | 
| COgre::TextAreaOverlayElement | This class implements an overlay element which contains simple unformatted text | 
| COgre::ShadowRenderable | Class which represents the renderable aspects of a set of shadow volume faces | 
| COgre::SimpleRenderable | Simple implementation of MovableObject and Renderable for single-part custom objects | 
| COgre::StaticGeometry::GeometryBucket | A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored | 
| COgre::SubEntity | Utility class which defines the sub-parts of an Entity | 
| COgre::TerrainQuadTreeNode | A node in a quad tree used to store a patch of terrain | 
| COgre::Renderable::Visitor | Visitor object that can be used to iterate over a collection of Renderable instances abstractly | 
| COgre::RenderablePass | Struct associating a single Pass with a single Renderable | 
| COgre::RenderObjectListener | Abstract interface which classes must implement if they wish to receive events from the scene manager when single object is about to be rendered | 
| COgre::RenderOperation | 'New' rendering operation using vertex buffers | 
| COgre::RenderQueue::RenderableListener | Class to listen in on items being added to the render queue | 
| ►COgre::RenderQueueListener | Abstract interface which classes must implement if they wish to receive events from the render queue | 
| COgre::OverlaySystem | This class simplify initialization / finalization of the overlay system | 
| ►COgre::RenderSystem::Listener | Defines a listener on the custom events that this render system can raise | 
| COgre::OverlaySystem | This class simplify initialization / finalization of the overlay system | 
| COgre::RenderTarget::FrameStats |  | 
| COgre::RenderTargetEvent | Struct containing information about a RenderTarget event | 
| ►COgre::RenderTargetListener | A interface class defining a listener which can be used to receive notifications of RenderTarget events | 
| COgre::CompositorChain | Chain of compositor effects applying to one viewport | 
| COgre::RenderTargetViewportEvent | Struct containing information about a RenderTarget Viewport-specific event | 
| COgre::RenderToVertexBuffer | An object which renders geometry to a vertex | 
| COgre::RenderWindowDescription | Render window creation parameters | 
| ►COgre::Resource::Listener |  | 
| COgre::Entity | Defines an instance of a discrete, movable object based on a Mesh | 
| COgre::GpuProgramUsage | This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit | 
| ►COgre::ResourceGroupListener | This class defines an interface which is called back during resource group loading to indicate the progress of the load | 
| COgreBites::TrayManager | Main class to manage a cursor, backdrop, trays and widgets | 
| COgre::ResourceGroupManager::ResourceDeclaration | Nested struct defining a resource declaration | 
| COgre::ResourceGroupManager::ResourceLocation | Resource location entry | 
| COgre::ResourceLoadingListener | This class allows users to override resource loading behavior | 
| COgre::RotationalSpline | This class interpolates orientations (rotations) along a spline using derivatives of quaternions | 
| COgre::RTShader::FunctionInvocation::FunctionInvocationCompare | Comparator function to be used for comparisons | 
| COgre::RTShader::FunctionInvocation::FunctionInvocationLessThan | Comparator function to be used for sorting | 
| COgre::RTShader::FunctionStageRef | FFPShaderStage, part of a Function | 
| COgre::RTShader::ParameterFactory | Helper utility class that creates common parameters | 
| COgre::RTShader::SubRenderStateAccessor | This class uses as accessor from a template SubRenderState to all of its instances that created based on it | 
| COgre::Sampler | Class which determines how a TextureUnitState accesses data from a Texture | 
| COgre::Sampler::UVWAddressingMode | Texture addressing mode for each texture coordinate | 
| ►COgre::SceneManager::Listener | Class that allows listening in on the various stages of SceneManager processing, so that custom behaviour can be implemented from outside | 
| ►COgre::DebugDrawer | Interface for visualising debugging the SceneManager state | 
| COgre::DefaultDebugDrawer |  | 
| COgre::Terrain | The main containing class for a chunk of terrain | 
| COgre::SceneManager::RenderContext |  | 
| COgre::SceneManager::SkyBoxGenParameters |  | 
| COgre::SceneManager::SkyDomeGenParameters |  | 
| COgre::SceneManager::SkyPlaneGenParameters |  | 
| ►COgre::SceneManagerFactory | Class which will create instances of a given SceneManager | 
| COgre::BspSceneManagerFactory | Factory for BspSceneManager | 
| COgre::OctreeSceneManagerFactory | Factory for OctreeSceneManager | 
| COgre::PCZSceneManagerFactory | Factory for PCZSceneManager | 
| ►COgre::SceneQueryListener | This optional class allows you to receive per-result callbacks from SceneQuery executions instead of a single set of consolidated results | 
| ►COgre::RegionSceneQuery | Abstract class defining a query which returns single results from a region | 
| ►COgre::AxisAlignedBoxSceneQuery | Specialises the SceneQuery class for querying within an axis aligned box | 
| ►COgre::DefaultAxisAlignedBoxSceneQuery | Default implementation of AxisAlignedBoxSceneQuery | 
| COgre::OctreeAxisAlignedBoxSceneQuery | Octree implementation of AxisAlignedBoxSceneQuery | 
| COgre::PCZAxisAlignedBoxSceneQuery | PCZ implementation of AxisAlignedBoxSceneQuery | 
| ►COgre::PlaneBoundedVolumeListSceneQuery | Specialises the SceneQuery class for querying within a plane-bounded volume | 
| ►COgre::DefaultPlaneBoundedVolumeListSceneQuery | Default implementation of PlaneBoundedVolumeListSceneQuery | 
| COgre::OctreePlaneBoundedVolumeListSceneQuery | Octree implementation of PlaneBoundedVolumeListSceneQuery | 
| COgre::PCZPlaneBoundedVolumeListSceneQuery | PCZ implementation of PlaneBoundedVolumeListSceneQuery | 
| ►COgre::SphereSceneQuery | Specialises the SceneQuery class for querying within a sphere | 
| ►COgre::DefaultSphereSceneQuery | Default implementation of SphereSceneQuery | 
| COgre::OctreeSphereSceneQuery | Octree implementation of SphereSceneQuery | 
| COgre::PCZSphereSceneQuery | PCZ implementation of SphereSceneQuery | 
| ►COgre::ScriptCompilerEvent | This struct is a base class for events which can be thrown by the compilers and caught by subscribers | 
| COgre::CreateCompositorScriptCompilerEvent |  | 
| COgre::CreateGpuProgramScriptCompilerEvent |  | 
| COgre::CreateGpuSharedParametersScriptCompilerEvent |  | 
| COgre::CreateMaterialScriptCompilerEvent |  | 
| COgre::CreateParticleSystemScriptCompilerEvent |  | 
| COgre::ProcessNameExclusionScriptCompilerEvent |  | 
| COgre::ProcessResourceNameScriptCompilerEvent |  | 
| COgre::ScriptCompilerListener | This is a listener for the compiler | 
| ►COgre::ScriptLoader | Abstract class defining the interface used by classes which wish to perform script loading to define instances of whatever they manage | 
| COgre::CgFxScriptLoader | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them | 
| COgre::OverlayManager | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them | 
| COgre::Quake3ShaderManager | Class for managing Quake3 custom shaders | 
| ►COgre::ResourceManager | Defines a generic resource handler | 
| COgre::CompositorManager | Class for managing Compositor settings for Ogre | 
| COgre::FontManager | Manages Font resources, parsing .fontdef files and generally organising them | 
| COgre::GpuProgramManager | This ResourceManager manages GPU shader programs | 
| COgre::MaterialManager | Class for managing Material settings for Ogre | 
| COgre::MeshManager | Handles the management of mesh resources | 
| COgre::SkeletonManager | Handles the management of skeleton resources | 
| ►COgre::TextureManager | Class for loading & managing textures | 
| COgre::DefaultTextureManager | Specialisation of TextureManager for offline processing. Cannot be used with an active RenderSystem | 
| COgre::ScriptCompilerManager | Manages threaded compilation of scripts | 
| COgre::Segment | 3D Line Segment class for intersection testing in Ogre3D | 
| COgre::set< T, P > |  | 
| ►COgre::ShadowCaster | This class defines the interface that must be implemented by shadow casters | 
| COgre::MovableObject | Abstract class defining a movable object in a scene | 
| COgre::ShadowTextureConfig | Structure containing the configuration for one shadow texture | 
| ►COgre::ShadowTextureListener |  | 
| COgre::PCZSceneManager | Specialized SceneManager that uses Portal-Connected-Zones to divide the scene spatially | 
| COgre::SimpleSpline | A very simple spline class which implements the Catmull-Rom class of splines | 
| COgre::Singleton< T > | Template class for creating single-instance global classes | 
| ►COgre::Singleton< AbsolutePixelCountLodStrategy > |  | 
| COgre::AbsolutePixelCountLodStrategy |  | 
| ►COgre::Singleton< ArchiveManager > |  | 
| COgre::ArchiveManager | This class manages the available ArchiveFactory plugins | 
| ►COgre::Singleton< CgFxScriptLoader > |  | 
| COgre::CgFxScriptLoader | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them | 
| ►COgre::Singleton< CompositorManager > |  | 
| COgre::CompositorManager | Class for managing Compositor settings for Ogre | 
| ►COgre::Singleton< ControllerManager > |  | 
| COgre::ControllerManager | Class for managing Controller instances | 
| ►COgre::Singleton< DistanceLodBoxStrategy > |  | 
| COgre::DistanceLodBoxStrategy | Level of detail strategy based on distance from camera to an object's bounding box | 
| ►COgre::Singleton< DistanceLodSphereStrategy > |  | 
| COgre::DistanceLodSphereStrategy | Level of detail strategy based on distance from camera to an object's bounding sphere | 
| ►COgre::Singleton< DynLibManager > |  | 
| COgre::DynLibManager | Manager for Dynamic-loading Libraries | 
| ►COgre::Singleton< ExternalTextureSourceManager > |  | 
| COgre::ExternalTextureSourceManager | Singleton Class which handles the registering and control of texture plugins | 
| ►COgre::Singleton< FontManager > |  | 
| COgre::FontManager | Manages Font resources, parsing .fontdef files and generally organising them | 
| ►COgre::Singleton< GpuProgramManager > |  | 
| COgre::GpuProgramManager | This ResourceManager manages GPU shader programs | 
| ►COgre::Singleton< HardwareBufferManager > |  | 
| COgre::HardwareBufferManager | Singleton wrapper for hardware buffer manager | 
| ►COgre::Singleton< HardwareSkinningFactory > |  | 
| COgre::RTShader::HardwareSkinningFactory | A factory that enables creation of HardwareSkinning instances | 
| ►COgre::Singleton< LodStrategyManager > |  | 
| COgre::LodStrategyManager | Manager for LOD strategies | 
| ►COgre::Singleton< LogManager > |  | 
| COgre::LogManager | The log manager handles the creation and retrieval of logs for the application | 
| ►COgre::Singleton< MaterialManager > |  | 
| COgre::MaterialManager | Class for managing Material settings for Ogre | 
| ►COgre::Singleton< MeshLodGenerator > |  | 
| COgre::MeshLodGenerator |  | 
| ►COgre::Singleton< MeshManager > |  | 
| COgre::MeshManager | Handles the management of mesh resources | 
| ►COgre::Singleton< OverlayManager > |  | 
| COgre::OverlayManager | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them | 
| ►COgre::Singleton< OverlaySystem > |  | 
| COgre::OverlaySystem | This class simplify initialization / finalization of the overlay system | 
| ►COgre::Singleton< ParticleSystemManager > |  | 
| COgre::ParticleSystemManager | Manages particle systems, particle system scripts (templates) and the available emitter & affector factories | 
| ►COgre::Singleton< PCZoneFactoryManager > |  | 
| COgre::PCZoneFactoryManager |  | 
| ►COgre::Singleton< Profiler > |  | 
| COgre::Profiler | The profiler allows you to measure the performance of your code | 
| ►COgre::Singleton< ProgramManager > |  | 
| COgre::RTShader::ProgramManager | A singleton manager class that manages shader based programs | 
| ►COgre::Singleton< ProgramWriterManager > |  | 
| COgre::RTShader::ProgramWriterManager |  | 
| ►COgre::Singleton< Quake3ShaderManager > |  | 
| COgre::Quake3ShaderManager | Class for managing Quake3 custom shaders | 
| ►COgre::Singleton< RenderSystemCapabilitiesManager > |  | 
| COgre::RenderSystemCapabilitiesManager | Class for managing RenderSystemCapabilities database for Ogre | 
| ►COgre::Singleton< ResourceBackgroundQueue > |  | 
| COgre::ResourceBackgroundQueue | This class is used to perform Resource operations in a background thread | 
| ►COgre::Singleton< ResourceGroupManager > |  | 
| COgre::ResourceGroupManager | This singleton class manages the list of resource groups, and notifying the various resource managers of their obligations to load / unload resources in a group | 
| ►COgre::Singleton< Root > |  | 
| COgre::Root | The root class of the Ogre system | 
| ►COgre::Singleton< ScreenRatioPixelCountLodStrategy > |  | 
| COgre::ScreenRatioPixelCountLodStrategy |  | 
| ►COgre::Singleton< ScriptCompilerManager > |  | 
| COgre::ScriptCompilerManager | Manages threaded compilation of scripts | 
| ►COgre::Singleton< ShaderGenerator > |  | 
| COgre::RTShader::ShaderGenerator | Shader generator system main interface | 
| ►COgre::Singleton< SkeletonManager > |  | 
| COgre::SkeletonManager | Handles the management of skeleton resources | 
| ►COgre::Singleton< TerrainGlobalOptions > |  | 
| COgre::TerrainGlobalOptions | Options class which just stores default options for the terrain | 
| ►COgre::Singleton< TextureManager > |  | 
| COgre::TextureManager | Class for loading & managing textures | 
| ►COgre::SmallVectorBase | SmallVectorBase - This is all the non-templated stuff common to all SmallVectors | 
| ►COgre::SmallVectorTemplateCommon< T > |  | 
| ►COgre::SmallVectorTemplateBase< T, isPodLike< T >::value > |  | 
| COgre::U< T > |  | 
| ►COgre::SmallVectorImpl< T > | SmallVectorImpl - This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter | 
| COgre::iterator< T, S > |  | 
| ►COgre::SmallVector< T, S > |  | 
| COgre::VectorSet< T, S > | VectorSet is basically a helper to use a vector as a small set container | 
| COgre::SmallVector< T, 0 > | Specialize SmallVector at N=0 | 
| ►COgre::SmallVector< T, N > | SmallVector - This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small | 
| COgre::VectorSet< Edge, 8 > |  | 
| COgre::VectorSet< Line *, 7 > |  | 
| COgre::VectorSet< Triangle *, 7 > |  | 
| COgre::SmallVector< T, 0 > | Specialize SmallVector at N=0 | 
| COgre::SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's | 
| COgre::SmallVectorTemplateBase< T, isPodLike > | SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's | 
| COgre::SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's | 
| COgre::SPFMDeleteT |  | 
| COgre::SPFMNone |  | 
| COgre::Sphere | A sphere primitive, mostly used for bounds checking | 
| COgre::StaticCache< cacheSize > | Template version of cache based on static array | 
| COgre::StaticFaceGroup | Collects a group of static i.e | 
| COgre::StaticGeometry::SubMeshLodGeometryLink | Saved link between SubMesh at a LOD and vertex/index data May point to original or optimised geometry | 
| COgre::StencilState | Describes the stencil buffer operation | 
| COgre::StringConverter | Class for converting the core Ogre data types to/from Strings | 
| ►COgre::StringInterface | Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers | 
| COgre::ExternalTextureSource | IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from | 
| COgre::OverlayElement | Abstract definition of a 2D element to be displayed in an Overlay | 
| COgre::ParticleAffector | Abstract class defining the interface to be implemented by particle affectors | 
| COgre::ParticleEmitter | Abstract class defining the interface to be implemented by particle emitters | 
| COgre::ParticleSystem | Class defining particle system based special effects | 
| COgre::ParticleSystemRenderer | Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances | 
| ►COgre::Resource | Abstract class representing a loadable resource | 
| COgre::BspLevel | Holds all the data associated with a Binary Space Parition (BSP) based indoor level | 
| COgre::Compositor | Class representing a Compositor object | 
| COgre::Font | Class representing a font in the system | 
| ►COgre::GpuProgram | Defines a program which runs on the GPU such as a vertex or fragment program | 
| ►COgre::HighLevelGpuProgram | Abstract base class representing a high-level program (a vertex or fragment program) | 
| COgre::CgProgram | Specialisation of HighLevelGpuProgram to provide support for nVidia's CG language | 
| COgre::GLSLangProgram | Specialisation of HighLevelGpuProgram to provide support for the GLSLang compiler by Khronos | 
| COgre::Material | Class encapsulates rendering properties of an object | 
| COgre::Mesh | Resource holding data about 3D mesh | 
| COgre::Skeleton | A collection of Bone objects used to animate a skinned mesh | 
| COgre::Texture | Abstract class representing a Texture resource | 
| COgre::StringUtil | Utility class for manipulating Strings | 
| COgre::TangentSpaceCalc | Class for calculating a tangent space basis | 
| COgre::TangentSpaceCalc::IndexRemap | Information about a remapped index | 
| COgre::TangentSpaceCalc::Result | The result of having built a tangent space basis | 
| COgre::Technique::GPUDeviceNameRule | Rule controlling whether technique is deemed supported based on GPU device name | 
| COgre::Technique::GPUVendorRule | Rule controlling whether technique is deemed supported based on GPU vendor | 
| COgre::Terrain::ImportData | Structure encapsulating import data that you may use to bootstrap the terrain without loading from a native data stream | 
| COgre::Terrain::LayerInstance | An instance of a layer, with specific texture names | 
| COgre::TerrainAutoUpdateLodFactory |  | 
| COgre::TerrainGroup | Helper class to assist you in managing multiple terrain instances that are connected to each other | 
| COgre::TerrainGroup::RayResult | Result from a terrain ray intersection with the terrain group | 
| COgre::TerrainGroup::TerrainSlotDefinition | Definition of how to populate a 'slot' in the terrain group | 
| COgre::TerrainLayerSampler | Description of a sampler that will be used with each layer | 
| COgre::TerrainLodManager | Terrain LOD data manager | 
| COgre::TerrainLodManager::LoadLodRequest |  | 
| COgre::TerrainLodManager::LodInfo |  | 
| ►COgre::TerrainMaterialGenerator::Profile |  | 
| COgre::TerrainMaterialGeneratorA::SM2Profile | Shader model 2 profile target | 
| COgre::TextureUnitState::TextureEffect | Internal structure defining a texture effect | 
| COgre::TimeIndex | Time index object used to search keyframe at the given position | 
| COgre::TransformBase< rows, T > | Class encapsulating a standard 4x4 homogeneous matrix | 
| ►COgre::TransformBase< 4, Real > |  | 
| ►COgre::TransformBaseReal |  | 
| COgre::Affine3 | Transform specialization for 3D Affine - encapsulating a 3x4 Matrix | 
| COgre::Matrix4 | Transform specialization for projective - encapsulating a 4x4 Matrix | 
| COgre::TRect< T > |  | 
| COgre::vector< T > |  | 
| ►COgre::VectorBase< dims, T > | Helper class to implement legacy API. Notably x, y, z access | 
| COgre::Vector< 2, Real > |  | 
| COgre::Vector< 2, float > |  | 
| COgre::Vector< 2, int > |  | 
| COgre::Vector< 3, Real > |  | 
| COgre::Vector< 3, float > |  | 
| COgre::Vector< 3, int > |  | 
| COgre::Vector< 4, Real > |  | 
| COgre::Vector< 4, float > |  | 
| COgre::Vector< 3, uchar > |  | 
| COgre::Vector< 4, uchar > |  | 
| COgre::Vector< dims, T > | Standard N-dimensional vector | 
| COgre::VectorBase< 2, Real > |  | 
| COgre::VectorBase< 3, Real > |  | 
| COgre::VectorBase< 4, Real > |  | 
| COgre::VertexBoneAssignment | Records the assignment of a single vertex to a single bone with the corresponding weight | 
| COgre::VertexData::HardwareAnimationData | Struct used to hold hardware morph / pose vertex data information | 
| COgre::VertexPoseKeyFrame::PoseRef | Reference to a pose at a given influence level | 
| COgre::ViewPoint | Structure for holding a position & orientation pair | 
| ►COgre::Viewport::Listener | Listener interface so you can be notified of Viewport changes | 
| COgre::CompositorChain | Chain of compositor effects applying to one viewport | 
| COgre::VisibleObjectsBoundsInfo | Structure collecting together information about the visible objects that have been discovered in a scene | 
| COgre::Volume::ChunkParameters | Parameters for loading the volume | 
| COgre::Volume::ChunkTreeSharedData | Internal shared values of the chunks which are equal in the whole tree | 
| COgre::Volume::DualCell | To store the generated dual cells in a vector | 
| COgre::Volume::MeshBuilderCallback | Callback class when the user needs information about the triangles of chunks of a LOD level | 
| COgre::Volume::OctreeNodeSplitPolicy | The class deciding on whether to split an octree node or not when building the octree | 
| COgre::Volume::SimplexNoise | Simplex Noise ported from public domain Java Implementation http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java Thanks Stefan Gustavson! | 
| ►COgre::Volume::Source | Abstract class defining the density function | 
| COgre::Volume::CSGCubeSource | A not rotated cube | 
| ►COgre::Volume::CSGOperationSource | Abstract operation volume source holding two sources as operants | 
| COgre::Volume::CSGDifferenceSource | Builds the difference between two sources | 
| COgre::Volume::CSGIntersectionSource | Builds the intersection between two sources | 
| COgre::Volume::CSGUnionSource | Builds the union between two sources | 
| COgre::Volume::CSGPlaneSource | A plane | 
| COgre::Volume::CSGSphereSource | A sphere | 
| ►COgre::Volume::CSGUnarySource | Source which does a unary operation to another one | 
| COgre::Volume::CSGNegateSource | Negates the given volume | 
| COgre::Volume::CSGNoiseSource |  | 
| COgre::Volume::CSGScaleSource | Scales the given volume source | 
| COgre::Volume::CacheSource | A caching Source | 
| ►COgre::Volume::GridSource | A volume source from a discrete 3d grid | 
| COgre::Volume::HalfFloatGridSource | A volume source from a 16 Bit float 3D grid capable of loading volume serializations | 
| COgre::Volume::TextureSource | A volume source from a 3D texture | 
| COgre::Volume::Vertex | Lightweight struct to represent a mesh vertex | 
| COgre::WorldFragment | Represents part of the world geometry that is a result of a SceneQuery | 
| COgreBites::AxisEvent |  | 
| COgreBites::ButtonEvent |  | 
| COgreBites::Event |  | 
| ►COgreBites::InputListener | Return values of the callbacks are ignored by ApplicationContext however they can be used to control event propagation in a hierarchy | 
| COgreBites::AdvancedRenderControls |  | 
| COgreBites::CameraMan | Utility class for controlling the camera in samples | 
| COgreBites::ImGuiInputListener |  | 
| COgreBites::InputListenerChain | Chain of multiple InputListeners that acts as a single InputListener | 
| COgreBites::TrayManager | Main class to manage a cursor, backdrop, trays and widgets | 
| COgreBites::KeyboardEvent |  | 
| COgreBites::Keysym |  | 
| COgreBites::MouseButtonEvent |  | 
| COgreBites::MouseMotionEvent |  | 
| COgreBites::MouseWheelEvent |  | 
| COgreBites::NativeWindowPair | Link between a renderwindow and a platform specific window | 
| COgreBites::StaticPluginLoader | Utility class for loading the plugins statically | 
| COgreBites::TextInputEvent |  | 
| COgreBites::TouchFingerEvent |  | 
| ►COgreBites::TrayListener | Listener class for responding to tray events | 
| COgreBites::TrayManager | Main class to manage a cursor, backdrop, trays and widgets | 
| ►COgreBites::Widget | Abstract base class for all widgets | 
| COgreBites::Button | Basic button class | 
| COgreBites::CheckBox | Basic check box widget | 
| COgreBites::DecorWidget | Custom, decorative widget created from a template | 
| COgreBites::Label | Basic label widget | 
| COgreBites::ParamsPanel | Basic parameters panel widget | 
| COgreBites::ProgressBar | Basic progress bar widget | 
| COgreBites::SelectMenu | Basic selection menu widget | 
| COgreBites::Separator | Basic separator widget | 
| COgreBites::Slider | Basic slider widget | 
| COgreBites::TextBox | Scrollable text box widget | 
| COgreBites::WindowEventListener | Callback class used to send out window events to client app | 
| COgreBites::WindowEventUtilities | Utility class to handle Window Messages | 
| ►COverlayAlloc |  | 
| COgre::BorderRenderable | Class for rendering the border of a BorderPanelOverlayElement | 
| ►COgre::Overlay | Represents a layer which is rendered on top of the 'normal' scene contents | 
| COgre::ImGuiOverlay | Ogre's integrated support for Dear ImGui | 
| COgre::OverlayElement | Abstract definition of a 2D element to be displayed in an Overlay | 
| COgre::OverlayElementFactory | Defines the interface which all components wishing to supply OverlayElement subclasses must implement | 
| COgre::OverlayManager | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them | 
| ►CPageAlloc |  | 
| COgre::PageContent | Interface definition for a unit of content within a page | 
| ►COgre::PageContentCollection | Definition of the interface for a collection of PageContent instances | 
| COgre::SimplePageContentCollection | Specialisation of PageContentCollection which just provides a simple list of PageContent instances | 
| ►COgre::PageContentCollectionFactory | Define the interface to a factory class that will create subclasses of PageContentCollection | 
| COgre::SimplePageContentCollectionFactory | Factory class for SimplePageContentCollection | 
| COgre::PageContentFactory | Define the interface to a factory class that will create subclasses of PageContent | 
| COgre::PageManager | The PageManager is the entry point through which you load all PagedWorld instances, and the place where PageStrategy instances and factory classes are registered to customise the paging behaviour | 
| ►COgre::PageStrategy | Defines the interface to a strategy class which is responsible for deciding when Page instances are requested for addition and removal from the paging system | 
| COgre::Grid2DPageStrategy | Page strategy which loads new pages based on a regular 2D grid | 
| COgre::Grid3DPageStrategy | Page strategy which loads new pages based on a regular 3D grid | 
| ►COgre::PageStrategyData | Abstract marker class representing the data held against the PagedWorldSection which is specifically used by the PageStrategy | 
| COgre::Grid2DPageStrategyData | Specialisation of PageStrategyData for Grid2DPageStrategy | 
| COgre::Grid3DPageStrategyData | Specialisation of PageStrategyData for Grid3DPageStrategy | 
| COgre::PagedWorld | This class represents a collection of pages which make up a world | 
| ►COgre::PagedWorldSection | Represents a section of the PagedWorld which uses a given PageStrategy, and which is made up of a generally localised set of Page instances | 
| COgre::TerrainPagedWorldSection | A world section which includes paged terrain | 
| COgre::PagedWorldSectionFactory | A factory class for creating types of world section | 
| ►CPassAlloc |  | 
| COgre::GpuProgramUsage | This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit | 
| COgre::IlluminationPass | Struct recording a pass which can be used for a specific illumination stage | 
| COgre::Pass | Class defining a single pass of a Technique (of a Material): a single rendering call | 
| ►CPatchAlloc |  | 
| COgre::PatchSurface | A surface which is defined by curves of some kind to form a patch, e.g | 
| ►CPluginAlloc |  | 
| ►COgre::Plugin | Class defining a generic OGRE plugin | 
| COgre::AssimpPlugin |  | 
| COgre::BspSceneManagerPlugin | Plugin instance for BSPSceneManager | 
| COgre::CgPlugin | Plugin instance for Cg Program Manager | 
| COgre::DotScenePlugin |  | 
| COgre::GLSLangPlugin | Plugin instance for Cg Program Manager | 
| COgre::OctreePlugin | Plugin instance for Octree Manager | 
| COgre::OctreeZonePlugin | Plugin instance for OctreeZone | 
| COgre::PCZPlugin | Plugin instance for PCZ Manager | 
| COgre::ParticleFXPlugin | Plugin instance for ParticleFX Manager | 
| ►CProfilerAlloc |  | 
| COgre::Profile | An individual profile that will be processed by the Profiler | 
| COgre::ProfileInstance | Represents an individual profile call | 
| COgre::Profiler | The profiler allows you to measure the performance of your code | 
| ►CPropertyAlloc |  | 
| ►COgre::PropertyBase | Base interface for an instance of a property | 
| COgre::Property< T > | Property instance with passthrough calls to a given object | 
| COgre::PropertyDef | Definition of a property of an object | 
| COgre::PropertySet | Defines a complete set of properties for a single object instance | 
| ►CQObject |  | 
| COgreBites::ApplicationContextQt | Specialization for connecting with Qt | 
| ►CRenderQueueAlloc |  | 
| COgre::QueuedRenderableCollection | Lowest level collection of renderables | 
| COgre::RenderPriorityGroup | Collection of renderables by priority | 
| COgre::RenderQueue | Class to manage the scene object rendering queue | 
| COgre::RenderQueueGroup | A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same time to the renderer | 
| ►CRenderSysAlloc |  | 
| COgre::DepthBuffer | An abstract class that contains a depth/stencil buffer | 
| COgre::HardwareOcclusionQuery | Query how many pixels have passed the per-fragment tests | 
| ►COgre::RenderSystem | Defines the functionality of a 3D API | 
| COgre::D3D11RenderSystem | Implementation of DirectX11 as a rendering system | 
| COgre::D3D9RenderSystem | Implementation of DirectX9 as a rendering system | 
| COgre::MetalRenderSystem |  | 
| COgre::TinyRenderSystem | Software rasterizer Implementation as a rendering system | 
| COgre::VulkanRenderSystem |  | 
| COgre::RenderSystemCapabilities | This class stores the capabilities of the graphics card | 
| COgre::RenderSystemCapabilitiesManager | Class for managing RenderSystemCapabilities database for Ogre | 
| COgre::RenderSystemCapabilitiesSerializer | Class for serializing RenderSystemCapabilities to / from a .rendercaps script | 
| ►COgre::RenderTarget | A 'canvas' which can receive the results of a rendering operation | 
| COgre::MultiRenderTarget | This class represents a render target that renders to multiple RenderTextures at once | 
| COgre::RenderTexture | This class represents a RenderTarget that renders to a Texture | 
| COgre::RenderWindow | Manages the target rendering window | 
| ►CResourceAlloc |  | 
| COgre::D3D9ResourceManager |  | 
| COgre::ExternalTextureSourceManager | Singleton Class which handles the registering and control of texture plugins | 
| COgre::Quake3Level | Support for loading and extracting data from a Quake3 level file | 
| COgre::Quake3Shader | Class for recording Quake3 shaders | 
| COgre::Quake3ShaderManager | Class for managing Quake3 custom shaders | 
| COgre::Resource | Abstract class representing a loadable resource | 
| COgre::ResourceGroupManager | This singleton class manages the list of resource groups, and notifying the various resource managers of their obligations to load / unload resources in a group | 
| COgre::ResourceManager | Defines a generic resource handler | 
| COgre::ResourceManager::ResourcePool | Definition of a pool of resources, which users can use to reuse similar resources many times without destroying and recreating them | 
| ►CRootAlloc |  | 
| COgre::Root | The root class of the Ogre system | 
| ►CRTShaderSystemAlloc |  | 
| COgre::RTShader::Function | A class that represents a shader based program function | 
| ►COgre::RTShader::FunctionAtom | A class that represents an atomic code section of shader based program function | 
| COgre::RTShader::AssignmentAtom | Shorthand for "lhs = rhs;" insted of using FFP_Assign(rhs, lhs) | 
| COgre::RTShader::BinaryOpAtom | Shorthand for "dst = a OP b;" | 
| COgre::RTShader::BuiltinFunctionAtom | Shorthand for "dst = BUILTIN(args);" | 
| COgre::RTShader::FunctionInvocation | A class that represents function invocation code from shader based program function | 
| COgre::RTShader::SampleTextureAtom | Shorthand for "dst = texture(sampler, uv);" instead of using FFP_SampleTexture | 
| ►COgre::RTShader::Operand | A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields) | 
| COgre::RTShader::At | Shorthand for operator[] on preceding operand. e.g. myArray[p] | 
| COgre::RTShader::In |  | 
| COgre::RTShader::InOut |  | 
| COgre::RTShader::Out |  | 
| ►COgre::RTShader::Parameter | A class that represents a shader based program parameter | 
| COgre::RTShader::ConstParameter< valueType > | Helper template which is the base for our ConstParameters | 
| COgre::RTShader::UniformParameter | Uniform parameter class | 
| COgre::RTShader::Program | A class that represents a shader based program | 
| COgre::RTShader::ProgramManager | A singleton manager class that manages shader based programs | 
| COgre::RTShader::ProgramSet | Container class for shader based programs | 
| COgre::RTShader::ProgramWriter | Base class interface for shader program writers | 
| COgre::RTShader::ProgramWriterManager |  | 
| ►COgre::RTShader::RenderState | This is a container class for sub render state class | 
| COgre::RTShader::TargetRenderState | This is the target render state | 
| COgre::RTShader::ShaderGenerator | Shader generator system main interface | 
| ►COgre::RTShader::SubRenderState | This class is the base interface of sub part from a shader based rendering pipeline | 
| ►COgre::RTShader::FFPTexturing | Texturing sub render state implementation of the Fixed Function Pipeline | 
| COgre::RTShader::LayeredBlending |  | 
| ►COgre::RTShader::SubRenderStateFactory | Abstract factory interface for creating SubRenderState implementation instances | 
| COgre::RTShader::HardwareSkinningFactory | A factory that enables creation of HardwareSkinning instances | 
| ►CSceneCtlAllocatedObject |  | 
| COgre::Octree | Octree datastructure for managing scene nodes | 
| ►COgre::PCZone | Portal-Connected Zone datastructure for managing scene nodes | 
| COgre::DefaultZone |  | 
| COgre::OctreeZone |  | 
| ►COgre::PCZoneFactory | Factory for PCZones | 
| COgre::DefaultZoneFactory |  | 
| COgre::OctreeZoneFactory | Factory for OctreeZone | 
| COgre::PCZoneFactoryManager |  | 
| ►COgre::ZoneData |  | 
| COgre::OctreeZoneData |  | 
| ►CSceneMgtAlloc |  | 
| COgre::AutoParamDataSource | This utility class is used to hold the information used to generate the matrices and other information required to automatically populate GpuProgramParameters | 
| COgre::IntersectionSceneQueryResult | Holds the results of an intersection scene query (pair values) | 
| COgre::SceneManager | Manages the organisation and rendering of a 'scene': a collection of objects and potentially world geometry | 
| ►COgre::SceneQuery | A class for performing queries on a scene | 
| COgre::IntersectionSceneQuery | Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another | 
| COgre::RaySceneQuery | Specialises the SceneQuery class for querying along a ray | 
| COgre::RegionSceneQuery | Abstract class defining a query which returns single results from a region | 
| COgre::SceneQueryResult | Holds the results of a scene query | 
| ►CScriptCompilerAlloc |  | 
| COgre::CgFxScriptLoader | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them | 
| COgre::ConcreteNode |  | 
| COgre::ScriptCompiler | This is the main class for the compiler | 
| COgre::ScriptCompilerManager | Manages threaded compilation of scripts | 
| ►CScriptTranslatorAlloc |  | 
| ►COgre::ScriptTranslator | This class translates script AST (abstract syntax tree) into Ogre resources | 
| COgre::RTShader::SGScriptTranslator | This class responsible for translating core features of the RT Shader System for Ogre material scripts | 
| COgre::ScriptTranslatorManager | The ScriptTranslatorManager manages the lifetime and access to script translators | 
| ►CSerializerAlloc |  | 
| COgre::MaterialSerializer | Class for serializing Materials to a .material script | 
| ►COgre::Serializer | Generic class for serialising data to / from binary stream-based files | 
| COgre::GpuNamedConstantsSerializer | Simple class for loading / saving GpuNamedConstants | 
| COgre::LodConfigSerializer |  | 
| COgre::MeshSerializer | Class for serialising mesh data to/from an OGRE .mesh file | 
| COgre::SkeletonSerializer | Class for serialising skeleton data to/from an OGRE .skeleton file | 
| ►CShadowDataAlloc |  | 
| ►COgre::ShadowCameraSetup | This class allows you to plug in new ways to define the camera setup when rendering and projecting shadow textures | 
| ►COgre::DefaultShadowCameraSetup | Implements default shadow camera setup | 
| ►COgre::FocusedShadowCameraSetup | Implements the uniform shadow mapping algorithm in focused mode | 
| ►COgre::LiSPSMShadowCameraSetup | Implements the Light Space Perspective Shadow Mapping Algorithm [WSP04] | 
| COgre::PSSMShadowCameraSetup | Parallel Split Shadow Map (PSSM) shadow camera setup | 
| COgre::PlaneOptimalShadowCameraSetup | Implements the plane optimal shadow camera algorithm | 
| COgre::ShadowRenderable | Class which represents the renderable aspects of a set of shadow volume faces | 
| ►Cshared_ptr |  | 
| COgre::SharedPtr< FileInfoList > |  | 
| COgre::SharedPtr< ControllerValue< float > > |  | 
| COgre::SharedPtr< ControllerFunction< float > > |  | 
| COgre::SharedPtr< AnimableValue > |  | 
| COgre::SharedPtr< Compositor > |  | 
| COgre::SharedPtr< DataStream > |  | 
| COgre::SharedPtr< GpuProgram > |  | 
| COgre::SharedPtr< GpuNamedConstants > |  | 
| COgre::SharedPtr< GpuLogicalBufferStruct > |  | 
| COgre::SharedPtr< GpuSharedParameters > |  | 
| COgre::SharedPtr< GpuProgramParameters > |  | 
| COgre::SharedPtr< HardwareBuffer > |  | 
| COgre::SharedPtr< HardwareIndexBuffer > |  | 
| COgre::SharedPtr< HardwarePixelBuffer > |  | 
| COgre::SharedPtr< HardwareVertexBuffer > |  | 
| COgre::SharedPtr< Material > |  | 
| COgre::SharedPtr< MemoryDataStream > |  | 
| COgre::SharedPtr< Mesh > |  | 
| COgre::SharedPtr< PatchMesh > |  | 
| COgre::SharedPtr< RenderToVertexBuffer > |  | 
| COgre::SharedPtr< Resource > |  | 
| COgre::SharedPtr< ShadowCameraSetup > |  | 
| COgre::SharedPtr< Skeleton > |  | 
| COgre::SharedPtr< Texture > |  | 
| COgre::SharedPtr< ConcreteNode > |  | 
| COgre::SharedPtr< ConcreteNodeList > |  | 
| COgre::SharedPtr< AbstractNode > |  | 
| COgre::SharedPtr< AbstractNodeList > |  | 
| COgre::SharedPtr< StringVector > |  | 
| COgre::SharedPtr< Font > |  | 
| COgre::SharedPtr< SubRenderStateAccessor > |  | 
| COgre::SharedPtr< TerrainMaterialGenerator > |  | 
| COgre::SharedPtr< BspLevel > |  | 
| COgre::SharedPtr< Ogre::ControllerValue< T > > |  | 
| COgre::SharedPtr< Ogre::ControllerFunction< T > > |  | 
| COgre::SharedPtr< T > |  | 
| ►Cstd::allocator |  | 
| COgre::AlignedAllocator< Other, Alignment > |  | 
| COgre::AlignedAllocator< T, Alignment > | STL compatible wrapper for AlignedMemory | 
| ►Cstd::exception |  | 
| ►COgre::Exception | When thrown, provides information about an error that has occurred inside the engine | 
| COgre::FileNotFoundException |  | 
| COgre::IOException |  | 
| COgre::InternalErrorException |  | 
| COgre::InvalidCallException |  | 
| COgre::InvalidParametersException |  | 
| COgre::InvalidStateException |  | 
| COgre::ItemIdentityException |  | 
| COgre::RenderingAPIException |  | 
| COgre::RuntimeAssertionException |  | 
| COgre::UnimplementedException | Template struct which creates a distinct type for each exception code | 
| ►CStreamAlloc |  | 
| ►COgre::DataStream | General purpose class used for encapsulating the reading and writing of data | 
| COgre::DeflateStream | Stream which compresses / uncompresses data using the 'deflate' compression algorithm | 
| COgre::FileHandleDataStream | Common subclass of DataStream for handling data from C-style file handles | 
| COgre::FileStreamDataStream | Common subclass of DataStream for handling data from std::basic_istream | 
| COgre::MemoryDataStream | Common subclass of DataStream for handling data from chunks of memory | 
| COgre::StreamSerialiser | Utility class providing helper methods for reading / writing structured data held in a DataStream | 
| COgre::StreamSerialiser::Chunk | Definition of a chunk of data in a file | 
| ►CSubEntityAlloc |  | 
| COgre::SubEntity | Utility class which defines the sub-parts of an Entity | 
| ►CSubMeshAlloc |  | 
| COgre::SubMesh | Defines a part of a complete mesh | 
| ►CTechniqueAlloc |  | 
| COgre::Technique | Class representing an approach to rendering this particular Material | 
| ►CTerrainAlloc |  | 
| ►COgre::Terrain::GpuBufferAllocator | Interface used to by the Terrain instance to allocate GPU buffers | 
| COgre::Terrain::DefaultGpuBufferAllocator | Standard implementation of a buffer allocator which re-uses buffers | 
| ►COgre::TerrainAutoUpdateLod | Terrain automatic LOD loading | 
| COgre::TerrainAutoUpdateLodByDistance | Class implementing TerrainAutoUpdateLod interface | 
| COgre::TerrainGlobalOptions | Options class which just stores default options for the terrain | 
| COgre::TerrainGroup::TerrainSlot | Slot for a terrain instance, together with its definition | 
| COgre::TerrainLayerBlendMap | Class exposing an interface to a blend map for a given layer | 
| ►COgre::TerrainMaterialGenerator | Class that provides functionality to generate materials for use with a terrain | 
| COgre::TerrainMaterialGeneratorA | A TerrainMaterialGenerator which can cope with normal mapped, specular mapped terrain | 
| COgre::TerrainPagedWorldSection::TerrainDefiner |  | 
| COgre::TerrainPaging | This class is the 'core' class for paging terrain, that will integrate with the larger paging system and provide the appropriate utility classes required | 
| COgre::TerrainQuadTreeNode::LodLevel |  | 
| ►CTextureUnitStateAlloc |  | 
| COgre::TextureUnitState | Class representing the state of a single texture unit during a Pass of a Technique, of a Material | 
| ►CTimerAlloc |  | 
| COgre::Timer | Timer class | 
| ►CUtilityAlloc |  | 
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog | 
| COgre::Volume::DualGridGenerator | Class for the generation of the DualGrid | 
| ►COgre::Volume::IsoSurface | Abstract IsoSurface | 
| COgre::Volume::IsoSurfaceMC | Marching Cubes implementation like at http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/ | 
| COgre::Volume::MeshBuilder | Class to build up a mesh with vertices and indices | 
| COgre::Volume::OctreeNode | A node in the volume octree | 
| ►COgre::WorkQueue | Interface to a general purpose task-basedbackground work queue | 
| ►COgre::DefaultWorkQueueBase | Base for a general purpose task-based background work queue | 
| COgre::DefaultWorkQueue | Implementation of a general purpose request / response style background work queue | 
| COgre::WorkQueue::Request | General purpose request structure | 
| COgre::WorkQueue::Response | General purpose response structure | 
| ►CVertexDataAlloc |  | 
| COgre::VertexBufferBinding | Records the state of all the vertex buffer bindings required to provide a vertex declaration with the input data it needs for the vertex elements | 
| COgre::VertexData | Collects together all the vertex-related information used to render geometry | 
| COgre::VertexDeclaration | This class declares the format of a set of vertex inputs, which can be issued to the rendering API through a RenderOperation | 
| COgre::VertexElement | This class declares the usage of a single vertex buffer as a component of a complete VertexDeclaration | 
| ►CViewportAlloc |  | 
| COgre::Viewport | An abstraction of a viewport, i.e., a rendering region on a render target |