OgrePrerequisites.h
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2This source file is a part of OGRE
3(Object-oriented Graphics Rendering Engine)
4
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2013 Torus Knot Software Ltd
8Permission is hereby granted, free of charge, to any person obtaining a copy
9of this software and associated documentation files (the "Software"), to deal
10in the Software without restriction, including without limitation the rights
11to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12copies of the Software, and to permit persons to whom the Software is
13furnished to do so, subject to the following conditions:
14
15The above copyright notice and this permission notice shall be included in
16all copies or substantial portions of the Software.
17
18THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24THE 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
49namespace 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
65 typedef double Real;
66 #else
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;
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;
168 class IndexData;
169 class InstanceBatch;
170 class InstanceBatchHW;
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;
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;
202 class NumericKeyFrame;
203 class Particle;
204 class ParticleAffector;
206 class ParticleEmitter;
208 class ParticleSystem;
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;
230 class Renderable;
232 class RenderQueue;
233 class RenderQueueGroup;
238 class RenderSystem;
242 class RenderTarget;
244 class RenderTexture;
245 class MultiRenderTarget;
246 class RenderWindow;
247 class RenderOperation;
248 class Resource;
251 class ResourceManager;
252 class RibbonTrail;
253 class Root;
254 class SceneManager;
256 class SceneNode;
257 class SceneQuery;
258 class SceneQueryListener;
259 class ScriptCompiler;
261 class ScriptLoader;
262 class Serializer;
263 class ShadowCaster;
264 class ShadowRenderable;
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;
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;
295 class VertexData;
296 class VertexDeclaration;
298 class WireBoundingBox;
299 class WorkQueue;
300 class Compositor;
301 class CompositorManager;
302 class CompositorChain;
303 class CompositorInstance;
304 class CompositorLogic;
306 class CompositionPass;
309
310 template<typename T> class SharedPtr;
320}
321
322/* Include all the standard header *after* all the configuration
323settings have been made.
324*/
325#include "OgreStdHeaders.h"
327
328
329namespace 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
446namespace 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
474namespace 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
This file configures Ogre's memory allocators.
Wrapper class which identifies a value as the currently default angle type, as defined by Math::setAn...
Definition: OgreMath.h:151
Class encapsulating a set of AnimationState objects.
Represents the state of an animation and the weight of its influence.
A 'track' in an animation sequence, i.e.
An animation sequence.
Definition: OgreAnimation.h:93
Abstract factory class, archive codec plugins can register concrete subclasses of this.
This class manages the available ArchiveFactory plugins.
Archive-handling class.
Definition: OgreArchive.h:89
This utility class is used to hold the information used to generate the matrices and other informatio...
Specialises the SceneQuery class for querying within an axis aligned box.
A 3D box aligned with the x/y/z axes.
Allows the rendering of a chain of connected billboards.
A collection of billboards (faces which are always facing the given direction) with the same (default...
A billboard is a primitive which always faces the camera in every frame.
Definition: OgreBillboard.h:68
A bone in a skeleton.
Definition: OgreBone.h:52
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:87
Abstract class that defines a 'codec'.
Definition: OgreCodec.h:57
Class representing colour.
Object representing one pass or operation in a composition sequence.
Object representing one render to a RenderTarget or Viewport in the Ogre Composition framework.
Base composition technique, can be subclassed in plugins.
Chain of compositor effects applying to one viewport.
An instance of a Compositor object for one Viewport.
Interface for compositor logics, which can be automatically binded to compositors,...
Class for managing Compositor settings for Ogre.
Class representing a Compositor object.
Defines the behaviour of an automatic renderer configuration dialog.
Subclasses of this class are responsible for performing a function on an input value for a Controller...
Class for managing Controller instances.
Can either be used as an input or output value.
Instances of this class 'control' the value of another object in the system.
Interface for custom composition passes, allowing custom operations (in addition to the quad,...
Implementation of a general purpose request / response style background work queue.
Wrapper class which indicates a given angle value is in Degrees.
Definition: OgreMath.h:99
An abstract class that contains a depth/stencil buffer.
Manager for Dynamic-loading Libraries.
Resource holding data about a dynamic library.
Definition: OgreDynLib.h:85
This class contains the information required to describe the edge connectivity of a given set of vert...
General utility class for building edge lists for geometry.
Defines an instance of a discrete, movable object based on a Mesh.
Definition: OgreEntity.h:83
Class for displaying the error dialog if Ogre fails badly.
Singleton Class which handles the registering and control of texture plugins.
IMPORTANT: Plugins must override default dictionary name! Base class that texture plugins derive from...
A interface class defining a listener which can be used to receive notifications of frame events.
A frustum represents a pyramid, capped at the near and far end which is used to represent either a vi...
Definition: OgreFrustum.h:86
This class makes the usage of a vertex and fragment programs (low-level or high-level),...
Defines a program which runs on the GPU such as a vertex or fragment program.
Specialisation of HardwareBuffer for vertex index buffers, still abstract.
This is a abstract class that that provides the interface for the query class for hardware occlusion.
Shared pointer implementation used to share pixel buffers.
Specialisation of HardwareBuffer for a pixel buffer.
Specialisation of HardwareBuffer for a vertex buffer.
Interface definition for factories of HighLevelGpuProgram.
This ResourceManager manages high-level vertex and fragment programs.
Abstract base class representing a high-level program (a vertex or fragment program).
Class representing an image file.
Definition: OgreImage.h:62
Summary class collecting together index data source information.
Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and hardware instan...
This is technique requires true instancing hardware support.
This is the same technique the old "InstancedGeometry" implementation used (with improvements).
InstanceBatch forms part of the new Instancing system This is an abstract class that must be derived ...
This is the main starting point for the new instancing system.
Alternative listener class for dealing with IntersectionSceneQuery.
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another.
A key frame in an animation sequence defined by an AnimationTrack.
Definition: OgreKeyFrame.h:57
Representation of a dynamic light source in the scene.
Definition: OgreLight.h:74
Strategy for determining level of detail.
The log manager handles the creation and retrieval of logs for the application.
Class providing a much simplified interface to generating manual objects with custom geometry.
Interface describing a manual resource loader.
Definition: OgreResource.h:515
Class for managing Material settings for Ogre.
Class encapsulates rendering properties of an object.
Definition: OgreMaterial.h:89
Class to provide access to common mathematical functions.
Definition: OgreMath.h:192
A 3x3 matrix which can represent rotations around axes.
Definition: OgreMatrix3.h:69
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:79
Handles the management of mesh resources.
Internal implementation of Mesh reading / writing for the latest version of the .mesh format.
Class for serialising mesh data to/from an OGRE .mesh file.
Resource holding data about 3D mesh.
Definition: OgreMesh.h:94
Abstract class defining a movable object in a scene.
Definition of a Plane that may be attached to a node, and the derived details of it retrieved simply.
This class represents a render target that renders to multiple RenderTextures at once.
Specialised AnimationTrack for dealing with node transforms.
Class representing a general-purpose node an articulated scene graph.
Definition: OgreNode.h:65
Specialised AnimationTrack for dealing with generic animable values.
Specialised KeyFrame which stores any numeric value.
Definition: OgreKeyFrame.h:81
Injects the output of a request to the mesh in a thread safe way.
Abstract class defining the interface to be implemented by creators of ParticleAffector subclasses.
Abstract class defining the interface to be implemented by particle affectors.
Abstract class defining the interface to be implemented by creators of ParticleEmitter subclasses.
Abstract class defining the interface to be implemented by particle emitters.
Manages particle systems, particle system scripts (templates) and the available emitter & affector fa...
Abstract class definition of a factory object for ParticleSystemRenderer.
Abstract class defining the interface required to be implemented by classes which provide rendering c...
Class defining particle system based special effects.
Abstract class containing any additional data required to be associated with a particle to perform th...
Definition: OgreParticle.h:53
Class representing a single particle instance.
Definition: OgreParticle.h:62
Class defining a single pass of a Technique (of a Material), i.e.
Definition: OgrePass.h:81
Patch specialisation of Mesh.
Definition: OgrePatchMesh.h:48
A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory.
Represents a convex volume bounded by planes.
Defines a plane in 3D space.
Definition: OgrePlane.h:62
Class defining a generic OGRE plugin.
Definition: OgrePlugin.h:80
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:56
An individual profile that will be processed by the Profiler.
Definition: OgreProfiler.h:106
The profiler allows you to measure the performance of your code.
Definition: OgreProfiler.h:283
Improved version of ProgressiveMesh.
Implementation of a Quaternion, i.e.
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:48
Alternative listener class for dealing with RaySceneQuery.
Specialises the SceneQuery class for querying along a ray.
Representation of a ray in space, i.e.
Definition: OgreRay.h:47
Abstract interface which classes must implement if they wish to receive events from the scene manager...
'New' rendering operation using vertex buffers.
Collection of renderables by priority.
A grouping level underneath RenderQueue which groups renderables to be issued at coarsely the same ti...
Class to hold a linear sequence of RenderQueueInvocation objects.
Class representing the invocation of queue groups in a RenderQueue.
Abstract interface which classes must implement if they wish to receive events from the render queue.
Class to manage the scene object rendering queue.
Class for managing RenderSystemCapabilities database for Ogre.
Class for serializing RenderSystemCapabilities to / from a .rendercaps script.
singleton class for storing the capabilities of the graphics card.
Defines the functionality of a 3D API.
A interface class defining a listener which can be used to receive notifications of RenderTarget even...
A 'canvas' which can receive the results of a rendering operation.
This class represents a RenderTarget that renders to a Texture.
Manages the target rendering window.
Abstract class defining the interface all renderable objects must implement.
This class is used to perform Resource operations in a background thread.
This singleton class manages the list of resource groups, and notifying the various resource managers...
Defines a generic resource handler.
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:80
Subclass of BillboardChain which automatically leaves a trail behind one or more Node instances.
The root class of the Ogre system.
Definition: OgreRoot.h:72
Enumerates the SceneManager classes available to applications.
Manages the organisation and rendering of a 'scene' i.e.
Class representing a node in the scene graph.
Definition: OgreSceneNode.h:59
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
A class for performing queries on a scene.
Manages threaded compilation of scripts.
This is the main class for the compiler.
Abstract class defining the interface used by classes which wish to perform script loading to define ...
Generic class for serialising data to / from binary stream-based files.
This class defines the interface that must be implemented by shadow casters.
Class which represents the renderable aspects of a set of shadow volume faces.
Class to manage the available shadow textures which may be shared between many SceneManager instances...
Reference-counted shared pointer, used for objects where implicit destruction is required.
Simple implementation of MovableObject and Renderable for single-part custom objects.
A very simple spline class which implements the Catmull-Rom class of splines.
A SkeletonInstance is a single instance of a Skeleton used by a world object.
Handles the management of skeleton resources.
A collection of Bone objects used to animate a skinned mesh.
Definition: OgreSkeleton.h:88
Specialises the SceneQuery class for querying within a sphere.
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:52
Pre-transforms and batches up meshes for efficient use as static geometry in a scene.
Utility class providing helper methods for reading / writing structured data held in a DataStream.
Class for converting the core Ogre data types to/from Strings.
Class defining the common interface which classes can use to present a reflection-style,...
Utility class which defines the sub-parts of an Entity.
Definition: OgreSubEntity.h:64
Defines a part of a complete mesh.
Definition: OgreSubMesh.h:63
A tagged point on a skeleton, which can be used to attach entities to on specific other entities.
Definition: OgreTagPoint.h:61
Class representing an approach to rendering this particular Material.
Definition: OgreTechnique.h:54
Structure for recording the use of temporary blend buffers.
Class for loading & managing textures.
Class representing the state of a single texture unit during a Pass of a Technique,...
Abstract class representing a Texture resource.
Definition: OgreTexture.h:103
Timer class.
Specialised KeyFrame which stores a full transform.
Definition: OgreKeyFrame.h:104
Class that provides convenient interface to establish a linkage between custom user application objec...
Standard 2-dimensional vector.
Definition: OgreVector2.h:52
Standard 3-dimensional vector.
Definition: OgreVector3.h:52
4-dimensional homogeneous vector.
Definition: OgreVector4.h:46
Specialised AnimationTrack for dealing with changing vertex position information.
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
Summary class collecting together vertex source information.
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
Specialised KeyFrame which stores absolute vertex positions for a complete buffer,...
Definition: OgreKeyFrame.h:155
An abstraction of a viewport, i.e.
Definition: OgreViewport.h:58
Allows the rendering of a wireframe bounding box.
Interface to a general purpose request / response style background work queue.
Definition: OgreWorkQueue.h:71
SharedPtr< Skeleton > SkeletonPtr
bool operator<(SharedPtr< T > const &a, SharedPtr< U > const &b)
bool operator!=(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator,...
bool operator==(STLAllocator< T, P > const &, STLAllocator< T2, P > const &)
determine equality, can memory from another allocator be released by this allocator,...
SharedPtr< Resource > ResourcePtr
Shared pointer to a Resource.
unsigned char uchar
In order to avoid finger-aches :)
SharedPtr< Compositor > CompositorPtr
SharedPtr< GpuProgram > GpuProgramPtr
unsigned long ulong
SharedPtr< Material > MaterialPtr
SharedPtr< Mesh > MeshPtr
std::string _StringBase
StringStream stringstream
SharedPtr< PatchMesh > PatchMeshPtr
std::basic_stringstream< char, std::char_traits< char >, std::allocator< char > > _StringStreamBase
_StringStreamBase StringStream
SharedPtr< HighLevelGpuProgram > HighLevelGpuProgramPtr
SharedPtr< Texture > TexturePtr
float Real
Software floating point type.
unsigned int uint
_StringBase String
unsigned short ushort
Struct containing information about a frame event.
std::deque< T, A > type
std::deque< T, A >::const_iterator const_iterator
std::deque< T, A >::iterator iterator
std::list< T, A >::const_iterator const_iterator
std::list< T, A > type
std::list< T, A >::iterator iterator
std::map< K, V, P, A > type
std::map< K, V, P, A >::iterator iterator
std::map< K, V, P, A >::const_iterator const_iterator
std::multimap< K, V, P, A >::iterator iterator
std::multimap< K, V, P, A >::const_iterator const_iterator
std::multimap< K, V, P, A > type
std::set< T, P, A >::const_iterator const_iterator
std::set< T, P, A > type
std::set< T, P, A >::iterator iterator
std::vector< T, A >::iterator iterator
std::vector< T, A > type
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.