| C_finddata_t | |
| COgre::AtomicScalar< LoadingState > | |
| COgre::AtomicScalar< ResourceHandle > | |
| COgre::AtomicScalar< size_t > | |
| COgre::AtomicScalar< uint32 > | |
| COgre::AtomicScalar< unsigned > | |
| 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 | |
| ►COgre::cbitsetN< _N, uint32, 5u, 0x1Fu > | |
| COgre::cbitset32< _N > | This is similar to std::bitset, except waaay less bloat |
| COgre::ComPtr< ID3D11Buffer > | |
| COgre::ComPtr< ID3D11ClassLinkage > | |
| COgre::ComPtr< ID3D11ComputeShader > | |
| COgre::ComPtr< ID3D11DepthStencilView > | |
| COgre::ComPtr< ID3D11DeviceContextN > | |
| COgre::ComPtr< ID3D11DeviceN > | |
| COgre::ComPtr< ID3D11DomainShader > | |
| COgre::ComPtr< ID3D11GeometryShader > | |
| COgre::ComPtr< ID3D11HullShader > | |
| COgre::ComPtr< ID3D11InfoQueue > | |
| COgre::ComPtr< ID3D11PixelShader > | |
| COgre::ComPtr< ID3D11Query > | |
| COgre::ComPtr< ID3D11RenderTargetView > | |
| COgre::ComPtr< ID3D11Resource > | |
| COgre::ComPtr< ID3D11ShaderResourceView > | |
| COgre::ComPtr< ID3D11Texture1D > | |
| COgre::ComPtr< ID3D11Texture2D > | |
| COgre::ComPtr< ID3D11Texture3D > | |
| COgre::ComPtr< ID3D11UnorderedAccessView > | |
| COgre::ComPtr< ID3D11VertexShader > | |
| COgre::ComPtr< IDXGIAdapterN > | |
| COgre::ComPtr< IDXGIFactoryN > | |
| COgre::ComPtr< IDXGISwapChainN > | |
| COgre::deque< Chunk * > | |
| COgre::deque< Request * > | |
| COgre::deque< Response * > | |
| COgre::deque< SceneManager * > | |
| COgre::deque< unsignedlong > | |
| CDisplay | |
| ►COgre::FactoryObj< Archive > | |
| ►COgre::ArchiveFactory | Abstract factory class, archive codec plugins can register concrete subclasses of this |
| COgre::APKFileSystemArchiveFactory | |
| COgre::FileSystemArchiveFactory | Specialisation of ArchiveFactory for FileSystem files |
| ►COgre::ZipArchiveFactory | Specialisation of ArchiveFactory for Zip files |
| ►COgre::EmbeddedZipArchiveFactory | Specialisation of ZipArchiveFactory for embedded Zip files |
| COgre::APKZipArchiveFactory | |
| ►COgre::FactoryObj< ParticleSystemRenderer > | |
| ►COgre::ParticleSystemRendererFactory | Abstract class definition of a factory object for ParticleSystemRenderer |
| COgre::v1::BillboardParticleRendererFactory | Factory class for BillboardParticleRenderer |
| COgre::FastArray< BoneTransform > | |
| COgre::FastArray< bool > | |
| COgre::FastArray< BuildLightListRequest > | |
| COgre::FastArray< float > | |
| COgre::FastArray< Light * > | |
| COgre::FastArray< LightArray > | |
| COgre::FastArray< LightClosest > | |
| COgre::FastArray< LightCount > | |
| COgre::FastArray< Ogre::SkeletonInstance * > | |
| COgre::FastArray< Ogre::Texture * > | |
| COgre::FastArray< PbsBakedTexture > | |
| COgre::FastArray< PerThreadData * > | |
| COgre::FastArray< ProfileSample * > | |
| COgre::FastArray< QueuedRenderable > | |
| COgre::FastArray< Real > | |
| COgre::FastArray< Renderable * > | |
| COgre::FastArray< Resolution > | |
| COgre::FastArray< SharedPtr< Texture > > | |
| COgre::FastArray< size_t > | |
| COgre::FastArray< ThreadRenderQueue > | |
| COgre::FastArray< TrackedRenderable > | |
| COgre::FastArray< uint8_t * > | |
| COgre::FastArray< UnlitBakedTexture > | |
| COgre::FastArray< unsigned char > | |
| COgre::FastArray< unsigned short > | |
| COgre::FastArray< VertexArrayObject * > | |
| COgre::FastArray< VisibleObjectsPerRq > | |
| ►CGLES2RenderTexture MANAGED_RESOURCE | |
| COgre::GLES2FBORenderTexture | RenderTexture for GL ES 2 FBO |
| ►CGLSLESProgram | |
| COgre::GLSLESCgProgram | Specialisation of HighLevelGpuProgram to provide support for CG |
| ►CGLSLESProgramCommon MANAGED_RESOURCE | |
| COgre::GLSLESLinkProgram | C++ encapsulation of GLSL ES Program Object |
| ►CGtk::GL::DrawingArea | |
| COgre::OGREWidget | |
| ►CHardwareBufferManager | |
| COgre::D3D9HardwareBufferManager | D3D9HardwareBufferManagerBase as a Singleton |
| ►CHardwareBufferManagerBase | |
| COgre::D3D9HardwareBufferManagerBase | Implementation of HardwareBufferManager for D3D9 |
| ►CHardwareIndexBuffer | |
| COgre::D3D9HardwareIndexBuffer | |
| ►CHardwareIndexBuffer MANAGED_RESOURCE | |
| COgre::v1::GLES2HardwareIndexBuffer | |
| ►CHardwareOcclusionQuery MANAGED_RESOURCE | |
| COgre::GLES2HardwareOcclusionQuery | |
| ►CHardwarePixelBuffer | |
| COgre::D3D9HardwarePixelBuffer | |
| ►CHardwareVertexBuffer | |
| COgre::D3D9HardwareVertexBuffer | Specialisation of HardwareVertexBuffer for D3D9 |
| ►CHardwareVertexBuffer MANAGED_RESOURCE | |
| COgre::v1::GLES2HardwareVertexBuffer | Specialisation of HardwareVertexBuffer for OpenGL ES |
| COgre::HashedVector< LightClosest > | |
| ►CHighLevelGpuProgram MANAGED_RESOURCE | |
| COgre::GLSLESShader | Specialisation of HighLevelGpuProgram to encapsulate shader objects obtained from compiled shaders written in the OpenGL Shader Language (GLSL ES) for OpenGL ES 2.0 |
| ►COgre::IteratorWrapper< T, IteratorType, T::mapped_type > | |
| COgre::MapIteratorWrapper< T, IteratorType > | Prepared IteratorWrapper for key-value container |
| ►COgre::IteratorWrapper< T, IteratorType, T::value_type > | |
| COgre::VectorIteratorWrapper< T, IteratorType > | Prepared IteratorWrapper for container like std::vector |
| COgre::IteratorWrapper< T, T::const_iterator, T::mapped_type > | |
| COgre::IteratorWrapper< T, T::const_iterator, T::value_type > | |
| COgre::IteratorWrapper< T, T::iterator, T::mapped_type > | |
| COgre::IteratorWrapper< T, T::iterator, T::value_type > | |
| COgre::list< AbstractNodePtr > | |
| COgre::list< AnimationState * > | |
| COgre::list< AntiPortal * > | |
| COgre::list< Billboard * > | |
| COgre::list< BySkeletonDef > | |
| COgre::list< ChannelRoute > | |
| COgre::list< ConcreteNodePtr > | |
| COgre::list< ErrorPtr > | |
| COgre::list< GL3PlusContext * > | |
| COgre::list< GLES2Context * > | |
| COgre::list< HardwareOcclusionQuery * > | |
| COgre::list< HardwareVertexBufferSharedPtr > | |
| COgre::list< IndexRemap > | |
| COgre::list< Listener * > | |
| COgre::list< MovableObject * > | |
| COgre::list< OctreeNode * > | |
| COgre::list< Ogre::Particle * > | |
| COgre::list< Ogre::Plane > | |
| COgre::list< OptimisedSubMeshGeometry * > | |
| COgre::list< OverlayContainer * > | |
| COgre::list< OverlayElement * > | |
| COgre::list< Particle * > | |
| COgre::list< ParticleEmitter * > | |
| COgre::list< PCPlane * > | |
| COgre::list< PCZone * > | |
| COgre::list< Portal * > | |
| COgre::list< ResourceDeclaration > | |
| COgre::list< ResourceLocation * > | |
| COgre::list< ResourcePtr > | |
| COgre::list< SceneManagerFactory * > | |
| COgre::list< SceneQuery::WorldFragment * > | |
| COgre::list< SceneQueryMovableObjectPair > | |
| COgre::list< SceneQueryMovableObjectWorldFragmentPair > | |
| COgre::list< TagPoint * > | |
| COgre::list< VertexElement > | |
| COgre::list< VertexSplit > | |
| COgre::list< WireBoundingBox * > | |
| COgre::map< CGstate, CgGlobalStateListener * > | |
| COgre::map< CGstate, CgSamplerStateListener * > | |
| COgre::map< CodePoint, GlyphInfo > | |
| COgre::map< constMovableObject *, list< BspNode * >::type > | |
| COgre::map< constNode *, size_t > | |
| COgre::map< D3D9RenderWindow *, RenderWindowResources * > | |
| COgre::map< FunctionInvocation, String > | |
| COgre::map< GpuConstantType, constchar * > | |
| COgre::map< GpuResource *, ResourceAccess::ResourceAccess > | |
| COgre::map< GpuResource *, ResourceLayout::Layout > | |
| COgre::map< GpuSharedParametersPtr, v1::HardwareUniformBufferSharedPtr > | |
| COgre::map< HardwareVertexBuffer *, VertexBufferLicense > | |
| COgre::map< Hash, GpuProgramPtr > | |
| COgre::map< Hash, Microcode > | |
| COgre::map< IDirect3DDevice9 *, BufferResources * > | |
| COgre::map< IDirect3DDevice9 *, IDirect3DPixelShader9 * > | |
| COgre::map< IDirect3DDevice9 *, IDirect3DQuery9 * > | |
| COgre::map< IDirect3DDevice9 *, IDirect3DVertexDeclaration9 * > | |
| COgre::map< IDirect3DDevice9 *, IDirect3DVertexShader9 * > | |
| COgre::map< IDirect3DDevice9 *, TextureResources * > | |
| COgre::map< IdString, BatchSettings > | |
| COgre::map< IdString, Camera * > | |
| COgre::map< IdString, CompositorNodeDef * > | |
| COgre::map< IdString, CompositorShadowNodeDef * > | |
| COgre::map< IdString, CompositorWorkspaceDef * > | |
| COgre::map< IdString, IdString > | |
| COgre::map< IdString, InstanceBatchVec > | |
| COgre::map< IdString, MetadataCacheEntry > | |
| COgre::map< IdString, size_t > | |
| COgre::map< IdString, SkeletonDefPtr > | |
| COgre::map< IdString, String > | |
| COgre::map< IdString, uint32 > | |
| COgre::map< int, PatchSurface * > | |
| COgre::map< Lightconst *, LightClippingInfo > | |
| COgre::map< Material *, vector< StaticFaceGroup * >::type, materialLess > | |
| COgre::map< MatGroupPair, SGMaterial *, MatGroupPair_less > | |
| COgre::map< Node *, uint32 > | |
| COgre::map< Ogre::IdString, Ogre::ShaderParams > | |
| COgre::map< Ogre::IdString, size_t > | |
| COgre::map< Ogre::LwConstString, constHlmsBlendblock * > | |
| COgre::map< Ogre::LwConstString, constHlmsMacroblock * > | |
| COgre::map< Ogre::LwConstString, constHlmsSamplerblock * > | |
| COgre::map< Ogre::RTShader::Function *, String * > | |
| COgre::map< PageID, Page * > | |
| COgre::map< Parameter::Content, constchar * > | |
| COgre::map< Parameter::Semantic, constchar * > | |
| COgre::map< RBFormat, RBRef > | |
| COgre::map< Real, LoadUnloadResourceSet * > | |
| COgre::map< Resource *, MeshBuildParams > | |
| COgre::map< ResourceHandle, ResourcePtr > | |
| COgre::map< SGTechnique *, SGTechnique * > | |
| COgre::map< size_t, GpuLogicalIndexUse > | |
| COgre::map< size_t, Vector3 > | |
| COgre::map< size_t, Vector4 > | |
| COgre::map< SkeletonInstance *, BoneVec > | |
| COgre::map< String, AbstractNodeListPtr > | |
| COgre::map< String, Animation * > | |
| COgre::map< String, AnimationState * > | |
| COgre::map< String, Archive * > | |
| COgre::map< String, ArchiveFactory * > | |
| COgre::map< String, Capabilities > | |
| COgre::map< String, CapabilityKeywordType > | |
| COgre::map< String, ConfigOption > | |
| COgre::map< String, CreateGpuProgramCallback > | |
| COgre::map< String, D3D9RenderWindow * > | |
| COgre::map< String, DynLib * > | |
| COgre::map< String, EmittedEmitterList > | |
| COgre::map< String, ExternalTextureSource * > | |
| COgre::map< String, FreeEmittedEmitterList > | |
| COgre::map< String, GeometryBucket * > | |
| COgre::map< String, GLenum > | |
| COgre::map< String, GpuConstantDefinition > | |
| COgre::map< String, GpuProgramPtr > | |
| COgre::map< String, GpuSharedParametersPtr > | |
| COgre::map< String, HighLevelGpuProgramFactory * > | |
| COgre::map< String, int > | |
| COgre::map< String, ListenerList > | |
| COgre::map< String, LodStrategy * > | |
| COgre::map< String, Log * > | |
| COgre::map< String, MaterialBucket * > | |
| COgre::map< String, MovableObjectCollection * > | |
| COgre::map< String, MovableObjectFactory * > | |
| COgre::map< String, OgreStereoHandle > | |
| COgre::map< String, OldBone * > | |
| COgre::map< String, Overlay * > | |
| COgre::map< String, OverlayContainer * > | |
| COgre::map< String, OverlayElement * > | |
| COgre::map< String, OverlayElementFactory * > | |
| COgre::map< String, PageContentCollectionFactory * > | |
| COgre::map< String, PageContentFactory * > | |
| COgre::map< String, PagedWorld * > | |
| COgre::map< String, PagedWorldSection * > | |
| COgre::map< String, PagedWorldSectionFactory * > | |
| COgre::map< String, PageStrategy * > | |
| COgre::map< String, ParamCommand * > | |
| COgre::map< String, ParticleAffectorFactory * > | |
| COgre::map< String, ParticleEmitterFactory * > | |
| COgre::map< String, ParticleSystem * > | |
| COgre::map< String, ParticleSystemRendererFactory * > | |
| COgre::map< String, PCZone * > | |
| COgre::map< String, PCZoneFactory * > | |
| COgre::map< String, ProfileInstance * > | |
| COgre::map< String, ProgramProcessor * > | |
| COgre::map< String, ProgramWriter * > | |
| COgre::map< String, ProgramWriterFactory * > | |
| COgre::map< String, PropertyBase * > | |
| COgre::map< String, Quake3Shader * > | |
| COgre::map< String, RenderSystemCapabilities * > | |
| COgre::map< String, RenderTarget * > | |
| COgre::map< String, ResourceGroup * > | |
| COgre::map< String, ResourceManager * > | |
| COgre::map< String, ResourcePool * > | |
| COgre::map< String, SceneManager * > | |
| COgre::map< String, ScriptTranslator * > | |
| COgre::map< String, SetBoolMethod > | |
| COgre::map< String, SetIntMethod > | |
| COgre::map< String, SetRealMethod > | |
| COgre::map< String, SetStringMethod > | |
| COgre::map< String, SettingsMultiMap * > | |
| COgre::map< String, SGScheme * > | |
| COgre::map< String, String > | |
| COgre::map< String, SubRenderStateFactory * > | |
| COgre::map< String, TextureAtlasTablePtr > | |
| COgre::map< String, uint16 > | |
| COgre::map< String, unsignedshort > | |
| COgre::map< String, v1::Animation * > | |
| COgre::map< String, v1::StaticGeometry * > | |
| COgre::map< String, VertexElementSemantic > | |
| COgre::map< String, ZoneData * > | |
| COgre::map< SubMesh *, SubMeshLodGeometryLinkList * > | |
| COgre::map< Texture *, Image > | |
| COgre::map< uint16, DepthBufferVec > | |
| COgre::map< uint16, RequestHandlerList > | |
| COgre::map< uint16, ResponseHandlerList > | |
| COgre::map< uint16, Vector4 > | |
| COgre::map< uint32, BufferPoolVec > | |
| COgre::map< uint32, GLSLMonolithicProgram * > | |
| COgre::map< uint32, GLSLSeparableProgram * > | |
| COgre::map< uint32, HardwareIndexBufferSharedPtr > | |
| COgre::map< uint32, Region * > | |
| COgre::map< uint32, SceneNode * > | |
| COgre::map< uint32, TerrainSlot * > | |
| COgre::map< uint32, uint32 > | |
| COgre::map< uint64, GLSLESLinkProgram * > | |
| COgre::map< uint64, GLSLESProgramPipeline * > | |
| COgre::map< unsignedshort, bool > | |
| COgre::map< unsignedshort, HardwareVertexBufferSharedPtr > | |
| COgre::map< unsignedshort, LodTechniques * > | |
| COgre::map< unsignedshort, NumericAnimationTrack * > | |
| COgre::map< unsignedshort, OldNodeAnimationTrack * > | |
| COgre::map< unsignedshort, VertexAnimationTrack * > | |
| COgre::map< v1::RenderOperation, MeshData, OrderRenderOperation > | |
| COgre::map< Vector3, size_t, vectorLess > | |
| COgre::map< Vector3, Vector4 > | |
| COgre::map< Vertex, size_t > | |
| COgre::map< VertexArrayObject *, MeshData > | |
| COgre::map< VertexElement2Vec, Vbo > | |
| COgre::multimap< HardwareVertexBuffer *, HardwareVertexBufferSharedPtr > | |
| COgre::multimap< Real, ScriptLoader * > | |
| COgre::multimap< Real, Vertex * > | |
| COgre::multimap< size_t, VertexBoneAssignment > | |
| COgre::multimap< std::pair< size_t, size_t >, std::pair< size_t, size_t > > | |
| COgre::multimap< String, String > | |
| COgre::multimap< TextureEffectType, TextureEffect > | |
| CNotPointerAtom | |
| ►CNSObject | |
| CCocoaWindowDelegate | |
| ►CNSOpenGLView | |
| COgreGL3PlusView | |
| ►CNSView | |
| COgreMetalView | |
| ►CNSWindow | |
| COgreGL3PlusWindow | |
| COgre::_ConfigOption | Packages the details of a configuration option |
| COgre::Aabb | AoS (array of structures) version of ArrayAabb |
| COgre::ActiveActorData | |
| COgre::AlignedMemory | Class to provide aligned memory allocate functionality |
| ►COgre::AllocatedObject< Alloc > | Superclass for all objects that wish to use custom memory allocators when their new / delete operators are called |
| COgre::Controller< Real > | |
| ►COgre::ControllerFunction< Real > | |
| 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< Real > | |
| 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::v1::AnimationStateControllerValue | ControllerValue wrapper class for AnimationState |
| ►COgre::ControllerValue< Ogre::Real > | |
| COgre::TextureAnimationControllerValue | Predefined controller value for getting / setting a texture coordinate modifications (scales and translates) |
| ►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 |
| COgre::AndroidLogListener | |
| COgre::AnimableValue | Defines an object property which is animable, i.e |
| ►COgre::Archive | Archive-handling class |
| COgre::APKFileSystemArchive | |
| COgre::FileSystemArchive | Specialisation of the Archive class to allow reading of files from filesystem folders / directories |
| COgre::ZipArchive | Specialisation of the Archive class to allow reading of files from a zip format source archive |
| COgre::ArchiveFactory | Abstract factory class, archive codec plugins can register concrete subclasses of this |
| COgre::ArchiveManager | This class manages the available ArchiveFactory plugins |
| ►COgre::AsyncTicket | In Ogre 2.0 data structures, reading data from GPU back to CPU is asynchronous |
| COgre::D3D11AsyncTicket | |
| COgre::GL3PlusAsyncTicket | |
| COgre::GLES2AsyncTicket | |
| COgre::MetalAsyncTicket | |
| COgre::NULLAsyncTicket | |
| 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::Bone | Class representing a Bone in the join hierarchy of a skeleton |
| COgre::BspNode | Encapsulates a node in a BSP tree |
| ►COgre::BufferPacked | |
| ►COgre::ConstBufferPacked | Represents constant buffers (also known as Uniform Buffers in GL) |
| COgre::D3D11ConstBufferPacked | |
| COgre::GL3PlusConstBufferPacked | |
| COgre::GLES2ConstBufferPacked | |
| COgre::MetalConstBufferPacked | |
| COgre::NULLConstBufferPacked | |
| COgre::IndexBufferPacked | |
| COgre::IndirectBufferPacked | Represents Indirect buffers for storing draw call commands |
| ►COgre::TexBufferPacked | Represents Texture buffers (also known as tbuffers in D3D11) |
| COgre::D3D11TexBufferPacked | |
| COgre::GL3PlusTexBufferEmulatedPacked | |
| COgre::GL3PlusTexBufferPacked | |
| COgre::GLES2TexBufferEmulatedPacked | |
| COgre::MetalTexBufferPacked | |
| COgre::NULLTexBufferPacked | |
| ►COgre::UavBufferPacked | Represents UAV buffers (also known as SSBOs in OpenGL) Uav buffers are supported in DX10/DX10.1 hardware (with up to date drivers) |
| COgre::D3D11UavBufferPacked | |
| COgre::GL3PlusUavBufferPacked | |
| COgre::MetalUavBufferPacked | |
| COgre::NULLUavBufferPacked | |
| COgre::VertexBufferPacked | |
| COgre::CgFxScriptLoader | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them |
| COgre::CocoaContext | |
| ►COgre::Codec | Abstract class that defines a 'codec' |
| ►COgre::ImageCodec | Codec specialized in images |
| COgre::ASTCCodec | Codec specialized in loading ASTC (ARM Adaptive Scalable Texture Compression) images |
| COgre::DDSCodec | Codec specialized in loading DDS (Direct Draw Surface) images |
| COgre::ETCCodec | Codec specialized in loading ETC (Ericsson Texture Compression) images |
| COgre::EXRCodec | Codec specialized in loading OpenEXR high dynamic range images |
| COgre::FreeImageCodec | Codec specialized in images loaded using FreeImage |
| COgre::OITDCodec | Codec specialized in loading OITD (Ogre Internal Texture Dump) format |
| COgre::PVRTCCodec | Codec specialized in loading PVRTC (PowerVR) images |
| COgre::STBIImageCodec | Codec specialized in images loaded using stbi (https://github.com/nothings/stb) |
| ►COgre::Codec::CodecData | |
| COgre::ImageCodec::ImageData | Codec return class for images |
| COgre::CompositorManager2 | Main system for managing Render Targets through the use of nodes |
| ►COgre::CompositorNode | Compositor nodes are the core subject of compositing |
| COgre::CompositorShadowNode | Shadow Nodes are special nodes (not to be confused with |
| ►COgre::CompositorPass | Abstract class for compositor passes |
| COgre::CompositorPassClear | Implementation of CompositorPass This implementation will clear the RenderTarget using the parameters from definition (rectangle area, which buffers, what values, etc) |
| COgre::CompositorPassCompute | Implementation of CompositorPass This implementation will render a fullscreen triangle/quad to the RenderTarget using the parameters from definition (rectangle area, whether triangle or quad pass, whether to include frustum corners, etc) |
| COgre::CompositorPassDepthCopy | Implementation of CompositorPass This implementation will copy one DepthBuffer to another DepthBuffer from two RTs |
| COgre::CompositorPassMipmap | Implementation of CompositorPass This implementation will Mipmap the texture used by this RenderTarget |
| COgre::CompositorPassQuad | Implementation of CompositorPass This implementation will render a fullscreen triangle/quad to the RenderTarget using the parameters from definition (rectangle area, whether triangle or quad pass, whether to include frustum corners, etc) |
| COgre::CompositorPassScene | Implementation of CompositorPass This implementation will perform main rendering, selecting several parameters (like viewport's visibility mask, first and last render queue to render) it will render the main scene |
| COgre::CompositorPassStencil | Implementation of CompositorPass This implementation will clear the RenderTarget using the parameters from definition (rectangle area, which buffers, what values, etc) |
| COgre::CompositorPassUav | Implementation of CompositorPass This implementation will set UAVs |
| ►COgre::CompositorPassDef | Interface to abstract all types of pass definitions ( |
| COgre::CompositorPassClearDef | |
| COgre::CompositorPassComputeDef | |
| COgre::CompositorPassDepthCopyDef | |
| COgre::CompositorPassMipmapDef | |
| COgre::CompositorPassQuadDef | |
| COgre::CompositorPassSceneDef | |
| COgre::CompositorPassStencilDef | |
| COgre::CompositorPassUavDef | |
| COgre::CompositorPassProvider | Base class that users can derive from in order to implement custom passes for the compositor |
| COgre::CompositorTargetDef | |
| COgre::CompositorWorkspace | A compositor workspace is the main interface to render into an RT, be it a RenderWindow or an RTT (Render Texture Target) |
| COgre::ConcreteNode | |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigDialog | Defines the behaviour of an automatic renderer configuration dialog |
| COgre::ConfigFile | Class for quickly loading settings from a text file |
| 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 |
| COgre::CubemapProbe | |
| COgre::D3D11StereoDriverBridge | Bridge interface from the render system to the stereo driver |
| ►COgre::D3D11StereoDriverImpl | Virtual interface of the stereo driver |
| COgre::D3D11StereoDriverAMD | Virtual interface of the stereo driver |
| COgre::D3D11StereoDriverNVIDIA | Interface of the NVIDIA stereo driver |
| COgre::D3D9Device | High level interface of Direct3D9 Device |
| COgre::D3D9DeviceManager | Device manager interface |
| COgre::D3D9Driver | |
| COgre::D3D9DriverList | |
| COgre::D3D9ResourceManager | |
| COgre::D3D9StereoDriverBridge | Bridge interface from the render system to the stereo driver |
| ►COgre::D3D9StereoDriverImpl | Virtual interface of the stereo driver |
| COgre::D3D9StereoDriverAMD | Virtual interface of the stereo driver |
| COgre::D3D9StereoDriverNVIDIA | Interface of the NVIDIA stereo driver |
| COgre::D3D9VideoModeList | |
| ►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::ZipDataStream | Specialisation of DataStream to handle streaming data from zip archives |
| ►COgre::DepthBuffer | An abstract class that contains a depth/stencil buffer |
| COgre::D3D11DepthBuffer | |
| COgre::D3D9DepthBuffer | |
| COgre::GL3PlusDepthBuffer | |
| COgre::GLES2DepthBuffer | |
| COgre::MetalDepthBuffer | |
| COgre::DynLib | Resource holding data about a dynamic library |
| COgre::DynLibManager | Manager for Dynamic-loading Libraries |
| COgre::ExternalTextureSourceManager | Singleton Class which handles the registering and control of texture plugins |
| COgre::FileSystemLayer | Provides methods to find out where the Ogre config files are stored and where logs and settings files should be written to |
| ►COgre::ForwardPlusBase | ForwardPlusBase |
| COgre::Forward3D | Forward3D |
| COgre::ForwardClustered | Implementation of Clustered Forward Shading |
| COgre::FrameStats | All return values are either in milliseconds or frames per second; but they're internally stored in microseconds |
| 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::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::GpuSharedParameters | Definition of container that holds the current bool constants |
| COgre::GpuSharedParametersUsage | This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters |
| ►COgre::HardwareOcclusionQuery | This is a abstract class that that provides the interface for the query class for hardware occlusion |
| COgre::D3D11HardwareOcclusionQuery | This is a class that is the DirectX9 implementation of hardware occlusion testing |
| COgre::D3D9HardwareOcclusionQuery | This is a class that is the DirectX9 implementation of hardware occlusion testing |
| COgre::GL3PlusHardwareOcclusionQuery | This is a class that is the base class of the query class for hardware occlusion |
| ►COgre::HighLevelGpuProgramFactory | Interface definition for factories of HighLevelGpuProgram |
| COgre::CgProgramFactory | Factory class for Cg programs |
| COgre::D3D11HLSLProgramFactory | Factory class for D3D11 HLSL programs |
| COgre::D3D9HLSLProgramFactory | Factory class for D3D9 HLSL programs |
| COgre::GLSLESCgProgramFactory | Factory class for GLSL ES programs |
| COgre::GLSLESShaderFactory | Factory class for GLSL ES programs |
| COgre::GLSLShaderFactory | Factory class for GLSL shaders |
| COgre::MetalProgramFactory | Factory class for Metal programs |
| COgre::UnifiedHighLevelGpuProgramFactory | Factory class for Unified programs |
| ►COgre::Hlms | HLMS stands for "High Level Material System" |
| ►COgre::HlmsBufferManager | Managing constant and texture buffers for sending shader parameters is a very similar process to most Hlms implementations using them |
| COgre::HlmsPbs | Physically based shading implementation specfically designed for OpenGL 3+, D3D11 and other RenderSystems which support uniform buffers |
| COgre::HlmsUnlit | Implementation without lighting or skeletal animation specfically designed for OpenGL 3+, D3D11 and other RenderSystems which support uniform buffers |
| COgre::HlmsCompute | HLMS implementation that handles compute shaders |
| COgre::HlmsLowLevel | This is an HLMS implementation that acts as proxy to use the Material system from Ogre 1.9 The older material system is data-driven (thanks to AutoParamDataSource) compared to HLMS where the user needs to write its own implementation in C++ (or modify an exisiting one) |
| COgre::HlmsPbsMobile | Physically based shading implementation specfically designed for OpenGL ES 2.0 and other RenderSystems which do not support uniform buffers |
| COgre::HlmsUnlitMobile | User Interface (2D) implementation specfically designed for OpenGL ES 2.0 and other RenderSystems which do not support uniform buffers |
| COgre::HlmsComputeJob | |
| ►COgre::HlmsDatablock | An hlms datablock contains individual information about a specific material |
| COgre::HlmsLowLevelDatablock | Contains information needed by the UI (2D) for OpenGL ES 2.0 |
| COgre::HlmsPbsDatablock | Contains information needed by PBS (Physically Based Shading) for OpenGL 3+ & D3D11+ |
| COgre::HlmsPbsMobileDatablock | Contains information needed by PBS (Physically Based Shading) for OpenGL ES 2.0 |
| COgre::HlmsUnlitDatablock | Contains information needed by PBS (Physically Based Shading) for OpenGL 3+ & D3D11+ |
| COgre::HlmsUnlitMobileDatablock | Contains information needed by the UI (2D) for OpenGL ES 2.0 |
| COgre::HlmsDiskCache | This class allows saving the current state of an Hlms to disk: both its compiled shaders with source and the generated PSOs |
| COgre::HlmsJson | HLMS stands for "High Level Material System" |
| COgre::HlmsJsonCompute | HLMS stands for "High Level Material System" |
| COgre::HlmsManager | HLMS stands for "High Level Material System" |
| COgre::HlmsTextureManager | HLMS Texture Manager manages textures in the way HLMS expects |
| COgre::Image | Class representing an image file |
| COgre::IntersectionSceneQueryResult | Holds the results of an intersection scene query (pair values) |
| ►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 |
| COgre::Log | |
| COgre::LogManager | The log manager handles the creation and retrieval of logs for the application |
| COgre::ManualObject::ManualObjectSection | Built, renderable section of geometry |
| COgre::MaterialSerializer | Class for serializing Materials to / from a .material script |
| COgre::MetalDiscardBuffer | |
| COgre::MetalDiscardBufferManager | 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) |
| ►COgre::MovableObject | Abstract class defining a movable object in a scene |
| COgre::Decal | Decals can have diffuse, normal map, and emissive on top of regular objects |
| ►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::Item | Defines an instance of a discrete, movable object based on a Mesh |
| ►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 | |
| COgre::MovablePlane | Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply |
| COgre::NullEntity | |
| 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::WireAabb | Helper class to display the Aabb of a MovableObject as lines |
| ►COgre::v1::BillboardChain | Allows the rendering of a chain of connected billboards |
| COgre::v1::RibbonTrail | Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances |
| COgre::v1::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::v1::Entity | Defines an instance of a discrete, movable object based on a Mesh |
| ►COgre::v1::InstanceBatch | InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived to implement different instancing techniques ( |
| ►COgre::v1::BaseInstanceBatchVTF | 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 |
| COgre::v1::InstanceBatchHW_VTF | Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instancing |
| COgre::v1::InstanceBatchVTF | |
| COgre::v1::InstanceBatchHW | This is technique requires true instancing hardware support |
| COgre::v1::InstanceBatchShader | This is the same technique the old "InstancedGeometry" implementation used (with improvements) |
| COgre::v1::InstancedEntity | |
| COgre::v1::ManualObject | Class providing a much simplified interface to generating manual objects with custom geometry |
| COgre::v1::Overlay | Represents a layer which is rendered on top of the 'normal' scene contents |
| COgre::v1::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 'depth_write off' materials |
| ►COgre::v1::SimpleRenderable | Simple implementation of MovableObject and Renderable for single-part custom objects |
| COgre::v1::WireBoundingBox | Allows the rendering of a wireframe bounding box |
| COgre::v1::StaticGeometry::Region | The details of a topological region which is the highest level of partitioning for this class |
| ►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::DecalFactory | |
| COgre::ItemFactory | FItemy object for creating Item instances |
| COgre::LightFactory | Factory object for creating Light instances |
| COgre::ManualObjectFactory | Factory object for creating ManualObject instances |
| COgre::PCZLightFactory | Factory object for creating PCZLight instances |
| COgre::ParticleSystemFactory | Factory object for creating ParticleSystem 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 |
| COgre::WireAabbFactory | Factory object for creating WireAabb instances |
| COgre::v1::BillboardChainFactory | Factory object for creating BillboardChain instances |
| COgre::v1::BillboardSetFactory | Factory object for creating BillboardSet instances |
| COgre::v1::EntityFactory | Factory object for creating Entity instances |
| COgre::v1::ManualObjectFactory | Factory object for creating ManualObject instances |
| COgre::v1::Rectangle2DFactory | Factory object for creating Entity instances |
| COgre::v1::RibbonTrailFactory | Factory object for creating RibbonTrail instances |
| ►COgre::MultiSourceVertexBufferPool | Vertex Array Objects do not need to change when: The same (internal) vertex buffer is still bound |
| COgre::GL3PlusMultiSourceVertexBufferPool | |
| COgre::GLES2MultiSourceVertexBufferPool | |
| COgre::MetalMultiSourceVertexBufferPool | |
| COgre::NULLMultiSourceVertexBufferPool | |
| ►COgre::Node | Class representing a general-purpose node an articulated scene graph |
| ►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 | |
| COgre::TagPoint | TagPoints are like SceneNodes, that can be children of a Bone |
| COgre::Octree | Octree datastructure for managing scene nodes |
| 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::Page | Page class |
| 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 |
| ►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 | Particle emitter which emits particles randomly from points inside a box |
| COgre::CylinderEmitter | Particle emitter which emits particles randomly from points inside a cylinder |
| ►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 | Particle emitter which emits particles from a single point |
| ►COgre::ParticleAffector | Abstract class defining the interface to be implemented by particle affectors |
| COgre::ColourFaderAffector | This plugin subclass of ParticleAffector allows you to alter the colour of particles |
| COgre::ColourFaderAffector2 | This plugin subclass of ParticleAffector allows you to alter the colour of particles |
| COgre::ColourImageAffector | |
| COgre::ColourInterpolatorAffector | |
| COgre::DeflectorPlaneAffector | This class defines a ParticleAffector which deflects particles |
| COgre::DirectionRandomiserAffector | This class defines a ParticleAffector which applies randomness to the movement of the particles |
| COgre::LinearForceAffector | This class defines a ParticleAffector which applies a linear force to particles in a system |
| COgre::RotationAffector | This plugin subclass of ParticleAffector allows you to alter the rotation of particles |
| COgre::ScaleAffector | This plugin subclass of ParticleAffector allows you to alter the scale of particles |
| ►COgre::ParticleAffectorFactory | Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses |
| COgre::ColourFaderAffectorFactory | Factory class for ColourFaderAffector |
| COgre::ColourFaderAffectorFactory2 | Factory class for ColourFaderAffector |
| COgre::ColourImageAffectorFactory | Factory class for ColourImageAffector |
| COgre::ColourInterpolatorAffectorFactory | Factory class for ColourInterpolatorAffector |
| COgre::DeflectorPlaneAffectorFactory | Factory class for DeflectorPlaneAffector |
| COgre::DirectionRandomiserAffectorFactory | Factory class for DirectionRandomiserAffector |
| COgre::LinearForceAffectorFactory | Factory class for LinearForceAffector |
| COgre::RotationAffectorFactory | Factory class for RotationAffector |
| COgre::ScaleAffectorFactory | Factory class for ScaleAffector |
| ►COgre::ParticleEmitterFactory | Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses |
| COgre::BoxEmitterFactory | Factory class for particle emitter of type "Box" |
| COgre::CylinderEmitterFactory | Factory class for particle emitter of type "Cylinder" |
| COgre::EllipsoidEmitterFactory | Factory class for particle emitter of type "Ellipsoid" |
| COgre::HollowEllipsoidEmitterFactory | Factory class for particle emitter of type "HollowEllipsoid" |
| COgre::PointEmitterFactory | Factory class for particle emitter of type "Point" |
| COgre::RingEmitterFactory | Factory class for particle emitter of type "Ring" |
| COgre::ParticleSystemManager | Manages particle systems, particle system scripts (templates) and the available emitter & affector factories |
| ►COgre::ParticleSystemRenderer | Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances |
| COgre::v1::BillboardParticleRenderer | Specialisation of ParticleSystemRenderer to render particles using a BillboardSet |
| COgre::ParticleSystemRendererFactory | Abstract class definition of a factory object for ParticleSystemRenderer |
| COgre::ParticleVisualData | Abstract class containing any additional data required to be associated with a particle to perform the required rendering |
| COgre::Pass | Class defining a single pass of a Technique (of a Material), i.e |
| COgre::PixelBox | |
| ►COgre::Plugin | Class defining a generic OGRE plugin |
| COgre::BspSceneManagerPlugin | Plugin instance for BSPSceneManager |
| COgre::CgPlugin | Plugin instance for Cg Program Manager |
| COgre::D3D11Plugin | Plugin instance for D3D11 Manager |
| COgre::D3D9Plugin | Plugin instance for D3D9 Manager |
| COgre::GL3PlusPlugin | Plugin instance for GL3Plus Manager |
| COgre::GLES2Plugin | Plugin instance for GL ES 2 Manager |
| COgre::MetalPlugin | Plugin instance for Metal Manager |
| COgre::NULLPlugin | Plugin instance for NULL 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 |
| 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 |
| ►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 |
| COgre::PsoCacheHelper | Utility class to cache PSOs |
| 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::RTShader::FFPRenderStateBuilder | Fixed Function Pipeline render state builder |
| 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::FunctionInvocation | A class that represents function invocation code from shader based program function |
| ►COgre::RTShader::HardwareSkinningTechnique | Implement a sub render state which performs hardware skinning |
| COgre::RTShader::DualQuaternionSkinning | Implement a sub render state which performs dual quaternion hardware skinning |
| COgre::RTShader::LinearSkinning | Implement a sub render state which performs hardware skinning |
| 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::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::ProgramProcessor | A class that provides extra processing services on CPU based programs |
| COgre::RTShader::CGProgramProcessor | CG Language program processor class |
| COgre::RTShader::GLSLESProgramProcessor | GLSL ES Language program processor class |
| COgre::RTShader::GLSLProgramProcessor | GLSL Language program processor class |
| COgre::RTShader::HLSLProgramProcessor | CG Language program processor class |
| COgre::RTShader::ProgramSet | Container class for shader based programs |
| ►COgre::RTShader::ProgramWriter | Base class interface for shader program writers |
| COgre::RTShader::CGProgramWriter | CG target language writer implementation |
| COgre::RTShader::GLSLESProgramWriter | GLSL ES target language writer implementation |
| COgre::RTShader::GLSLProgramWriter | GLSL target language writer implementation |
| COgre::RTShader::HLSLProgramWriter | HLSL target language writer implementation |
| ►COgre::RTShader::ProgramWriterFactory | Interface definition for factories of ShaderProgramWriter |
| COgre::RTShader::ShaderProgramWriterCGFactory | CG program writer factory implementation |
| COgre::RTShader::ShaderProgramWriterGLSLESFactory | GLSL ES program writer factory implementation |
| COgre::RTShader::ShaderProgramWriterGLSLFactory | GLSL program writer factory implementation |
| COgre::RTShader::ShaderProgramWriterHLSLFactory | HLSL program writer factory implementation |
| 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::SGMaterialSerializerListener | This class responsible for translating core features of the RT Shader System for Ogre material scripts |
| 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::FFPAlphaTest | A factory that enables creation of LayeredBlending instances |
| COgre::RTShader::FFPColour | Colour sub render state implementation of the Fixed Function Pipeline |
| COgre::RTShader::FFPFog | Fog sub render state implementation of the Fixed Function Pipeline |
| COgre::RTShader::FFPLighting | Lighting sub render state implementation of the Fixed Function Pipeline |
| ►COgre::RTShader::FFPTexturing | Texturing sub render state implementation of the Fixed Function Pipeline |
| COgre::RTShader::LayeredBlending | Texturing sub render state implementation of layered blending |
| COgre::RTShader::FFPTransform | Transform sub render state implementation of the Fixed Function Pipeline |
| COgre::RTShader::HardwareSkinning | Implement a sub render state which performs hardware skinning |
| COgre::RTShader::IntegratedPSSM3 | Integrated PSSM shadow receiver with 3 splits sub render state implementation |
| COgre::RTShader::NormalMapLighting | Normal Map Lighting extension sub render state implementation |
| COgre::RTShader::PerPixelLighting | Per pixel Lighting extension sub render state implementation |
| COgre::RTShader::TextureAtlasSampler | Implements texture atlas sampling |
| COgre::RTShader::TriplanarTexturing | Triplanar Texturing |
| ►COgre::RTShader::SubRenderStateFactory | Abstract factory interface for creating SubRenderState implementation instances |
| COgre::RTShader::FFPAlphaTestFactory | |
| COgre::RTShader::FFPColourFactory | A factory that enables creation of FFPColour instances |
| COgre::RTShader::FFPFogFactory | A factory that enables creation of FFPFog instances |
| COgre::RTShader::FFPLightingFactory | A factory that enables creation of FFPLighting instances |
| COgre::RTShader::FFPTexturingFactory | A factory that enables creation of FFPTexturing instances |
| COgre::RTShader::FFPTransformFactory | A factory that enables creation of FFPTransform instances |
| COgre::RTShader::HardwareSkinningFactory | A factory that enables creation of HardwareSkinning instances |
| COgre::RTShader::IntegratedPSSM3Factory | A factory that enables creation of IntegratedPSSM3 instances |
| COgre::RTShader::LayeredBlendingFactory | A factory that enables creation of LayeredBlending instances |
| COgre::RTShader::NormalMapLightingFactory | A factory that enables creation of NormalMapLighting instances |
| COgre::RTShader::PerPixelLightingFactory | A factory that enables creation of PerPixelLighting instances |
| COgre::RTShader::TextureAtlasSamplerFactory | A factory that enables creation of TextureAtlasSampler instances |
| COgre::RTShader::TriplanarTexturingFactory | A factory that enables creation of TriplanarMapping instances |
| COgre::RenderQueue | Enumeration of queue groups, by which the application may group queued renderables so that they are rendered together with events in between |
| ►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::GL3PlusRenderSystem | Implementation of GL 3 as a rendering system |
| COgre::GLES2RenderSystem | Implementation of GL ES 2.x as a rendering system |
| COgre::MetalRenderSystem | Implementation of Metal as a rendering system |
| COgre::NULLRenderSystem | Implementation of NULL as a rendering system |
| COgre::RenderSystemCapabilities | Singleton class for storing 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::D3D11MultiRenderTarget | |
| COgre::D3D9MultiRenderTarget | |
| COgre::GL3PlusFBOMultiRenderTarget | MultiRenderTarget for OpenGL |
| COgre::GLES2FBOMultiRenderTarget | MultiRenderTarget for GL ES 2.x |
| COgre::MetalMultiRenderTarget | |
| ►COgre::RenderTexture | This class represents a RenderTarget that renders to a Texture |
| COgre::D3D11DepthTextureTarget | |
| COgre::D3D11NullTextureTarget | |
| COgre::D3D11RenderTexture | RenderTexture implementation for D3D11 |
| COgre::D3D9RenderTexture | RenderTexture implementation for D3D9 |
| COgre::GL3PlusDepthTextureTarget | |
| COgre::GL3PlusNullTextureTarget | |
| ►COgre::GL3PlusRenderTexture | Base class for GL Render Textures |
| COgre::GL3PlusFBORenderTexture | RenderTexture for GL FBO |
| COgre::GLES2DepthTextureTarget | |
| COgre::GLES2NullTextureTarget | |
| COgre::GLES2RenderTexture | Base class for GL Render Textures |
| COgre::MetalDepthTextureTarget | |
| COgre::MetalNullTextureTarget | |
| COgre::MetalRenderTexture | |
| COgre::NULLRenderTexture | |
| ►COgre::RenderWindow | Manages the target rendering window |
| COgre::CocoaWindow | |
| ►COgre::D3D11RenderWindowBase | |
| COgre::D3D11RenderWindowSwapChainBased | |
| COgre::D3D9RenderWindow | |
| ►COgre::EGLWindow | |
| COgre::AndroidEGLWindow | |
| COgre::EmscriptenEGLWindow | |
| COgre::Win32EGLWindow | |
| COgre::X11EGLWindow | |
| COgre::GLXWindow | |
| COgre::GTKWindow | |
| COgre::MetalRenderWindow | |
| COgre::NULLRenderWindow | |
| COgre::NaClWindow | |
| COgre::SDLWindow | |
| COgre::Win32Window | |
| ►COgre::Resource | Abstract class representing a loadable resource (e.g |
| COgre::BspLevel | Holds all the data associated with a Binary Space Parition (BSP) based indoor level |
| 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::D3D9GpuProgram | Direct3D implementation of a few things common to low-level vertex & fragment programs |
| COgre::D3D9GpuFragmentProgram | Direct3D implementation of low-level fragment programs |
| COgre::D3D9GpuVertexProgram | Direct3D implementation of low-level vertex programs |
| ►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::D3D11HLSLProgram | Specialization of HighLevelGpuProgram to provide support for D3D11 High-Level Shader Language (HLSL) |
| COgre::D3D9HLSLProgram | Specialisation of HighLevelGpuProgram to provide support for D3D9 High-Level Shader Language (HLSL) |
| COgre::GLSLShader | Specialisation of HighLevelGpuProgram to encapsulate shader objects obtained from compiled shaders written in the OpenGL Shader Language (GLSL) |
| COgre::MetalProgram | Specialisation of HighLevelGpuProgram to provide support for Metal Shader Language |
| COgre::UnifiedHighLevelGpuProgram | Specialisation of HighLevelGpuProgram which just delegates its implementation to one other high level program, allowing a single program definition to represent one supported program from a number of options |
| COgre::Material | Class encapsulates rendering properties of an object |
| COgre::Mesh | Resource holding data about 3D mesh |
| ►COgre::Texture | Abstract class representing a Texture resource |
| ►COgre::D3D11Texture | |
| COgre::D3D11DepthTexture | |
| COgre::D3D11NullTexture | |
| COgre::D3D9Texture | |
| ►COgre::GL3PlusTexture | |
| COgre::GL3PlusDepthTexture | |
| COgre::GL3PlusNullTexture | |
| ►COgre::MetalTexture | |
| COgre::MetalDepthTexture | |
| COgre::MetalNullTexture | |
| COgre::NULLTexture | |
| ►COgre::v1::Mesh | Resource holding data about 3D mesh |
| COgre::v1::PatchMesh | Patch specialisation of Mesh |
| ►COgre::v1::Skeleton | A collection of OldBone objects used to animate a skinned mesh |
| COgre::v1::OldSkeletonInstance | A OldSkeletonInstance is a single instance of a Skeleton used by a world object |
| COgre::ResourceBackgroundQueue | This class is used to perform Resource operations in a background thread |
| 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::BspResourceManager | Manages the locating and loading of BSP-based indoor levels |
| COgre::FontManager | Manages Font resources, parsing .fontdef files and generally organising them |
| ►COgre::GpuProgramManager | |
| COgre::D3D11GpuProgramManager | |
| COgre::D3D9GpuProgramManager | |
| COgre::GLES2GpuProgramManager | |
| COgre::GLSLShaderManager | |
| COgre::MetalGpuProgramManager | |
| COgre::HighLevelGpuProgramManager | This ResourceManager manages high-level vertex and fragment programs |
| COgre::MaterialManager | Class for managing Material settings for Ogre |
| COgre::MeshManager | Handles the management of mesh resources |
| ►COgre::TextureManager | Class for loading & managing textures |
| COgre::D3D11TextureManager | |
| COgre::D3D9TextureManager | |
| COgre::GL3PlusTextureManager | GL3Plus-specific implementation of a TextureManager |
| COgre::GLES2TextureManager | GL ES-specific implementation of a TextureManager |
| COgre::MetalTextureManager | |
| COgre::NULLTextureManager | |
| COgre::v1::MeshManager | Handles the management of mesh resources |
| COgre::v1::OldSkeletonManager | Handles the management of skeleton resources |
| 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::Root | The root class of the Ogre system |
| ►COgre::SceneManager | Manages the organisation and rendering of a 'scene' i.e |
| COgre::BspSceneManager | Specialisation of the SceneManager class to deal with indoor scenes based on a BSP tree |
| COgre::DefaultSceneManager | Default scene manager |
| 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::SceneManagerEnumerator | Enumerates the SceneManager classes available to applications |
| ►COgre::SceneManagerFactory | Class which will create instances of a given SceneManager |
| COgre::BspSceneManagerFactory | Factory for BspSceneManager |
| COgre::DefaultSceneManagerFactory | Factory for default scene manager |
| COgre::OctreeSceneManagerFactory | Factory for OctreeSceneManager |
| COgre::PCZSceneManagerFactory | Factory for PCZSceneManager |
| ►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::DefaultIntersectionSceneQuery | Default implementation of IntersectionSceneQuery |
| COgre::BspIntersectionSceneQuery | BSP specialisation of IntersectionSceneQuery |
| COgre::OctreeIntersectionSceneQuery | Octree implementation of IntersectionSceneQuery |
| COgre::PCZIntersectionSceneQuery | PCZ implementation of IntersectionSceneQuery |
| ►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::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::SceneQueryResult | Holds the results of a scene query |
| COgre::ScriptCompiler | This is the main class for the compiler |
| COgre::ScriptCompiler::Error | |
| COgre::ScriptCompilerManager | Manages threaded compilation of scripts |
| COgre::ScriptLexer | |
| COgre::ScriptParser | |
| ►COgre::ScriptTranslator | This class translates script AST (abstract syntax tree) into Ogre resources |
| COgre::CompositorPassTranslator | |
| COgre::CompositorShadowMapRepeatTranslator | |
| COgre::CompositorShadowMapTargetTranslator | |
| COgre::CompositorShadowMapTargetTypeTranslator | |
| COgre::CompositorTargetTranslator | |
| ►COgre::CompositorTextureBaseTranslator | |
| COgre::CompositorNodeTranslator | |
| COgre::CompositorShadowNodeTranslator | |
| COgre::CompositorWorkspaceTranslator | |
| COgre::GpuProgramTranslator | |
| COgre::HlmsTranslator | |
| COgre::MaterialTranslator | |
| COgre::ParticleAffectorTranslator | |
| COgre::ParticleEmitterTranslator | |
| COgre::ParticleSystemTranslator | |
| COgre::PassTranslator | |
| COgre::RTShader::SGScriptTranslator | This class responsible for translating core features of the RT Shader System for Ogre material scripts |
| COgre::SharedParamsTranslator | |
| COgre::TechniqueTranslator | |
| COgre::TextureSourceTranslator | |
| COgre::TextureUnitTranslator | |
| ►COgre::ScriptTranslatorManager | The ScriptTranslatorManager manages the lifetime and access to script translators |
| COgre::BuiltinScriptTranslatorManager | This class manages the builtin translators |
| ►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::MeshSerializerImpl | Internal implementation of Mesh reading / writing for the latest version of the .mesh format |
| ►COgre::MeshSerializerImpl_v2_1_R1 | |
| COgre::MeshSerializerImpl_v2_1_R0 | |
| COgre::v1::MeshSerializer | Class for serialising mesh data to/from an OGRE .mesh file |
| ►COgre::v1::MeshSerializerImpl | Internal implementation of Mesh reading / writing for the latest version of the .mesh format |
| ►COgre::v1::MeshSerializerImpl_v1_10 | Class for providing backwards-compatibility for loading version 1.10 of the .mesh format |
| ►COgre::v1::MeshSerializerImpl_v1_8 | Class for providing backwards-compatibility for loading version 1.8 of the .mesh format |
| ►COgre::v1::MeshSerializerImpl_v1_41 | Class for providing backwards-compatibility for loading version 1.41 of the .mesh format |
| ►COgre::v1::MeshSerializerImpl_v1_4 | Class for providing backwards-compatibility for loading version 1.4 of the .mesh format |
| ►COgre::v1::MeshSerializerImpl_v1_3 | Class for providing backwards-compatibility for loading version 1.3 of the .mesh format |
| ►COgre::v1::MeshSerializerImpl_v1_2 | Class for providing backwards-compatibility for loading version 1.2 of the .mesh format |
| COgre::v1::MeshSerializerImpl_v1_1 | Class for providing backwards-compatibility for loading version 1.1 of the .mesh format |
| COgre::v1::SkeletonSerializer | Class for serialising skeleton data to/from an OGRE .skeleton file |
| COgre::ShaderParams | The purpose of this class is to contain a set of both auto and manual parameters that may apply to multiple shaders; without having the shader to be created first (the drawback of GpuProgramParameters) |
| ►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::PSSMShadowCameraSetup | Parallel Split Shadow Map (PSSM) shadow camera setup |
| COgre::PlaneOptimalShadowCameraSetup | Implements the plane optimal shadow camera algorithm |
| COgre::ShadowTextureDefinition | Local texture definition |
| COgre::ShadowVolumeExtrudeProgram | Static class containing source for vertex programs for extruding shadow volumes |
| COgre::SkeletonAnimation | Represents the instance of a Skeletal animation based on its definition |
| COgre::SkeletonAnimationDef | |
| COgre::SkeletonDef | |
| COgre::SkeletonInstance | Instance of a Skeleton, main external interface for retrieving bone positions and applying animations |
| COgre::SkeletonManager | Handles the management of skeleton resources |
| COgre::SkeletonTrack | |
| ►COgre::StagingBuffer | 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 |
| COgre::D3D11StagingBuffer | NOTE FOR D3D12 PORTING: The GL3Plus implementation should be used as reference, since it is much lower level than this implementation for D3D11 |
| COgre::GL3PlusStagingBuffer | 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 |
| COgre::GLES2StagingBuffer | 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 |
| COgre::MetalStagingBuffer | 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 |
| COgre::NULLStagingBuffer | 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 |
| 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 |
| COgre::SubItem | Utility class which defines the sub-parts of an Item |
| COgre::SubMesh | Defines a part of a complete mesh |
| COgre::Technique | Class representing an approach to rendering this particular Material |
| COgre::Terrain | The main containing class for a chunk of terrain |
| ►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 | Helper class to assist you in managing multiple terrain instances that are connected to each other |
| 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::TerrainLodManager | Terrain LOD data manager |
| ►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::TerrainMaterialGenerator::Profile | Inner class which should also be subclassed to provide profile-specific material generation |
| COgre::TerrainMaterialGeneratorA::SM2Profile | Shader model 2 profile target |
| 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 | A node in a quad tree used to store a patch of terrain |
| COgre::TerrainQuadTreeNode::LodLevel | |
| ►COgre::TextureDefinitionBase | Centralized class for dealing with declarations of textures in Node & Workspace definitions |
| ►COgre::CompositorNodeDef | Compositor nodes are the core subject of compositing |
| COgre::CompositorShadowNodeDef | Shadow Nodes are special nodes (not to be confused with |
| COgre::CompositorWorkspaceDef | @See CompositorWorkspace |
| COgre::TextureDefinitionBase::BufferDefinition | |
| COgre::TextureDefinitionBase::TextureDefinition | Local texture definition |
| COgre::TextureUnitState | Class representing the state of a single texture unit during a Pass of a Technique, of a Material |
| COgre::Timer | Timer class |
| COgre::Timer | Timer class |
| COgre::Timer | Timer class |
| COgre::Timer | Timer class |
| COgre::Timer | Timer class |
| COgre::Timer | Timer class |
| COgre::Timer | Timer class |
| COgre::UserObjectBindings | Class that provides convenient interface to establish a linkage between custom user application objects and Ogre core classes |
| ►COgre::VaoManager | |
| COgre::D3D11VaoManager | |
| COgre::GL3PlusVaoManager | |
| COgre::GLES2VaoManager | |
| COgre::MetalVaoManager | |
| COgre::NULLVaoManager | |
| ►COgre::VertexArrayObject | Vertex array objects (Vaos) are immutable objects that describe a combination of vertex buffers and index buffer with a given operation type |
| COgre::D3D11VertexArrayObject | |
| COgre::GL3PlusVertexArrayObject | |
| COgre::GLES2VertexArrayObject | |
| COgre::NULLVertexArrayObject | |
| COgre::Viewport | An abstraction of a viewport, i.e |
| 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 request / response style background work queue |
| ►COgre::DefaultWorkQueueBase | Base for a general purpose request / response style background work queue |
| COgre::DefaultWorkQueue | Implementation of a general purpose request / response style 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 |
| ►COgre::ZoneData | |
| COgre::OctreeZoneData | |
| COgre::v1::Animation | An animation sequence |
| COgre::v1::AnimationState | Represents the state of an animation and the weight of its influence |
| COgre::v1::AnimationStateSet | Class encapsulating a set of AnimationState objects |
| ►COgre::v1::AnimationTrack | A 'track' in an animation sequence, i.e |
| COgre::v1::NodeAnimationTrack | Specialised AnimationTrack for dealing with node transforms |
| COgre::v1::NumericAnimationTrack | Specialised AnimationTrack for dealing with generic animable values |
| COgre::v1::OldNodeAnimationTrack | Specialised AnimationTrack for dealing with node transforms |
| COgre::v1::VertexAnimationTrack | Specialised AnimationTrack for dealing with changing vertex position information |
| COgre::v1::Billboard | A billboard is a primitive which always faces the camera in every frame |
| COgre::v1::BorderRenderable | Class for rendering the border of a BorderPanelOverlayElement |
| COgre::v1::EdgeData | This class contains the information required to describe the edge connectivity of a given set of vertices and indexes |
| ►COgre::v1::HardwareBuffer | Abstract class defining common features of hardware buffers |
| COgre::v1::D3D11HardwareBuffer | Base implementation of a D3D11 buffer, dealing with all the common aspects |
| ►COgre::v1::HardwareCounterBuffer | Specialisation of HardwareBuffer for a counter buffer |
| COgre::v1::DefaultHardwareCounterBuffer | Specialisation of HardwareCounterBuffer for emulation |
| COgre::v1::GL3PlusDefaultHardwareCounterBuffer | Specialisation of HardwareCounterBuffer for emulation |
| COgre::v1::GL3PlusHardwareCounterBuffer | Specialisation of HardwareCounterBuffer for OpenGL |
| ►COgre::v1::HardwareIndexBuffer | Specialisation of HardwareBuffer for vertex index buffers, still abstract |
| COgre::v1::D3D11HardwareIndexBuffer | |
| COgre::v1::DefaultHardwareIndexBuffer | Specialisation of HardwareIndexBuffer for emulation |
| COgre::v1::GL3PlusDefaultHardwareIndexBuffer | Specialisation of HardwareIndexBuffer for emulation |
| COgre::v1::GL3PlusHardwareIndexBuffer | |
| COgre::v1::GLES2DefaultHardwareIndexBuffer | Specialisation of HardwareIndexBuffer for emulation |
| COgre::v1::MetalHardwareIndexBuffer | Specialisation of HardwareIndexBuffer for Metal |
| ►COgre::v1::HardwarePixelBuffer | Specialisation of HardwareBuffer for a pixel buffer |
| COgre::v1::D3D11DepthPixelBuffer | |
| COgre::v1::D3D11HardwarePixelBuffer | |
| COgre::v1::D3D11NullPixelBuffer | |
| ►COgre::v1::GL3PlusHardwarePixelBuffer | |
| COgre::v1::GL3PlusRenderBuffer | Renderbuffer surface |
| COgre::v1::GL3PlusTextureBuffer | Texture surface |
| ►COgre::v1::GLES2HardwarePixelBuffer | |
| COgre::v1::GLES2RenderBuffer | Renderbuffer surface |
| COgre::v1::GLES2TextureBuffer | Texture surface |
| ►COgre::v1::MetalHardwarePixelBuffer | |
| COgre::v1::MetalTextureBuffer | Texture surface |
| COgre::v1::MetalNullPixelBuffer | |
| COgre::v1::NULLHardwarePixelBuffer | |
| ►COgre::v1::HardwareUniformBuffer | Specialisation of HardwareBuffer for a uniform buffer |
| COgre::v1::D3D11HardwareUniformBuffer | Specialisation of HardwareBuffer for D3D11 |
| COgre::v1::DefaultHardwareUniformBuffer | Specialisation of HardwareUniformBuffer for emulation |
| COgre::v1::GL3PlusDefaultHardwareUniformBuffer | Specialisation of HardwareUniformBuffer for emulation |
| COgre::v1::GL3PlusHardwareShaderStorageBuffer | Specialisation of HardwareUniformBuffer for the OpenGL Shader Storage Buffer |
| COgre::v1::GL3PlusHardwareUniformBuffer | Specialisation of HardwareUniformBuffer for OpenGL |
| COgre::v1::GLES2DefaultHardwareUniformBuffer | Specialisation of HardwareUniformBuffer for emulation |
| COgre::v1::GLES2HardwareUniformBuffer | Specialisation of HardwareUniformBuffer for OpenGL |
| ►COgre::v1::HardwareVertexBuffer | Specialisation of HardwareBuffer for a vertex buffer |
| COgre::v1::D3D11HardwareVertexBuffer | Specialisation of HardwareVertexBuffer for D3D11 |
| COgre::v1::DefaultHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for emulation |
| COgre::v1::GL3PlusDefaultHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for emulation |
| COgre::v1::GL3PlusHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for OpenGL |
| COgre::v1::GLES2DefaultHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for emulation |
| COgre::v1::MetalHardwareVertexBuffer | Specialisation of HardwareVertexBuffer for Metal |
| ►COgre::v1::HardwareBufferManagerBase | Base definition of a hardware buffer manager |
| COgre::v1::D3D11HardwareBufferManagerBase | Implementation of HardwareBufferManager for D3D11 |
| COgre::v1::DefaultHardwareBufferManagerBase | Specialisation of HardwareBufferManagerBase to emulate hardware buffers |
| COgre::v1::GL3PlusDefaultHardwareBufferManagerBase | Specialisation of HardwareBufferManager to emulate hardware buffers |
| COgre::v1::GL3PlusHardwareBufferManagerBase | Implementation of HardwareBufferManager for OpenGL |
| COgre::v1::GLES2DefaultHardwareBufferManagerBase | Specialisation of HardwareBufferManager to emulate hardware buffers |
| COgre::v1::GLES2HardwareBufferManagerBase | Implementation of HardwareBufferManager for OpenGL ES |
| ►COgre::v1::HardwareBufferManager | Singleton wrapper for hardware buffer manager |
| COgre::v1::D3D11HardwareBufferManager | D3D11HardwareBufferManagerBase as a Singleton |
| COgre::v1::DefaultHardwareBufferManager | DefaultHardwareBufferManager as a Singleton |
| COgre::v1::GL3PlusDefaultHardwareBufferManager | GL3PlusDefaultHardwareBufferManagerBase as a Singleton |
| COgre::v1::GL3PlusHardwareBufferManager | GL3PlusHardwareBufferManagerBase as a Singleton |
| COgre::v1::GLES2DefaultHardwareBufferManager | GLES2DefaultHardwareBufferManagerBase as a Singleton |
| COgre::v1::GLES2HardwareBufferManager | GLES2HardwareBufferManagerBase as a Singleton |
| COgre::v1::MetalHardwareBufferManager | MetalHardwareBufferManagerBase as a Singleton |
| COgre::v1::MetalHardwareBufferManagerBase | Implementation of HardwareBufferManager for Metal |
| COgre::v1::IndexData | Summary class collecting together index data source information |
| COgre::v1::InstanceManager | This is the main starting point for the new instancing system |
| ►COgre::v1::KeyFrame | A key frame in an animation sequence defined by an AnimationTrack |
| COgre::v1::NumericKeyFrame | Specialised KeyFrame which stores any numeric value |
| COgre::v1::TransformKeyFrame | Specialised KeyFrame which stores a full transform |
| COgre::v1::VertexMorphKeyFrame | Specialised KeyFrame which stores absolute vertex positions for a complete buffer, designed to be interpolated with other keys in the same track |
| COgre::v1::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::v1::ManualObject::ManualObjectSection | Built, renderable section of geometry |
| ►COgre::v1::OldNode | Class representing a general-purpose OldNode an articulated scene graph |
| ►COgre::v1::OldBone | A bone in a skeleton |
| COgre::v1::TagPoint | A tagged point on a skeleton, which can be used to attach entities to on specific other entities |
| ►COgre::v1::OverlayElement | Abstract definition of a 2D element to be displayed in an Overlay |
| ►COgre::v1::OverlayContainer | A 2D element which contains other OverlayElement instances |
| ►COgre::v1::PanelOverlayElement | OverlayElement representing a flat, single-material (or transparent) panel which can contain other elements |
| COgre::v1::BorderPanelOverlayElement | A specialisation of the PanelOverlayElement to provide a panel with a border |
| COgre::v1::TextAreaOverlayElement | This class implements an overlay element which contains simple unformatted text |
| ►COgre::v1::OverlayElementFactory | Defines the interface which all components wishing to supply OverlayElement subclasses must implement |
| COgre::v1::BorderPanelOverlayElementFactory | Factory for creating BorderPanelOverlayElement instances |
| COgre::v1::PanelOverlayElementFactory | Factory for creating PanelOverlayElement instances |
| COgre::v1::TextAreaOverlayElementFactory | Factory for creating TextAreaOverlayElement instances |
| COgre::v1::OverlayManager | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them |
| COgre::v1::OverlaySystem | This class simplify initialization / finalization of the overlay system |
| COgre::v1::PatchSurface | A surface which is defined by curves of some kind to form a patch, e.g |
| COgre::v1::Pose | A pose is a linked set of vertex offsets applying to one set of vertex data |
| COgre::v1::StaticGeometry | Pre-transforms and batches up meshes for efficient use as static geometry in a scene |
| COgre::v1::StaticGeometry::GeometryBucket | A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored |
| COgre::v1::StaticGeometry::LODBucket | A LODBucket is a collection of smaller buckets with the same LOD |
| COgre::v1::StaticGeometry::MaterialBucket | A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same LOD) |
| COgre::v1::StaticGeometry::OptimisedSubMeshGeometry | Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances |
| COgre::v1::StaticGeometry::QueuedGeometry | Structure recording a queued geometry for low level builds |
| COgre::v1::StaticGeometry::QueuedSubMesh | Structure recording a queued submesh for the build |
| COgre::v1::SubEntity | Utility class which defines the sub-parts of an Entity |
| COgre::v1::SubMesh | Defines a part of a complete mesh |
| COgre::v1::TempBlendedBufferInfo | Structure for recording the use of temporary blend buffers |
| COgre::v1::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::v1::VertexCacheProfiler | Vertex cache profiler |
| COgre::v1::VertexData | Summary class collecting together vertex source information |
| COgre::v1::VertexDeclaration | This class declares the format of a set of vertex inputs, which can be issued to the rendering API through a RenderOperation |
| COgre::v1::VertexElement | This class declares the usage of a single vertex buffer as a component of a complete VertexDeclaration |
| 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::Any | Variant type that can hold Any other type |
| COgre::AnyNumeric | Specialised Any class which has built in arithmetic operators, but can hold only types which support operator +,-,* and / |
| COgre::ArrayAabb | Cache-friendly array of Aabb represented as a SoA array |
| COgre::ArrayActorPlane | Actors are defined by a plane and a rectangle that limits that plane |
| COgre::ArrayMatrix4 | Cache-friendly container of 4x4 matrices represented as a SoA array |
| COgre::ArrayMatrixAf4x3 | Cache-friendly container of AFFINE 4x4 matrices represented as a SoA array |
| ►COgre::ArrayMemoryManager | Abstract memory manager for managing large chunks of contiguous memory, optimized for SoA (Structure of Arrays) implementations |
| COgre::BoneArrayMemoryManager | Implementation to create the Transform variables needed by Bones |
| COgre::KfTransformArrayMemoryManager | Implementation to create the KfTransform variables needed by SkeletonTrack @See SkeletonAnimationDef and |
| COgre::NodeArrayMemoryManager | Implementation to create the Transform variables needed by Nodes & SceneNodes |
| COgre::ObjectDataArrayMemoryManager | Implementation to create the ObjectData variables needed by MovableObjects |
| ►COgre::ArrayMemoryManager::RebaseListener | When mUsedMemory >= mMaxMemory (that is, we've exhausted all our preallocated memory) ArrayMemoryManager will proceed to reallocate all memory |
| COgre::BoneMemoryManager | Wrap-around class that contains multiple ArrayMemoryManager, one per hierarchy depth |
| COgre::NodeMemoryManager | Wrap-around class that contains multiple ArrayMemoryManager, one per hierarchy depth |
| COgre::ObjectMemoryManager | Wrap-around class that contains multiple ArrayMemoryManager, one per render queue |
| COgre::ArrayQuaternion | Cache-friendly array of Quaternion represented as a SoA array |
| COgre::ArrayRay | |
| COgre::ArraySphere | Cache-friendly array of Sphere represented as a SoA array |
| COgre::ArrayVector3 | Cache-friendly array of 3-dimensional represented as a SoA array |
| COgre::AtomicObject< T > | |
| COgre::AtomicScalar< T > | |
| COgre::AxisAlignedBox | A 3D box aligned with the x/y/z axes |
| COgre::BackgroundProcessResult | Encapsulates the result of a background queue request |
| COgre::Barrier | A barrier is a synchronization mechanism where multiple threads wait until all of them have reached the barrier sync point before continuing |
| ►COgre::BasicBlock | |
| COgre::HlmsBlendblock | A blend block contains settings that rarely change, and thus are common to many materials |
| COgre::HlmsMacroblock | A macro block contains settings that will rarely change, and thus are common to many materials |
| COgre::HlmsSamplerblock | A sampler block contains settings that go hand in hand with a texture, and thus are common to many textures |
| COgre::Bitwise | Class for manipulating bit patterns |
| COgre::BoneTransform | Represents the transform of a single object, arranged in SoA (Structure of Arrays) |
| COgre::BooleanMask4 | |
| COgre::BoundUav | |
| ►COgre::Box | Structure used to define a box in a 3-D integer space |
| COgre::PixelBox | |
| COgre::BspNode::Brush | |
| ►COgre::BufferInterface | Most (if not all) buffers, can be treated with the same code |
| ►COgre::D3D11BufferInterfaceBase | For D3D11, most (if not all) buffers, can be treated with the same code |
| COgre::D3D11BufferInterface | For D3D11, most (if not all) buffers, can be treated with the same code |
| COgre::D3D11CompatBufferInterface | In D3D11, const buffers can't be bound by offset |
| COgre::GL3PlusBufferInterface | For GL3+, most (if not all) buffers, can be treated with the same code |
| COgre::GLES2BufferInterface | For GL3+, most (if not all) buffers, can be treated with the same code |
| COgre::MetalBufferInterface | For Metal, all buffers can be treated with the same code |
| COgre::NULLBufferInterface | For GL3+, most (if not all) buffers, can be treated with the same code |
| COgre::BuildLightListRequest | |
| COgre::BySkeletonDef | |
| COgre::Camera::Listener | Listener interface so you can be notified of Camera events |
| COgre::Capsule | |
| ►COgre::CbBase | |
| ►COgre::CbDrawCall | |
| COgre::CbDrawCallIndexed | |
| COgre::CbDrawCallStrip | |
| COgre::CbIndirectBuffer | |
| COgre::CbLowLevelMaterial | |
| COgre::CbPipelineStateObject | |
| COgre::CbShaderBuffer | |
| COgre::CbTexture | |
| COgre::CbTextureDisableFrom | |
| COgre::CbVao | |
| ►COgre::v1::CbDrawCall | |
| COgre::v1::CbDrawCallIndexed | |
| COgre::v1::CbDrawCallStrip | |
| COgre::v1::CbRenderOp | |
| COgre::v1::CbStartV1LegacyRendering | |
| COgre::cbitsetN< _N, _internalDataType, _bits, _mask > | |
| ►COgre::CbSharedDraw | |
| COgre::CbDrawIndexed | |
| COgre::CbDrawStrip | |
| COgre::ColourValue | Class representing colour |
| COgre::CommandBuffer | Command Buffer implementation |
| COgre::CompositorChannel | A channel in the compositor transports textures between nodes |
| COgre::CompositorNamedBuffer | |
| COgre::CompositorPassComputeDef::BufferSource | |
| COgre::CompositorPassComputeDef::ComputeTextureSource | |
| COgre::CompositorPassDef::UavDependency | |
| COgre::CompositorPassQuadDef::QuadTextureSource | |
| COgre::CompositorPassUavDef::BufferSource | |
| COgre::CompositorPassUavDef::TextureSource | |
| COgre::CompositorTexture | |
| COgre::CompositorWorkspaceDef::ChannelRoute | |
| ►COgre::CompositorWorkspaceListener | |
| COgre::ParallaxCorrectedCubemap | |
| COgre::ComPtr< T > | |
| COgre::ComPtr< T >::SafeBoolHelper | |
| COgre::ComputeProperty | |
| ►COgre::ConstBufferPool | Maintains a pool of buffers grouped by hash ID |
| COgre::HlmsPbs | Physically based shading implementation specfically designed for OpenGL 3+, D3D11 and other RenderSystems which support uniform buffers |
| COgre::HlmsUnlit | Implementation without lighting or skeletal animation specfically designed for OpenGL 3+, D3D11 and other RenderSystems which support uniform buffers |
| COgre::ConstBufferPool::BufferPool | |
| COgre::ConstBufferPool::ExtraBufferParams | |
| ►COgre::ConstBufferPoolUser | |
| COgre::HlmsPbsDatablock | Contains information needed by PBS (Physically Based Shading) for OpenGL 3+ & D3D11+ |
| COgre::HlmsUnlitDatablock | Contains information needed by PBS (Physically Based Shading) for OpenGL 3+ & D3D11+ |
| COgre::ConvexBody | Holds a solid representation of a convex body |
| COgre::CPreprocessor | This is a simplistic C/C++-like preprocessor |
| ►COgre::CullFrustumRequest | All variables are read-only for the worker threads |
| COgre::UpdateLodRequest | |
| COgre::CustomCompositionPass | Interface for custom composition passes, allowing custom operations (in addition to the quad, scene and clear operations) in composition passes |
| COgre::D3D11Device | |
| ►COgre::D3D11DeviceResource | Represents a Direct3D rendering resource |
| COgre::D3D11HLSLProgram | Specialization of HighLevelGpuProgram to provide support for D3D11 High-Level Shader Language (HLSL) |
| COgre::D3D11RenderTexture | RenderTexture implementation for D3D11 |
| COgre::D3D11RenderWindowBase | |
| COgre::D3D11Texture | |
| ►COgre::D3D11DeviceResourceManager | Singleton that is used to propagate device state changed notifications |
| COgre::D3D11RenderSystem | Implementation of DirectX11 as a rendering system |
| COgre::D3D11Driver | |
| COgre::D3D11DriverList | |
| COgre::D3D11DynamicBuffer | D3D11 doesn't support mapping the same buffer twice even if the regions don't overlap |
| COgre::D3D11HlmsPso | @See HlmsPso |
| COgre::D3D11Mappings | |
| COgre::D3D11VaoManager::Block | |
| COgre::D3D11VaoManager::StrideChanger | |
| COgre::D3D11VaoManager::Vao::VertexBinding | |
| COgre::D3D11VertexArrayObjectShared | |
| COgre::D3D11VideoMode | |
| COgre::D3D11VideoModeList | |
| COgre::D3D9Mappings | |
| ►COgre::D3D9Resource | Represents a Direct3D rendering resource |
| COgre::D3D9GpuProgram | Direct3D implementation of a few things common to low-level vertex & fragment programs |
| COgre::D3D9HardwareIndexBuffer | |
| COgre::D3D9HardwareOcclusionQuery | This is a class that is the DirectX9 implementation of hardware occlusion testing |
| COgre::D3D9HardwareVertexBuffer | Specialisation of HardwareVertexBuffer for D3D9 |
| COgre::D3D9Texture | |
| COgre::D3D9VertexDeclaration | Specialisation of VertexDeclaration for D3D9 |
| COgre::D3D9VideoMode | |
| COgre::Degree | Wrapper class which indicates a given angle value is in Degrees |
| COgre::deque< T, A > | |
| 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::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::ErrorDialog | Class for displaying the error dialog if Ogre fails badly |
| 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::FastArray< T > | Lightweight implementation of std::vector |
| COgre::FileInfo | Information about a file/directory within the archive will be returned using a FileInfo struct |
| COgre::FilterKernel | |
| COgre::FilterSeparableKernel | |
| COgre::Font::GlyphInfo | Information about the position and size of a glyph in a texture |
| COgre::ForwardPlusBase::CachedGridBuffer | |
| 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::ParallaxCorrectedCubemap | |
| COgre::Terrain | The main containing class for a chunk of terrain |
| COgre::Volume::Chunk | A single volume chunk mesh |
| COgre::FreeOnDestructor | Helper class to that will free the pointer on the destructor |
| ►COgre::GL3PlusContext | Class that encapsulates an GL context |
| COgre::CocoaContext | |
| COgre::GLXContext | |
| COgre::Win32Context | |
| COgre::GL3PlusDynamicBuffer | GL3+ doesn't support mapping the same buffer twice even if the regions don't overlap |
| COgre::GL3PlusFBOManager::FormatProperties::Mode | Allowed modes/properties for this pixel format |
| COgre::GL3PlusFrameBufferObject | Frame Buffer Object abstraction |
| COgre::GL3PlusHlmsPso | @See HlmsPso |
| COgre::GL3PlusOldVertexArrayObject | Specialisation of VertexDeclaration for OpenGL Vertex Array Object usage |
| COgre::GL3PlusPixelUtil | Class to do pixel format mapping between GL and OGRE |
| ►COgre::GL3PlusSupport | |
| COgre::GLXGLSupport | |
| COgre::GTKGLSupport | GL support in a GTK window |
| COgre::OSXGL3PlusSupport | |
| COgre::SDLGLSupport | |
| COgre::Win32GLSupport | |
| COgre::GL3PlusSurfaceDesc | GL surface descriptor |
| COgre::GL3PlusVaoManager::Block | |
| COgre::GL3PlusVaoManager::StrideChanger | |
| COgre::GL3PlusVaoManager::Vao::VertexBinding | |
| COgre::GLAtomicCounterReference | Structure used to keep track of named atomic counter uniforms in the linked program object |
| ►COgre::GLES2Context | Class that encapsulates an GL context |
| ►COgre::EGLContext | |
| COgre::AndroidEGLContext | |
| COgre::EmscriptenEGLContext | |
| COgre::Win32EGLContext | |
| COgre::X11EGLContext | |
| COgre::NaClGLContext | |
| COgre::GLES2DynamicBuffer | GL3+ doesn't support mapping the same buffer twice even if the regions don't overlap |
| COgre::GLES2FBOManager::FormatProperties::Mode | Allowed modes/properties for this pixel format |
| COgre::GLES2FrameBufferObject | Frame Buffer Object abstraction |
| COgre::GLES2HlmsPso | @See HlmsPso |
| COgre::GLES2HlmsSamplerblock | A sampler block contains settings that go hand in hand with a texture, and thus are common to many textures |
| COgre::GLES2OldVertexArrayObject | Specialisation of VertexDeclaration for OpenGL ES 2 Vertex Array Object usage |
| COgre::GLES2PixelUtil | Class to do pixel format mapping between GL and OGRE |
| ►COgre::GLES2Support | |
| ►COgre::EGLSupport | |
| COgre::AndroidEGLSupport | |
| COgre::EmscriptenEGLSupport | |
| COgre::Win32EGLSupport | |
| COgre::X11EGLSupport | |
| COgre::NaClGLSupport | |
| COgre::GLES2SurfaceDesc | GL surface descriptor |
| COgre::GLES2VaoManager::Block | |
| COgre::GLES2VaoManager::StrideChanger | |
| COgre::GLES2VaoManager::Vao::VertexBinding | |
| ►COgre::GLSLESProgramCommon | C++ encapsulation of GLSL ES Program Object |
| COgre::GLSLESProgramPipeline | Specialisation of GLSLESProgramCommon to provide support for separable programs via the Open GL program pipeline |
| ►COgre::GLSLESProgramManagerCommon | Ogre assumes that there are separate programs to deal with but GLSL ES has one program object that represents the active shader objects during a rendering state |
| COgre::GLSLESLinkProgramManager | 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 |
| COgre::GLSLESProgramPipelineManager | Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL ES has one program pipeline object that represents the active vertex and fragment program objects during a rendering state |
| ►COgre::GLSLProgram | C++ encapsulation of GLSL program object |
| COgre::GLSLMonolithicProgram | Model of OpenGL program object created using the glLinkProgram method of linking |
| COgre::GLSLSeparableProgram | Specialisation of GLSLProgram to provide support for separable programs via the OpenGL program pipeline |
| ►COgre::GLSLProgramManager | 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 |
| COgre::GLSLMonolithicProgramManager | 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 |
| COgre::GLSLSeparableProgramManager | Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL has one program pipeline object that represents the active vertex and fragment program objects during a rendering state |
| COgre::GLUniformReference | Structure used to keep track of named uniforms in the linked program object |
| COgre::GLXUtils | |
| COgre::GpuConstantDefinition | Information about predefined program constants |
| COgre::GpuLogicalIndexUse | Structure recording the use of a physical buffer by a logical parameter index |
| COgre::GpuProgramManager::Hash | |
| 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::GpuResource | |
| COgre::BufferPacked | |
| COgre::RenderTarget | A 'canvas' which can receive the results of a rendering operation |
| COgre::HashedVector< T > | A hashed vector |
| COgre::Hlms::DatablockEntry | |
| COgre::Hlms::Library | |
| COgre::HlmsBasePieces | |
| COgre::HlmsBaseProp | These are "default" or "Base" properties common to many implementations and thus defined here |
| COgre::HlmsBits | |
| COgre::HlmsCache | |
| COgre::HlmsComputePso | |
| COgre::HlmsDiskCache::Cache | |
| COgre::HlmsDiskCache::Pso | |
| COgre::HlmsDiskCache::SourceCode | |
| COgre::HlmsJson::NamedBlocks | |
| ►COgre::HlmsJsonListener | |
| ►COgre::SceneFormatListener | Override this listener if you want to filter which objects get exported |
| COgre::DefaultSceneFormatListener | Default implementation that prevents a SceneNode from being exported if the only attached objects |
| COgre::HlmsJsonPbs | |
| COgre::HlmsJsonUnlit | |
| COgre::HlmsListener | Listener that can be hooked to an Hlms implementation for extending it with custom code |
| COgre::HlmsPassPso | IT'S MEMBERS MUST BE KEPT POD (Otherwise HlmsPso needs to be modified) |
| COgre::HlmsProperty | |
| COgre::HlmsPso | Defines a PipelineStateObject as required by Vulkan, Metal & DX12 |
| COgre::HlmsPsoProp | |
| ►COgre::HlmsTextureExportListener | |
| COgre::SceneFormatListener | Override this listener if you want to filter which objects get exported |
| COgre::HlmsTextureManager::DefaultTextureParameters | |
| COgre::HlmsTextureManager::MetadataCacheEntry | |
| COgre::HlmsTextureManager::TextureArray::NamePair | |
| COgre::HlmsTextureManager::TextureLocation | |
| COgre::HlmsTextureManager::Threshold | Textures whose size are less or equal to minTextureSize (without considering mipmaps) will have their maxTexturesPerArray clamped to the value given in this threshold structure |
| COgre::HlmsTexturePack | |
| COgre::HlmsTexturePack::TextureEntry | |
| COgre::HlmsUnlitMobileDatablock::UvAtlasParams | |
| COgre::Id | Usage: OGRE_NEW SceneNode( Id::generateNewId< Node >() ) |
| ►COgre::IdObject | |
| COgre::Bone | Class representing a Bone in the join hierarchy of a skeleton |
| COgre::CompositorNode | Compositor nodes are the core subject of compositing |
| COgre::CompositorWorkspace | A compositor workspace is the main interface to render into an RT, be it a RenderWindow or an RTT (Render Texture Target) |
| COgre::MovableObject | Abstract class defining a movable object in a scene |
| COgre::Node | Class representing a general-purpose node an articulated scene graph |
| COgre::ParallaxCorrectedCubemap | |
| COgre::IdString | Hashed string |
| COgre::InstanceBatchCullRequest | |
| COgre::InstantRadiosity | |
| COgre::InstantRadiosity::AreaOfInterest | Areas of Interest are defined by both AABB and distance (can be 0) |
| ►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::IrradianceVolume | |
| 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::iterator_range< T > | Base for an iterator_range |
| COgre::ConstMapRange< T > | Predefined type |
| COgre::ConstVectorRange< T > | Predefined type |
| COgre::MapRange< T > | Predefined type |
| COgre::VectorRange< T > | Predefined type |
| ►COgre::IteratorWrapper< T, IteratorType, ValType > | Basefunctionality for IteratorWrappers |
| ►COgre::MapIteratorWrapper< T, T::const_iterator > | |
| COgre::ConstMapIterator< T > | Concrete IteratorWrapper for const access to the underlying key-value container |
| ►COgre::MapIteratorWrapper< T, T::iterator > | |
| COgre::MapIterator< T > | Concrete IteratorWrapper for nonconst access to the underlying key-value container |
| ►COgre::VectorIteratorWrapper< T, T::const_iterator > | |
| COgre::ConstVectorIterator< T > | Concrete IteratorWrapper for const access to the underlying container |
| ►COgre::VectorIteratorWrapper< T, T::iterator > | |
| COgre::VectorIterator< T > | Concrete IteratorWrapper for nonconst access to the underlying container |
| COgre::KeyFrameRig | |
| COgre::KfTransform | Holds the transform of a KeyFrame (which is part of an animation) |
| COgre::LayerBlendModeEx | Class which manages blending of both colour and alpha components |
| COgre::LightClosest | Used as the light list, sorted |
| COgre::LightListInfo | Holds all lights in SoA after being culled over all frustums |
| COgre::LightweightMutex | A lightweight mutex is a synchronization mechanism, very similar to a regular mutex |
| COgre::LinearResampler | |
| COgre::LinearResampler_Byte< channels > | |
| COgre::LinearResampler_Float32 | |
| COgre::list< T, A > | |
| 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::Triangle | |
| COgre::LodData::Vertex | |
| COgre::LodData::VertexEqual | |
| COgre::LodData::VertexHash | |
| COgre::LodIndexBuffer | Thread-safe buffer for storing Hardware index buffer |
| COgre::LodInputBuffer | Data representing all required information from a Mesh. Used by LodInputProviderBuffer |
| COgre::LodInputBuffer::Submesh | |
| ►COgre::LodInputProvider | |
| COgre::LodInputProviderBuffer | |
| COgre::LodInputProviderMesh | |
| 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::LodOutputBuffer | Data representing the output of the Mesh reduction. Used by LodOutputProviderBuffer |
| COgre::LodOutputBuffer::Submesh | |
| ►COgre::LodOutputProvider | |
| COgre::LodOutputProviderBuffer | |
| ►COgre::LodOutputProviderCompressedMesh | |
| COgre::LodOutputProviderCompressedBuffer | |
| COgre::LodOutputProviderMesh | |
| COgre::LodOutsideMarker | This class will mark vertices of a mesh, which are visible from far away (from outside) |
| COgre::LodVertexBuffer | Thread-safe buffer for storing Hardware vertex buffer |
| COgre::LodWorkQueueInjectorListener | |
| COgre::LodWorkQueueRequest | |
| 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::AndroidLogListener | |
| COgre::LowLevelProp | |
| ►COgre::LwConstString | |
| COgre::LwString | This is a Light-weight string wrapper around the C string interface |
| COgre::LwString::Float | |
| ►COgre::ManualResourceLoader | Interface describing a manual resource loader |
| COgre::Font | Class representing a font in the system |
| COgre::v1::MeshManager | Handles the management of mesh resources |
| COgre::map< K, V, P, A > | |
| COgre::MaterialManager::Listener | Listener on any general material events |
| COgre::MaterialScriptProgramDefinition | Struct for holding a program definition which is in progress |
| ►COgre::MaterialSerializer::Listener | Class that allows listening in on the various stages of material serialization process |
| COgre::RTShader::SGMaterialSerializerListener | This class responsible for translating core features of the RT Shader System for Ogre material scripts |
| 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::MathlibC | |
| COgre::Matrix3 | A 3x3 matrix which can represent rotations around axes |
| COgre::Matrix4 | Class encapsulating a standard 4x4 homogeneous matrix |
| COgre::MeshSerializerListener | |
| COgre::MetalDevice | |
| COgre::MetalDynamicBuffer | Metal doesn't "map" |
| COgre::MetalHlmsPso | @See HlmsPso |
| COgre::MetalMappings | |
| ►COgre::MetalRenderTargetCommon | |
| COgre::MetalRenderTexture | |
| COgre::MetalRenderWindow | |
| ►COgre::MetalVaoManager::Block | |
| COgre::MetalDiscardBufferManager::UnsafeBlock | |
| COgre::MetalVaoManager::StrideChanger | |
| COgre::MetalVaoManager::Vao::VertexBinding | |
| 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, A > | |
| COgre::NameGenerator | Utility class to generate a sequentially numbered series of names |
| COgre::NearestResampler< elemsize > | |
| ►COgre::Node::Listener | Listener which gets called back on Node events |
| COgre::v1::RibbonTrail | Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances |
| COgre::NULLVaoManager::Block | |
| COgre::NULLVaoManager::StrideChanger | |
| COgre::NULLVaoManager::Vao::VertexBinding | |
| COgre::NumericSolver | Provides numeric solvers for Ogre |
| COgre::ObjectData | Represents the transform of a single object, arranged in SoA (Structure of Arrays) |
| COgre::OfflineProfiler | Simple profiler that will produce a CSV file for offline analysis once dumpProfileResults is called |
| COgre::OptimisedUtil | Utility class for provides optimised functions |
| COgre::PackedTexture | Used by JSON serialization, but can also be used outside of it |
| 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::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::CmdEntryPoint | Command object for setting entry point |
| 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::D3D11HLSLProgram::CmdColumnMajorMatrices | Command object for setting matrix packing in column-major order |
| COgre::D3D11HLSLProgram::CmdEnableBackwardsCompatibility | Command object for setting backwards compatibility |
| COgre::D3D11HLSLProgram::CmdEntryPoint | Command object for setting entry point |
| COgre::D3D11HLSLProgram::CmdPreprocessorDefines | Command object for setting macro defines |
| COgre::D3D11HLSLProgram::CmdTarget | Command object for setting target assembler |
| COgre::D3D9GpuProgram::CmdColumnMajorMatrices | Command object for setting matrix packing in column-major order |
| COgre::D3D9GpuProgram::CmdExternalMicrocode | Command object for getting/setting external micro code (void*) |
| COgre::D3D9HLSLProgram::CmdAssemblerCode | Command object for getting/setting assembler code |
| COgre::D3D9HLSLProgram::CmdBackwardsCompatibility | Command object for enabling backwards compatibility |
| COgre::D3D9HLSLProgram::CmdColumnMajorMatrices | Command object for setting matrix packing in column-major order |
| COgre::D3D9HLSLProgram::CmdEntryPoint | Command object for setting entry point |
| COgre::D3D9HLSLProgram::CmdMicrocode | Command object for getting/setting micro code |
| COgre::D3D9HLSLProgram::CmdOptimisation | Command object for setting optimisation level |
| COgre::D3D9HLSLProgram::CmdPreprocessorDefines | Command object for setting macro defines |
| COgre::D3D9HLSLProgram::CmdTarget | Command object for setting target assembler |
| 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::EmitterCommands::CmdAngle | Command object for ParticleEmitter - see ParamCommand |
| COgre::EmitterCommands::CmdColour | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdColourRangeEnd | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdColourRangeStart | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdDirPositionRef | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdDirection | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdDuration | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdEmissionRate | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdEmittedEmitter | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMaxDuration | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMaxRepeatDelay | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMaxTTL | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMaxVelocity | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMinDuration | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMinRepeatDelay | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMinTTL | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdMinVelocity | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdName | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdPosition | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdRepeatDelay | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdTTL | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdUp | Command object for particle emitter - see ParamCommand |
| COgre::EmitterCommands::CmdVelocity | Command object for particle emitter - see ParamCommand |
| COgre::ExternalTextureSource::CmdFPS | |
| COgre::ExternalTextureSource::CmdInputFileName | |
| COgre::ExternalTextureSource::CmdPlayMode | |
| COgre::ExternalTextureSource::CmdTecPassState | |
| COgre::GLSLESCgProgram::CmdEntryPoint | Command object for setting entry point |
| COgre::GLSLESCgProgram::CmdProfiles | Command object for setting profiles |
| COgre::GLSLESShader::CmdOptimisation | Command object for running the GLSL optimiser |
| COgre::GLSLESShader::CmdPreprocessorDefines | Command object for setting macro defines |
| COgre::GLSLShader::CmdAttach | Command object for attaching another GLSL Program |
| COgre::GLSLShader::CmdColumnMajorMatrices | Command object for setting matrix packing in column-major order |
| COgre::GLSLShader::CmdInputOperationType | Command object for setting the input operation type (geometry shader only) |
| COgre::GLSLShader::CmdMaxOutputVertices | Command object for setting the maximum output vertices (geometry shader only) |
| COgre::GLSLShader::CmdOutputOperationType | Command object for setting the output operation type (geometry shader only) |
| COgre::GLSLShader::CmdPreprocessorDefines | Command object for setting macro defines |
| COgre::HighLevelGpuProgram::CmdEnableIncludeHeader | Command object for enabling include in shaders |
| 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::MetalProgram::CmdEntryPoint | Command object for setting entry point |
| COgre::MetalProgram::CmdPreprocessorDefines | Command object for setting macro defines |
| COgre::MetalProgram::CmdShaderReflectionPairHint | Command object for setting vertex shader pair |
| COgre::ParticleSystem::CmdCull | Command object for cull_each (see ParamCommand) |
| COgre::ParticleSystem::CmdEmittedEmitterQuota | Command object for emittedEmitterQuota (see ParamCommand) |
| COgre::ParticleSystem::CmdHeight | Command object for particle_height (see ParamCommand) |
| COgre::ParticleSystem::CmdIterationInterval | Command object for iteration interval(see ParamCommand) |
| COgre::ParticleSystem::CmdLocalSpace | Command object for local space (see ParamCommand) |
| COgre::ParticleSystem::CmdMaterial | Command object for material (see ParamCommand) |
| COgre::ParticleSystem::CmdNonvisibleTimeout | Command object for nonvisible timeout (see ParamCommand) |
| COgre::ParticleSystem::CmdQuota | Command object for quota (see ParamCommand) |
| COgre::ParticleSystem::CmdRenderer | Command object for renderer (see ParamCommand) |
| COgre::ParticleSystem::CmdSorted | Command object for sorting (see ParamCommand) |
| COgre::ParticleSystem::CmdWidth | Command object for particle_width (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::UnifiedHighLevelGpuProgram::CmdDelegate | Command object for setting delegate (can set more than once) |
| COgre::v1::BillboardParticleRenderer::CmdAccurateFacing | Command object for accurate facing(see ParamCommand) |
| COgre::v1::BillboardParticleRenderer::CmdBillboardOrigin | Command object for billboard origin (see ParamCommand) |
| COgre::v1::BillboardParticleRenderer::CmdBillboardRotationType | Command object for billboard rotation type (see ParamCommand) |
| COgre::v1::BillboardParticleRenderer::CmdBillboardType | Command object for billboard type (see ParamCommand) |
| COgre::v1::BillboardParticleRenderer::CmdCommonDirection | Command object for common direction (see ParamCommand) |
| COgre::v1::BillboardParticleRenderer::CmdCommonUpVector | Command object for common up-vector (see ParamCommand) |
| COgre::v1::BillboardParticleRenderer::CmdPointRendering | Command object for point rendering (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderBottomLeftUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderBottomRightUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderBottomUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderLeftUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderMaterial | Command object for specifying the Material for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderRightUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderSize | Command object for specifying border sizes (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderTopLeftUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderTopRightUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::BorderPanelOverlayElement::CmdBorderTopUV | Command object for specifying texture coordinates for the border (see ParamCommand) |
| COgre::v1::OverlayElementCommands::CmdCaption | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdHeight | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdHorizontalAlign | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdLeft | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdMaterial | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdMetricsMode | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdTop | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdVerticalAlign | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdVisible | Command object for OverlayElement - see ParamCommand |
| COgre::v1::OverlayElementCommands::CmdWidth | Command object for OverlayElement - see ParamCommand |
| COgre::v1::PanelOverlayElement::CmdTiling | Command object for specifying tiling (see ParamCommand) |
| COgre::v1::PanelOverlayElement::CmdTransparent | Command object for specifying transparency (see ParamCommand) |
| COgre::v1::PanelOverlayElement::CmdUVCoords | Command object for specifying UV coordinates (see ParamCommand) |
| COgre::v1::TextAreaOverlayElement::CmdAlignment | Command object for setting the alignment |
| COgre::v1::TextAreaOverlayElement::CmdCaption | Command object for setting the caption |
| COgre::v1::TextAreaOverlayElement::CmdCharHeight | Command object for setting the char height |
| COgre::v1::TextAreaOverlayElement::CmdColour | Command object for setting the constant colour |
| COgre::v1::TextAreaOverlayElement::CmdColourBottom | Command object for setting the bottom colour |
| COgre::v1::TextAreaOverlayElement::CmdColourTop | Command object for setting the top colour |
| COgre::v1::TextAreaOverlayElement::CmdFontName | Command object for setting the caption |
| COgre::v1::TextAreaOverlayElement::CmdSpaceWidth | Command object for setting the width of a space |
| COgre::ParamDictionary | Class to hold a dictionary of parameters for a single class |
| COgre::ParameterDef | Definition of a parameter supported by a StringInterface class, for introspection |
| COgre::ParticleIterator | Convenience class to make it easy to step through all particles in a ParticleSystem |
| COgre::PbsBakedTexture | |
| COgre::PbsMobileProperty | |
| COgre::PbsMobileShaderCreationData | |
| COgre::PbsProperty | |
| COgre::PbsUvAtlasParams | |
| COgre::PCZFrustum | Specialized frustum shaped culling volume that has culling planes created from portals |
| COgre::PixelFormatDescription | A record that describes a pixel format in detail |
| ►COgre::PixelFormatToShaderType | |
| COgre::D3D11PixelFormatToShaderType | |
| COgre::GL3PlusPixelFormatToShaderType | |
| COgre::GLES2PixelFormatToShaderType | |
| COgre::MetalPixelFormatToShaderType | |
| COgre::NULLPixelFormatToShaderType | |
| COgre::PixelUtil | Some utility functions for packing and unpacking pixel data |
| COgre::PlanarReflectionActor | |
| COgre::PlanarReflections | Planar Reflections can be used with both Unlit and PBS, but they're setup differently |
| COgre::PlanarReflections::TrackedRenderable | |
| ►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 | |
| 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::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::v1::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::QueuedRenderable | |
| COgre::Radian | Wrapper class which indicates a given angle value is in Radians |
| COgre::RadixSort< TContainer, TContainerValueType, TCompValueType > | Class for performing a radix sort (fast comparison-less sort based on byte value) on various standard STL containers |
| COgre::RawSimdUniquePtr< T, M_CATEGORY > | Similar to std::unique_ptr, but: Uses a custom allocator (OGRE_MALLOC_SIMD) Pointers must be really unique (RESTRICT_ALIAS modifier is used!) To access the pointer, use get(); instead of using this container directly The purpose of this container is to enclose a raw pointer while avoiding breaking the rule of 3 when copying |
| 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::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::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::ManualObject::ManualObjectSection | Built, renderable section of geometry |
| ►COgre::RenderableAnimated | |
| COgre::SubItem | Utility class which defines the sub-parts of an Item |
| COgre::WireAabb | Helper class to display the Aabb of a MovableObject as lines |
| COgre::v1::BillboardChain | Allows the rendering of a chain of connected billboards |
| COgre::v1::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::v1::BorderRenderable | Class for rendering the border of a BorderPanelOverlayElement |
| COgre::v1::InstanceBatch | InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived to implement different instancing techniques ( |
| COgre::v1::ManualObject::ManualObjectSection | Built, renderable section of geometry |
| COgre::v1::OverlayElement | Abstract definition of a 2D element to be displayed in an Overlay |
| COgre::v1::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 'depth_write off' materials |
| COgre::v1::SimpleRenderable | Simple implementation of MovableObject and Renderable for single-part custom objects |
| COgre::v1::StaticGeometry::GeometryBucket | A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored |
| COgre::v1::SubEntity | Utility class which defines the sub-parts of an Entity |
| 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::RenderQueueListener | Abstract interface which classes must implement if they wish to receive events from the render queue |
| COgre::v1::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::D3D9StereoDriverAMD | Virtual interface of the stereo driver |
| COgre::v1::OverlaySystem | This class simplify initialization / finalization of the overlay system |
| COgre::RenderSystem::RenderSystemContext | |
| COgre::RenderTarget::FrameStats | |
| COgre::RenderTarget::Impl | RenderSystem specific interface for a RenderTarget; this should be subclassed by RenderSystems |
| 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::D3D9StereoDriverAMD | Virtual interface of the stereo driver |
| COgre::RenderTargetViewportEvent | Struct containing information about a RenderTarget Viewport-specific event |
| COgre::RenderWindowDescription | Render window creation parameters |
| ►COgre::Resource::Listener | |
| 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::Item | Defines an instance of a discrete, movable object based on a Mesh |
| COgre::v1::Entity | Defines an instance of a discrete, movable object based on a Mesh |
| COgre::ResourceBackgroundQueue::Listener | This abstract listener interface lets you get notifications of completed background processes instead of having to poll ticket statuses |
| COgre::ResourceGroupListener | This abstract class defines an interface which is called back during resource group loading to indicate the progress of the load |
| COgre::ResourceGroupManager::ResourceDeclaration | Nested struct defining a resource declaration |
| COgre::ResourceGroupManager::ResourceLocation | Resource location entry |
| COgre::ResourceLoadingListener | |
| COgre::ResourceTransition | |
| COgre::RotationalSpline | This class interpolates orientations (rotations) along a spline using derivatives of quaternions |
| COgre::RqBits | |
| COgre::RTShader::FunctionInvocation::FunctionInvocationCompare | Comparator function to be used for comparisons |
| COgre::RTShader::FunctionInvocation::FunctionInvocationLessThan | Comparator function to be used for sorting |
| COgre::RTShader::HardwareSkinning::SkinningData | |
| COgre::RTShader::LayeredBlending::TextureBlend | |
| 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::RTShader::TextureAtlasRecord | |
| COgre::RTShader::TextureAtlasSamplerFactory::TextureAtlasAttib | |
| ►COgre::SceneFormatBase | |
| COgre::SceneFormatExporter | |
| COgre::SceneFormatImporter | |
| ►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::Terrain | The main containing class for a chunk of terrain |
| COgre::SceneManager::RenderContext | |
| COgre::SceneManager::SkyBoxGenParameters | |
| COgre::SceneManager::SkyDomeGenParameters | |
| COgre::SceneManager::SkyPlaneGenParameters | |
| COgre::SceneManagerMetaData | Structure containing information about a scene manager |
| COgre::SceneQuery::WorldFragment | Represents part of the world geometry that is a result of a SceneQuery |
| ►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::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::CreateHighLevelGpuProgramScriptCompilerEvent | |
| COgre::CreateMaterialScriptCompilerEvent | |
| COgre::CreateParticleSystemScriptCompilerEvent | |
| COgre::PreApplyTextureAliasesScriptCompilerEvent | |
| 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::HlmsManager | HLMS stands for "High Level Material System" |
| COgre::ParticleSystemManager | Manages particle systems, particle system scripts (templates) and the available emitter & affector factories |
| COgre::Quake3ShaderManager | Class for managing Quake3 custom shaders |
| COgre::ResourceManager | Defines a generic resource handler |
| COgre::ScriptCompilerManager | Manages threaded compilation of scripts |
| COgre::v1::OverlayManager | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them |
| COgre::ScriptToken | This struct represents a token, which is an ID'd lexeme from the parsing input stream |
| COgre::Segment | |
| COgre::set< T, P, A > | |
| COgre::ShaderParams::AutoParam | |
| COgre::ShaderParams::ManualParam | |
| COgre::ShaderParams::Param | |
| COgre::ShadowNodeHelper | |
| COgre::ShadowNodeHelper::Resolution | |
| COgre::ShadowNodeHelper::ShadowParam | |
| COgre::SharedPtr< T > | Reference-counted shared pointer, used for objects where implicit destruction is required |
| ►COgre::SharedPtrInfo | |
| COgre::SharedPtrInfoDelete< T > | |
| COgre::SharedPtrInfoDeleteT< T > | |
| COgre::SharedPtrInfoFree< T > | |
| COgre::SharedPtrInfoNone | |
| COgre::SimpleMatrix4 | Simple wrap up to load an AoS matrix 4x4 using SSE |
| COgre::SimpleMatrixAf4x3 | Simple wrap up to load an AoS matrix 4x3 using SSE |
| 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::SkeletonAnimManager | This is how the Skeleton system works in 2.0: There is one BoneMemoryManager per skeleton |
| COgre::SkeletonDef::BoneData | |
| COgre::SkeletonDef::DepthLevelInfo | |
| ►COgre::SmallVectorBase | SmallVectorBase - This is all the non-templated stuff common to all SmallVectors |
| COgre::SmallVectorTemplateCommon< Edge > | |
| COgre::SmallVectorTemplateCommon< Triangle * > | |
| COgre::SmallVectorTemplateCommon< Edge > | |
| COgre::SmallVectorTemplateCommon< Triangle * > | |
| ►COgre::SmallVectorTemplateCommon< T > | |
| ►COgre::SmallVectorTemplateBase< T, isPodLike< T >::value > | |
| ►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::SmallVector< T, S > | |
| COgre::VectorSet< T, S > | VectorSet is basically a helper to use a vector as a small set container |
| COgre::SmallVector< Edge, S > | |
| COgre::SmallVector< Triangle *, S > | |
| COgre::SmallVector< T, S > | |
| COgre::SmallVector< Edge, S > | |
| COgre::SmallVector< Triangle *, S > | |
| ►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< Triangle *, 7 > | |
| COgre::SmallVector< T, N > | SmallVector - This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small |
| COgre::SmallVector< T, 0 > | Specialize SmallVector at N=0 |
| COgre::SmallVector< T, 0 > | Specialize SmallVector at N=0 |
| 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::SmallVectorTemplateBase< Edge, isPodLike< Edge >::value > | |
| COgre::SmallVectorTemplateBase< Triangle *, isPodLike< Triangle * >::value > | |
| COgre::SmallVectorTemplateBase< T, isPodLike< T >::value > | |
| COgre::SmallVectorTemplateBase< Edge, isPodLike< Edge >::value > | |
| COgre::SmallVectorTemplateBase< Triangle *, isPodLike< Triangle * >::value > | |
| ►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::SmallVectorImpl< Edge > | |
| COgre::SmallVectorImpl< Triangle * > | |
| COgre::SmallVectorImpl< Edge > | |
| COgre::SmallVectorImpl< Triangle * > | |
| 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::SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's |
| COgre::SmallVectorTemplateCommon< T > | |
| COgre::Sphere | A sphere primitive, mostly used for bounds checking |
| COgre::StagingBuffer::Destination | |
| COgre::StaticCache< cacheSize > | Template version of cache based on static array |
| COgre::StaticFaceGroup | Collects a group of static i.e |
| COgre::StencilParams | |
| COgre::StencilStateOp | |
| COgre::STLAllocator< T, AllocPolicy >::rebind< U > | Standard rebind mechanism |
| ►COgre::STLAllocatorBase< T > | Wrapper class for operating as an STL container allocator |
| COgre::STLAllocator< T, AllocPolicy > | |
| COgre::STLAllocatorBase< const T > | |
| 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::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 (e.g |
| COgre::v1::OverlayElement | Abstract definition of a 2D element to be displayed in an Overlay |
| COgre::StringUtil | Utility class for manipulating Strings |
| COgre::SubMesh::SourceData | |
| COgre::SubStringRef | |
| 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::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::TerrainLayerDeclaration | The definition of the information each layer will contain in this terrain |
| COgre::TerrainLayerSampler | Description of a sampler that will be used with each layer |
| COgre::TerrainLayerSamplerElement | Information about one element of a sampler / texture within a layer |
| COgre::TerrainLodManager::LoadLodRequest | |
| COgre::TerrainLodManager::LodInfo | |
| COgre::TextureUnitState::TextureEffect | Internal structure defining a texture effect |
| COgre::ThreadHandle | |
| COgre::ThreadLocalPtr< T > | |
| COgre::Threads | |
| COgre::Transform | Represents the transform of a single object, arranged in SoA (Structure of Arrays) |
| COgre::TRect< T > | |
| ►COgre::UniformScalableTask | A uniform task is a highly parallelizable task that can be divided in many threads where all threads take near the same amount of time to perform |
| COgre::ForwardClustered | Implementation of Clustered Forward Shading |
| COgre::UnlitBakedTexture | |
| COgre::UnlitMobileProp | |
| COgre::UnlitProperty | |
| COgre::UnlitProperty::DiffuseMapPtr | |
| COgre::unordered_map< K, V, H, E, A > | |
| COgre::unordered_multimap< K, V, H, E, A > | |
| COgre::unordered_multiset< K, H, E, A > | |
| COgre::unordered_set< K, H, E, A > | |
| COgre::UpdateTransformRequest | |
| ►COgre::v1::AnimationContainer | An animation container interface, which allows generic access to sibling animations |
| COgre::v1::Mesh | Resource holding data about 3D mesh |
| COgre::v1::Skeleton | A collection of OldBone objects used to animate a skinned mesh |
| COgre::v1::AnimationTrack::Listener | Listener allowing you to override certain behaviour of a track, for example to drive animation procedurally |
| COgre::v1::BillboardChain::Element | Contains the data of an element of the BillboardChain |
| COgre::v1::EdgeData::Edge | Edge data |
| COgre::v1::EdgeData::EdgeGroup | A group of edges sharing the same vertex data |
| COgre::v1::EdgeData::Triangle | Basic triangle structure |
| COgre::v1::EdgeListBuilder | General utility class for building edge lists for geometry |
| ►COgre::v1::HardwareBufferLicensee | Abstract interface representing a 'licensee' of a hardware buffer copy |
| COgre::v1::TempBlendedBufferInfo | Structure for recording the use of temporary blend buffers |
| COgre::v1::HardwareBufferLockGuard | Locking helper |
| COgre::v1::InstanceManagerCmp | |
| COgre::v1::LinkedSkeletonAnimationSource | Link to another skeleton to share animations |
| COgre::v1::MeshLodUsage | A way of recording the way each LODs is recorded this Mesh |
| COgre::v1::MeshSerializerListener | |
| COgre::v1::MetalHardwareBufferCommon | 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 |
| COgre::v1::OldNode::Listener | Listener which gets called back on OldNode events |
| COgre::v1::PrefabFactory | A factory class that can create various mesh prefabs |
| COgre::v1::RenderOperation | 'New' rendering operation using vertex buffers |
| ►COgre::v1::RenderToVertexBuffer | |
| COgre::v1::D3D11RenderToVertexBuffer | An object which renders geometry to a vertex |
| COgre::v1::GL3PlusRenderToVertexBuffer | An object which renders geometry to a vertex |
| COgre::v1::GLES2RenderToVertexBuffer | |
| COgre::v1::StaticGeometry::SubMeshLodGeometryLink | Saved link between SubMesh at a LOD and vertex/index data May point to original or optimised geometry |
| COgre::v1::TangentSpaceCalc | Class for calculating a tangent space basis |
| COgre::v1::TangentSpaceCalc::IndexRemap | Information about a remapped index |
| COgre::v1::TangentSpaceCalc::Result | The result of having built a tangent space basis |
| COgre::v1::TimeIndex | Time index object used to search keyframe at the given position |
| COgre::v1::VertexBoneAssignment_s | Records the assignment of a single vertex to a single bone with the corresponding weight |
| COgre::v1::VertexData::HardwareAnimationData | Struct used to hold hardware morph / pose vertex data information |
| COgre::v1::VertexData::ReadRequests | |
| COgre::v1::VertexPoseKeyFrame::PoseRef | Reference to a pose at a given influence level |
| COgre::v1::VertexShadowMapHelper | |
| COgre::v1::VertexShadowMapHelper::Geometry | |
| COgre::vector< T, A > | |
| COgre::Vector2 | Standard 2-dimensional vector |
| COgre::Vector3 | Standard 3-dimensional vector |
| COgre::Vector4 | 4-dimensional homogeneous vector |
| COgre::VertexArrayObject::ReadRequests | |
| COgre::VertexBoneAssignment | Records the assignment of a single vertex to a single bone with the corresponding weight. |
| COgre::VertexElement2 | |
| COgre::VertexShadowMapHelper | |
| COgre::ViewPoint | Structure for holding a position & orientation pair |
| COgre::Volume::ChunkParameters | Parameters for loading the volume |
| COgre::Volume::ChunkRequest | Data being passed around while loading |
| 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::WindowEventListener | |
| COgre::WindowEventUtilities | |
| ►COgre::WorkQueue::RequestHandler | Interface definition for a handler of requests |
| COgre::LodWorkQueueWorker | Processes requests |
| COgre::Page | Page class |
| COgre::ResourceBackgroundQueue | This class is used to perform Resource operations in a background thread |
| COgre::Terrain | The main containing class for a chunk of terrain |
| COgre::TerrainGroup | Helper class to assist you in managing multiple terrain instances that are connected to each other |
| COgre::TerrainLodManager | Terrain LOD data manager |
| COgre::TerrainPagedWorldSection | A world section which includes paged terrain |
| COgre::Volume::ChunkHandler | Handles the WorkQueue management of the chunks |
| ►COgre::WorkQueue::ResponseHandler | Interface definition for a handler of responses |
| COgre::LodWorkQueueInjector | Injects the output of a request to the mesh in a thread safe way |
| COgre::Page | Page class |
| COgre::ResourceBackgroundQueue | This class is used to perform Resource operations in a background thread |
| COgre::Terrain | The main containing class for a chunk of terrain |
| COgre::TerrainGroup | Helper class to assist you in managing multiple terrain instances that are connected to each other |
| COgre::TerrainLodManager | Terrain LOD data manager |
| COgre::TerrainPagedWorldSection | A world section which includes paged terrain |
| COgre::Volume::ChunkHandler | Handles the WorkQueue management of the chunks |
| ►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 |
| ►Cpp::Graphics3DClient | |
| COgre::NaClGLContext | |
| COgre::RadixSort< ActiveBillboardList, Ogre::v1::Billboard *, float > | |
| COgre::RadixSort< ActiveParticleList, Ogre::Particle *, float > | |
| Crapidjson::GenericDocument< typename, typename, typename > | |
| Crapidjson::GenericValue< Encoding, typename > | |
| Crapidjson::MemoryPoolAllocator< typename > | |
| Crapidjson::UTF8< typename > | |
| COgre::RawSimdUniquePtr< ArrayPlane, MEMCATEGORY_GENERAL > | |
| COgre::RawSimdUniquePtr< ArrayReal, MEMCATEGORY_ANIMATION > | |
| COgre::RawSimdUniquePtr< FrustumRegion, MEMCATEGORY_SCENE_CONTROL > | |
| COgre::RawSimdUniquePtr< Ogre::ArrayMatrixAf4x3, MEMCATEGORY_ANIMATION > | |
| COgre::RawSimdUniquePtr< Ogre::ArrayRay, MEMCATEGORY_GENERAL > | |
| COgre::RawSimdUniquePtr< Ogre::KfTransform, MEMCATEGORY_ANIMATION > | |
| CRotation | |
| COgre::set< BackgroundProcessTicket > | |
| COgre::set< constMesh * > | |
| COgre::set< constMovableObject * > | |
| COgre::set< constv1::Mesh * > | |
| COgre::set< Controller< Real > * > | |
| COgre::set< D3D9Resource * > | |
| COgre::set< HardwareCounterBuffer * > | |
| COgre::set< HardwareIndexBuffer * > | |
| COgre::set< HardwareUniformBuffer * > | |
| COgre::set< HardwareVertexBuffer * > | |
| COgre::set< int > | |
| COgre::set< Listener * > | |
| COgre::set< LodListener * > | |
| COgre::set< Ogre::FrameListener * > | |
| COgre::set< Ogre::MovableObject * > | |
| COgre::set< OldBone * > | |
| COgre::set< OldNode * > | |
| COgre::set< PCZSceneNode * > | |
| COgre::set< Program * > | |
| COgre::set< RenderTarget * > | |
| COgre::set< SparseCluster, SparseCluster > | |
| COgre::set< String > | |
| COgre::set< SubRenderState * > | |
| COgre::set< VertexBufferBinding * > | |
| COgre::set< VertexDeclaration * > | |
| COgre::set< WorldFragmentType > | |
| COgre::SharedPtr< AbstractNodeList > | |
| COgre::SharedPtr< AnimableValue > | |
| COgre::SharedPtr< AsyncTicket > | |
| COgre::SharedPtr< BspLevel > | |
| COgre::SharedPtr< ControllerFunction< Real > > | |
| COgre::SharedPtr< ControllerValue< Real > > | |
| COgre::SharedPtr< DataStream > | |
| COgre::SharedPtr< Font > | |
| COgre::SharedPtr< GpuLogicalBufferStruct > | |
| COgre::SharedPtr< GpuNamedConstants > | |
| COgre::SharedPtr< GpuProgram > | |
| COgre::SharedPtr< GpuProgramParameters > | |
| COgre::SharedPtr< GpuSharedParameters > | |
| ►COgre::SharedPtr< HardwareCounterBuffer > | |
| COgre::v1::HardwareCounterBufferSharedPtr | Shared pointer implementation used to share counter buffers |
| ►COgre::SharedPtr< HardwareIndexBuffer > | |
| COgre::v1::HardwareIndexBufferSharedPtr | Shared pointer implementation used to share index buffers |
| ►COgre::SharedPtr< HardwarePixelBuffer > | |
| COgre::v1::HardwarePixelBufferSharedPtr | Shared pointer implementation used to share pixel buffers |
| ►COgre::SharedPtr< HardwareUniformBuffer > | |
| COgre::v1::HardwareUniformBufferSharedPtr | Shared pointer implementation used to share uniform buffers |
| ►COgre::SharedPtr< HardwareVertexBuffer > | |
| COgre::v1::HardwareVertexBufferSharedPtr | Shared pointer implementation used to share vertex buffers |
| COgre::SharedPtr< HighLevelGpuProgram > | |
| COgre::SharedPtr< LodCollapseCost > | |
| COgre::SharedPtr< LodCollapser > | |
| COgre::SharedPtr< LodData > | |
| COgre::SharedPtr< LodInputProvider > | |
| COgre::SharedPtr< LodOutputProvider > | |
| COgre::SharedPtr< Material > | |
| COgre::SharedPtr< MemoryDataStream > | |
| COgre::SharedPtr< Mesh > | |
| COgre::SharedPtr< Ogre::ControllerFunction< Real > > | |
| COgre::SharedPtr< Ogre::ControllerFunction< T > > | |
| COgre::SharedPtr< Ogre::ControllerValue< Real > > | |
| COgre::SharedPtr< Ogre::ControllerValue< T > > | |
| COgre::SharedPtr< Ogre::D3D11VideoModeList > | |
| COgre::SharedPtr< Ogre::RTShader::DualQuaternionSkinning > | |
| COgre::SharedPtr< Ogre::RTShader::HardwareSkinningTechnique > | |
| COgre::SharedPtr< Ogre::RTShader::LinearSkinning > | |
| COgre::SharedPtr< Ogre::Vector3 > | |
| COgre::SharedPtr< Parameter > | |
| COgre::SharedPtr< PoseData > | |
| COgre::SharedPtr< Resource > | |
| COgre::SharedPtr< ShadowCameraSetup > | |
| COgre::SharedPtr< Skeleton > | |
| COgre::SharedPtr< SkeletonDef > | |
| COgre::SharedPtr< SubRenderStateAccessor > | |
| COgre::SharedPtr< TerrainMaterialGenerator > | |
| COgre::SharedPtr< Texture > | |
| COgre::SharedPtr< TextureAtlasTable > | |
| COgre::SharedPtr< UniformParameter > | |
| COgre::SharedPtr< unsigned char > | |
| COgre::SharedPtr< vector< Image >::type > | |
| COgre::SharedPtr< vector< MemoryDataStreamPtr >::type > | |
| ►CSigC::Object | |
| COgre::GTKWindow | |
| ►CSimpleRenderable | |
| COgre::Volume::Chunk | A single volume chunk mesh |
| ►COgre::Singleton< AbsolutePixelCountLodStrategy > | |
| COgre::AbsolutePixelCountLodStrategy | |
| ►COgre::Singleton< ArchiveManager > | |
| COgre::ArchiveManager | This class manages the available ArchiveFactory plugins |
| ►COgre::Singleton< BspResourceManager > | |
| COgre::BspResourceManager | Manages the locating and loading of BSP-based indoor levels |
| ►COgre::Singleton< CgFxScriptLoader > | |
| COgre::CgFxScriptLoader | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them |
| ►COgre::Singleton< ControllerManager > | |
| COgre::ControllerManager | Class for managing Controller instances |
| ►COgre::Singleton< D3D11StereoDriverBridge > | |
| COgre::D3D11StereoDriverBridge | Bridge interface from the render system to the stereo driver |
| ►COgre::Singleton< D3D9StereoDriverBridge > | |
| COgre::D3D9StereoDriverBridge | Bridge interface from the render system to the stereo driver |
| ►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< FFPRenderStateBuilder > | |
| COgre::RTShader::FFPRenderStateBuilder | Fixed Function Pipeline render state builder |
| ►COgre::Singleton< FontManager > | |
| COgre::FontManager | Manages Font resources, parsing .fontdef files and generally organising them |
| ►COgre::Singleton< GL3PlusRTTManager > | |
| ►COgre::GL3PlusRTTManager | Manager/factory for RenderTextures |
| COgre::GL3PlusFBOManager | Factory for GL Frame Buffer Objects, and related things |
| ►COgre::Singleton< GLES2RTTManager > | |
| ►COgre::GLES2RTTManager | Manager/factory for RenderTextures |
| COgre::GLES2FBOManager | Factory for GL ES 2 Frame Buffer Objects, and related things |
| ►COgre::Singleton< GLSLESLinkProgramManager > | |
| COgre::GLSLESLinkProgramManager | 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 |
| ►COgre::Singleton< GLSLESProgramPipelineManager > | |
| COgre::GLSLESProgramPipelineManager | Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL ES has one program pipeline object that represents the active vertex and fragment program objects during a rendering state |
| ►COgre::Singleton< GLSLMonolithicProgramManager > | |
| COgre::GLSLMonolithicProgramManager | 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 |
| ►COgre::Singleton< GLSLSeparableProgramManager > | |
| COgre::GLSLSeparableProgramManager | Ogre assumes that there are separate vertex and fragment programs to deal with but GLSL has one program pipeline object that represents the active vertex and fragment program objects during a rendering state |
| ►COgre::Singleton< GpuProgramManager > | |
| COgre::GpuProgramManager | |
| ►COgre::Singleton< GTKGLSupport > | |
| COgre::GTKGLSupport | GL support in a GTK window |
| ►COgre::Singleton< HardwareBufferManager > | |
| COgre::v1::HardwareBufferManager | Singleton wrapper for hardware buffer manager |
| ►COgre::Singleton< HardwareSkinningFactory > | |
| COgre::RTShader::HardwareSkinningFactory | A factory that enables creation of HardwareSkinning instances |
| ►COgre::Singleton< HighLevelGpuProgramManager > | |
| COgre::HighLevelGpuProgramManager | This ResourceManager manages high-level vertex and fragment programs |
| ►COgre::Singleton< LodStrategyManager > | |
| COgre::LodStrategyManager | Manager for LOD strategies |
| ►COgre::Singleton< LodWorkQueueInjector > | |
| COgre::LodWorkQueueInjector | Injects the output of a request to the mesh in a thread safe way |
| ►COgre::Singleton< LodWorkQueueWorker > | |
| COgre::LodWorkQueueWorker | Processes requests |
| ►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::v1::MeshManager | Handles the management of mesh resources |
| ►COgre::Singleton< OldSkeletonManager > | |
| COgre::v1::OldSkeletonManager | Handles the management of skeleton resources |
| ►COgre::Singleton< OverlayManager > | |
| COgre::v1::OverlayManager | Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them |
| ►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< SceneManagerEnumerator > | |
| COgre::SceneManagerEnumerator | Enumerates the SceneManager classes available to applications |
| ►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< TextureAtlasSamplerFactory > | |
| COgre::RTShader::TextureAtlasSamplerFactory | A factory that enables creation of TextureAtlasSampler instances |
| ►COgre::Singleton< TextureManager > | |
| COgre::TextureManager | Class for loading & managing textures |
| COgre::StaticCache< 16 *OGRE_STREAM_TEMP_SIZE > | |
| COgre::StaticCache< 2 *OGRE_STREAM_TEMP_SIZE > | |
| ►Cstd::binary_function | |
| COgre::RTShader::CompareUniformByName | |
| ►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 |
| CStrangeData | |
| ►CT | |
| COgre::NoAddRefRelease< T > | |
| ►CTexture MANAGED_RESOURCE | |
| ►COgre::GLES2Texture | |
| COgre::GLES2DepthTexture | |
| COgre::GLES2NullTexture | |
| COgre::TRect< float > | |
| COgre::TRect< long > | |
| COgre::TRect< Real > | |
| ►CUIView | |
| COgreMetalView | |
| COgreView | |
| ►CUIWindow | |
| COgreWindow | |
| COgre::unordered_map< GLenum, GLuint > | |
| COgre::unordered_map< String, OldNode * > | |
| COgre::unordered_map< String, ResourceMap > | |
| COgre::unordered_map< String, ResourcePtr > | |
| COgre::unordered_map< String, uint32 > | |
| COgre::unordered_map< String, ushort > | |
| COgre::unordered_map< unsignedint, String > | |
| COgre::unordered_multimap< LodData::Vertex *, ProfiledEdge > | |
| COgre::unordered_set< BufferPacked * > | |
| COgre::unordered_set< Vertex *, VertexHash, VertexEqual > | |
| COgre::unordered_set< VertexArrayObject * > | |
| COgre::vector< ActiveActorData > | |
| COgre::vector< AreaOfInterest > | |
| COgre::vector< AutoConstantEntry > | |
| COgre::vector< AutoTrackingSceneNode > | |
| COgre::vector< Billboard * > | |
| COgre::vector< Block > | |
| COgre::vector< Bone * > | |
| COgre::vector< Bone > | |
| COgre::vector< BoneArrayMemoryManager > | |
| COgre::vector< BoneData > | |
| COgre::vector< bool > | |
| COgre::vector< Brush * > | |
| COgre::vector< BufferDefinition > | |
| COgre::vector< BufferPacked * > | |
| COgre::vector< BufferSource > | |
| COgre::vector< byte > | |
| COgre::vector< CachedDepthStencilState > | |
| COgre::vector< CachedGrid > | |
| COgre::vector< CachedGridBuffer > | |
| COgre::vector< Camera * > | |
| COgre::vector< CgStateListener * > | |
| COgre::vector< ChainSegment > | |
| COgre::vector< char * > | |
| COgre::vector< char > | |
| COgre::vector< CHTriangle * > | |
| COgre::vector< CHTriangle > | |
| COgre::vector< CodePointRange > | |
| COgre::vector< CollapsedEdge > | |
| COgre::vector< ColourValue > | |
| COgre::vector< CommonVertex > | |
| COgre::vector< CompositorChannel > | |
| COgre::vector< CompositorNamedBuffer > | |
| COgre::vector< CompositorNode * > | |
| COgre::vector< CompositorPass * > | |
| COgre::vector< CompositorPassDef * > | |
| COgre::vector< CompositorShadowNode * > | |
| COgre::vector< CompositorShadowNodeDef * > | |
| COgre::vector< CompositorTargetDef > | |
| COgre::vector< CompositorTexture > | |
| COgre::vector< CompositorWorkspace * > | |
| COgre::vector< CompositorWorkspaceListener * > | |
| COgre::vector< ComputePsoCache > | |
| COgre::vector< ComputeTextureSource > | |
| COgre::vector< ConstBufferPacked * > | |
| COgre::vector< ConstBufferPoolUser * > | |
| COgre::vector< ConstBufferSlot > | |
| COgre::vector< constSceneManagerMetaData * > | |
| COgre::vector< constVertexData * > | |
| COgre::vector< CopyDataEntry > | |
| COgre::vector< CubemapProbe * > | |
| COgre::vector< D3D11_SHADER_BUFFER_DESC > | |
| COgre::vector< D3D11_SHADER_TYPE_DESC > | |
| COgre::vector< D3D11_SHADER_VARIABLE_DESC > | |
| COgre::vector< D3D11_SIGNATURE_PARAMETER_DESC > | |
| COgre::vector< D3D11RenderWindowBase * > | |
| COgre::vector< D3D9Device * > | |
| COgre::vector< D3D9RenderWindow * > | |
| COgre::vector< DelayedBuffer > | |
| COgre::vector< DepthBuffer * > | |
| COgre::vector< DepthLevelInfo > | |
| COgre::vector< DEVMODE > | |
| COgre::vector< DisplayMonitorInfo > | |
| COgre::vector< double > | |
| COgre::vector< DualCell > | |
| COgre::vector< DynLib * > | |
| COgre::vector< Edge > | |
| COgre::vector< EdgeGroup > | |
| COgre::vector< Element > | |
| COgre::vector< Entity * > | |
| COgre::vector< EntityMaterialLodChangedEvent > | |
| COgre::vector< EntityMeshLodChangedEvent > | |
| COgre::vector< Fence > | |
| COgre::vector< FileInfo > | |
| COgre::vector< float > | |
| COgre::vector< Frustum * > | |
| COgre::vector< Function * > | |
| COgre::vector< FunctionAtom * > | |
| COgre::vector< Geometry > | |
| COgre::vector< GeometryBucket * > | |
| COgre::vector< GLAtomicCounterReference > | |
| COgre::vector< GLFence > | |
| COgre::vector< GLSLShader * > | |
| COgre::vector< GLsync > | |
| COgre::vector< GLuint > | |
| COgre::vector< GLUniformReference > | |
| COgre::vector< GpuConstantDefinitionWithName > | |
| COgre::vector< GPUDeviceNameRule > | |
| COgre::vector< GpuSharedParametersUsage > | |
| COgre::vector< GPUVendorRule > | |
| COgre::vector< HardwareAnimationData > | |
| COgre::vector< HardwarePixelBufferSharedPtr > | |
| COgre::vector< HardwareVertexBufferSharedPtrVec > | |
| COgre::vector< HlmsBlendblock > | |
| COgre::vector< HlmsCache * > | |
| COgre::vector< HlmsMacroblock > | |
| COgre::vector< HlmsProperty > | |
| COgre::vector< ID3D11Query * > | |
| COgre::vector< IdString > | |
| COgre::vector< Image > | |
| COgre::vector< IndexBufferInfo > | |
| COgre::vector< IndexData * > | |
| COgre::vector< IndirectBufferPacked * > | |
| COgre::vector< InputLayouts > | |
| COgre::vector< InstanceBatch * > | |
| COgre::vector< InstancedEntity * > | |
| COgre::vector< int > | |
| COgre::vector< int8 > | |
| COgre::vector< JobWithBarrier > | |
| COgre::vector< KeyFrame * > | |
| COgre::vector< KeyFrameRig > | |
| COgre::vector< KeyFrameRigVec::const_iterator > | |
| COgre::vector< LayerInstance > | |
| COgre::vector< Library > | |
| COgre::vector< LightParams > | |
| COgre::vector< LinkedSkeletonAnimationSource > | |
| COgre::vector< Listener * > | |
| COgre::vector< LODBucket * > | |
| COgre::vector< LodData::Vertex * > | |
| COgre::vector< LodLevel * > | |
| COgre::vector< LodLevel > | |
| COgre::vector< LogListener * > | |
| COgre::vector< ManualObjectSection * > | |
| COgre::vector< MappedRange > | |
| COgre::vector< MemberTypeName > | |
| COgre::vector< MemoryDataStreamPtr > | |
| COgre::vector< MergeCombination > | |
| COgre::vector< MeshLodUsage > | |
| COgre::vector< MeshVersionData * > | |
| COgre::vector< MetalDiscardBuffer * > | |
| COgre::vector< MetalFence > | |
| COgre::vector< MovableObject * > | |
| COgre::vector< MovableObjectLodChangedEvent > | |
| COgre::vector< NamePair > | |
| COgre::vector< Node * > | |
| COgre::vector< NodeAnimationTrack * > | |
| COgre::vector< NodeArrayMemoryManager > | |
| COgre::vector< NodeMemoryManager * > | |
| COgre::vector< ObjectDataArrayMemoryManager > | |
| COgre::vector< ObjectMemoryManager * > | |
| COgre::vector< Ogre::Aabb > | |
| COgre::vector< Ogre::Camera * > | |
| COgre::vector< Ogre::D3D11DeviceResource * > | |
| COgre::vector< Ogre::D3D11VideoMode > | |
| COgre::vector< Ogre::D3D9Driver > | |
| COgre::vector< Ogre::D3D9VideoMode > | |
| COgre::vector< Ogre::FloatRect > | |
| COgre::vector< Ogre::GL3PlusFBOManager::FormatProperties::Mode > | |
| COgre::vector< Ogre::GLES2FBOManager::FormatProperties::Mode > | |
| COgre::vector< Ogre::GpuConstantDefinition > | |
| COgre::vector< Ogre::Item * > | |
| COgre::vector< Ogre::list< size_t >::type > | |
| COgre::vector< Ogre::Lod0Stripifier::RemapInfo > | |
| COgre::vector< Ogre::LodIndexBuffer > | |
| COgre::vector< Ogre::LodInputBuffer::Submesh > | |
| COgre::vector< Ogre::LodOutputBuffer::Submesh > | |
| COgre::vector< Ogre::Matrix4 > | |
| COgre::vector< Ogre::ParticleAffector * > | |
| COgre::vector< Ogre::ParticleAffectorFactory * > | |
| COgre::vector< Ogre::ParticleEmitter * > | |
| COgre::vector< Ogre::ParticleEmitterFactory * > | |
| COgre::vector< Ogre::Plane > | |
| COgre::vector< Ogre::Quaternion > | |
| COgre::vector< Ogre::Renderable * > | |
| COgre::vector< Ogre::RenderTarget * > | |
| COgre::vector< Ogre::RTShader::LayeredBlending::TextureBlend > | |
| COgre::vector< Ogre::SceneQuery::WorldFragment * > | |
| COgre::vector< Ogre::ScriptTranslatorManager * > | |
| COgre::vector< Ogre::SharedPtr< Ogre::D3D11Driver > > | |
| COgre::vector< Ogre::TexBufferPacked * > | |
| COgre::vector< Ogre::Vector3 > | |
| COgre::vector< Ogre::ViewPoint > | |
| COgre::vector< Ogre::WireAabb * > | |
| COgre::vector< OldBone * > | |
| COgre::vector< Operand > | |
| COgre::vector< OperationType > | |
| COgre::vector< OutsideData > | |
| COgre::vector< PageContent * > | |
| COgre::vector< PageContentCollection * > | |
| COgre::vector< Param > | |
| COgre::vector< ParameterDef > | |
| COgre::vector< ParameterPtr > | |
| COgre::vector< Particle * > | |
| COgre::vector< ParticleAffector * > | |
| COgre::vector< ParticleEmitter * > | |
| COgre::vector< Pass * > | |
| COgre::vector< Pass > | |
| COgre::vector< PassCache > | |
| COgre::vector< PassCacheEntry > | |
| COgre::vector< PixelFormat > | |
| COgre::vector< PlanarReflectionActor * > | |
| COgre::vector< Plane > | |
| COgre::vector< PlaneBoundedVolume > | |
| COgre::vector< Plugin * > | |
| COgre::vector< Polygon * > | |
| COgre::vector< Pose * > | |
| COgre::vector< PoseRef > | |
| COgre::vector< Profile * > | |
| COgre::vector< ProfiledEdge > | |
| COgre::vector< ProfileInstance * > | |
| COgre::vector< ProfileSessionListener * > | |
| COgre::vector< ProgramProcessor * > | |
| COgre::vector< ProgramWriterFactory * > | |
| COgre::vector< Pso > | |
| COgre::vector< PsoCacheEntry > | |
| COgre::vector< QuadTextureSource > | |
| COgre::vector< QueuedGeometry * > | |
| COgre::vector< QueuedSubMesh * > | |
| COgre::vector< QueuedWorkspace > | |
| COgre::vector< RayHit > | |
| COgre::vector< RaySceneQueryResultEntry > | |
| COgre::vector< Real > | |
| COgre::vector< RenderableCache > | |
| COgre::vector< RenderableCacheEntry > | |
| COgre::vector< RenderObjectListener * > | |
| COgre::vector< RenderQueueListener * > | |
| COgre::vector< RenderState * > | |
| COgre::vector< RenderSystem * > | |
| COgre::vector< RenderTargetListener * > | |
| COgre::vector< RenderTexture * > | |
| COgre::vector< ResourceGroupListener * > | |
| COgre::vector< ResourceTransition > | |
| COgre::vector< SceneNode * > | |
| COgre::vector< SceneNodeBonePair > | |
| COgre::vector< SGPass * > | |
| COgre::vector< SGTechnique * > | |
| COgre::vector< ShaderCodeCache > | |
| COgre::vector< ShaderGenerator::SGPass * > | |
| COgre::vector< ShaderVarWithPosInBuf > | |
| COgre::vector< ShadowMapCamera > | |
| COgre::vector< ShadowTextureDefinition > | |
| COgre::vector< ShadowTextureParams > | |
| COgre::vector< SharedPtr< Texture > > | |
| COgre::vector< size_t > | |
| COgre::vector< SkeletonAnimation * > | |
| COgre::vector< SkeletonAnimation > | |
| COgre::vector< SkeletonAnimationDef > | |
| COgre::vector< SkeletonAnimManager * > | |
| COgre::vector< SkeletonTrack > | |
| COgre::vector< SourceCode > | |
| COgre::vector< StagingBuffer * > | |
| COgre::vector< std::pair< CHVertex *, CHVertex * > > | |
| COgre::vector< std::pair< String, String > > | |
| COgre::vector< StrideChanger > | |
| COgre::vector< String * > | |
| COgre::vector< String > | |
| COgre::vector< SubEntity > | |
| COgre::vector< SubItem > | |
| COgre::vector< SubMesh * > | |
| COgre::vector< SubRenderState * > | |
| COgre::vector< SubRenderStateFactory * > | |
| COgre::vector< TagPoint * > | |
| COgre::vector< Technique * > | |
| COgre::vector< TempRtt > | |
| COgre::vector< TerrainLayerBlendMap * > | |
| COgre::vector< TerrainLayerSampler > | |
| COgre::vector< TerrainLayerSamplerElement > | |
| COgre::vector< TexBufferPacked * > | |
| COgre::vector< TextureArray > | |
| COgre::vector< TextureDefinition > | |
| COgre::vector< TextureEntry > | |
| COgre::vector< TexturePtr > | |
| COgre::vector< TextureSlot > | |
| COgre::vector< TextureSource > | |
| COgre::vector< TextureUnitParams > | |
| COgre::vector< TextureUnitState * > | |
| COgre::vector< ThreadHandlePtr > | |
| COgre::vector< Threshold > | |
| COgre::vector< Triangle > | |
| COgre::vector< TriangleCache > | |
| COgre::vector< UavBufferPacked * > | |
| COgre::vector< UavDependency > | |
| COgre::vector< UINT > | |
| COgre::vector< uint > | |
| COgre::vector< uint16 > | |
| COgre::vector< uint32 > | |
| COgre::vector< uint8 * > | |
| COgre::vector< uint8 > | |
| COgre::vector< UniformParameterPtr > | |
| COgre::vector< UnsafeBlock > | |
| COgre::vector< unsigned > | |
| COgre::vector< ushort > | |
| COgre::vector< v1::HardwareCounterBufferSharedPtr > | |
| COgre::vector< v1::HardwarePixelBufferSharedPtr > | |
| COgre::vector< v1::HardwareUniformBufferSharedPtr > | |
| COgre::vector< v1::InstanceManager * > | |
| COgre::vector< Vao > | |
| COgre::vector< Vbo > | |
| COgre::vector< Vector3 > | |
| COgre::vector< Vector4 > | |
| COgre::vector< Vertex > | |
| COgre::vector< VertexBinding > | |
| COgre::vector< VertexBoneAssignment > | |
| COgre::vector< VertexBufferPacked * > | |
| COgre::vector< VertexElement2 > | |
| COgre::vector< VertexElement2Vec > | |
| COgre::vector< VertexInfo > | |
| COgre::vector< Viewport * > | |
| COgre::vector< Vpl > | |
| COgre::vector< WireAabb * > | |
| ►CVertexDeclaration | |
| COgre::D3D9VertexDeclaration | Specialisation of VertexDeclaration for D3D9 |
| CVisual | |
| CXClientMessageEvent | |
| CXClientMessageEventData | |
| CXErrorEvent | |
| CXEvent | |
| CXRRScreenConfiguration | |
| CXRRScreenSize | |
| CXSetWindowAttributes | |
| CXSizeHints | |
| CXTextProperty | |
| CXVisualInfo | |
| CXWindowAttributes | |
| CXWMHints | |
1.9.8 