OgrePrerequisites.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2 This source file is a part of OGRE
3 (Object-oriented Graphics Rendering Engine)
4 
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 Permission is hereby granted, free of charge, to any person obtaining a copy
9 of this software and associated documentation files (the "Software"), to deal
10 in the Software without restriction, including without limitation the rights
11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 copies of the Software, and to permit persons to whom the Software is
13 furnished to do so, subject to the following conditions:
14 
15 The above copyright notice and this permission notice shall be included in
16 all copies or substantial portions of the Software.
17 
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 THE SOFTWARE
25 -------------------------------------------------------------------------*/
26 #ifndef __OgrePrerequisites_H__
27 #define __OgrePrerequisites_H__
28 
29 // Platform-specific stuff
30 #include "OgrePlatform.h"
31 
32 #include <string>
33 
34 // configure memory tracking
35 #if OGRE_DEBUG_MODE
36 # if OGRE_MEMORY_TRACKER_DEBUG_MODE
37 # define OGRE_MEMORY_TRACKER 1
38 # else
39 # define OGRE_MEMORY_TRACKER 0
40 # endif
41 #else
42 # if OGRE_MEMORY_TRACKER_RELEASE_MODE
43 # define OGRE_MEMORY_TRACKER 1
44 # else
45 # define OGRE_MEMORY_TRACKER 0
46 # endif
47 #endif
48 
49 namespace Ogre {
50  // Define ogre version
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"
56 
57  #define OGRE_VERSION ((OGRE_VERSION_MAJOR << 16) | (OGRE_VERSION_MINOR << 8) | OGRE_VERSION_PATCH)
58 
59  // define the real number values to be used
60  // default to use 'float' unless precompiler option set
61  #if OGRE_DOUBLE_PRECISION == 1
62 
65  typedef double Real;
66  #else
67 
70  typedef float Real;
71  #endif
72 
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
77  # else
78  # define HashMap ::__gnu_cxx::hash_map
79  # define HashSet ::__gnu_cxx::hash_set
80  # endif
81  #elif OGRE_COMPILER == OGRE_COMPILER_CLANG
82  # if defined(_LIBCPP_VERSION)
83  # define HashMap ::std::unordered_map
84  # define HashSet ::std::unordered_set
85  # else
86  # define HashMap ::std::tr1::unordered_map
87  # define HashSet ::std::tr1::unordered_set
88  # endif
89  #else
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
97  # else
98  # define HashMap ::std::unordered_map
99  # define HashSet ::std::unordered_set
100  # endif
101  # else
102  # define HashMap ::std::unordered_map
103  # define HashSet ::std::unordered_set
104  # endif
105  #endif
106 
107  #define OGRE_DEFINE_STATIC_LOCAL(type, name, arguments) \
108  static type& name = *new type arguments
109 
112  typedef unsigned char uchar;
113  typedef unsigned short ushort;
114  typedef unsigned int uint;
115  typedef unsigned long ulong;
116 
117 // Pre-declare classes
118 // Allows use of pointers in header files without including individual .h
119 // so decreases dependencies between files
120  class Angle;
121  class Animation;
122  class AnimationState;
123  class AnimationStateSet;
124  class AnimationTrack;
125  class Archive;
126  class ArchiveFactory;
127  class ArchiveManager;
128  class AutoParamDataSource;
129  class AxisAlignedBox;
131  class Billboard;
132  class BillboardChain;
133  class BillboardSet;
134  class Bone;
135  class Camera;
136  class Codec;
137  class ColourValue;
138  class ConfigDialog;
139  template <typename T> class Controller;
140  template <typename T> class ControllerFunction;
141  class ControllerManager;
142  template <typename T> class ControllerValue;
143  class DefaultWorkQueue;
144  class Degree;
145  class DepthBuffer;
146  class DynLib;
147  class DynLibManager;
148  class EdgeData;
149  class EdgeListBuilder;
150  class Entity;
151  class ErrorDialog;
153  class Factory;
154  struct FrameEvent;
155  class FrameListener;
156  class Frustum;
157  class GpuProgram;
158  class GpuProgramManager;
159  class GpuProgramUsage;
160  class HardwareIndexBuffer;
162  class HardwareVertexBuffer;
163  class HardwarePixelBuffer;
165  class HighLevelGpuProgram;
168  class IndexData;
169  class InstanceBatch;
170  class InstanceBatchHW;
171  class InstanceBatchHW_VTF;
172  class InstanceBatchShader;
173  class InstanceBatchVTF;
174  class InstanceManager;
175  class InstancedEntity;
178  class Image;
179  class KeyFrame;
180  class Light;
181  class Log;
182  class LogManager;
183  class LodStrategy;
184  class ManualResourceLoader;
185  class ManualObject;
186  class Material;
187  class MaterialManager;
188  class Math;
189  class Matrix3;
190  class Matrix4;
191  class MemoryManager;
192  class Mesh;
193  class MeshSerializer;
194  class MeshSerializerImpl;
195  class MeshManager;
196  class MovableObject;
197  class MovablePlane;
198  class Node;
199  class NodeAnimationTrack;
200  class NodeKeyFrame;
201  class NumericAnimationTrack;
202  class NumericKeyFrame;
203  class Particle;
204  class ParticleAffector;
206  class ParticleEmitter;
208  class ParticleSystem;
209  class ParticleSystemManager;
212  class ParticleVisualData;
213  class Pass;
214  class PatchMesh;
215  class PixelBox;
216  class Plane;
217  class PlaneBoundedVolume;
218  class Plugin;
219  class PMWorker;
220  class PMInjector;
221  class Pose;
223  class Profile;
224  class Profiler;
225  class Quaternion;
226  class Radian;
227  class Ray;
228  class RaySceneQuery;
229  class RaySceneQueryListener;
230  class Renderable;
231  class RenderPriorityGroup;
232  class RenderQueue;
233  class RenderQueueGroup;
234  class RenderQueueInvocation;
236  class RenderQueueListener;
237  class RenderObjectListener;
238  class RenderSystem;
242  class RenderTarget;
243  class RenderTargetListener;
244  class RenderTexture;
245  class MultiRenderTarget;
246  class RenderWindow;
247  class RenderOperation;
248  class Resource;
250  class ResourceGroupManager;
251  class ResourceManager;
252  class RibbonTrail;
253  class Root;
254  class SceneManager;
256  class SceneNode;
257  class SceneQuery;
258  class SceneQueryListener;
259  class ScriptCompiler;
260  class ScriptCompilerManager;
261  class ScriptLoader;
262  class Serializer;
263  class ShadowCaster;
264  class ShadowRenderable;
265  class ShadowTextureManager;
266  class SimpleRenderable;
267  class SimpleSpline;
268  class Skeleton;
269  class SkeletonInstance;
270  class SkeletonManager;
271  class Sphere;
272  class SphereSceneQuery;
273  class StaticGeometry;
274  class StreamSerialiser;
275  class StringConverter;
276  class StringInterface;
277  class SubEntity;
278  class SubMesh;
279  class TagPoint;
280  class Technique;
281  class TempBlendedBufferInfo;
282  class ExternalTextureSource;
283  class TextureUnitState;
284  class Texture;
285  class TextureManager;
286  class TransformKeyFrame;
287  class Timer;
288  class UserObjectBindings;
289  class Vector2;
290  class Vector3;
291  class Vector4;
292  class Viewport;
293  class VertexAnimationTrack;
294  class VertexBufferBinding;
295  class VertexData;
296  class VertexDeclaration;
297  class VertexMorphKeyFrame;
298  class WireBoundingBox;
299  class WorkQueue;
300  class Compositor;
301  class CompositorManager;
302  class CompositorChain;
303  class CompositorInstance;
304  class CompositorLogic;
305  class CompositionTechnique;
306  class CompositionPass;
307  class CompositionTargetPass;
308  class CustomCompositionPass;
309 
310  template<typename T> class SharedPtr;
320 }
321 
322 /* Include all the standard header *after* all the configuration
323 settings have been made.
324 */
325 #include "OgreStdHeaders.h"
327 
328 
329 namespace Ogre
330 {
331 #if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
332  typedef std::basic_string<char, std::char_traits<char>, STLAllocator<char,GeneralAllocPolicy > > _StringBase;
333  typedef std::basic_stringstream<char,std::char_traits<char>,STLAllocator<char,GeneralAllocPolicy > > _StringStreamBase;
334 
335  #define StdStringT(T) std::basic_string<T, std::char_traits<T>, std::allocator<T> >
336  #define CustomMemoryStringT(T) std::basic_string<T, std::char_traits<T>, STLAllocator<T,GeneralAllocPolicy> >
337 
338  template<typename T>
339  bool operator <(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
340  {
341  return l.compare(0,l.length(),o.c_str(),o.length())<0;
342  }
343  template<typename T>
344  bool operator <(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
345  {
346  return l.compare(0,l.length(),o.c_str(),o.length())<0;
347  }
348  template<typename T>
349  bool operator <=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
350  {
351  return l.compare(0,l.length(),o.c_str(),o.length())<=0;
352  }
353  template<typename T>
354  bool operator <=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
355  {
356  return l.compare(0,l.length(),o.c_str(),o.length())<=0;
357  }
358  template<typename T>
359  bool operator >(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
360  {
361  return l.compare(0,l.length(),o.c_str(),o.length())>0;
362  }
363  template<typename T>
364  bool operator >(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
365  {
366  return l.compare(0,l.length(),o.c_str(),o.length())>0;
367  }
368  template<typename T>
369  bool operator >=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
370  {
371  return l.compare(0,l.length(),o.c_str(),o.length())>=0;
372  }
373  template<typename T>
374  bool operator >=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
375  {
376  return l.compare(0,l.length(),o.c_str(),o.length())>=0;
377  }
378 
379  template<typename T>
380  bool operator ==(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
381  {
382  return l.compare(0,l.length(),o.c_str(),o.length())==0;
383  }
384  template<typename T>
385  bool operator ==(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
386  {
387  return l.compare(0,l.length(),o.c_str(),o.length())==0;
388  }
389 
390  template<typename T>
391  bool operator !=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
392  {
393  return l.compare(0,l.length(),o.c_str(),o.length())!=0;
394  }
395  template<typename T>
396  bool operator !=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
397  {
398  return l.compare(0,l.length(),o.c_str(),o.length())!=0;
399  }
400 
401  template<typename T>
402  CustomMemoryStringT(T) operator +=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
403  {
404  return CustomMemoryStringT(T)(l)+=o.c_str();
405  }
406  template<typename T>
407  CustomMemoryStringT(T) operator +=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
408  {
409  return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
410  }
411 
412  template<typename T>
413  CustomMemoryStringT(T) operator +(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
414  {
415  return CustomMemoryStringT(T)(l)+=o.c_str();
416  }
417 
418  template<typename T>
419  CustomMemoryStringT(T) operator +(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
420  {
421  return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
422  }
423 
424  template<typename T>
425  CustomMemoryStringT(T) operator +(const T* l,const CustomMemoryStringT(T)& o)
426  {
427  return CustomMemoryStringT(T)(l)+=o;
428  }
429 
430  #undef StdStringT
431  #undef CustomMemoryStringT
432 
433 #else
434  typedef std::string _StringBase;
435  typedef std::basic_stringstream<char,std::char_traits<char>,std::allocator<char> > _StringStreamBase;
436 
437 #endif
438 
442 
443 }
444 
445 #if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
446 namespace std
447 {
448 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
449  namespace tr1
450  {
451 #endif
452  template <> struct hash<Ogre::String>
453  {
454  public :
455  size_t operator()(const Ogre::String &str ) const
456  {
457  size_t _Val = 2166136261U;
458  size_t _First = 0;
459  size_t _Last = str.size();
460  size_t _Stride = 1 + _Last / 10;
461 
462  for(; _First < _Last; _First += _Stride)
463  _Val = 16777619U * _Val ^ (size_t)str[_First];
464  return (_Val);
465  }
466  };
467 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
468  }
469 #endif
470 }
471 #endif
472 
473 //for stl container
474 namespace Ogre
475 {
476  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
477  struct deque
478  {
479 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
480  typedef typename std::deque<T, A> type;
481  typedef typename std::deque<T, A>::iterator iterator;
482  typedef typename std::deque<T, A>::const_iterator const_iterator;
483 #else
484  typedef typename std::deque<T> type;
485  typedef typename std::deque<T>::iterator iterator;
486  typedef typename std::deque<T>::const_iterator const_iterator;
487 #endif
488  };
489 
490  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
491  struct vector
492  {
493 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
494  typedef typename std::vector<T, A> type;
495  typedef typename std::vector<T, A>::iterator iterator;
496  typedef typename std::vector<T, A>::const_iterator const_iterator;
497 #else
498  typedef typename std::vector<T> type;
499  typedef typename std::vector<T>::iterator iterator;
500  typedef typename std::vector<T>::const_iterator const_iterator;
501 #endif
502  };
503 
504  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
505  struct list
506  {
507 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
508  typedef typename std::list<T, A> type;
509  typedef typename std::list<T, A>::iterator iterator;
510  typedef typename std::list<T, A>::const_iterator const_iterator;
511 #else
512  typedef typename std::list<T> type;
513  typedef typename std::list<T>::iterator iterator;
514  typedef typename std::list<T>::const_iterator const_iterator;
515 #endif
516  };
517 
518  template <typename T, typename P = std::less<T>, typename A = STLAllocator<T, GeneralAllocPolicy> >
519  struct set
520  {
521 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
522  typedef typename std::set<T, P, A> type;
523  typedef typename std::set<T, P, A>::iterator iterator;
524  typedef typename std::set<T, P, A>::const_iterator const_iterator;
525 #else
526  typedef typename std::set<T, P> type;
527  typedef typename std::set<T, P>::iterator iterator;
528  typedef typename std::set<T, P>::const_iterator const_iterator;
529 #endif
530  };
531 
532  template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
533  struct map
534  {
535 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
536  typedef typename std::map<K, V, P, A> type;
537  typedef typename std::map<K, V, P, A>::iterator iterator;
538  typedef typename std::map<K, V, P, A>::const_iterator const_iterator;
539 #else
540  typedef typename std::map<K, V, P> type;
541  typedef typename std::map<K, V, P>::iterator iterator;
542  typedef typename std::map<K, V, P>::const_iterator const_iterator;
543 #endif
544  };
545 
546  template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
547  struct multimap
548  {
549 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
550  typedef typename std::multimap<K, V, P, A> type;
551  typedef typename std::multimap<K, V, P, A>::iterator iterator;
552  typedef typename std::multimap<K, V, P, A>::const_iterator const_iterator;
553 #else
554  typedef typename std::multimap<K, V, P> type;
555  typedef typename std::multimap<K, V, P>::iterator iterator;
556  typedef typename std::multimap<K, V, P>::const_iterator const_iterator;
557 #endif
558  };
559 
560 } // Ogre
561 
562 #endif // __OgrePrerequisites_H__
563 
564 
Class which represents the renderable aspects of a set of shadow volume faces.
A 'track' in an animation sequence, i.e.
A 'canvas' which can receive the results of a rendering operation.
Patch specialisation of Mesh.
Definition: OgrePatchMesh.h:47
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another...
Utility class which defines the sub-parts of an Entity.
Definition: OgreSubEntity.h:63
std::set< T, P, A >::const_iterator const_iterator
Class for loading & managing textures.
Abstract class that defines a 'codec'.
Definition: OgreCodec.h:56
Abstract class defining the interface all renderable objects must implement.
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:80
Class to provide access to common mathematical functions.
Definition: OgreMath.h:191
Generic class for serialising data to / from binary stream-based files.
Class for managing RenderSystemCapabilities database for Ogre.
Abstract class defining the interface used by classes which wish to perform script loading to define ...
Specialisation of HardwareBuffer for a pixel buffer.
Abstract class defining a movable object in a scene.
unsigned int uint
Strategy for determining level of detail.
std::list< T, A >::iterator iterator
Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instan...
std::set< T, P, A > type
Specialises the SceneQuery class for querying within an axis aligned box.
Singleton Class which handles the registering and control of texture plugins.
std::vector< T, A > type
A very simple spline class which implements the Catmull-Rom class of splines.
Interface to a general purpose request / response style background work queue.
Definition: OgreWorkQueue.h:70
Summary class collecting together vertex source information.
Class representing the invocation of queue groups in a RenderQueue.
Represents a convex volume bounded by planes.
Implementation of a Quaternion, i.e.
SharedPtr< Resource > ResourcePtr
Shared pointer to a Resource.
Injects the output of a request to the mesh in a thread safe way.
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:51
Interface for compositor logics, which can be automatically binded to compositors, allowing per-compositor logic (such as attaching a relevant listener) to happen automatically.
An instance of a Compositor object for one Viewport.
A 3x3 matrix which can represent rotations around axes.
Definition: OgreMatrix3.h:68
4-dimensional homogeneous vector.
Definition: OgreVector4.h:45
Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework...
Handles the management of skeleton resources.
SharedPtr< Mesh > MeshPtr
Standard 2-dimensional vector.
Definition: OgreVector2.h:51
Subclasses of this class are responsible for performing a function on an input value for a Controller...
Class representing colour.
float Real
Software floating point type.
Alternative listener class for dealing with IntersectionSceneQuery.
Class to manage the scene object rendering queue.
Summary class collecting together index data source information.
SharedPtr< GpuProgram > GpuProgramPtr
Specialisation of HardwareBuffer for a vertex buffer.
Structure for recording the use of temporary blend buffers.
Object representing one pass or operation in a composition sequence.
unsigned char uchar
In order to avoid finger-aches :)
Specialised KeyFrame which stores a full transform.
Definition: OgreKeyFrame.h:103
Resource holding data about a dynamic library.
Definition: OgreDynLib.h:84
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:79
A collection of Bone objects used to animate a skinned mesh.
Definition: OgreSkeleton.h:87
Class for displaying the error dialog if Ogre fails badly.
Abstract base class representing a high-level program (a vertex or fragment program).
Class representing a node in the scene graph.
Definition: OgreSceneNode.h:58
Specialisation of HardwareBuffer for vertex index buffers, still abstract.
Interface describing a manual resource loader.
Definition: OgreResource.h:514
Abstract class representing a Texture resource.
Definition: OgreTexture.h:102
Abstract class defining the interface to be implemented by particle affectors.
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:57
An individual profile that will be processed by the Profiler.
Definition: OgreProfiler.h:104
Class providing a much simplified interface to generating manual objects with custom geometry...
Specialised AnimationTrack for dealing with generic animable values.
This class contains the information required to describe the edge connectivity of a given set of vert...
Can either be used as an input or output value.
Timer class.
Class for managing Material settings for Ogre.
Defines a plane in 3D space.
Definition: OgrePlane.h:61
Defines a part of a complete mesh.
Definition: OgreSubMesh.h:62
Specialises the SceneQuery class for querying within a sphere.
Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances...
Class for serialising mesh data to/from an OGRE .mesh file.
Class encapsulating a set of AnimationState objects.
SharedPtr< Material > MaterialPtr
Improved version of ProgressiveMesh.
Instances of this class 'control' the value of another object in the system.
Base composition technique, can be subclassed in plugins.
std::deque< T, A >::iterator iterator
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
Class to hold a linear sequence of RenderQueueInvocation objects.
std::set< T, P, A >::iterator iterator
std::basic_stringstream< char, std::char_traits< char >, std::allocator< char > > _StringStreamBase
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
Class representing a Compositor object.
The profiler allows you to measure the performance of your code.
Definition: OgreProfiler.h:280
Class for managing Compositor settings for Ogre.
Class representing the state of a single texture unit during a Pass of a Technique, of a Material.
Abstract class definition of a factory object for ParticleSystemRenderer.
std::map< K, V, P, A > type
A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same ti...
Class for managing Controller instances.
A SkeletonInstance is a single instance of a Skeleton used by a world object.
Abstract class defining the interface required to be implemented by classes which provide rendering c...
std::string _StringBase
A bone in a skeleton.
Definition: OgreBone.h:51
Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses...
Class representing a general-purpose node an articulated scene graph.
Definition: OgreNode.h:64
StringStream stringstream
std::multimap< K, V, P, A >::const_iterator const_iterator
An animation sequence.
Definition: OgreAnimation.h:92
Defines the functionality of a 3D API.
Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAn...
Definition: OgreMath.h:150
bool operator!=(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator, (ISO C++)
Collection of renderables by priority.
Struct containing information about a frame event.
This class represents a RenderTarget that renders to a Texture.
Enumerates the SceneManager classes available to applications.
A key frame in an animation sequence defined by an AnimationTrack.
Definition: OgreKeyFrame.h:56
Specialises the SceneQuery class for querying along a ray.
_StringStreamBase StringStream
Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers.
SharedPtr< Compositor > CompositorPtr
Resource holding data about 3D mesh.
Definition: OgreMesh.h:93
This class defines the interface that must be implemented by shadow casters.
Abstract interface which classes must implement if they wish to receive events from the scene manager...
_StringBase String
Class for serializing RenderSystemCapabilities to / from a .rendercaps script.
Class defining a generic OGRE plugin.
Definition: OgrePlugin.h:79
Class for converting the core Ogre data types to/from Strings.
This class is used to perform Resource operations in a background thread.
An abstract class that contains a depth/stencil buffer.
Shared pointer implementation used to share pixel buffers.
This is the main starting point for the new instancing system.
Defines the behaviour of an automatic renderer configuration dialog.
Manager for Dynamic-loading Libraries.
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
Abstract class containing any additional data required to be associated with a particle to perform th...
Definition: OgreParticle.h:52
Class to manage the available shadow textures which may be shared between many SceneManager instances...
Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses...
Utility class providing helper methods for reading / writing structured data held in a DataStream...
singleton class for storing the capabilities of the graphics card.
Manages threaded compilation of scripts.
Allows the rendering of a wireframe bounding box.
Abstract factory class, archive codec plugins can register concrete subclasses of this...
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86
Chain of compositor effects applying to one viewport.
A class for performing queries on a scene.
std::vector< T, A >::iterator iterator
Handles the management of mesh resources.
std::multimap< K, V, P, A > type
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
This class manages the available ArchiveFactory plugins.
Defines a generic resource handler.
Class representing a single particle instance.
Definition: OgreParticle.h:61
Class representing an image file.
Definition: OgreImage.h:61
Abstract interface which classes must implement if they wish to receive events from the render queue...
InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived ...
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
Interface for custom composition passes, allowing custom operations (in addition to the quad...
This ResourceManager manages high-level vertex and fragment programs.
Defines a program which runs on the GPU such as a vertex or fragment program.
The log manager handles the creation and retrieval of logs for the application.
A tagged point on a skeleton, which can be used to attach entities to on specific other entities...
Definition: OgreTagPoint.h:60
Class encapsulates rendering properties of an object.
Definition: OgreMaterial.h:88
std::map< K, V, P, A >::iterator iterator
Internal implementation of Mesh reading / writing for the latest version of the .mesh format...
std::multimap< K, V, P, A >::iterator iterator
Manages the target rendering window.
Abstract class defining the interface to be implemented by particle emitters.
This singleton class manages the list of resource groups, and notifying the various resource managers...
This is a abstract class that that provides the interface for the query class for hardware occlusion...
A interface class defining a listener which can be used to receive notifications of RenderTarget even...
Pre-transforms and batches up meshes for efficient use as static geometry in a scene.
Reference-counted shared pointer, used for objects where implicit destruction is required.
std::deque< T, A >::const_iterator const_iterator
unsigned long ulong
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++)
std::list< T, A >::const_iterator const_iterator
'New' rendering operation using vertex buffers.
Class representing an approach to rendering this particular Material.
Definition: OgreTechnique.h:53
Defines an instance of a discrete, movable object based on a Mesh.
Definition: OgreEntity.h:82
Archive-handling class.
Definition: OgreArchive.h:88
A collection of billboards (faces which are always facing the given direction) with the same (default...
Wrapper class which indicates a given angle value is in Degrees.
Definition: OgreMath.h:98
Interface definition for factories of HighLevelGpuProgram.
Class defining particle system based special effects.
A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory.
Represents the state of an animation and the weight of its influence.
Alternative listener class for dealing with RaySceneQuery.
unsigned short ushort
SharedPtr< Skeleton > SkeletonPtr
This utility class is used to hold the information used to generate the matrices and other informatio...
IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from...
This is the same technique the old "InstancedGeometry" implementation used (with improvements).
std::list< T, A > type
This class makes the usage of a vertex and fragment programs (low-level or high-level), with a given set of parameters, explicit.
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:85
This class represents a render target that renders to multiple RenderTextures at once.
Specialised AnimationTrack for dealing with changing vertex position information. ...
std::map< K, V, P, A >::const_iterator const_iterator
A 3D box aligned with the x/y/z axes.
Manages the organisation and rendering of a 'scene' i.e.
Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply...
This file configures Ogre's memory allocators.
A billboard is a primitive which always faces the camera in every frame.
Definition: OgreBillboard.h:67
Manages particle systems, particle system scripts (templates) and the available emitter & affector fa...
std::deque< T, A > type
The root class of the Ogre system.
Definition: OgreRoot.h:71
SharedPtr< PatchMesh > PatchMeshPtr
Simple implementation of MovableObject and Renderable for single-part custom objects.
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:73
Allows the rendering of a chain of connected billboards.
A interface class defining a listener which can be used to receive notifications of frame events...
This is the main class for the compiler.
General utility class for building edge lists for geometry.
Specialised AnimationTrack for dealing with node transforms.
Representation of a ray in space, i.e.
Definition: OgreRay.h:46
This is technique requires true instancing hardware support.
Specialised KeyFrame which stores any numeric value.
Definition: OgreKeyFrame.h:80
bool operator<(SharedPtr< T > const &a, SharedPtr< U > const &b)
SharedPtr< Texture > TexturePtr
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:55
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:47
Implementation of a general purpose request / response style background work queue.
SharedPtr< HighLevelGpuProgram > HighLevelGpuProgramPtr
std::vector< T, A >::const_iterator const_iterator

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Mon Jun 30 2014 22:23:11