OGRE  1.9.0
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-2014 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  #if __cplusplus >= 201103L
118  #define register
119  #endif
120 // Pre-declare classes
121 // Allows use of pointers in header files without including individual .h
122 // so decreases dependencies between files
123  class Angle;
124  class Animation;
125  class AnimationState;
126  class AnimationStateSet;
127  class AnimationTrack;
128  class Archive;
129  class ArchiveFactory;
130  class ArchiveManager;
131  class AutoParamDataSource;
132  class AxisAlignedBox;
134  class Billboard;
135  class BillboardChain;
136  class BillboardSet;
137  class Bone;
138  class Camera;
139  class Codec;
140  class ColourValue;
141  class ConfigDialog;
142  template <typename T> class Controller;
143  template <typename T> class ControllerFunction;
144  class ControllerManager;
145  template <typename T> class ControllerValue;
146  class DefaultWorkQueue;
147  class Degree;
148  class DepthBuffer;
149  class DynLib;
150  class DynLibManager;
151  class EdgeData;
152  class EdgeListBuilder;
153  class Entity;
154  class ErrorDialog;
156  class Factory;
157  struct FrameEvent;
158  class FrameListener;
159  class Frustum;
160  class GpuProgram;
161  class GpuProgramManager;
162  class GpuProgramUsage;
163  class HardwareIndexBuffer;
165  class HardwareVertexBuffer;
166  class HardwarePixelBuffer;
168  class HighLevelGpuProgram;
171  class IndexData;
172  class InstanceBatch;
173  class InstanceBatchHW;
174  class InstanceBatchHW_VTF;
175  class InstanceBatchShader;
176  class InstanceBatchVTF;
177  class InstanceManager;
178  class InstancedEntity;
181  class Image;
182  class KeyFrame;
183  class Light;
184  class Log;
185  class LogManager;
186  class LodStrategy;
187  class ManualResourceLoader;
188  class ManualObject;
189  class Material;
190  class MaterialManager;
191  class Math;
192  class Matrix3;
193  class Matrix4;
194  class MemoryManager;
195  class Mesh;
196  class MeshSerializer;
197  class MeshSerializerImpl;
198  class MeshManager;
199  class MovableObject;
200  class MovablePlane;
201  class Node;
202  class NodeAnimationTrack;
203  class NodeKeyFrame;
204  class NumericAnimationTrack;
205  class NumericKeyFrame;
206  class Particle;
207  class ParticleAffector;
209  class ParticleEmitter;
211  class ParticleSystem;
212  class ParticleSystemManager;
215  class ParticleVisualData;
216  class Pass;
217  class PatchMesh;
218  class PixelBox;
219  class Plane;
220  class PlaneBoundedVolume;
221  class Plugin;
222  class PMWorker;
223  class PMInjector;
224  class Pose;
226  class Profile;
227  class Profiler;
228  class Quaternion;
229  class Radian;
230  class Ray;
231  class RaySceneQuery;
232  class RaySceneQueryListener;
233  class Renderable;
234  class RenderPriorityGroup;
235  class RenderQueue;
236  class RenderQueueGroup;
237  class RenderQueueInvocation;
239  class RenderQueueListener;
240  class RenderObjectListener;
241  class RenderSystem;
245  class RenderTarget;
246  class RenderTargetListener;
247  class RenderTexture;
248  class MultiRenderTarget;
249  class RenderWindow;
250  class RenderOperation;
251  class Resource;
253  class ResourceGroupManager;
254  class ResourceManager;
255  class RibbonTrail;
256  class Root;
257  class SceneManager;
259  class SceneNode;
260  class SceneQuery;
261  class SceneQueryListener;
262  class ScriptCompiler;
263  class ScriptCompilerManager;
264  class ScriptLoader;
265  class Serializer;
266  class ShadowCaster;
267  class ShadowRenderable;
268  class ShadowTextureManager;
269  class SimpleRenderable;
270  class SimpleSpline;
271  class Skeleton;
272  class SkeletonInstance;
273  class SkeletonManager;
274  class Sphere;
275  class SphereSceneQuery;
276  class StaticGeometry;
277  class StreamSerialiser;
278  class StringConverter;
279  class StringInterface;
280  class SubEntity;
281  class SubMesh;
282  class TagPoint;
283  class Technique;
284  class TempBlendedBufferInfo;
285  class ExternalTextureSource;
286  class TextureUnitState;
287  class Texture;
288  class TextureManager;
289  class TransformKeyFrame;
290  class Timer;
291  class UserObjectBindings;
292  class Vector2;
293  class Vector3;
294  class Vector4;
295  class Viewport;
296  class VertexAnimationTrack;
297  class VertexBufferBinding;
298  class VertexData;
299  class VertexDeclaration;
300  class VertexMorphKeyFrame;
301  class WireBoundingBox;
302  class WorkQueue;
303  class Compositor;
304  class CompositorManager;
305  class CompositorChain;
306  class CompositorInstance;
307  class CompositorLogic;
308  class CompositionTechnique;
309  class CompositionPass;
310  class CompositionTargetPass;
311  class CustomCompositionPass;
312 
313  template<typename T> class SharedPtr;
323 }
324 
325 /* Include all the standard header *after* all the configuration
326 settings have been made.
327 */
328 #include "OgreStdHeaders.h"
330 
331 
332 namespace Ogre
333 {
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;
337 
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> >
340 
341  template<typename T>
342  bool operator <(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
343  {
344  return l.compare(0,l.length(),o.c_str(),o.length())<0;
345  }
346  template<typename T>
347  bool operator <(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
348  {
349  return l.compare(0,l.length(),o.c_str(),o.length())<0;
350  }
351  template<typename T>
352  bool operator <=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
353  {
354  return l.compare(0,l.length(),o.c_str(),o.length())<=0;
355  }
356  template<typename T>
357  bool operator <=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
358  {
359  return l.compare(0,l.length(),o.c_str(),o.length())<=0;
360  }
361  template<typename T>
362  bool operator >(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
363  {
364  return l.compare(0,l.length(),o.c_str(),o.length())>0;
365  }
366  template<typename T>
367  bool operator >(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
368  {
369  return l.compare(0,l.length(),o.c_str(),o.length())>0;
370  }
371  template<typename T>
372  bool operator >=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
373  {
374  return l.compare(0,l.length(),o.c_str(),o.length())>=0;
375  }
376  template<typename T>
377  bool operator >=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
378  {
379  return l.compare(0,l.length(),o.c_str(),o.length())>=0;
380  }
381 
382  template<typename T>
383  bool operator ==(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
384  {
385  return l.compare(0,l.length(),o.c_str(),o.length())==0;
386  }
387  template<typename T>
388  bool operator ==(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
389  {
390  return l.compare(0,l.length(),o.c_str(),o.length())==0;
391  }
392 
393  template<typename T>
394  bool operator !=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
395  {
396  return l.compare(0,l.length(),o.c_str(),o.length())!=0;
397  }
398  template<typename T>
399  bool operator !=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
400  {
401  return l.compare(0,l.length(),o.c_str(),o.length())!=0;
402  }
403 
404  template<typename T>
405  CustomMemoryStringT(T) operator +=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
406  {
407  return CustomMemoryStringT(T)(l)+=o.c_str();
408  }
409  template<typename T>
410  CustomMemoryStringT(T) operator +=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
411  {
412  return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
413  }
414 
415  template<typename T>
416  CustomMemoryStringT(T) operator +(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
417  {
418  return CustomMemoryStringT(T)(l)+=o.c_str();
419  }
420 
421  template<typename T>
422  CustomMemoryStringT(T) operator +(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
423  {
424  return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
425  }
426 
427  template<typename T>
428  CustomMemoryStringT(T) operator +(const T* l,const CustomMemoryStringT(T)& o)
429  {
430  return CustomMemoryStringT(T)(l)+=o;
431  }
432 
433  #undef StdStringT
434  #undef CustomMemoryStringT
435 
436 #else
437  typedef std::string _StringBase;
438  typedef std::basic_stringstream<char,std::char_traits<char>,std::allocator<char> > _StringStreamBase;
439 
440 #endif
441 
445 
446 }
447 
448 #if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
449 namespace std
450 {
451 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
452  namespace tr1
453  {
454 #endif
455  template <> struct hash<Ogre::String>
456  {
457  public :
458  size_t operator()(const Ogre::String &str ) const
459  {
460  size_t _Val = 2166136261U;
461  size_t _First = 0;
462  size_t _Last = str.size();
463  size_t _Stride = 1 + _Last / 10;
464 
465  for(; _First < _Last; _First += _Stride)
466  _Val = 16777619U * _Val ^ (size_t)str[_First];
467  return (_Val);
468  }
469  };
470 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
471  }
472 #endif
473 }
474 #endif
475 
476 //for stl container
477 namespace Ogre
478 {
479  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
480  struct deque
481  {
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;
485  typedef typename std::deque<T, A>::const_iterator const_iterator;
486 #else
487  typedef typename std::deque<T> type;
488  typedef typename std::deque<T>::iterator iterator;
489  typedef typename std::deque<T>::const_iterator const_iterator;
490 #endif
491  };
492 
493  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
494  struct vector
495  {
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;
499  typedef typename std::vector<T, A>::const_iterator const_iterator;
500 #else
501  typedef typename std::vector<T> type;
502  typedef typename std::vector<T>::iterator iterator;
503  typedef typename std::vector<T>::const_iterator const_iterator;
504 #endif
505  };
506 
507  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
508  struct list
509  {
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;
513  typedef typename std::list<T, A>::const_iterator const_iterator;
514 #else
515  typedef typename std::list<T> type;
516  typedef typename std::list<T>::iterator iterator;
517  typedef typename std::list<T>::const_iterator const_iterator;
518 #endif
519  };
520 
521  template <typename T, typename P = std::less<T>, typename A = STLAllocator<T, GeneralAllocPolicy> >
522  struct set
523  {
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;
527  typedef typename std::set<T, P, A>::const_iterator const_iterator;
528 #else
529  typedef typename std::set<T, P> type;
530  typedef typename std::set<T, P>::iterator iterator;
531  typedef typename std::set<T, P>::const_iterator const_iterator;
532 #endif
533  };
534 
535  template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
536  struct map
537  {
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;
541  typedef typename std::map<K, V, P, A>::const_iterator const_iterator;
542 #else
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;
546 #endif
547  };
548 
549  template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
550  struct multimap
551  {
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;
555  typedef typename std::multimap<K, V, P, A>::const_iterator const_iterator;
556 #else
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;
560 #endif
561  };
562 
563 } // Ogre
564 
565 #endif // __OgrePrerequisites_H__
566 
567 
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,...
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,...
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
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,...
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,...
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,...
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),...
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