OGRE  2.0
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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 2
52  #define OGRE_VERSION_MINOR 0
53  #define OGRE_VERSION_PATCH 0
54  #define OGRE_VERSION_SUFFIX "unstable"
55  #define OGRE_VERSION_NAME "Tindalos"
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 HashMultiMap ::std::tr1::unordered_multimap
77  # define HashSet ::std::tr1::unordered_set
78  # define HashMultiSet ::std::tr1::unordered_multiset
79  # else
80  # define HashMap ::__gnu_cxx::hash_map
81  # define HashMultiMap ::__gnu_cxx::hash_multimap
82  # define HashSet ::__gnu_cxx::hash_set
83  # define HashMultiSet ::__gnu_cxx::hash_multiset
84  # endif
85  #elif OGRE_COMPILER == OGRE_COMPILER_CLANG
86  # if defined(_LIBCPP_VERSION)
87  # define HashMap ::std::unordered_map
88  # define HashMultiMap ::std::unordered_multimap
89  # define HashSet ::std::unordered_set
90  # define HashMultiSet ::std::unordered_multiset
91  # else
92  # define HashMap ::std::tr1::unordered_map
93  # define HashMultiMap ::std::tr1::unordered_multimap
94  # define HashSet ::std::tr1::unordered_set
95  # define HashMultiSet ::std::tr1::unordered_multiset
96  # endif
97  #else
98  # if OGRE_COMPILER == OGRE_COMPILER_MSVC && !defined(_STLP_MSVC)
99  # if _MSC_FULL_VER >= 150030729 // VC++ 9.0 SP1+
100  # define HashMap ::std::tr1::unordered_map
101  # define HashMultiMap ::std::tr1::unordered_multimap
102  # define HashSet ::std::tr1::unordered_set
103  # define HashMultiSet ::std::tr1::unordered_multiset
104  # elif OGRE_THREAD_PROVIDER == 1
105  # define HashMap ::boost::unordered_map
106  # define HashMultiMap ::boost::unordered_multimap
107  # define HashSet ::boost::unordered_set
108  # define HashMultiSet ::boost::unordered_multiset
109  # else
110  # define HashMap ::std::unordered_map
111  # define HashMultiMap ::std::unordered_multimap
112  # define HashSet ::std::unordered_set
113  # define HashMultiSet ::std::unordered_multiset
114  # endif
115  # else
116  # define HashMap ::std::unordered_map
117  # define HashMultiMap ::std::unordered_multimap
118  # define HashSet ::std::unordered_set
119  # define HashMultiSet ::std::unordered_multiset
120  # endif
121  #endif
122 
123  #define OGRE_DEFINE_STATIC_LOCAL(type, name, arguments) \
124  static type& name = *new type arguments
125 
128  typedef unsigned char uchar;
129  typedef unsigned short ushort;
130  typedef unsigned int uint;
131  typedef unsigned long ulong;
132 
133  #if __cplusplus >= 201103L
134  #define register
135  #endif
136 // Pre-declare classes
137 // Allows use of pointers in header files without including individual .h
138 // so decreases dependencies between files
139  struct Aabb;
140  class Angle;
141  class AnimableValue;
142  class Animation;
143  class AnimationState;
144  class AnimationStateSet;
145  class AnimationTrack;
146  class ArrayMatrix4;
147  class ArrayMatrixAf4x3;
148  class ArrayQuaternion;
149  class ArrayVector3;
150  class ArrayMemoryManager;
151  class Archive;
152  class ArchiveFactory;
153  class ArchiveManager;
154  class AutoParamDataSource;
155  class AxisAlignedBox;
157  class Barrier;
158  class Billboard;
159  class BillboardChain;
160  class BillboardSet;
161  class Bone;
162  class BoneMemoryManager;
163  struct BoneTransform;
164  class Camera;
165  class Codec;
166  class ColourValue;
167  class ConfigDialog;
168  template <typename T> class Controller;
169  template <typename T> class ControllerFunction;
170  class ControllerManager;
171  template <typename T> class ControllerValue;
172  class DataStream;
173  class DefaultWorkQueue;
174  class Degree;
175  class DepthBuffer;
176  class DynLib;
177  class DynLibManager;
178  class EdgeData;
179  class EdgeListBuilder;
180  class Entity;
181  class ErrorDialog;
183  class Factory;
184  struct FrameEvent;
185  class FrameListener;
186  class Frustum;
187  struct GpuLogicalBufferStruct;
188  struct GpuNamedConstants;
189  class GpuProgramParameters;
190  class GpuSharedParameters;
191  class GpuProgram;
192  class GpuProgramManager;
193  class GpuProgramUsage;
194  class HardwareIndexBuffer;
196  class HardwareVertexBuffer;
197  class HardwarePixelBuffer;
199  class HighLevelGpuProgram;
202  class IndexData;
203  class InstanceBatch;
204  class InstanceBatchHW;
205  class InstanceBatchHW_VTF;
206  class InstanceBatchShader;
207  class InstanceBatchVTF;
208  class InstanceManager;
209  class InstancedEntity;
212  class Image;
213  class KeyFrame;
214  struct KfTransform;
215  class Light;
216  class Log;
217  class LogManager;
218  class LodStrategy;
219  class LodStrategyManager;
220  class ManualResourceLoader;
221  class ManualObject;
222  class Material;
223  class MaterialManager;
224  class Math;
225  class Matrix3;
226  class Matrix4;
227  class MemoryDataStream;
228  class MemoryManager;
229  class Mesh;
230  class MeshSerializer;
231  class MeshSerializerImpl;
232  class MeshManager;
233  class MovableObject;
234  class MovablePlane;
235  class Node;
236  class NodeMemoryManager;
237  class NumericAnimationTrack;
238  class NumericKeyFrame;
239  struct ObjectData;
240  class ObjectMemoryManager;
241  class OldBone;
242  class OldNode;
243  class OldNodeAnimationTrack;
244  class OldSkeletonInstance;
245  class OldSkeletonManager;
246  class Particle;
247  class ParticleAffector;
249  class ParticleEmitter;
251  class ParticleSystem;
252  class ParticleSystemManager;
255  class ParticleVisualData;
256  class Pass;
257  class PatchMesh;
258  class PixelBox;
259  class Plane;
260  class PlaneBoundedVolume;
261  class Plugin;
262  class Pose;
263  class Profile;
264  class Profiler;
265  class Quaternion;
266  class Radian;
267  class Ray;
268  class RaySceneQuery;
269  class RaySceneQueryListener;
270  class Renderable;
271  class RenderPriorityGroup;
272  class RenderQueue;
273  class RenderQueueGroup;
274  class RenderQueueInvocation;
276  class RenderQueueListener;
277  class RenderObjectListener;
278  class RenderSystem;
282  class RenderTarget;
283  class RenderTargetListener;
284  class RenderTexture;
285  class RenderToVertexBuffer;
286  class MultiRenderTarget;
287  class RenderWindow;
288  class RenderOperation;
289  class Resource;
291  class ResourceGroupManager;
292  class ResourceManager;
293  class RibbonTrail;
294  class Root;
295  class SceneManager;
297  class SceneNode;
298  class SceneQuery;
299  class SceneQueryListener;
300  class ScriptCompiler;
301  class ScriptCompilerManager;
302  class ScriptLoader;
303  class Serializer;
304  class ShadowCameraSetup;
305  class ShadowTextureManager;
306  class SimpleMatrixAf4x3;
307  class SimpleRenderable;
308  class SimpleSpline;
309  class Skeleton;
310  class SkeletonDef;
311  class SkeletonInstance;
312  class SkeletonManager;
313  class Sphere;
314  class SphereSceneQuery;
315  class StaticGeometry;
316  class StreamSerialiser;
317  class StringConverter;
318  class StringInterface;
319  class SubEntity;
320  class SubMesh;
321  class TagPoint;
322  class Technique;
323  class TempBlendedBufferInfo;
324  class ExternalTextureSource;
325  class TextureUnitState;
326  class Texture;
327  class TextureManager;
328  struct Transform;
329  class TransformKeyFrame;
330  class Timer;
331  class UserObjectBindings;
332  class Vector2;
333  class Vector3;
334  class Vector4;
335  class Viewport;
336  class VertexAnimationTrack;
337  class VertexBufferBinding;
338  class VertexData;
339  class VertexDeclaration;
340  class VertexMorphKeyFrame;
341  class WireBoundingBox;
342  class WorkQueue;
343  class CompositorManager2;
344  class CompositorWorkspace;
345 
346  template<typename T> class SharedPtr;
365 }
366 
367 /* Include all the standard header *after* all the configuration
368 settings have been made.
369 */
370 #include "OgreStdHeaders.h"
372 
373 
374 namespace Ogre
375 {
376 #if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
377  #if OGRE_WCHAR_T_STRINGS
378  typedef std::basic_string<wchar_t, std::char_traits<wchar_t>, STLAllocator<wchar_t,GeneralAllocPolicy > > _StringBase;
379  #else
380  typedef std::basic_string<char, std::char_traits<char>, STLAllocator<char,GeneralAllocPolicy > > _StringBase;
381  #endif
382 
383  #if OGRE_WCHAR_T_STRINGS
384  typedef std::basic_stringstream<wchar_t,std::char_traits<wchar_t>,STLAllocator<wchar_t,GeneralAllocPolicy >> _StringStreamBase;
385  #else
386  typedef std::basic_stringstream<char,std::char_traits<char>,STLAllocator<char,GeneralAllocPolicy > > _StringStreamBase;
387  #endif
388 
389  #define StdStringT(T) std::basic_string<T, std::char_traits<T>, std::allocator<T> >
390  #define CustomMemoryStringT(T) std::basic_string<T, std::char_traits<T>, STLAllocator<T,GeneralAllocPolicy> >
391 
392  template<typename T>
393  bool operator <(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
394  {
395  return l.compare(0,l.length(),o.c_str(),o.length())<0;
396  }
397  template<typename T>
398  bool operator <(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
399  {
400  return l.compare(0,l.length(),o.c_str(),o.length())<0;
401  }
402  template<typename T>
403  bool operator <=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
404  {
405  return l.compare(0,l.length(),o.c_str(),o.length())<=0;
406  }
407  template<typename T>
408  bool operator <=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
409  {
410  return l.compare(0,l.length(),o.c_str(),o.length())<=0;
411  }
412  template<typename T>
413  bool operator >(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
414  {
415  return l.compare(0,l.length(),o.c_str(),o.length())>0;
416  }
417  template<typename T>
418  bool operator >(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
419  {
420  return l.compare(0,l.length(),o.c_str(),o.length())>0;
421  }
422  template<typename T>
423  bool operator >=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
424  {
425  return l.compare(0,l.length(),o.c_str(),o.length())>=0;
426  }
427  template<typename T>
428  bool operator >=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
429  {
430  return l.compare(0,l.length(),o.c_str(),o.length())>=0;
431  }
432 
433  template<typename T>
434  bool operator ==(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
435  {
436  return l.compare(0,l.length(),o.c_str(),o.length())==0;
437  }
438  template<typename T>
439  bool operator ==(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
440  {
441  return l.compare(0,l.length(),o.c_str(),o.length())==0;
442  }
443 
444  template<typename T>
445  bool operator !=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
446  {
447  return l.compare(0,l.length(),o.c_str(),o.length())!=0;
448  }
449  template<typename T>
450  bool operator !=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
451  {
452  return l.compare(0,l.length(),o.c_str(),o.length())!=0;
453  }
454 
455  template<typename T>
456  CustomMemoryStringT(T) operator +=(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
457  {
458  return CustomMemoryStringT(T)(l)+=o.c_str();
459  }
460  template<typename T>
461  CustomMemoryStringT(T) operator +=(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
462  {
463  return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
464  }
465 
466  template<typename T>
467  CustomMemoryStringT(T) operator +(const CustomMemoryStringT(T)& l,const StdStringT(T)& o)
468  {
469  return CustomMemoryStringT(T)(l)+=o.c_str();
470  }
471 
472  template<typename T>
473  CustomMemoryStringT(T) operator +(const StdStringT(T)& l,const CustomMemoryStringT(T)& o)
474  {
475  return CustomMemoryStringT(T)(l.c_str())+=o.c_str();
476  }
477 
478  template<typename T>
479  CustomMemoryStringT(T) operator +(const T* l,const CustomMemoryStringT(T)& o)
480  {
481  return CustomMemoryStringT(T)(l)+=o;
482  }
483 
484  #undef StdStringT
485  #undef CustomMemoryStringT
486 
487 #else
488  #if OGRE_WCHAR_T_STRINGS
489  typedef std::wstring _StringBase;
490  #else
491  typedef std::string _StringBase;
492  #endif
493 
494  #if OGRE_WCHAR_T_STRINGS
495  typedef std::basic_stringstream<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t> > _StringStreamBase;
496  #else
497  typedef std::basic_stringstream<char,std::char_traits<char>,std::allocator<char> > _StringStreamBase;
498  #endif
499 
500 #endif
501 
502  typedef _StringBase String;
505 
506 }
507 
508 #if OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR
509 namespace std
510 {
511 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
512  namespace tr1
513  {
514 #endif
515  template <> struct hash<Ogre::String>
516  {
517  public :
518  size_t operator()(const Ogre::String &str ) const
519  {
520  size_t _Val = 2166136261U;
521  size_t _First = 0;
522  size_t _Last = str.size();
523  size_t _Stride = 1 + _Last / 10;
524 
525  for(; _First < _Last; _First += _Stride)
526  _Val = 16777619U * _Val ^ (size_t)str[_First];
527  return (_Val);
528  }
529  };
530 #if (OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 430) || OGRE_COMPILER == OGRE_COMPILER_CLANG && !defined(STLPORT) && __cplusplus < 201103L
531  }
532 #endif
533 }
534 #endif
535 
536 //for stl container
537 namespace Ogre
538 {
539  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
540  struct deque
541  {
542 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
543  typedef typename std::deque<T, A> type;
544  typedef typename std::deque<T, A>::iterator iterator;
545  typedef typename std::deque<T, A>::const_iterator const_iterator;
546 #else
547  typedef typename std::deque<T> type;
548  typedef typename std::deque<T>::iterator iterator;
549  typedef typename std::deque<T>::const_iterator const_iterator;
550 #endif
551  };
552 
553  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
554  struct vector
555  {
556 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
557  typedef typename std::vector<T, A> type;
558  typedef typename std::vector<T, A>::iterator iterator;
559  typedef typename std::vector<T, A>::const_iterator const_iterator;
560 #else
561  typedef typename std::vector<T> type;
562  typedef typename std::vector<T>::iterator iterator;
563  typedef typename std::vector<T>::const_iterator const_iterator;
564 #endif
565  };
566 
567  template <typename T, typename A = STLAllocator<T, GeneralAllocPolicy> >
568  struct list
569  {
570 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
571  typedef typename std::list<T, A> type;
572  typedef typename std::list<T, A>::iterator iterator;
573  typedef typename std::list<T, A>::const_iterator const_iterator;
574 #else
575  typedef typename std::list<T> type;
576  typedef typename std::list<T>::iterator iterator;
577  typedef typename std::list<T>::const_iterator const_iterator;
578 #endif
579  };
580 
581  template <typename T, typename P = std::less<T>, typename A = STLAllocator<T, GeneralAllocPolicy> >
582  struct set
583  {
584 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
585  typedef typename std::set<T, P, A> type;
586  typedef typename std::set<T, P, A>::iterator iterator;
587  typedef typename std::set<T, P, A>::const_iterator const_iterator;
588 #else
589  typedef typename std::set<T, P> type;
590  typedef typename std::set<T, P>::iterator iterator;
591  typedef typename std::set<T, P>::const_iterator const_iterator;
592 #endif
593  };
594 
595  template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
596  struct map
597  {
598 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
599  typedef typename std::map<K, V, P, A> type;
600  typedef typename std::map<K, V, P, A>::iterator iterator;
601  typedef typename std::map<K, V, P, A>::const_iterator const_iterator;
602 #else
603  typedef typename std::map<K, V, P> type;
604  typedef typename std::map<K, V, P>::iterator iterator;
605  typedef typename std::map<K, V, P>::const_iterator const_iterator;
606 #endif
607  };
608 
609  template <typename K, typename V, typename P = std::less<K>, typename A = STLAllocator<std::pair<const K, V>, GeneralAllocPolicy> >
610  struct multimap
611  {
612 #if OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR
613  typedef typename std::multimap<K, V, P, A> type;
614  typedef typename std::multimap<K, V, P, A>::iterator iterator;
615  typedef typename std::multimap<K, V, P, A>::const_iterator const_iterator;
616 #else
617  typedef typename std::multimap<K, V, P> type;
618  typedef typename std::multimap<K, V, P>::iterator iterator;
619  typedef typename std::multimap<K, V, P>::const_iterator const_iterator;
620 #endif
621  };
622 
623 } // Ogre
624 
625 #endif // __OgrePrerequisites_H__
626 
627 
Representation of a ray in space, i.e.
Definition: OgreRay.h:45
Manages the target rendering window.
Class encapsulating a set of AnimationState objects.
Wrap-around class that contains multiple ArrayMemoryManager, one per hierarchy depth.
std::vector< T, A >::iterator iterator
SharedPtr< MemoryDataStream > MemoryDataStreamPtr
A 'canvas' which can receive the results of a rendering operation.
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:82
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:153
Abstract class that defines a 'codec'.
Definition: OgreCodec.h:54
Represents the transform of a single object, arranged in SoA (Structure of Arrays) ...
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.
Definition: OgreMatrix4.h:79
Represents the transform of a single object, arranged in SoA (Structure of Arrays) ...
Definition: OgreTransform.h:37
std::list< T, A >::iterator iterator
float Real
Software floating point type.
Specialised KeyFrame which stores a full transform.
Definition: OgreKeyFrame.h:102
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.
Definition: OgreRoot.h:67
Defines an object property which is animable, i.e.
Definition: OgreAnimable.h:72
A key frame in an animation sequence defined by an AnimationTrack.
Definition: OgreKeyFrame.h:55
std::multimap< K, V, P, A > type
SharedPtr< AnimableValue > AnimableValuePtr
std::vector< T, 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
unsigned long ulong
SharedPtr< SkeletonDef > SkeletonDefPtr
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.
Definition: OgrePlane.h:61
Singleton Class which handles the registering and control of texture plugins.
std::string _StringBase
Cache-friendly container of 4x4 matrices represented as a SoA array.
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.
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.
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 compositor workspace is the main interface to render into an RT, be it a RenderWindow or an RTT (Re...
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:84
SharedPtr< RenderToVertexBuffer > RenderToVertexBufferSharedPtr
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.
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:54
std::map< K, V, P, A >::iterator iterator
Class encapsulates rendering properties of an object.
Definition: OgreMaterial.h:84
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...
Definition: OgreMath.h:152
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.
Cache-friendly container of AFFINE 4x4 matrices represented as a SoA array.
A 3x3 matrix which can represent rotations around axes.
Definition: OgreMatrix3.h:68
Definition of container that holds the current bool constants.
Represents the state of an animation and the weight of its influence.
std::list< T, A > type
Interface describing a manual resource loader.
Definition: OgreResource.h:498
Class representing an approach to rendering this particular Material.
Definition: OgreTechnique.h:50
Class for managing RenderSystemCapabilities database for Ogre.
Strategy for determining level of detail.
This ResourceManager manages high-level vertex and fragment programs.
Class to manage the available shadow textures which may be shared between many SceneManager instances...
Resource holding data about a dynamic library.
Definition: OgreDynLib.h:84
Wrap-around class that contains multiple ArrayMemoryManager, one per render queue.
Class to provide access to common mathematical functions.
Definition: OgreMath.h:193
std::set< T, P, A >::iterator iterator
std::list< T, A >::const_iterator const_iterator
Manager for LOD strategies.
Abstract class defining a movable object in a scene.
Class representing a node in the scene graph.
Definition: OgreSceneNode.h:53
Manager for Dynamic-loading Libraries.
An object which renders geometry to a vertex.
std::multimap< K, V, P, A >::const_iterator const_iterator
_StringStreamBase StringStream
Abstract memory manager for managing large chunks of contiguous memory, optimized for SoA (Structure ...
Interface definition for factories of HighLevelGpuProgram.
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:78
Abstract class defining the interface all renderable objects must implement.
std::set< T, P, A > type
The log manager handles the creation and retrieval of logs for the application.
std::deque< T, A >::const_iterator const_iterator
Class representing a general-purpose OldNode an articulated scene graph.
Definition: OgreOldNode.h:63
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.
SharedPtr< GpuNamedConstants > GpuNamedConstantsPtr
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.
Definition: OgreLight.h:70
The profiler allows you to measure the performance of your code.
Definition: OgreProfiler.h:279
Class defining the common interface which classes can use to present a reflection-style, self-defining parameter set to callers.
Timer class.
SharedPtr< Skeleton > SkeletonPtr
Abstract class defining the interface used by classes which wish to perform script loading to define ...
A barrier is a synchronization mechanism where multiple threads wait until all of them have reached t...
Definition: OgreBarrier.h:62
An abstract class that contains a depth/stencil buffer.
Cache-friendly array of 3-dimensional represented as a SoA array.
Can either be used as an input or output value.
Holds the transform of a KeyFrame (which is part of an animation)
Common subclass of DataStream for handling data from chunks of memory.
Alternative listener class for dealing with RaySceneQuery.
SharedPtr< Material > MaterialPtr
This class manages the available ArchiveFactory plugins.
This class allows you to plug in new ways to define the camera setup when rendering and projecting sh...
Utility class which defines the sub-parts of an Entity.
Definition: OgreSubEntity.h:62
Class representing a single particle instance.
Definition: OgreParticle.h:60
Alternative listener class for dealing with IntersectionSceneQuery.
Class defining a generic OGRE plugin.
Definition: OgrePlugin.h:79
Instances of this class 'control' the value of another object in the system.
unsigned char uchar
In order to avoid finger-aches :)
SharedPtr< GpuProgramParameters > GpuProgramParametersSharedPtr
SharedPtr< DataStream > DataStreamPtr
Container struct to allow params to safely & update shared list of logical buffer assignments...
Struct collecting together the information for named constants.
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:51
SharedPtr< ShadowCameraSetup > ShadowCameraSetupPtr
Defines an instance of a discrete, movable object based on a Mesh.
Definition: OgreEntity.h:81
Internal implementation of Mesh reading / writing for the latest version of the .mesh format...
Handles the management of skeleton resources.
Collects together the program parameters used for a GpuProgram.
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.
Definition: OgreVector2.h:51
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.
Class representing the invocation of queue groups in a RenderQueue.
AoS (array of structures) version of ArrayAabb.
Definition: C/OgreAabb.h:78
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...
Definition: OgreTagPoint.h:60
Wrapper class which indicates a given angle value is in Degrees.
Definition: OgreMath.h:100
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.
Definition: OgreSubMesh.h:60
A bone in a skeleton.
Definition: OgreOldBone.h:51
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.
Represents the transform of a single object, arranged in SoA (Structure of Arrays) ...
Shared pointer implementation used to share pixel buffers.
Standard 3-dimensional vector.
Definition: OgreVector3.h:50
Manages particle systems, particle system scripts (templates) and the available emitter & affector fa...
Class representing an image file.
Definition: OgreImage.h:60
Specialisation of HardwareBuffer for a pixel buffer.
std::map< K, V, P, A > type
unsigned short ushort
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:77
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.
Definition: OgreViewport.h:56
'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...
SharedPtr< Resource > ResourcePtr
Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses...
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:49
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.
Simple wrap up to load an AoS matrix 4x3 using SSE.
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.
Archive-handling class.
Definition: OgreArchive.h:86
General purpose class used for encapsulating the reading and writing of data.
A billboard is a primitive which always faces the camera in every frame.
Definition: OgreBillboard.h:66
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.
Specialised AnimationTrack for dealing with node transforms.
Enumerates the SceneManager classes available to applications.
_StringBase String
Definition: OgreCommon.h:53
Class for serializing RenderSystemCapabilities to / from a .rendercaps script.
This is the main class for the compiler.
Patch specialisation of Mesh.
Definition: OgrePatchMesh.h:47
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.
Definition: OgreVector4.h:45
SharedPtr< HighLevelGpuProgram > HighLevelGpuProgramPtr
Abstract base class representing a high-level program (a vertex or fragment program).
A OldSkeletonInstance is a single instance of a Skeleton used by a world object.
Resource holding data about 3D mesh.
Definition: OgreMesh.h:86
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.
Definition: OgreKeyFrame.h:79
SharedPtr< Texture > TexturePtr
Interface to a general purpose request / response style background work queue.
Definition: OgreWorkQueue.h:71
Abstract class containing any additional data required to be associated with a particle to perform th...
Definition: OgreParticle.h:51
Defines the functionality of a 3D API.
Abstract class representing a Texture resource.
Definition: OgreTexture.h:111
Class representing the state of a single texture unit during a Pass of a Technique, of a Material.
Cache-friendly array of Quaternion represented as a SoA array.
An animation sequence.
Definition: OgreAnimation.h:90
SharedPtr< GpuSharedParameters > GpuSharedParametersPtr
Specialises the SceneQuery class for querying along a ray.
Class representing a general-purpose node an articulated scene graph.
Definition: OgreNode.h:58
Main system for managing Render Targets through the use of nodes.
Class representing a Bone in the join hierarchy of a skeleton.
Definition: OgreBone.h:61
A collection of OldBone objects used to animate a skinned mesh.
Definition: OgreSkeleton.h:84
An individual profile that will be processed by the Profiler.
Definition: OgreProfiler.h:103
Instance of a Skeleton, main external interface for retrieving bone positions and applying animations...
This is technique requires true instancing hardware support.
SharedPtr< GpuLogicalBufferStruct > GpuLogicalBufferStructPtr
unsigned int uint
Wrap-around class that contains multiple ArrayMemoryManager, one per hierarchy depth.
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
std::deque< T, A > type
Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instan...
Class for managing Controller instances.