26 #ifndef __OgrePrerequisites_H__
27 #define __OgrePrerequisites_H__
36 # if OGRE_MEMORY_TRACKER_DEBUG_MODE
37 # define OGRE_MEMORY_TRACKER 1
39 # define OGRE_MEMORY_TRACKER 0
42 # if OGRE_MEMORY_TRACKER_RELEASE_MODE
43 # define OGRE_MEMORY_TRACKER 1
45 # define OGRE_MEMORY_TRACKER 0
51 #define OGRE_VERSION_MAJOR 1
52 #define OGRE_VERSION_MINOR 9
53 #define OGRE_VERSION_PATCH 0
54 #define OGRE_VERSION_SUFFIX ""
55 #define OGRE_VERSION_NAME "Ghadamon"
57 #define OGRE_VERSION ((OGRE_VERSION_MAJOR << 16) | (OGRE_VERSION_MINOR << 8) | OGRE_VERSION_PATCH)
61 #if OGRE_DOUBLE_PRECISION == 1
73 #if OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 310 && !defined(STLPORT)
74 # if OGRE_COMP_VER >= 430
75 # define HashMap ::std::tr1::unordered_map
76 # define HashSet ::std::tr1::unordered_set
78 # define HashMap ::__gnu_cxx::hash_map
79 # define HashSet ::__gnu_cxx::hash_set
81 #elif OGRE_COMPILER == OGRE_COMPILER_CLANG
82 # if defined(_LIBCPP_VERSION)
83 # define HashMap ::std::unordered_map
84 # define HashSet ::std::unordered_set
86 # define HashMap ::std::tr1::unordered_map
87 # define HashSet ::std::tr1::unordered_set
90 # if OGRE_COMPILER == OGRE_COMPILER_MSVC && !defined(_STLP_MSVC)
91 # if _MSC_FULL_VER >= 150030729 // VC++ 9.0 SP1+
92 # define HashMap ::std::tr1::unordered_map
93 # define HashSet ::std::tr1::unordered_set
94 # elif OGRE_THREAD_PROVIDER == 1
95 # define HashMap ::boost::unordered_map
96 # define HashSet ::boost::unordered_set
98 # define HashMap ::std::unordered_map
99 # define HashSet ::std::unordered_set
102 # define HashMap ::std::unordered_map
103 # define HashSet ::std::unordered_set
107 #define OGRE_DEFINE_STATIC_LOCAL(type, name, arguments) \
108 static type& name = *new type arguments
117 #if __cplusplus >= 201103L
334 #if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
335 typedef std::basic_string<char, std::char_traits<char>, STLAllocator<char,GeneralAllocPolicy > >
_StringBase;
336 typedef std::basic_stringstream<char,std::char_traits<char>,STLAllocator<char,GeneralAllocPolicy > >
_StringStreamBase;
338 #define StdStringT(T) std::basic_string<T, std::char_traits<T>, std::allocator<T> >
339 #define CustomMemoryStringT(T) std::basic_string<T, std::char_traits<T>, STLAllocator<T,GeneralAllocPolicy> >
342 bool operator <(
const CustomMemoryStringT(T)& l,
const StdStringT(T)& o)
344 return l.compare(0,l.length(),o.c_str(),o.length())<0;
347 bool operator <(
const StdStringT(T)& l,
const CustomMemoryStringT(T)& o)
349 return l.compare(0,l.length(),o.c_str(),o.length())<0;
352 bool operator <=(
const CustomMemoryStringT(T)& l,
const StdStringT(T)& o)
354 return l.compare(0,l.length(),o.c_str(),o.length())<=0;
357 bool operator <=(
const StdStringT(T)& l,
const CustomMemoryStringT(T)& o)
359 return l.compare(0,l.length(),o.c_str(),o.length())<=0;
362 bool operator >(
const CustomMemoryStringT(T)& l,
const StdStringT(T)& o)
364 return l.compare(0,l.length(),o.c_str(),o.length())>0;
367 bool operator >(
const StdStringT(T)& l,
const CustomMemoryStringT(T)& o)
369 return l.compare(0,l.length(),o.c_str(),o.length())>0;
372 bool operator >=(
const CustomMemoryStringT(T)& l,
const StdStringT(T)& o)
374 return l.compare(0,l.length(),o.c_str(),o.length())>=0;
377 bool operator >=(
const StdStringT(T)& l,
const CustomMemoryStringT(T)& o)
379 return l.compare(0,l.length(),o.c_str(),o.length())>=0;
383 bool operator ==(
const CustomMemoryStringT(T)& l,
const StdStringT(T)& o)
385 return l.compare(0,l.length(),o.c_str(),o.length())==0;
388 bool operator ==(
const StdStringT(T)& l,
const CustomMemoryStringT(T)& o)
390 return l.compare(0,l.length(),o.c_str(),o.length())==0;
394 bool operator !=(
const CustomMemoryStringT(T)& l,
const StdStringT(T)& o)
396 return l.compare(0,l.length(),o.c_str(),o.length())!=0;
399 bool operator !=(
const StdStringT(T)& l,
const CustomMemoryStringT(T)& o)
401 return l.compare(0,l.length(),o.c_str(),o.length())!=0;
405 CustomMemoryStringT(T) operator +=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
407 return CustomMemoryStringT(T)(l)+=o.c_str();
410 CustomMemoryStringT(T) operator +=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
412 return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
416 CustomMemoryStringT(T) operator +(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
418 return CustomMemoryStringT(T)(l)+=o.c_str();
422 CustomMemoryStringT(T) operator +(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
424 return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
428 CustomMemoryStringT(T) operator +(const T* l,const CustomMemoryStringT(T)& o)
430 return CustomMemoryStringT(T)(l)+=o;
434 #undef CustomMemoryStringT
438 typedef std::basic_stringstream<char,std::char_traits<char>,std::allocator<char> >
_StringStreamBase;
448 #if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
451 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
455 template <>
struct hash<Ogre::
String>
460 size_t _Val = 2166136261U;
462 size_t _Last = str.size();
463 size_t _Stride = 1 + _Last / 10;
465 for(; _First < _Last; _First += _Stride)
466 _Val = 16777619U * _Val ^ (
size_t)str[_First];
470 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
479 template <
typename T,
typename A = STLAllocator<T, GeneralAllocPolicy> >
482 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
483 typedef typename std::deque<T, A>
type;
484 typedef typename std::deque<T, A>::iterator
iterator;
487 typedef typename std::deque<T>
type;
488 typedef typename std::deque<T>::iterator
iterator;
493 template <
typename T,
typename A = STLAllocator<T, GeneralAllocPolicy> >
496 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
497 typedef typename std::vector<T, A>
type;
498 typedef typename std::vector<T, A>::iterator
iterator;
501 typedef typename std::vector<T>
type;
502 typedef typename std::vector<T>::iterator
iterator;
507 template <
typename T,
typename A = STLAllocator<T, GeneralAllocPolicy> >
510 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
511 typedef typename std::list<T, A>
type;
512 typedef typename std::list<T, A>::iterator
iterator;
515 typedef typename std::list<T>
type;
516 typedef typename std::list<T>::iterator
iterator;
521 template <
typename T,
typename P = std::less<T>,
typename A = STLAllocator<T, GeneralAllocPolicy> >
524 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
525 typedef typename std::set<T, P, A>
type;
526 typedef typename std::set<T, P, A>::iterator
iterator;
529 typedef typename std::set<T, P>
type;
530 typedef typename std::set<T, P>::iterator
iterator;
535 template <
typename K,
typename V,
typename P = std::less<K>,
typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
538 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
539 typedef typename std::map<K, V, P, A>
type;
540 typedef typename std::map<K, V, P, A>::iterator
iterator;
543 typedef typename std::map<K, V, P>
type;
544 typedef typename std::map<K, V, P>::iterator
iterator;
545 typedef typename std::map<K, V, P>::const_iterator
const_iterator;
549 template <
typename K,
typename V,
typename P = std::less<K>,
typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
552 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
553 typedef typename std::multimap<K, V, P, A>
type;
554 typedef typename std::multimap<K, V, P, A>::iterator
iterator;
557 typedef typename std::multimap<K, V, P>
type;
558 typedef typename std::multimap<K, V, P>::iterator
iterator;
559 typedef typename std::multimap<K, V, P>::const_iterator
const_iterator;
565 #endif // __OgrePrerequisites_H__
Chain of compositor effects applying to one viewport.
Representation of a ray in space, i.e.
Manages the target rendering window.
Class encapsulating a set of AnimationState objects.
std::vector< T, A >::iterator iterator
A 'canvas' which can receive the results of a rendering operation.
A viewpoint from which the scene will be rendered.
Specialised KeyFrame which stores absolute vertex positions for a complete buffer, designed to be interpolated with other keys in the same track.
Abstract class that defines a 'codec'.
SharedPtr< GpuProgram > GpuProgramPtr
Implementation of a general purpose request / response style background work queue.
Class defining particle system based special effects.
Class encapsulating a standard 4x4 homogeneous matrix.
std::list< T, A >::iterator iterator
float Real
Software floating point type.
Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses...
Abstract class defining the interface required to be implemented by classes which provide rendering c...
The root class of the Ogre system.
A key frame in an animation sequence defined by an AnimationTrack.
std::multimap< K, V, P, A > type
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
std::multimap< K, V, P, A >::iterator iterator
Pre-transforms and batches up meshes for efficient use as static geometry in a scene.
IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from...
Defines a plane in 3D space.
Singleton Class which handles the registering and control of texture plugins.
Generic class for serialising data to / from binary stream-based files.
Abstract interface which classes must implement if they wish to receive events from the scene manager...
A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same ti...
Structure for recording the use of temporary blend buffers.
Class providing a much simplified interface to generating manual objects with custom geometry...
Class for converting the core Ogre data types to/from Strings.
Injects the output of a request to the mesh in a thread safe way.
bool operator<(SharedPtr< T > const &a, SharedPtr< U > const &b)
Class for loading & managing textures.
This class represents a RenderTarget that renders to a Texture.
Interface for compositor logics, which can be automatically binded to compositors, allowing per-compositor logic (such as attaching a relevant listener) to happen automatically.
Collection of renderables by priority.
Class for serialising mesh data to/from an OGRE .mesh file.
Class representing colour.
Specialised AnimationTrack for dealing with generic animable values.
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
A class for performing queries on a scene.
Manages the organisation and rendering of a 'scene' i.e.
This is the same technique the old "InstancedGeometry" implementation used (with improvements).
std::basic_stringstream< char, std::char_traits< char >, std::allocator< char > > _StringStreamBase
Specialisation of HardwareBuffer for vertex index buffers, still abstract.
General utility class for building edge lists for geometry.
Defines a program which runs on the GPU such as a vertex or fragment program.
Specialised AnimationTrack for dealing with node transforms.
A pose is a linked set of vertex offsets applying to one set of vertex data.
std::map< K, V, P, A >::iterator iterator
Class encapsulates rendering properties of an object.
SharedPtr< Resource > ResourcePtr
Shared pointer to a Resource.
Defines the behaviour of an automatic renderer configuration dialog.
Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAn...
Specialises the SceneQuery class for querying within a sphere.
Simple implementation of MovableObject and Renderable for single-part custom objects.
Abstract class definition of a factory object for ParticleSystemRenderer.
A 3D box aligned with the x/y/z axes.
A 3x3 matrix which can represent rotations around axes.
Represents the state of an animation and the weight of its influence.
Interface describing a manual resource loader.
Class representing a Compositor object.
Class representing an approach to rendering this particular Material.
Class for managing RenderSystemCapabilities database for Ogre.
Strategy for determining level of detail.
This ResourceManager manages high-level vertex and fragment programs.
Object representing one pass or operation in a composition sequence.
Class to manage the available shadow textures which may be shared between many SceneManager instances...
Resource holding data about a dynamic library.
Class to provide access to common mathematical functions.
std::set< T, P, A >::iterator iterator
std::list< T, A >::const_iterator const_iterator
Abstract class defining a movable object in a scene.
Class representing a node in the scene graph.
Manager for Dynamic-loading Libraries.
std::multimap< K, V, P, A >::const_iterator const_iterator
_StringStreamBase StringStream
Interface definition for factories of HighLevelGpuProgram.
Class defining a single pass of a Technique (of a Material), i.e.
Abstract class defining the interface all renderable objects must implement.
The log manager handles the creation and retrieval of logs for the application.
std::deque< T, A >::const_iterator const_iterator
Implementation of a Quaternion, i.e.
A collection of billboards (faces which are always facing the given direction) with the same (default...
Allows the rendering of a chain of connected billboards.
This class represents a render target that renders to multiple RenderTextures at once.
This is a abstract class that that provides the interface for the query class for hardware occlusion...
Class to hold a linear sequence of RenderQueueInvocation objects.
Class for managing Material settings for Ogre.
Representation of a dynamic light source in the scene.
The profiler allows you to measure the performance of your code.
Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers.
Abstract class defining the interface used by classes which wish to perform script loading to define ...
An abstract class that contains a depth/stencil buffer.
Can either be used as an input or output value.
Alternative listener class for dealing with RaySceneQuery.
SharedPtr< Material > MaterialPtr
This class manages the available ArchiveFactory plugins.
Improved version of ProgressiveMesh.
Utility class which defines the sub-parts of an Entity.
Class representing a single particle instance.
Alternative listener class for dealing with IntersectionSceneQuery.
Class defining a generic OGRE plugin.
Instances of this class 'control' the value of another object in the system.
unsigned char uchar
In order to avoid finger-aches :)
Class which represents the renderable aspects of a set of shadow volume faces.
A sphere primitive, mostly used for bounds checking.
SharedPtr< Skeleton > SkeletonPtr
Defines an instance of a discrete, movable object based on a Mesh.
Internal implementation of Mesh reading / writing for the latest version of the .mesh format...
Abstract interface which classes must implement if they wish to receive events from the render queue...
std::vector< T, A >::const_iterator const_iterator
Standard 2-dimensional vector.
Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances...
Summary class collecting together index data source information.
A 'track' in an animation sequence, i.e.
SharedPtr< Compositor > CompositorPtr
Class representing the invocation of queue groups in a RenderQueue.
Specialised AnimationTrack for dealing with changing vertex position information. ...
This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit.
A tagged point on a skeleton, which can be used to attach entities to on specific other entities...
Wrapper class which indicates a given angle value is in Degrees.
A interface class defining a listener which can be used to receive notifications of frame events...
Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply...
Manages threaded compilation of scripts.
Utility class providing helper methods for reading / writing structured data held in a DataStream...
std::deque< T, A >::iterator iterator
A interface class defining a listener which can be used to receive notifications of RenderTarget even...
StringStream stringstream
Defines a part of a complete mesh.
Abstract class defining the interface to be implemented by particle emitters.
InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived ...
Handles the management of skeleton resources.
Shared pointer implementation used to share pixel buffers.
Standard 3-dimensional vector.
Manages particle systems, particle system scripts (templates) and the available emitter & affector fa...
Class representing an image file.
Base composition technique, can be subclassed in plugins.
Specialisation of HardwareBuffer for a pixel buffer.
std::map< K, V, P, A > type
Abstract class representing a loadable resource (e.g.
Represents a convex volume bounded by planes.
Abstract factory class, archive codec plugins can register concrete subclasses of this...
Class for displaying the error dialog if Ogre fails badly.
Abstract class defining the interface to be implemented by particle affectors.
Allows the rendering of a wireframe bounding box.
Summary class collecting together vertex source information.
An abstraction of a viewport, i.e.
'New' rendering operation using vertex buffers.
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
Subclasses of this class are responsible for performing a function on an input value for a Controller...
Class for managing Compositor settings for Ogre.
Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses...
Wrapper class which indicates a given angle value is in Radians.
An instance of a Compositor object for one Viewport.
This class is used to perform Resource operations in a background thread.
This file configures Ogre's memory allocators.
SharedPtr< Mesh > MeshPtr
This singleton class manages the list of resource groups, and notifying the various resource managers...
Class to manage the scene object rendering queue.
Specialises the SceneQuery class for querying within an axis aligned box.
Handles the management of mesh resources.
This class contains the information required to describe the edge connectivity of a given set of vert...
This is the main starting point for the new instancing system.
Defines a generic resource handler.
Specialisation of HardwareBuffer for a vertex buffer.
A very simple spline class which implements the Catmull-Rom class of splines.
A billboard is a primitive which always faces the camera in every frame.
Struct containing information about a frame event.
Reference-counted shared pointer, used for objects where implicit destruction is required.
singleton class for storing the capabilities of the graphics card.
Enumerates the SceneManager classes available to applications.
Class for serializing RenderSystemCapabilities to / from a .rendercaps script.
This is the main class for the compiler.
Patch specialisation of Mesh.
Interface for custom composition passes, allowing custom operations (in addition to the quad...
std::map< K, V, P, A >::const_iterator const_iterator
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another...
4-dimensional homogeneous vector.
SharedPtr< HighLevelGpuProgram > HighLevelGpuProgramPtr
Abstract base class representing a high-level program (a vertex or fragment program).
This class defines the interface that must be implemented by shadow casters.
Resource holding data about 3D mesh.
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
std::set< T, P, A >::const_iterator const_iterator
Specialised KeyFrame which stores any numeric value.
SharedPtr< Texture > TexturePtr
Interface to a general purpose request / response style background work queue.
Abstract class containing any additional data required to be associated with a particle to perform th...
Defines the functionality of a 3D API.
A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory.
Abstract class representing a Texture resource.
Class representing the state of a single texture unit during a Pass of a Technique, of a Material.
Specialises the SceneQuery class for querying along a ray.
Class representing a general-purpose node an articulated scene graph.
A collection of Bone objects used to animate a skinned mesh.
An individual profile that will be processed by the Profiler.
A SkeletonInstance is a single instance of a Skeleton used by a world object.
This is technique requires true instancing hardware support.
Class that provides convenient interface to establish a linkage between custom user application objec...
bool operator==(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator, (ISO C++)
This utility class is used to hold the information used to generate the matrices and other informatio...
bool operator!=(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator, (ISO C++)
SharedPtr< PatchMesh > PatchMeshPtr
Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework...
Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instan...
Class for managing Controller instances.