OGRE: Class List (original) (raw)
►NOgre
►NBullet
Simplified wrapper with automatic memory management
Simplified wrapper with automatic memory management
A MotionState is Bullet's way of informing you about updates to an object
►NRTShader
Shorthand for "lhs = rhs;" insted of using FFP_Assign(rhs, lhs)
CAt
Shorthand for operator[] on preceding operand. e.g. myArray[p]
Shorthand for "dst = a OP b;"
Shorthand for "dst = BUILTIN(args);"
Helper template which is the base for our ConstParameters
Texturing sub render state implementation of the Fixed Function Pipeline
A class that represents a shader based program function
A class that represents an atomic code section of shader based program function
A class that represents function invocation code from shader based program function
Comparator function to be used for comparisons
Comparator function to be used for sorting
FFPShaderStage, part of a Function
A factory that enables creation of HardwareSkinning instances
CIn
A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields)
COut
A class that represents a shader based program parameter
Helper utility class that creates common parameters
A class that represents a shader based program
A singleton manager class that manages shader based programs
Container class for shader based programs
Base class interface for shader program writers
This is a container class for sub render state class
Shorthand for "dst = texture(sampler, uv);" instead of using FFP_SampleTexture
This class responsible for translating core features of the RT Shader System for Ogre material scripts
Shader generator system main interface
This class is the base interface of sub part from a shader based rendering pipeline
This class uses as accessor from a template SubRenderState to all of its instances that created based on it
Abstract factory interface for creating SubRenderState implementation instances
This is the target render state
Uniform parameter class
►NVolume
A caching Source
A single volume chunk mesh
Parameters for loading the volume
Internal shared values of the chunks which are equal in the whole tree
A not rotated cube
Builds the difference between two sources
Builds the intersection between two sources
Negates the given volume
Abstract operation volume source holding two sources as operants
A plane
Scales the given volume source
A sphere
Source which does a unary operation to another one
Builds the union between two sources
To store the generated dual cells in a vector
Class for the generation of the DualGrid
A volume source from a discrete 3d grid
A volume source from a 16 Bit float 3D grid capable of loading volume serializations
Abstract IsoSurface
Marching Cubes implementation like at http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/
Class to build up a mesh with vertices and indices
Callback class when the user needs information about the triangles of chunks of a LOD level
A node in the volume octree
The class deciding on whether to split an octree node or not when building the octree
Simplex Noise ported from public domain Java Implementation http://webstaff.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java Thanks Stefan Gustavson!
Abstract class defining the density function
A volume source from a 3D texture
Lightweight struct to represent a mesh vertex
CAbsolutePixelCountLodStrategy
Transform specialization for 3D Affine - encapsulating a 3x4 Matrix
STL compatible wrapper for AlignedMemory
Class to provide aligned memory allocate functionality
Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAngleUnit
Defines an interface to classes which have one or more AnimableValue instances to expose
Defines an object property which is animable, i.e
An animation sequence
An animation container interface, which allows generic access to sibling animations
Predefined controller function for dealing with animation
Represents the state of an animation and the weight of its influence
CAnimationStateControllerValue
ControllerValue wrapper class for AnimationState
Class encapsulating a set of AnimationState objects
A 'track' in an animation sequence, i.e
Listener allowing you to override certain behaviour of a track, for example to drive animation procedurally
AntiPortal datastructure for occlusion culling
Factory object for creating AntiPortal instances
CAny
Variant type that can hold Any other type
Archive-handling class
Abstract factory class, archive codec plugins can register concrete subclasses of this
This class manages the available ArchiveFactory plugins
Particle emitter which emits particles randomly from points inside an area (box, sphere, ellipsoid whatever subclasses choose to be)
Command object for area emitter size (see ParamCommand)
Command object for area emitter size (see ParamCommand)
Command object for area emitter size (see ParamCommand)
This is an abstract node which cannot be broken down further
This utility class is used to hold the information used to generate the matrices and other information required to automatically populate GpuProgramParameters
A 3D box aligned with the x/y/z axes
Specialises the SceneQuery class for querying within an axis aligned box
Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) This implementation has the following advantages:
A billboard is a primitive which always faces the camera in every frame
Allows the rendering of a chain of connected billboards
Contains the data of an element of the BillboardChain
Specialisation of ParticleSystemRenderer to render particles using a BillboardSet
CBillboardParticleRendererFactory
Factory class for BillboardParticleRenderer
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
Class for manipulating bit patterns
CBone
A bone in a skeleton
A specialisation of the PanelOverlayElement to provide a panel with a border
Class for rendering the border of a BorderPanelOverlayElement
CBox
Structure used to define a box in a 3-D integer space
This emitter emits particles from a random location within a 3-dimensional box
BSP specialisation of IntersectionSceneQuery
Holds all the data associated with a Binary Space Parition (BSP) based indoor level
►CBspNode
Encapsulates a node in a BSP tree
BSP specialisation of RaySceneQuery
Specialisation of the SceneManager class to deal with indoor scenes based on a BSP tree
Factory for BspSceneManager
Plugin instance for BSPSceneManager
Specialisation of SceneNode for the BspSceneManager
►CCamera
A viewpoint from which the scene will be rendered
Listener interface so you can be notified of Camera events
3D Line-Swept-Sphere class for intersection testing in Ogre3D Some algorithms based off code from the Wild Magic library by Dave Eberly
Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them
Plugin instance for Cg Program Manager
Specialisation of HighLevelGpuProgram to provide support for nVidia's CG language
Command object for setting compilation arguments
Command object for setting profiles
Factory class for Cg programs
Abstract class that defines a 'codec'
Describes the global blending factors for combining subsequent renders with the existing frame contents
This affector modifies the colour of particles in flight
Command object for alpha adjust (see ParamCommand)
Command object for blue adjust (see ParamCommand)
Command object for green adjust (see ParamCommand)
Command object for red adjust (see ParamCommand)
Command object for alpha adjust (see ParamCommand)
Command object for alpha adjust (see ParamCommand)
Command object for blue adjust (see ParamCommand)
Command object for blue adjust (see ParamCommand)
Command object for green adjust (see ParamCommand)
Command object for green adjust (see ParamCommand)
Command object for red adjust (see ParamCommand)
Command object for red adjust (see ParamCommand)
Command object for alpha adjust (see ParamCommand)
Command object for red adjust (see ParamCommand)
Command object for red adjust (see ParamCommand)
Command object for red adjust (see ParamCommand)
Class representing colour
Object representing one pass or operation in a composition sequence
Inputs (for material used for rendering the quad)
Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework
Base composition technique, can be subclassed in plugins
Local texture definition
Class representing a Compositor object
Chain of compositor effects applying to one viewport
An instance of a Compositor object for one Viewport
Provides an interface to "listen in" to to render system operations executed by this CompositorInstance
Specific render system operation
Operation setup for a RenderTarget (collected)
Interface for compositor logics, which can be automatically binded to compositors, allowing per-compositor logic (such as attaching a relevant listener) to happen automatically
Class for managing Compositor settings for Ogre
Defines the behaviour of an automatic renderer configuration dialog
Class for quickly loading settings from a text file
Packages the details of a configuration option
Concrete IteratorWrapper for const access to the underlying key-value container
Concrete IteratorWrapper for const access to the underlying container
Instances of this class 'control' the value of another object in the system
Subclasses of this class are responsible for performing a function on an input value for a Controller
Class for managing Controller instances
Can either be used as an input or output value
Holds a solid representation of a convex body
CCreateCompositorScriptCompilerEvent
CCreateGpuProgramScriptCompilerEvent
CCreateGpuSharedParametersScriptCompilerEvent
CCreateMaterialScriptCompilerEvent
CCreateParticleSystemScriptCompilerEvent
Interface for custom composition passes, allowing custom operations (in addition to the quad, scene and clear operations) in composition passes
This emitter emits particles in a random direction from within a cylinder area, where the cylinder is oriented along the Z-axis
Implementation of DirectX11 as a rendering system
Implementation of DirectX9 as a rendering system
General purpose class used for encapsulating the reading and writing of data
Interface for visualising debugging the SceneManager state
CDefaultAxisAlignedBoxSceneQuery
Default implementation of AxisAlignedBoxSceneQuery
Specialisation of HardwareBuffer for emulation
DefaultHardwareBufferManager as a Singleton
CDefaultHardwareBufferManagerBase
Specialisation of HardwareBufferManagerBase to emulate hardware buffers
CDefaultIntersectionSceneQuery
Default implementation of IntersectionSceneQuery
CDefaultPlaneBoundedVolumeListSceneQuery
Default implementation of PlaneBoundedVolumeListSceneQuery
Default implementation of RaySceneQuery
Implements default shadow camera setup
Default implementation of SphereSceneQuery
Specialisation of TextureManager for offline processing. Cannot be used with an active RenderSystem
Implementation of a general purpose request / response style background work queue
Base for a general purpose task-based background work queue
Stream which compresses / uncompresses data using the 'deflate' compression algorithm
This affector defines a plane which deflects particles which collide with it
Command object for bounce (see ParamCommand)
Command object for plane normal (see ParamCommand)
Command object for plane point (see ParamCommand)
Wrapper class which indicates a given angle value is in Degrees
An abstract class that contains a depth/stencil buffer
This affector applies randomness to the movement of the particles
Command object for keep_velocity (see ParamCommand)
Command object for randomness (see ParamCommand)
Command object for scope (see ParamCommand)
Level of detail strategy based on distance from camera to an object's bounding box
Level of detail strategy based on distance from camera to an object's bounding sphere
Level of detail strategy based on distance from camera
DriverVersion is used by RenderSystemCapabilities and both GL and D3D9 to store the version of the current GPU driver
Implementation of a dual quaternion, i.e
Resource holding data about a dynamic library
Manager for Dynamic-loading Libraries
►CEdgeData
This class contains the information required to describe the edge connectivity of a given set of vertices and indexes
CEdge
Edge data
A group of edges sharing the same vertex data
Basic triangle structure
General utility class for building edge lists for geometry
Particle emitter which emits particles randomly from points inside an ellipsoid
Specialisation of ZipArchiveFactory for embedded Zip files
Defines an instance of a discrete, movable object based on a Mesh
CEntityMaterialLodChangedEvent
Struct containing information about a material LOD change event for entities
Struct containing information about a mesh LOD change event for entities
When thrown, provides information about an error that has occurred inside the engine
Class implementing dispatch methods in order to construct by-value exceptions of a derived type based just on an exception code
IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from
Singleton Class which handles the registering and control of texture plugins
Abstract factory class
Common subclass of DataStream for handling data from C-style file handles
Information about a file/directory within the archive will be returned using a FileInfo struct
Common subclass of DataStream for handling data from std::basic_istream
Specialisation of the ArchiveFactory to allow reading of files from filesystem folders / directories
Provides methods to find out where the Ogre config files are stored and where logs and settings files should be written to
CFloatGpuParameterControllerValue
Predefined controller value for setting a single floating- point value in a constant parameter of a vertex or fragment program
Implements the uniform shadow mapping algorithm in focused mode
CFont
Class representing a font in the system
Manages Font resources, parsing .fontdef files and generally organising them
Struct containing information about a frame event
A interface class defining a listener which can be used to receive notifications of frame events
Predefined controller value for getting the latest frame time
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
Implementation of GL 3 as a rendering system
Implementation of GL ES 2.x as a rendering system
Implementation of GL as a rendering system
Plugin instance for Cg Program Manager
Specialisation of HighLevelGpuProgram to provide support for the GLSLang compiler by Khronos
Factory class for GLSLang programs
Information about the position and size of a glyph in a texture
Information about predefined program constants
Container struct to allow params to safely & update shared list of logical buffer assignments
Structure recording the use of a physical buffer by a logical parameter index
Struct collecting together the information for named constants
Simple class for loading / saving GpuNamedConstants
Defines a program which runs on the GPU such as a vertex or fragment program
Interface definition for factories of GpuProgram
This ResourceManager manages GPU shader programs
Collects together the program parameters used for a GpuProgram
Structure defining an auto constant that's available for use in a parameters object
Structure recording the use of an automatic parameter
This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit
A group of manually updated parameters that are shared between many parameter sets
This class records the usage of a set of shared parameters in a concrete set of GpuProgramParameters
Page strategy which loads new pages based on a regular 2D grid
Specialisation of PageStrategyData for Grid2DPageStrategy
Page strategy which loads new pages based on a regular 3D grid
Specialisation of PageStrategyData for Grid3DPageStrategy
Abstract class defining common features of hardware buffers
Abstract interface representing a 'licensee' of a hardware buffer copy
Locking helper
Singleton wrapper for hardware buffer manager
Base definition of a hardware buffer manager
Specialisation of HardwareBuffer for vertex index buffers, still abstract
Query how many pixels have passed the per-fragment tests
Specialisation of HardwareBuffer for a pixel buffer
Specialisation of HardwareBuffer for a vertex buffer
Abstract base class representing a high-level program (a vertex or fragment program)
Particle emitter which emits particles randomly from points inside a hollow ellipsoid
Command object for inner size (see ParamCommand)
Command object for inner size (see ParamCommand)
Command object for inner size (see ParamCommand)
Struct recording a pass which can be used for a specific illumination stage
Class representing an image file
Codec specialized in images
Ogre's integrated support for Dear ImGui
This abstract node represents an import statement
Summary class collecting together index data source information
InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived to implement different instancing techniques (InstanceManager::InstancingTechnique) OGRE wasn't truly thought for instancing
This is technique requires true instancing hardware support
Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instancing
This is the same technique the old InstancedGeometry implementation used (with improvements)
This is the main starting point for the new instancing system
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another
CIntersectionSceneQueryListener
Alternative listener class for dealing with IntersectionSceneQuery
Holds the results of an intersection scene query (pair values)
CisPodLike< std::pair< T, U > >
Basefunctionality for IteratorWrappers
A key frame in an animation sequence defined by an AnimationTrack
Class which manages blending of both colour and alpha components
Representation of a dynamic light source in the scene
Predefined controller function based on linear function interpolation
This affector applies a force vector to all particles to modify their trajectory
Command object for force application (see ParamCommand)
Command object for force vector (see ParamCommand)
CLinkedSkeletonAnimationSource
Link to another skeleton to share animations
Implements the Light Space Perspective Shadow Mapping Algorithm [17]
Clist
►CLodData
CEdge
CLine
Equality function for UniqueVertexSet
Hash function for UniqueVertexSet
Structure for automatic Lod configuration
A interface class defining a listener which can be used to receive notifications of LOD events
This class will mark vertices of a mesh, which are visible from far away (from outside)
Strategy for determining level of detail
Manager for LOD strategies
►CLog
Log class for writing debug/log data to files
►CStream
Stream object which targets a log
Simple type to indicate a flush of the stream to the log
The log manager handles the creation and retrieval of logs for the application
Class providing a much simplified interface to generating manual objects with custom geometry
Built, renderable section of geometry
Interface describing a manual resource loader
Cmap
Concrete IteratorWrapper for nonconst access to the underlying key-value container
Prepared IteratorWrapper for key-value container
Class encapsulates rendering properties of an object
Class for managing Material settings for Ogre
Listener on any general material events
Class for serializing Materials to a .material script
Class that allows listening in on the various stages of material serialization process
►CMath
Class to provide access to common mathematical functions
This class is used to provide an external random value provider
A 3x3 matrix which can represent rotations around axes
Transform specialization for projective - encapsulating a 4x4 Matrix
Common subclass of DataStream for handling data from chunks of memory
CMesh
Resource holding data about 3D mesh
A way of recording the way each LODs is recorded this Mesh
Handles the management of mesh resources
Class for serialising mesh data to/from an OGRE .mesh file
This class allows users to hook into the mesh loading process and modify references within the mesh as they are loading
Abstract class defining a movable object in a scene
Listener which gets called back on MovableObject events
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
Struct containing information about a LOD change event for movable objects
Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply
This class represents a render target that renders to multiple RenderTextures at once
Utility class to generate a sequentially numbered series of names
►CNode
Class representing a general-purpose node an articulated scene graph
Listener which gets called back on Node events
Specialised AnimationTrack for dealing with node transforms
Specialised AnimationTrack for dealing with generic animable values
Specialised KeyFrame which stores any numeric value
This specific abstract node represents a script object
Octree datastructure for managing scene nodes
COctreeAxisAlignedBoxSceneQuery
Octree implementation of AxisAlignedBoxSceneQuery
Specialized viewpoint from which an Octree can be rendered
Octree implementation of IntersectionSceneQuery
Specialized SceneNode that is customized for working within an Octree
COctreePlaneBoundedVolumeListSceneQuery
Octree implementation of PlaneBoundedVolumeListSceneQuery
Plugin instance for Octree Manager
Octree implementation of RaySceneQuery
Specialized SceneManager that divides the geometry into an octree in order to facilitate spatial queries
Factory for OctreeSceneManager
Octree implementation of SphereSceneQuery
Factory for OctreeZone
Plugin instance for OctreeZone
Utility class for provides optimised functions
Represents a layer which is rendered on top of the 'normal' scene contents
A 2D element which contains other OverlayElement instances
Abstract definition of a 2D element to be displayed in an Overlay
Defines the interface which all components wishing to supply OverlayElement subclasses must implement
Manages Overlay objects, parsing them from .overlay files and storing a lookup library of them
COverlayProfileSessionListener
Concrete impl
This class simplify initialization / finalization of the overlay system
CPage
Page class
Interface definition for a unit of content within a page
Definition of the interface for a collection of PageContent instances
Define the interface to a factory class that will create subclasses of PageContentCollection
Define the interface to a factory class that will create subclasses of PageContent
This class represents a collection of pages which make up a world
Represents a section of the PagedWorld which uses a given PageStrategy, and which is made up of a generally localised set of Page instances
A factory class for creating types of world section
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
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
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
Abstract marker class representing the data held against the PagedWorldSection which is specifically used by the PageStrategy
OverlayElement representing a flat, single-material (or transparent) panel which can contain other elements
Class to hold a dictionary of parameters for a single class
Class representing a single particle instance
Abstract class defining the interface to be implemented by particle affectors
Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses
Abstract class defining the interface to be implemented by particle emitters
Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses
Plugin instance for ParticleFX Manager
Class defining particle system based special effects
Manages particle systems, particle system scripts (templates) and the available emitter & affector factories
Abstract class defining the interface required to be implemented by classes which provide rendering capability to ParticleSystem instances
►CPass
Class defining a single pass of a Technique (of a Material): a single rendering call
Definition of a functor for calculating the hashcode of a Pass
CPassthroughControllerFunction
Predefined controller function which just passes through the original source directly to dest
Patch specialisation of Mesh
A surface which is defined by curves of some kind to form a patch, e.g
PCZ implementation of AxisAlignedBoxSceneQuery
Specialized viewpoint from which an PCZone Scene can be rendered
Specialized frustum shaped culling volume that has culling planes created from portals
PCZ implementation of IntersectionSceneQuery
Specialized version of Ogre::Light which caches which zones the light affects
Factory object for creating PCZLight instances
Portal-Connected Zone datastructure for managing scene nodes
Factory for PCZones
CPCZPlaneBoundedVolumeListSceneQuery
PCZ implementation of PlaneBoundedVolumeListSceneQuery
Plugin instance for PCZ Manager
PCZ implementation of RaySceneQuery
Specialized SceneManager that uses Portal-Connected-Zones to divide the scene spatially
Factory for PCZSceneManager
The PCZSceneNode is an extension used to store zone information and provide additional functionality for a given Ogre::SceneNode
PCZ implementation of SphereSceneQuery
A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory
Abstract base class for level of detail strategy based on pixel count approximations from bounding sphere projection
Some utility functions for packing and unpacking pixel data
Defines a plane in 3D space
Represents a convex volume bounded by planes
CPlaneBoundedVolumeListSceneQuery
Specialises the SceneQuery class for querying within a plane-bounded volume
CPlaneOptimalShadowCameraSetup
Implements the plane optimal shadow camera algorithm
Class which provides the run-time platform information Ogre runs on
Class defining a generic OGRE plugin
This emitter emits particles from a single point, which is it’s position
The class represents a polygon in 3D space
CPool
Template class describing a simple pool of items
Portal datastructure for connecting zones
PortalBase - Base class to Portal and AntiPortal classes
Factory object for creating Portal instances
Factory object for creating Portal instances
CPose
A pose is a linked set of vertex offsets applying to one set of vertex data
CProcessNameExclusionScriptCompilerEvent
CProcessResourceNameScriptCompilerEvent
An individual profile that will be processed by the Profiler
Represents the total timing information of a profile since profiles can be called more than once each frame
Represents a history of each profile during the duration of the app
Represents an individual profile call
The profiler allows you to measure the performance of your code
ProfileSessionListener should be used to visualize profile results
Property instance with passthrough calls to a given object
This abstract node represents a script property
Base interface for an instance of a property
Definition of a property of an object
Defines a complete set of properties for a single object instance
A simple structure designed just as a holder of property values between the instances of objects they might target
Parallel Split Shadow Map (PSSM) shadow camera setup
Support for loading and extracting data from a Quake3 level file
Class for recording Quake3 shaders
CPass
Class for managing Quake3 custom shaders
Implementation of a Quaternion, i.e
Lowest level collection of renderables
Visitor interface for items in a QueuedRenderableCollection
Wrapper class which indicates a given angle value is in Radians
CRay
Representation of a ray in space, i.e
Specialises the SceneQuery class for querying along a ray
Alternative listener class for dealing with RaySceneQuery
This struct allows a single comparison of result data no matter what the type
Allows the rendering of a simple 2D rectangle This class renders a simple 2D rectangle; this rectangle has no depth and therefore is best used with specific render queue and depth settings, like RENDER_QUEUE_BACKGROUND and 'depth_write off' for backdrops, and RENDER_QUEUE_OVERLAY and 'depth_check off' for fullscreen quads
Abstract class defining a query which returns single results from a region
Abstract class defining the interface all renderable objects must implement
Visitor object that can be used to iterate over a collection of Renderable instances abstractly
Struct associating a single Pass with a single Renderable
Abstract interface which classes must implement if they wish to receive events from the scene manager when single object is about to be rendered
'New' rendering operation using vertex buffers
Collection of renderables by priority
Class to manage the scene object rendering queue
Class to listen in on items being added to the render queue
A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same time to the renderer
Abstract interface which classes must implement if they wish to receive events from the render queue
Defines the functionality of a 3D API
Defines a listener on the custom events that this render system can raise
This class stores the capabilities of the graphics card
CRenderSystemCapabilitiesManager
Class for managing RenderSystemCapabilities database for Ogre
CRenderSystemCapabilitiesSerializer
Class for serializing RenderSystemCapabilities to / from a .rendercaps script
A 'canvas' which can receive the results of a rendering operation
Struct containing information about a RenderTarget event
A interface class defining a listener which can be used to receive notifications of RenderTarget events
Struct containing information about a RenderTarget Viewport-specific event
This class represents a RenderTarget that renders to a Texture
An object which renders geometry to a vertex
Manages the target rendering window
Render window creation parameters
►CResource
Abstract class representing a loadable resource
This class is used to perform Resource operations in a background thread
This class defines an interface which is called back during resource group loading to indicate the progress of the load
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
Nested struct defining a resource declaration
Resource location entry
This class allows users to override resource loading behavior
Defines a generic resource handler
Definition of a pool of resources, which users can use to reuse similar resources many times without destroying and recreating them
Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances
Particle emitter which emits particles randomly from points inside a ring (e.g
Command object for inner size (see ParamCommand)
Command object for inner size (see ParamCommand)
CRoot
The root class of the Ogre system
This affector rotates particles in flight
Command object for particle emitter - see ParamCommand
Command object for particle emitter - see ParamCommand
Command object for particle emitter - see ParamCommand
Command object for particle emitter - see ParamCommand
This class interpolates orientations (rotations) along a spline using derivatives of quaternions
►CSampler
Class which determines how a TextureUnitState accesses data from a Texture
Texture addressing mode for each texture coordinate
This affector scales particles in flight
Command object for scale adjust (see ParamCommand)
Predefined controller function which simply scales an input to an output value
Manages the organisation and rendering of a 'scene': a collection of objects and potentially world geometry
Class that allows listening in on the various stages of SceneManager processing, so that custom behaviour can be implemented from outside
CSceneMgrQueuedRenderableVisitor
Inner helper class to implement the visitor pattern for rendering objects in a queue
Class which will create instances of a given SceneManager
Class representing a node in the scene graph
A class for performing queries on a scene
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of a single set of consolidated results
Holds the results of a scene query
CScreenRatioPixelCountLodStrategy
This is the main class for the compiler
This struct is a base class for events which can be thrown by the compilers and caught by subscribers
This is a listener for the compiler
Manages threaded compilation of scripts
Abstract class defining the interface used by classes which wish to perform script loading to define instances of whatever they manage
This class translates script AST (abstract syntax tree) into Ogre resources
The ScriptTranslatorManager manages the lifetime and access to script translators
3D Line Segment class for intersection testing in Ogre3D
Generic class for serialising data to / from binary stream-based files
Cset
This class allows you to plug in new ways to define the camera setup when rendering and projecting shadow textures
This class defines the interface that must be implemented by shadow casters
Class which represents the renderable aspects of a set of shadow volume faces
Structure containing the configuration for one shadow texture
Specialisation of PageContentCollection which just provides a simple list of PageContent instances
CSimplePageContentCollectionFactory
Factory class for SimplePageContentCollection
Generic ParamCommand implementation stores pointers to the class getter and setter functions
CSimpleParamCommand< _Class, const String &, getter, setter >
Specialization for strings
Simple implementation of MovableObject and Renderable for single-part custom objects
A very simple spline class which implements the Catmull-Rom class of splines
Template class for creating single-instance global classes
A collection of Bone objects used to animate a skinned mesh
A SkeletonInstance is a single instance of a Skeleton used by a world object
Handles the management of skeleton resources
Class for serialising skeleton data to/from an OGRE .skeleton file
SmallVector - This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small
Specialize SmallVector at N=0
SmallVectorBase - This is all the non-templated stuff common to all SmallVectors
SmallVectorImpl - This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter
SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's
CSmallVectorTemplateBase< T, true >
SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's
A sphere primitive, mostly used for bounds checking
Specialises the SceneQuery class for querying within a sphere
Template version of cache based on static array
Collects a group of static i.e
Pre-transforms and batches up meshes for efficient use as static geometry in a scene
A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is stored
A LODBucket is a collection of smaller buckets with the same LOD
A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same LOD)
Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances
Structure recording a queued geometry for low level builds
Structure recording a queued submesh for the build
The details of a topological region which is the highest level of partitioning for this class
Saved link between SubMesh at a LOD and vertex/index data May point to original or optimised geometry
Describes the stencil buffer operation
Utility class providing helper methods for reading / writing structured data held in a DataStream
Definition of a chunk of data in a file
Class for converting the core Ogre data types to/from Strings
Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers
Utility class for manipulating Strings
Utility class which defines the sub-parts of an Entity
Defines a part of a complete mesh
A tagged point on a skeleton, which can be used to attach entities to on specific other entities
Class for calculating a tangent space basis
Information about a remapped index
The result of having built a tangent space basis
Class representing an approach to rendering this particular Material
Rule controlling whether technique is deemed supported based on GPU device name
Rule controlling whether technique is deemed supported based on GPU vendor
►CTerrain
The main containing class for a chunk of terrain
Standard implementation of a buffer allocator which re-uses buffers
Interface used to by the Terrain instance to allocate GPU buffers
Structure encapsulating import data that you may use to bootstrap the terrain without loading from a native data stream
An instance of a layer, with specific texture names
Terrain automatic LOD loading
CTerrainAutoUpdateLodByDistance
Class implementing TerrainAutoUpdateLod interface
Options class which just stores default options for the terrain
Helper class to assist you in managing multiple terrain instances that are connected to each other
Result from a terrain ray intersection with the terrain group
Slot for a terrain instance, together with its definition
Definition of how to populate a 'slot' in the terrain group
Class exposing an interface to a blend map for a given layer
Description of a sampler that will be used with each layer
Terrain LOD data manager
Class that provides functionality to generate materials for use with a terrain
A TerrainMaterialGenerator which can cope with normal mapped, specular mapped terrain
Shader model 2 profile target
A world section which includes paged terrain
This class is the 'core' class for paging terrain, that will integrate with the larger paging system and provide the appropriate utility classes required
A node in a quad tree used to store a patch of terrain
CTexCoordModifierControllerValue
Predefined controller value for getting / setting a texture coordinate modifications (scales and translates)
This class implements an overlay element which contains simple unformatted text
Abstract class representing a Texture resource
This affector makes it possible to have an animated texture for each individual particle
CTextureAnimatorAffectorFactory
Factory class for TextureAnimatorAffector
Predefined controller value for getting / setting the frame number of a texture layer
Class for loading & managing textures
Class representing the state of a single texture unit during a Pass of a Technique, of a Material
Internal structure defining a texture effect
Time index object used to search keyframe at the given position
Timer class
Software rasterizer Implementation as a rendering system
Class encapsulating a standard 4x4 homogeneous matrix
Specialised KeyFrame which stores a full transform
Template struct which creates a distinct type for each exception code
Class that provides convenient interface to establish a linkage between custom user application objects and Ogre core classes
This abstract node represents a variable assignment
Standard N-dimensional vector
Helper class to implement legacy API. Notably x, y, z access
Concrete IteratorWrapper for nonconst access to the underlying container
Prepared IteratorWrapper for container like std::vector
VectorSet is basically a helper to use a vector as a small set container
Specialised AnimationTrack for dealing with changing vertex position information
Records the assignment of a single vertex to a single bone with the corresponding weight
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
Vertex cache profiler
Collects together all the vertex-related information used to render geometry
Struct used to hold hardware morph / pose vertex data information
This class declares the format of a set of vertex inputs, which can be issued to the rendering API through a RenderOperation
This class declares the usage of a single vertex buffer as a component of a complete VertexDeclaration
Specialised KeyFrame which stores absolute vertex positions for a complete buffer, designed to be interpolated with other keys in the same track
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
Reference to a pose at a given influence level
Structure for holding a position & orientation pair
►CViewport
An abstraction of a viewport, i.e., a rendering region on a render target
Listener interface so you can be notified of Viewport changes
Structure collecting together information about the visible objects that have been discovered in a scene
Predefined controller function based on a waveform
Allows the rendering of a wireframe bounding box
Interface to a general purpose task-basedbackground work queue
General purpose request structure
General purpose response structure
Represents part of the world geometry that is a result of a SceneQuery
Specialisation to allow reading of files from a zip format source archive
Base class responsible for setting up a common context for applications
Specialization for connecting with Qt
Basic button class
Utility class for controlling the camera in samples
Basic check box widget
Custom, decorative widget created from a template
Return values of the callbacks are ignored by ApplicationContext however they can be used to control event propagation in a hierarchy
Chain of multiple InputListeners that acts as a single InputListener
Basic label widget
Link between a renderwindow and a platform specific window
Basic parameters panel widget
Basic progress bar widget
Basic selection menu widget
Basic separator widget
Default implementation of a Listener to use with the Ogre::RTShader system
Basic slider widget
Utility class for loading the plugins statically
Scrollable text box widget
Listener class for responding to tray events
Main class to manage a cursor, backdrop, trays and widgets
Abstract base class for all widgets
Callback class used to send out window events to client app
Utility class to handle Window Messages