OgrePrerequisites.h
Go to the documentation of this file.
/*-------------------------------------------------------------------------
This source file is a part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/
Copyright (c) 2000-2013 Torus Knot Software Ltd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE
-------------------------------------------------------------------------*/
#ifndef __OgrePrerequisites_H__
#define __OgrePrerequisites_H__
// Platform-specific stuff
#include "OgrePlatform.h"
#include <string>
// configure memory tracking
#if OGRE_DEBUG_MODE
# if OGRE_MEMORY_TRACKER_DEBUG_MODE
# define OGRE_MEMORY_TRACKER 1
# else
# define OGRE_MEMORY_TRACKER 0
# endif
#else
# if OGRE_MEMORY_TRACKER_RELEASE_MODE
# define OGRE_MEMORY_TRACKER 1
# else
# define OGRE_MEMORY_TRACKER 0
# endif
#endif
namespace Ogre {
// Define ogre version
#define OGRE_VERSION_MAJOR 1
#define OGRE_VERSION_MINOR 9
#define OGRE_VERSION_PATCH 0
#define OGRE_VERSION_SUFFIX ""
#define OGRE_VERSION_NAME "Ghadamon"
#define OGRE_VERSION ((OGRE_VERSION_MAJOR << 16) | (OGRE_VERSION_MINOR << 8) | OGRE_VERSION_PATCH)
// define the real number values to be used
// default to use 'float' unless precompiler option set
#if OGRE_DOUBLE_PRECISION == 1
typedef double Real;
#else
typedef float Real;
#endif
#if OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 310 && !defined(STLPORT)
# if OGRE_COMP_VER >= 430
# define HashMap ::std::tr1::unordered_map
# define HashSet ::std::tr1::unordered_set
# else
# define HashMap ::__gnu_cxx::hash_map
# define HashSet ::__gnu_cxx::hash_set
# endif
#elif OGRE_COMPILER == OGRE_COMPILER_CLANG
# if defined(_LIBCPP_VERSION)
# define HashMap ::std::unordered_map
# define HashSet ::std::unordered_set
# else
# define HashMap ::std::tr1::unordered_map
# define HashSet ::std::tr1::unordered_set
# endif
#else
# if OGRE_COMPILER == OGRE_COMPILER_MSVC && !defined(_STLP_MSVC)
# if _MSC_FULL_VER >= 150030729 // VC++ 9.0 SP1+
# define HashMap ::std::tr1::unordered_map
# define HashSet ::std::tr1::unordered_set
# elif OGRE_THREAD_PROVIDER == 1
# define HashMap ::boost::unordered_map
# define HashSet ::boost::unordered_set
# else
# define HashMap ::std::unordered_map
# define HashSet ::std::unordered_set
# endif
# else
# define HashMap ::std::unordered_map
# define HashSet ::std::unordered_set
# endif
#endif
#define OGRE_DEFINE_STATIC_LOCAL(type, name, arguments) \
static type& name = *new type arguments
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
// Pre-declare classes
// Allows use of pointers in header files without including individual .h
// so decreases dependencies between files
class Angle;
class Animation;
class AnimationState;
class AnimationStateSet;
class AnimationTrack;
class Archive;
class ArchiveFactory;
class ArchiveManager;
class AutoParamDataSource;
class AxisAlignedBox;
class AxisAlignedBoxSceneQuery;
class Billboard;
class BillboardChain;
class BillboardSet;
class Bone;
class Camera;
class Codec;
class ColourValue;
class ConfigDialog;
template <typename T> class Controller;
template <typename T> class ControllerFunction;
class ControllerManager;
template <typename T> class ControllerValue;
class DefaultWorkQueue;
class Degree;
class DepthBuffer;
class DynLib;
class DynLibManager;
class EdgeData;
class EdgeListBuilder;
class Entity;
class ErrorDialog;
class ExternalTextureSourceManager;
class Factory;
struct FrameEvent;
class FrameListener;
class Frustum;
class GpuProgram;
class GpuProgramManager;
class GpuProgramUsage;
class HardwareIndexBuffer;
class HardwareOcclusionQuery;
class HardwareVertexBuffer;
class HardwarePixelBuffer;
class HardwarePixelBufferSharedPtr;
class HighLevelGpuProgram;
class HighLevelGpuProgramManager;
class HighLevelGpuProgramFactory;
class IndexData;
class InstanceBatch;
class InstanceBatchHW;
class InstanceBatchHW_VTF;
class InstanceBatchShader;
class InstanceBatchVTF;
class InstanceManager;
class InstancedEntity;
class IntersectionSceneQuery;
class IntersectionSceneQueryListener;
class Image;
class KeyFrame;
class Light;
class Log;
class LogManager;
class LodStrategy;
class ManualResourceLoader;
class ManualObject;
class Material;
class MaterialManager;
class Math;
class Matrix3;
class Matrix4;
class MemoryManager;
class Mesh;
class MeshSerializer;
class MeshSerializerImpl;
class MeshManager;
class MovableObject;
class MovablePlane;
class Node;
class NodeAnimationTrack;
class NodeKeyFrame;
class NumericAnimationTrack;
class NumericKeyFrame;
class Particle;
class ParticleAffector;
class ParticleAffectorFactory;
class ParticleEmitter;
class ParticleEmitterFactory;
class ParticleSystem;
class ParticleSystemManager;
class ParticleSystemRenderer;
class ParticleSystemRendererFactory;
class ParticleVisualData;
class Pass;
class PatchMesh;
class PixelBox;
class Plane;
class PlaneBoundedVolume;
class Plugin;
class PMWorker;
class PMInjector;
class Pose;
class ProgressiveMeshGenerator;
class Profile;
class Profiler;
class Quaternion;
class Radian;
class Ray;
class RaySceneQuery;
class RaySceneQueryListener;
class Renderable;
class RenderPriorityGroup;
class RenderQueue;
class RenderQueueGroup;
class RenderQueueInvocation;
class RenderQueueInvocationSequence;
class RenderQueueListener;
class RenderObjectListener;
class RenderSystem;
class RenderSystemCapabilities;
class RenderSystemCapabilitiesManager;
class RenderSystemCapabilitiesSerializer;
class RenderTarget;
class RenderTargetListener;
class RenderTexture;
class MultiRenderTarget;
class RenderWindow;
class RenderOperation;
class Resource;
class ResourceBackgroundQueue;
class ResourceGroupManager;
class ResourceManager;
class RibbonTrail;
class Root;
class SceneManager;
class SceneManagerEnumerator;
class SceneNode;
class SceneQuery;
class SceneQueryListener;
class ScriptCompiler;
class ScriptCompilerManager;
class ScriptLoader;
class Serializer;
class ShadowCaster;
class ShadowRenderable;
class ShadowTextureManager;
class SimpleRenderable;
class SimpleSpline;
class Skeleton;
class SkeletonInstance;
class SkeletonManager;
class Sphere;
class SphereSceneQuery;
class StaticGeometry;
class StreamSerialiser;
class StringConverter;
class StringInterface;
class SubEntity;
class SubMesh;
class TagPoint;
class Technique;
class TempBlendedBufferInfo;
class ExternalTextureSource;
class TextureUnitState;
class Texture;
class TextureManager;
class TransformKeyFrame;
class Timer;
class UserObjectBindings;
class Vector2;
class Vector3;
class Vector4;
class Viewport;
class VertexAnimationTrack;
class VertexBufferBinding;
class VertexData;
class VertexDeclaration;
class VertexMorphKeyFrame;
class WireBoundingBox;
class WorkQueue;
class Compositor;
class CompositorManager;
class CompositorChain;
class CompositorInstance;
class CompositorLogic;
class CompositionTechnique;
class CompositionPass;
class CompositionTargetPass;
class CustomCompositionPass;
template<typename T> class SharedPtr;
typedef SharedPtr<Compositor> CompositorPtr;
typedef SharedPtr<GpuProgram> GpuProgramPtr;
typedef SharedPtr<HighLevelGpuProgram> HighLevelGpuProgramPtr;
typedef SharedPtr<Material> MaterialPtr;
typedef SharedPtr<Mesh> MeshPtr;
typedef SharedPtr<PatchMesh> PatchMeshPtr;
typedef SharedPtr<Resource> ResourcePtr;
typedef SharedPtr<Skeleton> SkeletonPtr;
typedef SharedPtr<Texture> TexturePtr;
}
/* Include all the standard header *after* all the configuration
settings have been made.
*/
#include "OgreStdHeaders.h"
#include "OgreMemoryAllocatorConfig.h"
namespace Ogre
{
#if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
typedef std::basic_string<char, std::char_traits<char>, STLAllocator<char,GeneralAllocPolicy > > _StringBase;
typedef std::basic_stringstream<char,std::char_traits<char>,STLAllocator<char,GeneralAllocPolicy > > _StringStreamBase;
#define StdStringT(T) std::basic_string<T, std::char_traits<T>, std::allocator<T> >
#define CustomMemoryStringT(T) std::basic_string<T, std::char_traits<T>, STLAllocator<T,GeneralAllocPolicy> >
template<typename T>
bool operator <(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())<0;
}
template<typename T>
bool operator <(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())<0;
}
template<typename T>
bool operator <=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())<=0;
}
template<typename T>
bool operator <=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())<=0;
}
template<typename T>
bool operator >(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())>0;
}
template<typename T>
bool operator >(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())>0;
}
template<typename T>
bool operator >=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())>=0;
}
template<typename T>
bool operator >=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())>=0;
}
template<typename T>
bool operator ==(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())==0;
}
template<typename T>
bool operator ==(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())==0;
}
template<typename T>
bool operator !=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())!=0;
}
template<typename T>
bool operator !=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return l.compare(0,l.length(),o.c_str(),o.length())!=0;
}
template<typename T>
CustomMemoryStringT(T) operator +=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return CustomMemoryStringT(T)(l)+=o.c_str();
}
template<typename T>
CustomMemoryStringT(T) operator +=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
}
template<typename T>
CustomMemoryStringT(T) operator +(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
{
return CustomMemoryStringT(T)(l)+=o.c_str();
}
template<typename T>
CustomMemoryStringT(T) operator +(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
{
return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
}
template<typename T>
CustomMemoryStringT(T) operator +(const T* l,const CustomMemoryStringT(T)& o)
{
return CustomMemoryStringT(T)(l)+=o;
}
#undef StdStringT
#undef CustomMemoryStringT
#else
typedef std::string _StringBase;
typedef std::basic_stringstream<char,std::char_traits<char>,std::allocator<char> > _StringStreamBase;
#endif
typedef _StringBase String;
typedef _StringStreamBase StringStream;
typedef StringStream stringstream;
}
#if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
namespace std
{
#if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
namespace tr1
{
#endif
template <> struct hash<Ogre::String>
{
public :
size_t operator()(const Ogre::String &str ) const
{
size_t _Val = 2166136261U;
size_t _First = 0;
size_t _Last = str.size();
size_t _Stride = 1 + _Last / 10;
for(; _First < _Last; _First += _Stride)
_Val = 16777619U * _Val ^ (size_t)str[_First];
return (_Val);
}
};
#if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
}
#endif
}
#endif
//for stl container
namespace Ogre
{
template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
struct deque
{
#if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
typedef typename std::deque<T, A> type;
typedef typename std::deque<T, A>::iterator iterator;
typedef typename std::deque<T, A>::const_iterator const_iterator;
#else
typedef typename std::deque<T> type;
typedef typename std::deque<T>::iterator iterator;
typedef typename std::deque<T>::const_iterator const_iterator;
#endif
};
template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
struct vector
{
#if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
typedef typename std::vector<T, A> type;
typedef typename std::vector<T, A>::iterator iterator;
typedef typename std::vector<T, A>::const_iterator const_iterator;
#else
typedef typename std::vector<T> type;
typedef typename std::vector<T>::iterator iterator;
typedef typename std::vector<T>::const_iterator const_iterator;
#endif
};
template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
struct list
{
#if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
typedef typename std::list<T, A> type;
typedef typename std::list<T, A>::iterator iterator;
typedef typename std::list<T, A>::const_iterator const_iterator;
#else
typedef typename std::list<T> type;
typedef typename std::list<T>::iterator iterator;
typedef typename std::list<T>::const_iterator const_iterator;
#endif
};
template <typename T, typename P = std::less<T>, typename A = STLAllocator<T, GeneralAllocPolicy> >
struct set
{
#if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
typedef typename std::set<T, P, A> type;
typedef typename std::set<T, P, A>::iterator iterator;
typedef typename std::set<T, P, A>::const_iterator const_iterator;
#else
typedef typename std::set<T, P> type;
typedef typename std::set<T, P>::iterator iterator;
typedef typename std::set<T, P>::const_iterator const_iterator;
#endif
};
template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
struct map
{
#if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
typedef typename std::map<K, V, P, A> type;
typedef typename std::map<K, V, P, A>::iterator iterator;
typedef typename std::map<K, V, P, A>::const_iterator const_iterator;
#else
typedef typename std::map<K, V, P> type;
typedef typename std::map<K, V, P>::iterator iterator;
typedef typename std::map<K, V, P>::const_iterator const_iterator;
#endif
};
template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
struct multimap
{
#if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
typedef typename std::multimap<K, V, P, A> type;
typedef typename std::multimap<K, V, P, A>::iterator iterator;
typedef typename std::multimap<K, V, P, A>::const_iterator const_iterator;
#else
typedef typename std::multimap<K, V, P> type;
typedef typename std::multimap<K, V, P>::iterator iterator;
typedef typename std::multimap<K, V, P>::const_iterator const_iterator;
#endif
};
} // Ogre
#endif // __OgrePrerequisites_H__
Ogre::ShadowRenderable
Class which represents the renderable aspects of a set of shadow volume faces.
Definition: OgreShadowCaster.h:52
Ogre::AnimationTrack
A &#39;track&#39; in an animation sequence, i.e.
Definition: OgreAnimationTrack.h:122
Ogre::RenderTarget
A &#39;canvas&#39; which can receive the results of a rendering operation.
Definition: OgreRenderTarget.h:65
Ogre::PatchMesh
Patch specialisation of Mesh.
Definition: OgrePatchMesh.h:47
Ogre::IntersectionSceneQuery
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another...
Definition: OgreSceneQuery.h:512
Ogre::SubEntity
Utility class which defines the sub-parts of an Entity.
Definition: OgreSubEntity.h:63
Ogre::set::const_iterator
std::set< T, P, A >::const_iterator const_iterator
Definition: OgrePrerequisites.h:524
Ogre::TextureManager
Class for loading & managing textures.
Definition: OgreTextureManager.h:60
Ogre::Codec
Abstract class that defines a &#39;codec&#39;.
Definition: OgreCodec.h:56
Ogre::STLAllocator
Definition: OgreMemorySTLAllocator.h:81
Ogre::Renderable
Abstract class defining the interface all renderable objects must implement.
Definition: OgreRenderable.h:63
Ogre::GpuProgramManager
Definition: OgreGpuProgramManager.h:47
Ogre::Pass
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:80
Ogre::Math
Class to provide access to common mathematical functions.
Definition: OgreMath.h:191
Ogre::Serializer
Generic class for serialising data to / from binary stream-based files.
Definition: OgreSerializer.h:50
Ogre::RenderSystemCapabilitiesManager
Class for managing RenderSystemCapabilities database for Ogre.
Definition: OgreRenderSystemCapabilitiesManager.h:52
Ogre::ScriptLoader
Abstract class defining the interface used by classes which wish to perform script loading to define ...
Definition: OgreScriptLoader.h:59
Ogre::HardwarePixelBuffer
Specialisation of HardwareBuffer for a pixel buffer.
Definition: OgreHardwarePixelBuffer.h:53
Ogre::list
Definition: OgrePrerequisites.h:505
Ogre::MovableObject
Abstract class defining a movable object in a scene.
Definition: OgreMovableObject.h:60
Ogre::uint
unsigned int uint
Definition: OgrePrerequisites.h:114
Ogre::LodStrategy
Strategy for determining level of detail.
Definition: OgreLodStrategy.h:54
Ogre::list::iterator
std::list< T, A >::iterator iterator
Definition: OgrePrerequisites.h:509
Ogre::InstanceBatchHW_VTF
Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instan...
Definition: OgreInstanceBatchHW_VTF.h:60
Ogre::set::type
std::set< T, P, A > type
Definition: OgrePrerequisites.h:522
Ogre::AxisAlignedBoxSceneQuery
Specialises the SceneQuery class for querying within an axis aligned box.
Definition: OgreSceneQuery.h:270
Ogre::ExternalTextureSourceManager
Singleton Class which handles the registering and control of texture plugins.
Definition: OgreExternalTextureSourceManager.h:56
Ogre::vector::type
std::vector< T, A > type
Definition: OgrePrerequisites.h:494
Ogre::SimpleSpline
A very simple spline class which implements the Catmull-Rom class of splines.
Definition: OgreSimpleSpline.h:57
Ogre::WorkQueue
Interface to a general purpose request / response style background work queue.
Definition: OgreWorkQueue.h:70
Ogre::VertexData
Summary class collecting together vertex source information.
Definition: OgreVertexIndexData.h:49
Ogre::RenderQueueInvocation
Class representing the invocation of queue groups in a RenderQueue.
Definition: OgreRenderQueueInvocation.h:66
Ogre::PlaneBoundedVolume
Represents a convex volume bounded by planes.
Definition: OgrePlaneBoundedVolume.h:49
Ogre::Quaternion
Implementation of a Quaternion, i.e.
Definition: OgreQuaternion.h:57
Ogre::ResourcePtr
SharedPtr< Resource > ResourcePtr
Shared pointer to a Resource.
Definition: OgrePrerequisites.h:317
Ogre::PMInjector
Injects the output of a request to the mesh in a thread safe way.
Definition: OgreQueuedProgressiveMeshGenerator.h:143
Ogre::Sphere
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:51
Ogre::CompositorLogic
Interface for compositor logics, which can be automatically binded to compositors, allowing per-compositor logic (such as attaching a relevant listener) to happen automatically.
Definition: OgreCompositorLogic.h:46
Ogre::CompositorInstance
An instance of a Compositor object for one Viewport.
Definition: OgreCompositorInstance.h:50
Ogre::Matrix3
A 3x3 matrix which can represent rotations around axes.
Definition: OgreMatrix3.h:68
Ogre::Vector4
4-dimensional homogeneous vector.
Definition: OgreVector4.h:45
Ogre::CompositionTargetPass
Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework...
Definition: OgreCompositionTargetPass.h:45
Ogre::SkeletonManager
Handles the management of skeleton resources.
Definition: OgreSkeletonManager.h:51
Ogre::MeshPtr
SharedPtr< Mesh > MeshPtr
Definition: OgrePrerequisites.h:315
Ogre::Vector2
Standard 2-dimensional vector.
Definition: OgreVector2.h:51
Ogre::ControllerFunction
Subclasses of this class are responsible for performing a function on an input value for a Controller...
Definition: OgreController.h:55
Ogre::ColourValue
Class representing colour.
Definition: OgreColourValue.h:57
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::IntersectionSceneQueryListener
Alternative listener class for dealing with IntersectionSceneQuery.
Definition: OgreSceneQuery.h:461
Ogre::RenderQueue
Class to manage the scene object rendering queue.
Definition: OgreRenderQueue.h:92
Ogre::IndexData
Summary class collecting together index data source information.
Definition: OgreVertexIndexData.h:242
Ogre::GpuProgramPtr
SharedPtr< GpuProgram > GpuProgramPtr
Definition: OgrePrerequisites.h:312
Ogre::HardwareVertexBuffer
Specialisation of HardwareBuffer for a vertex buffer.
Definition: OgreHardwareVertexBuffer.h:48
Ogre::TempBlendedBufferInfo
Structure for recording the use of temporary blend buffers.
Definition: OgreHardwareBufferManager.h:71
Ogre::CompositionPass
Object representing one pass or operation in a composition sequence.
Definition: OgreCompositionPass.h:47
std
Definition: OgreSmallVector.h:798
Ogre::uchar
unsigned char uchar
In order to avoid finger-aches :)
Definition: OgrePrerequisites.h:112
Ogre::TransformKeyFrame
Specialised KeyFrame which stores a full transform.
Definition: OgreKeyFrame.h:103
Ogre::DynLib
Resource holding data about a dynamic library.
Definition: OgreDynLib.h:84
Ogre::Resource
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:79
Ogre::Skeleton
A collection of Bone objects used to animate a skinned mesh.
Definition: OgreSkeleton.h:87
Ogre::PMWorker
Processes requests.
Definition: OgreQueuedProgressiveMeshGenerator.h:73
Ogre::ErrorDialog
Class for displaying the error dialog if Ogre fails badly.
Definition: Android/OgreErrorDialogImp.h:36
Ogre::HighLevelGpuProgram
Abstract base class representing a high-level program (a vertex or fragment program).
Definition: OgreHighLevelGpuProgram.h:63
Ogre::SceneNode
Class representing a node in the scene graph.
Definition: OgreSceneNode.h:58
Ogre::HardwareIndexBuffer
Specialisation of HardwareBuffer for vertex index buffers, still abstract.
Definition: OgreHardwareIndexBuffer.h:46
Ogre::ManualResourceLoader
Interface describing a manual resource loader.
Definition: OgreResource.h:514
Ogre::Texture
Abstract class representing a Texture resource.
Definition: OgreTexture.h:102
Ogre::ParticleAffector
Abstract class defining the interface to be implemented by particle affectors.
Definition: OgreParticleAffector.h:64
Ogre::Viewport
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:57
Ogre::Profile
An individual profile that will be processed by the Profiler.
Definition: OgreProfiler.h:104
Ogre::ManualObject
Class providing a much simplified interface to generating manual objects with custom geometry...
Definition: OgreManualObject.h:106
Ogre::NumericAnimationTrack
Specialised AnimationTrack for dealing with generic animable values.
Definition: OgreAnimationTrack.h:265
Ogre::EdgeData
This class contains the information required to describe the edge connectivity of a given set of vert...
Definition: OgreEdgeListBuilder.h:52
Ogre::ControllerValue
Can either be used as an input or output value.
Definition: OgreController.h:104
Ogre::Timer
Timer class.
Definition: Android/OgreTimerImp.h:37
Ogre::MaterialManager
Class for managing Material settings for Ogre.
Definition: OgreMaterialManager.h:64
Ogre::Plane
Defines a plane in 3D space.
Definition: OgrePlane.h:61
Ogre::SubMesh
Defines a part of a complete mesh.
Definition: OgreSubMesh.h:62
Ogre::SphereSceneQuery
Specialises the SceneQuery class for querying within a sphere.
Definition: OgreSceneQuery.h:287
Ogre::RibbonTrail
Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances...
Definition: OgreRibbonTrail.h:71
Ogre::MeshSerializer
Class for serialising mesh data to/from an OGRE .mesh file.
Definition: OgreMeshSerializer.h:89
Ogre::AnimationStateSet
Class encapsulating a set of AnimationState objects.
Definition: OgreAnimationState.h:196
Ogre::MaterialPtr
SharedPtr< Material > MaterialPtr
Definition: OgrePrerequisites.h:314
Ogre::ProgressiveMeshGenerator
Improved version of ProgressiveMesh.
Definition: OgreProgressiveMeshGenerator.h:72
Ogre::Controller
Instances of this class &#39;control&#39; the value of another object in the system.
Definition: OgreController.h:135
Ogre::CompositionTechnique
Base composition technique, can be subclassed in plugins.
Definition: OgreCompositionTechnique.h:45
Ogre::deque::iterator
std::deque< T, A >::iterator iterator
Definition: OgrePrerequisites.h:481
Ogre::Matrix4
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Ogre::Vector3
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
Ogre::RenderQueueInvocationSequence
Class to hold a linear sequence of RenderQueueInvocation objects.
Definition: OgreRenderQueueInvocation.h:173
Ogre::set::iterator
std::set< T, P, A >::iterator iterator
Definition: OgrePrerequisites.h:523
Ogre::_StringStreamBase
std::basic_stringstream< char, std::char_traits< char >, std::allocator< char > > _StringStreamBase
Definition: OgrePrerequisites.h:435
Ogre::VertexDeclaration
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
Definition: OgreHardwareVertexBuffer.h:337
Ogre::Compositor
Class representing a Compositor object.
Definition: OgreCompositor.h:50
Ogre::Profiler
The profiler allows you to measure the performance of your code.
Definition: OgreProfiler.h:280
OgrePlatform.h
Ogre::CompositorManager
Class for managing Compositor settings for Ogre.
Definition: OgreCompositorManager.h:59
Ogre::TextureUnitState
Class representing the state of a single texture unit during a Pass of a Technique, of a Material.
Definition: OgreTextureUnitState.h:62
Ogre::ParticleSystemRendererFactory
Abstract class definition of a factory object for ParticleSystemRenderer.
Definition: OgreParticleSystemRenderer.h:133
Ogre::map::type
std::map< K, V, P, A > type
Definition: OgrePrerequisites.h:536
Ogre::RenderQueueGroup
A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same ti...
Definition: OgreRenderQueueSortingGrouping.h:465
Ogre::ControllerManager
Class for managing Controller instances.
Definition: OgreControllerManager.h:58
Ogre::SkeletonInstance
A SkeletonInstance is a single instance of a Skeleton used by a world object.
Definition: OgreSkeletonInstance.h:53
Ogre::InstanceBatchVTF
Definition: OgreInstanceBatchVTF.h:204
Ogre::ParticleSystemRenderer
Abstract class defining the interface required to be implemented by classes which provide rendering c...
Definition: OgreParticleSystemRenderer.h:49
Ogre::deque
Definition: OgrePrerequisites.h:477
Ogre::_StringBase
std::string _StringBase
Definition: OgrePrerequisites.h:434
Ogre::Bone
A bone in a skeleton.
Definition: OgreBone.h:51
Ogre::ParticleEmitterFactory
Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses...
Definition: OgreParticleEmitterFactory.h:56
Ogre::Node
Class representing a general-purpose node an articulated scene graph.
Definition: OgreNode.h:64
Ogre::stringstream
StringStream stringstream
Definition: OgrePrerequisites.h:441
Ogre::multimap::const_iterator
std::multimap< K, V, P, A >::const_iterator const_iterator
Definition: OgrePrerequisites.h:552
Ogre::Animation
An animation sequence.
Definition: OgreAnimation.h:92
Ogre::RenderSystem
Defines the functionality of a 3D API.
Definition: OgreRenderSystem.h:125
Ogre::Angle
Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAn...
Definition: OgreMath.h:150
Ogre::operator!=
bool operator!=(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator, (ISO C++)
Definition: OgreMemorySTLAllocator.h:202
Ogre::RenderPriorityGroup
Collection of renderables by priority.
Definition: OgreRenderQueueSortingGrouping.h:323
Ogre::FrameEvent
Struct containing information about a frame event.
Definition: OgreFrameListener.h:44
Ogre::RenderTexture
This class represents a RenderTarget that renders to a Texture.
Definition: OgreRenderTexture.h:48
Ogre::SceneManagerEnumerator
Enumerates the SceneManager classes available to applications.
Definition: OgreSceneManagerEnumerator.h:88
Ogre::KeyFrame
A key frame in an animation sequence defined by an AnimationTrack.
Definition: OgreKeyFrame.h:56
Ogre::RaySceneQuery
Specialises the SceneQuery class for querying along a ray.
Definition: OgreSceneQuery.h:376
OgreStdHeaders.h
Ogre::StringStream
_StringStreamBase StringStream
Definition: OgrePrerequisites.h:440
Ogre::StringInterface
Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers.
Definition: OgreStringInterface.h:163
Ogre::CompositorPtr
SharedPtr< Compositor > CompositorPtr
Definition: OgrePrerequisites.h:310
Ogre::Mesh
Resource holding data about 3D mesh.
Definition: OgreMesh.h:93
Ogre::ShadowCaster
This class defines the interface that must be implemented by shadow casters.
Definition: OgreShadowCaster.h:117
Ogre::RenderObjectListener
Abstract interface which classes must implement if they wish to receive events from the scene manager...
Definition: OgreRenderObjectListener.h:43
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::RenderSystemCapabilitiesSerializer
Class for serializing RenderSystemCapabilities to / from a .rendercaps script.
Definition: OgreRenderSystemCapabilitiesSerializer.h:48
Ogre::Plugin
Class defining a generic OGRE plugin.
Definition: OgrePlugin.h:79
Ogre::StringConverter
Class for converting the core Ogre data types to/from Strings.
Definition: OgreStringConverter.h:68
Ogre::ResourceBackgroundQueue
This class is used to perform Resource operations in a background thread.
Definition: OgreResourceBackgroundQueue.h:81
Ogre::DepthBuffer
An abstract class that contains a depth/stencil buffer.
Definition: OgreDepthBuffer.h:82
Ogre::HardwarePixelBufferSharedPtr
Shared pointer implementation used to share pixel buffers.
Definition: OgreHardwarePixelBuffer.h:193
Ogre::set
Definition: OgrePrerequisites.h:519
Ogre::InstanceManager
This is the main starting point for the new instancing system.
Definition: OgreInstanceManager.h:63
Ogre::ConfigDialog
Defines the behaviour of an automatic renderer configuration dialog.
Definition: Android/OgreConfigDialogImp.h:38
Ogre::DynLibManager
Manager for Dynamic-loading Libraries.
Definition: OgreDynLibManager.h:48
Ogre::VertexMorphKeyFrame
Specialised KeyFrame which stores absolute vertex positions for a complete buffer, designed to be interpolated with other keys in the same track.
Definition: OgreKeyFrame.h:154
Ogre::ParticleVisualData
Abstract class containing any additional data required to be associated with a particle to perform th...
Definition: OgreParticle.h:52
Ogre::ShadowTextureManager
Class to manage the available shadow textures which may be shared between many SceneManager instances...
Definition: OgreShadowTextureManager.h:81
Ogre::ParticleAffectorFactory
Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses...
Definition: OgreParticleAffectorFactory.h:55
Ogre::StreamSerialiser
Utility class providing helper methods for reading / writing structured data held in a DataStream...
Definition: OgreStreamSerialiser.h:66
Ogre::RenderSystemCapabilities
singleton class for storing the capabilities of the graphics card.
Definition: OgreRenderSystemCapabilities.h:279
Ogre::ScriptCompilerManager
Manages threaded compilation of scripts.
Definition: OgreScriptCompiler.h:384
Ogre::WireBoundingBox
Allows the rendering of a wireframe bounding box.
Definition: OgreWireBoundingBox.h:48
Ogre::ArchiveFactory
Abstract factory class, archive codec plugins can register concrete subclasses of this...
Definition: OgreArchiveFactory.h:59
Ogre::Camera
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86
Ogre::CompositorChain
Chain of compositor effects applying to one viewport.
Definition: OgreCompositorChain.h:48
Ogre::SceneQuery
A class for performing queries on a scene.
Definition: OgreSceneQuery.h:74
Ogre::vector::iterator
std::vector< T, A >::iterator iterator
Definition: OgrePrerequisites.h:495
Ogre::MeshManager
Handles the management of mesh resources.
Definition: OgreMeshManager.h:58
Ogre::multimap::type
std::multimap< K, V, P, A > type
Definition: OgrePrerequisites.h:550
Ogre::VertexBufferBinding
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
Definition: OgreHardwareVertexBuffer.h:521
Ogre::ArchiveManager
This class manages the available ArchiveFactory plugins.
Definition: OgreArchiveManager.h:47
Ogre::Log
Definition: OgreLog.h:103
Ogre::ResourceManager
Defines a generic resource handler.
Definition: OgreResourceManager.h:122
Ogre::Particle
Class representing a single particle instance.
Definition: OgreParticle.h:61
Ogre::Image
Class representing an image file.
Definition: OgreImage.h:61
Ogre::RenderQueueListener
Abstract interface which classes must implement if they wish to receive events from the render queue...
Definition: OgreRenderQueueListener.h:56
Ogre::InstanceBatch
InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived ...
Definition: OgreInstanceBatch.h:88
Ogre::SceneQueryListener
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
Definition: OgreSceneQuery.h:187
Ogre::CustomCompositionPass
Interface for custom composition passes, allowing custom operations (in addition to the quad...
Definition: OgreCustomCompositionPass.h:45
Ogre::HighLevelGpuProgramManager
This ResourceManager manages high-level vertex and fragment programs.
Definition: OgreHighLevelGpuProgramManager.h:72
Ogre::GpuProgram
Defines a program which runs on the GPU such as a vertex or fragment program.
Definition: OgreGpuProgram.h:69
Ogre::LogManager
The log manager handles the creation and retrieval of logs for the application.
Definition: OgreLogManager.h:65
Ogre::TagPoint
A tagged point on a skeleton, which can be used to attach entities to on specific other entities...
Definition: OgreTagPoint.h:60
Ogre
Definition: OgreAndroidLogListener.h:34
Ogre::Material
Class encapsulates rendering properties of an object.
Definition: OgreMaterial.h:88
Ogre::map::iterator
std::map< K, V, P, A >::iterator iterator
Definition: OgrePrerequisites.h:537
Ogre::MeshSerializerImpl
Internal implementation of Mesh reading / writing for the latest version of the .mesh format...
Definition: OgreMeshSerializerImpl.h:61
Ogre::multimap::iterator
std::multimap< K, V, P, A >::iterator iterator
Definition: OgrePrerequisites.h:551
Ogre::RenderWindow
Manages the target rendering window.
Definition: OgreRenderWindow.h:62
Ogre::ParticleEmitter
Abstract class defining the interface to be implemented by particle emitters.
Definition: OgreParticleEmitter.h:72
Ogre::ResourceGroupManager
This singleton class manages the list of resource groups, and notifying the various resource managers...
Definition: OgreResourceGroupManager.h:261
Ogre::HardwareOcclusionQuery
This is a abstract class that that provides the interface for the query class for hardware occlusion...
Definition: OgreHardwareOcclusionQuery.h:51
Ogre::RenderTargetListener
A interface class defining a listener which can be used to receive notifications of RenderTarget even...
Definition: OgreRenderTargetListener.h:77
Ogre::StaticGeometry
Pre-transforms and batches up meshes for efficient use as static geometry in a scene.
Definition: OgreStaticGeometry.h:121
Ogre::SharedPtr
Reference-counted shared pointer, used for objects where implicit destruction is required.
Definition: OgrePrerequisites.h:310
Ogre::deque::const_iterator
std::deque< T, A >::const_iterator const_iterator
Definition: OgrePrerequisites.h:482
Ogre::vector
Definition: OgrePrerequisites.h:491
Ogre::ulong
unsigned long ulong
Definition: OgrePrerequisites.h:115
Ogre::UserObjectBindings
Class that provides convenient interface to establish a linkage between custom user application objec...
Definition: OgreUserObjectBindings.h:49
Ogre::operator==
bool operator==(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator, (ISO C++)
Definition: OgreMemorySTLAllocator.h:184
Ogre::list::const_iterator
std::list< T, A >::const_iterator const_iterator
Definition: OgrePrerequisites.h:510
Ogre::RenderOperation
&#39;New&#39; rendering operation using vertex buffers.
Definition: OgreRenderOperation.h:45
Ogre::Technique
Class representing an approach to rendering this particular Material.
Definition: OgreTechnique.h:53
Ogre::Entity
Defines an instance of a discrete, movable object based on a Mesh.
Definition: OgreEntity.h:82
Ogre::Archive
Archive-handling class.
Definition: OgreArchive.h:88
Ogre::BillboardSet
A collection of billboards (faces which are always facing the given direction) with the same (default...
Definition: OgreBillboardSet.h:110
Ogre::Degree
Wrapper class which indicates a given angle value is in Degrees.
Definition: OgreMath.h:98
Ogre::HighLevelGpuProgramFactory
Interface definition for factories of HighLevelGpuProgram.
Definition: OgreHighLevelGpuProgramManager.h:47
Ogre::map
Definition: OgrePrerequisites.h:533
Ogre::ParticleSystem
Class defining particle system based special effects.
Definition: OgreParticleSystem.h:67
Ogre::PixelBox
A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory.
Definition: OgrePixelFormat.h:304
Ogre::AnimationState
Represents the state of an animation and the weight of its influence.
Definition: OgreAnimationState.h:54
Ogre::RaySceneQueryListener
Alternative listener class for dealing with RaySceneQuery.
Definition: OgreSceneQuery.h:335
Ogre::ushort
unsigned short ushort
Definition: OgrePrerequisites.h:113
Ogre::SkeletonPtr
SharedPtr< Skeleton > SkeletonPtr
Definition: OgrePrerequisites.h:318
Ogre::AutoParamDataSource
This utility class is used to hold the information used to generate the matrices and other informatio...
Definition: OgreAutoParamDataSource.h:60
Ogre::ExternalTextureSource
IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from...
Definition: OgreExternalTextureSource.h:74
Ogre::InstanceBatchShader
This is the same technique the old "InstancedGeometry" implementation used (with improvements).
Definition: OgreInstanceBatchShader.h:66
Ogre::list::type
std::list< T, A > type
Definition: OgrePrerequisites.h:508
Ogre::GpuProgramUsage
This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit.
Definition: OgreGpuProgramUsage.h:73
Ogre::Frustum
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:85
Ogre::MultiRenderTarget
This class represents a render target that renders to multiple RenderTextures at once.
Definition: OgreRenderTexture.h:69
Ogre::VertexAnimationTrack
Specialised AnimationTrack for dealing with changing vertex position information. ...
Definition: OgreAnimationTrack.h:480
Ogre::map::const_iterator
std::map< K, V, P, A >::const_iterator const_iterator
Definition: OgrePrerequisites.h:538
Ogre::AxisAlignedBox
A 3D box aligned with the x/y/z axes.
Definition: OgreAxisAlignedBox.h:54
Ogre::SceneManager
Manages the organisation and rendering of a &#39;scene&#39; i.e.
Definition: OgreSceneManager.h:143
Ogre::MovablePlane
Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply...
Definition: OgreMovablePlane.h:54
Ogre::InstancedEntity
Definition: OgreInstancedEntity.h:77
OgreMemoryAllocatorConfig.h
This file configures Ogre&#39;s memory allocators.
Ogre::Billboard
A billboard is a primitive which always faces the camera in every frame.
Definition: OgreBillboard.h:67
Ogre::ParticleSystemManager
Manages particle systems, particle system scripts (templates) and the available emitter & affector fa...
Definition: OgreParticleSystemManager.h:77
Ogre::deque::type
std::deque< T, A > type
Definition: OgrePrerequisites.h:480
Ogre::Root
The root class of the Ogre system.
Definition: OgreRoot.h:71
Ogre::PatchMeshPtr
SharedPtr< PatchMesh > PatchMeshPtr
Definition: OgrePrerequisites.h:316
Ogre::SimpleRenderable
Simple implementation of MovableObject and Renderable for single-part custom objects.
Definition: OgreSimpleRenderable.h:50
Ogre::Light
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:73
Ogre::BillboardChain
Allows the rendering of a chain of connected billboards.
Definition: OgreBillboardChain.h:77
Ogre::FrameListener
A interface class defining a listener which can be used to receive notifications of frame events...
Definition: OgreFrameListener.h:79
Ogre::ScriptCompiler
This is the main class for the compiler.
Definition: OgreScriptCompiler.h:188
Ogre::EdgeListBuilder
General utility class for building edge lists for geometry.
Definition: OgreEdgeListBuilder.h:169
Ogre::NodeAnimationTrack
Specialised AnimationTrack for dealing with node transforms.
Definition: OgreAnimationTrack.h:326
Ogre::Ray
Representation of a ray in space, i.e.
Definition: OgreRay.h:46
Ogre::InstanceBatchHW
This is technique requires true instancing hardware support.
Definition: OgreInstanceBatchHW.h:61
Ogre::NumericKeyFrame
Specialised KeyFrame which stores any numeric value.
Definition: OgreKeyFrame.h:80
Ogre::operator<
bool operator<(SharedPtr< T > const &a, SharedPtr< U > const &b)
Definition: OgreSharedPtr.h:326
Ogre::TexturePtr
SharedPtr< Texture > TexturePtr
Definition: OgrePrerequisites.h:319
Ogre::Pose
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:55
Ogre::Radian
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:47
Ogre::multimap
Definition: OgrePrerequisites.h:547
Ogre::DefaultWorkQueue
Implementation of a general purpose request / response style background work queue.
Definition: OgreDefaultWorkQueueStandard.h:38
Ogre::HighLevelGpuProgramPtr
SharedPtr< HighLevelGpuProgram > HighLevelGpuProgramPtr
Definition: OgrePrerequisites.h:313
Ogre::vector::const_iterator
std::vector< T, A >::const_iterator const_iterator
Definition: OgrePrerequisites.h:496

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.