OgreRoot.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4  (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __ROOT__
29 #define __ROOT__
30 
31 // Precompiler options
32 #include "OgrePrerequisites.h"
33 
34 #include "OgreSingleton.h"
35 #include "OgreString.h"
38 #include "OgreLodStrategyManager.h"
39 #include "OgreWorkQueue.h"
40 
41 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
43 #endif
44 
45 #include <exception>
46 
47 namespace Ogre
48 {
57 
71  class _OgreExport Root : public Singleton<Root>, public RootAlloc
72  {
73  // To allow update of active renderer if
74  // RenderSystem::initialise is used directly
75  friend class RenderSystem;
76  protected:
81  bool mQueuedEnd;
84 
85  // Singletons
97 
101 
102 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
103  AndroidLogListener* mAndroidLogger;
104 #endif
105 
114 
121  unsigned long mNextFrame;
125 
126  public:
129  protected:
134 
138  // stock movable factories
145 
148 
151 
153 
158 
166  void loadPlugins(const String& pluginsfile = "plugins" OGRE_BUILD_SUFFIX ".cfg");
175 
179 
182 
185 
190 
193  FETT_ANY = 0,
194  FETT_STARTED = 1,
195  FETT_QUEUED = 2,
196  FETT_ENDED = 3,
197  FETT_COUNT = 4
198  };
199 
202  EventTimesQueue mEventTimes[FETT_COUNT];
203 
208  Real calculateEventTime(unsigned long now, FrameEventTimeType type);
209 
212 
213  public:
214 
224  Root(const String& pluginFileName = "plugins" OGRE_BUILD_SUFFIX ".cfg",
225  const String& configFileName = "ogre.cfg",
226  const String& logFileName = "Ogre.log");
227  ~Root();
228 
234  void saveConfig(void);
235 
248  bool restoreConfig(void);
249 
266  bool showConfigDialog(void);
267 
280 
288 
296 
315 
319 
335  RenderWindow* initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window",
336  const String& customCapabilitiesConfig = StringUtil::BLANK);
337 
339  bool isInitialised(void) const { return mIsInitialised; }
340 
347 
351  bool getRemoveRenderQueueStructuresOnClear() const { return mRemoveQueueStructuresOnClear; }
352 
356  void setRemoveRenderQueueStructuresOnClear(bool r) { mRemoveQueueStructuresOnClear = r; }
357 
364 
368 
378  const SceneManagerMetaData* getSceneManagerMetaData(const String& typeName) const;
379 
384 
397  const String& instanceName = StringUtil::BLANK);
398 
412  const String& instanceName = StringUtil::BLANK);
413 
416 
421  SceneManager* getSceneManager(const String& instanceName) const;
422 
426  bool hasSceneManager(const String& instanceName) const;
429 
446 
453 
457  String getErrorDescription(long errorNumber);
458 
475  void addFrameListener(FrameListener* newListener);
476 
481  void removeFrameListener(FrameListener* oldListener);
482 
491  void queueEndRendering(bool state = true);
492 
499  bool endRenderingQueued(void);
500 
528  void startRendering(void);
529 
535  bool renderOneFrame(void);
536 
543  bool renderOneFrame(Real timeSinceLastFrame);
544 
552  void shutdown(void);
553 
600  void addResourceLocation(const String& name, const String& locType,
602  bool recursive = false);
603 
610  void removeResourceLocation(const String& name,
612 
635  bool overwrite = false, const String& locationPattern = StringUtil::BLANK);
636 
652  const String& locationPattern = StringUtil::BLANK);
653 
662  void convertColourValue(const ColourValue& colour, uint32* pDest);
663 
673 
676  RenderWindow* createRenderWindow(const String &name, unsigned int width, unsigned int height,
677  bool fullScreen, const NameValuePairList *miscParams = 0) ;
678 
681  bool createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
682  RenderWindowList& createdWindows);
683 
690 
697 
701 
704  void destroyRenderTarget(const String &name);
705 
709 
720  void loadPlugin(const String& pluginName);
721 
731  void unloadPlugin(const String& pluginName);
732 
743  void installPlugin(Plugin* plugin);
744 
753  void uninstallPlugin(Plugin* plugin);
754 
756  const PluginInstanceList& getInstalledPlugins() const { return mPlugins; }
757 
759  Timer* getTimer(void);
760 
791 
853 
862  unsigned long getNextFrameNumber(void) const { return mNextFrame; }
863 
880 
892 
905 
911  const String& name);
912 
917  const String& name);
918 
925  const String& name);
926 
932 
948  static Root& getSingleton(void);
964  static Root* getSingletonPtr(void);
965 
974  void clearEventTimes(void);
975 
988  void setFrameSmoothingPeriod(Real period) { mFrameSmoothingTime = period; }
990  Real getFrameSmoothingPeriod(void) const { return mFrameSmoothingTime; }
991 
1005  bool overrideExisting = false);
1015  bool hasMovableObjectFactory(const String& typeName) const;
1024 
1030 
1034  unsigned int getDisplayMonitorCount() const;
1035 
1042  WorkQueue* getWorkQueue() const { return mWorkQueue; }
1043 
1052  void setWorkQueue(WorkQueue* queue);
1053 
1060  void setBlendIndicesGpuRedundant(bool redundant) { mIsBlendIndicesGpuRedundant = redundant; }
1064  bool isBlendIndicesGpuRedundant() const { return mIsBlendIndicesGpuRedundant; }
1065 
1072  void setBlendWeightsGpuRedundant(bool redundant) { mIsBlendWeightsGpuRedundant = redundant; }
1076  bool isBlendWeightsGpuRedundant() const { return mIsBlendWeightsGpuRedundant; }
1077 
1082  void setDefaultMinPixelSize(Real pixelSize) { mDefaultMinPixelSize = pixelSize; }
1083 
1086  Real getDefaultMinPixelSize() { return mDefaultMinPixelSize; }
1087 
1088 
1089  };
1092 } // Namespace Ogre
1093 #endif
#define _OgreExport
Definition: OgrePlatform.h:257
#define OGRE_BUILD_SUFFIX
Definition: OgrePlatform.h:355
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Abstract factory class, archive codec plugins can register concrete subclasses of this.
This class manages the available ArchiveFactory plugins.
Class representing colour.
Class for managing Compositor settings for Ogre.
Concrete IteratorWrapper for const access to the underlying key-value container.
Concrete IteratorWrapper for const access to the underlying container.
Class for managing Controller instances.
Manager for Dynamic-loading Libraries.
Singleton Class which handles the registering and control of texture plugins.
A interface class defining a listener which can be used to receive notifications of frame events.
This ResourceManager manages high-level vertex and fragment programs.
Manager for LOD strategies.
The log manager handles the creation and retrieval of logs for the application.
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Class for managing Material settings for Ogre.
Handles the management of mesh resources.
Interface definition for a factory class which produces a certain kind of MovableObject,...
Injects the output of a request to the mesh in a thread safe way.
Manages particle systems, particle system scripts (templates) and the available emitter & affector fa...
Class defining a generic OGRE plugin.
Definition: OgrePlugin.h:80
The profiler allows you to measure the performance of your code.
Definition: OgreProfiler.h:283
Class to hold a linear sequence of RenderQueueInvocation objects.
Class for managing RenderSystemCapabilities database for Ogre.
singleton class for storing the capabilities of the graphics card.
Defines the functionality of a 3D API.
A 'canvas' which can receive the results of a rendering operation.
Manages the target rendering window.
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...
static String DEFAULT_RESOURCE_GROUP_NAME
Default resource group name.
The root class of the Ogre system.
Definition: OgreRoot.h:72
LodStrategyManager * mLodStrategyManager
Definition: OgreRoot.h:111
bool _fireFrameEnded(FrameEvent &evt)
Method for raising frame ended events.
static Root * getSingletonPtr(void)
Override standard Singleton retrieval.
bool isBlendIndicesGpuRedundant() const
Returns whether blend indices information needs to be passed to the GPU see setBlendIndicesGpuRedunda...
Definition: OgreRoot.h:1064
ResourceGroupManager * mResourceGroupManager
Definition: OgreRoot.h:106
void useCustomRenderSystemCapabilities(RenderSystemCapabilities *capabilities)
Requests active RenderSystem to use custom RenderSystemCapabilities.
DataStreamPtr openFileStream(const String &filename, const String &groupName=ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, const String &locationPattern=StringUtil::BLANK)
Helper method to assist you in accessing readable file streams.
void shutdownPlugins()
Shuts down all loaded plugins - allows things to be tidied up whilst all plugins are still loaded.
bool isInitialised(void) const
Returns whether the system is initialised or not.
Definition: OgreRoot.h:339
void _pushCurrentSceneManager(SceneManager *sm)
Pushes the scene manager currently being used to render.
unsigned int getDisplayMonitorCount() const
Gets the number of display monitors.
bool _fireFrameRenderingQueued()
Method for raising frame rendering queued events.
void _popCurrentSceneManager(SceneManager *sm)
Pops the scene manager currently being used to render.
void initialisePlugins()
Initialise all loaded plugins - allows plugins to perform actions once the renderer is initialised.
MovableObjectFactoryIterator getMovableObjectFactoryIterator(void) const
Return an iterator over all the MovableObjectFactory instances currently registered.
bool _fireFrameStarted(FrameEvent &evt)
Method for raising frame started events.
SceneManagerEnumerator * mSceneManagerEnum
Definition: OgreRoot.h:88
ArchiveFactory * mEmbeddedZipArchiveFactory
Definition: OgreRoot.h:99
void setFrameSmoothingPeriod(Real period)
Sets the period over which OGRE smooths out fluctuations in frame times.
Definition: OgreRoot.h:988
PMInjector * mPMInjector
Definition: OgreRoot.h:113
void addResourceLocation(const String &name, const String &locType, const String &groupName=ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, bool recursive=false)
Adds a location to the list of searchable locations for a Resource type.
MovableObjectFactory * mLightFactory
Definition: OgreRoot.h:140
void uninstallPlugin(Plugin *plugin)
Uninstall an existing plugin.
void _syncAddedRemovedFrameListeners()
bool _fireFrameRenderingQueued(FrameEvent &evt)
Method for raising frame rendering queued events.
bool _updateAllRenderTargets(void)
Internal method used for updating all RenderTarget objects (windows, renderable textures etc) which a...
void addMovableObjectFactory(MovableObjectFactory *fact, bool overrideExisting=false)
Register a new MovableObjectFactory which will create new MovableObject instances of a particular typ...
set< FrameListener * >::type mRemovedFrameListeners
Set of frame listeners marked for removal and addition.
Definition: OgreRoot.h:187
void clearEventTimes(void)
Clears the history of all event times.
ResourceBackgroundQueue * mResourceBackgroundQueue
Definition: OgreRoot.h:107
MeshManager * getMeshManager(void)
Retrieves a reference to the current MeshManager.
uint32 _allocateNextMovableObjectTypeFlag(void)
Allocate the next MovableObject type flag.
ArchiveManager * mArchiveManager
Definition: OgreRoot.h:92
ShadowTextureManager * mShadowTextureManager
Definition: OgreRoot.h:108
SceneManager * createSceneManager(const String &typeName, const String &instanceName=StringUtil::BLANK)
Create a SceneManager instance of a given type.
void removeResourceLocation(const String &name, const String &groupName=ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)
Removes a resource location from the list.
ScriptCompilerManager * mCompilerManager
Definition: OgreRoot.h:110
bool showConfigDialog(void)
Displays a dialog asking the user to choose system settings.
SkeletonManager * mSkeletonManager
Definition: OgreRoot.h:96
RenderSystemList mRenderers
Definition: OgreRoot.h:77
ArchiveFactory * mFileSystemArchiveFactory
Definition: OgreRoot.h:100
const RenderSystemList & getAvailableRenderers(void)
Retrieve a list of the available render systems.
map< String, RenderQueueInvocationSequence * >::type RenderQueueInvocationSequenceMap
Definition: OgreRoot.h:146
void oneTimePostWindowInit(void)
Internal method for one-time tasks after first window creation.
void destroyRenderQueueInvocationSequence(const String &name)
Destroy a RenderQueueInvocationSequence.
ArchiveFactory * mZipArchiveFactory
Definition: OgreRoot.h:98
Real mDefaultMinPixelSize
Definition: OgreRoot.h:124
String mVersion
Definition: OgreRoot.h:79
vector< DynLib * >::type PluginLibList
Definition: OgreRoot.h:127
Timer * getTimer(void)
Gets a pointer to the central timer used for all OGRE timings.
ExternalTextureSourceManager * mExternalTextureSourceManager
Definition: OgreRoot.h:119
RenderWindow * createRenderWindow(const String &name, unsigned int width, unsigned int height, bool fullScreen, const NameValuePairList *miscParams=0)
Creates a new rendering window.
void addSceneManagerFactory(SceneManagerFactory *fact)
Register a new SceneManagerFactory, a factory object for creating instances of specific SceneManagers...
vector< Plugin * >::type PluginInstanceList
Definition: OgreRoot.h:128
bool endRenderingQueued(void)
Check for planned end of rendering.
TextureManager * getTextureManager(void)
Retrieves a reference to the current TextureManager.
map< String, MovableObjectFactory * >::type MovableObjectFactoryMap
Definition: OgreRoot.h:135
const PluginInstanceList & getInstalledPlugins() const
Gets a read-only list of the currently installed plugins.
Definition: OgreRoot.h:756
bool _fireFrameEnded()
Method for raising frame ended events.
Real calculateEventTime(unsigned long now, FrameEventTimeType type)
Internal method for calculating the average time between recently fired events.
void convertColourValue(const ColourValue &colour, uint32 *pDest)
Generates a packed data version of the passed in ColourValue suitable for use with the current Render...
void removeMovableObjectFactory(MovableObjectFactory *fact)
Removes a previously registered MovableObjectFactory.
void installPlugin(Plugin *plugin)
Install a new plugin.
uint32 mNextMovableObjectTypeFlag
Definition: OgreRoot.h:137
WorkQueue * mWorkQueue
Definition: OgreRoot.h:152
set< FrameListener * >::type mFrameListeners
Set of registered frame listeners.
Definition: OgreRoot.h:184
HighLevelGpuProgramManager * mHighLevelGpuProgramManager
Definition: OgreRoot.h:118
static Root & getSingleton(void)
Override standard Singleton retrieval.
FrameEventTimeType
Indicates the type of event to be considered by calculateEventTime().
Definition: OgreRoot.h:192
String getErrorDescription(long errorNumber)
Utility function for getting a better description of an error code.
RenderWindow * mAutoWindow
Definition: OgreRoot.h:116
deque< SceneManager * >::type SceneManagerStack
Definition: OgreRoot.h:89
ConstMapIterator< MovableObjectFactoryMap > MovableObjectFactoryIterator
Definition: OgreRoot.h:1025
RenderSystemCapabilitiesManager * mRenderSystemCapabilitiesManager
Definition: OgreRoot.h:109
bool getRemoveRenderQueueStructuresOnClear() const
Get whether the entire render queue structure should be emptied on clearing, or whether just the obje...
Definition: OgreRoot.h:351
RenderQueueInvocationSequence * createRenderQueueInvocationSequence(const String &name)
Create a new RenderQueueInvocationSequence, useful for linking to Viewport instances to perform custo...
bool renderOneFrame(Real timeSinceLastFrame)
Render one frame, with custom frame time information.
PluginLibList mPluginLibs
List of plugin DLLs loaded.
Definition: OgreRoot.h:131
RenderTarget * getRenderTarget(const String &name)
Retrieves a pointer to a named render target.
CompositorManager * mCompositorManager
Definition: OgreRoot.h:120
void destroySceneManager(SceneManager *sm)
Destroy an instance of a SceneManager.
RenderWindow * getAutoCreatedWindow(void)
Retrieves a pointer to the window that was created automatically.
bool restoreConfig(void)
Checks for saved video/sound/etc settings.
const SceneManagerMetaData * getSceneManagerMetaData(const String &typeName) const
Get more information about a given type of SceneManager.
LogManager * mLogManager
Definition: OgreRoot.h:86
SceneManagerStack mSceneManagerStack
Definition: OgreRoot.h:90
SceneManager * _getCurrentSceneManager(void) const
Returns the scene manager currently being used to render a frame.
DataStreamPtr createFileStream(const String &filename, const String &groupName=ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, bool overwrite=false, const String &locationPattern=StringUtil::BLANK)
Helper method to assist you in creating writeable file streams.
Root(const String &pluginFileName="plugins" OGRE_BUILD_SUFFIX ".cfg", const String &configFileName="ogre.cfg", const String &logFileName="Ogre.log")
Constructor.
void startRendering(void)
Starts / restarts the automatic rendering cycle.
bool hasMovableObjectFactory(const String &typeName) const
Checks whether a factory is registered for a given MovableObject type.
SceneManager * getSceneManager(const String &instanceName) const
Get an existing SceneManager instance that has already been created, identified by the instance name.
void destroyRenderTarget(RenderTarget *target)
Destroys the given RenderTarget.
ParticleSystemManager * mParticleManager
Definition: OgreRoot.h:95
void setBlendIndicesGpuRedundant(bool redundant)
Sets whether blend indices information needs to be passed to the GPU.
Definition: OgreRoot.h:1060
void unloadPlugin(const String &pluginName)
Manually unloads a Plugin contained in a DLL / DSO.
unsigned long getNextFrameNumber(void) const
Gets the number of the next frame to be rendered.
Definition: OgreRoot.h:862
MovableObjectFactory * mEntityFactory
Definition: OgreRoot.h:139
RenderTarget * detachRenderTarget(RenderTarget *pWin)
Detaches a RenderTarget from the active render system and returns a pointer to it.
void setDefaultMinPixelSize(Real pixelSize)
Set the default minimum pixel size for object to be rendered by.
Definition: OgreRoot.h:1082
void loadPlugins(const String &pluginsfile="plugins" OGRE_BUILD_SUFFIX ".cfg")
Method reads a plugins configuration file and instantiates all plugins.
MovableObjectFactoryMap mMovableObjectFactoryMap
Definition: OgreRoot.h:136
bool mQueuedEnd
Definition: OgreRoot.h:81
bool mIsBlendWeightsGpuRedundant
Tells whether blend weights information needs to be passed to the GPU.
Definition: OgreRoot.h:157
WorkQueue * getWorkQueue() const
Get the WorkQueue for processing background tasks.
Definition: OgreRoot.h:1042
MovableObjectFactory * mManualObjectFactory
Definition: OgreRoot.h:142
SceneManager * createSceneManager(SceneTypeMask typeMask, const String &instanceName=StringUtil::BLANK)
Create a SceneManager instance based on scene type support.
bool mIsInitialised
Are we initialised yet?
Definition: OgreRoot.h:150
RenderQueueInvocationSequenceMap mRQSequenceMap
Definition: OgreRoot.h:147
deque< unsigned long >::type EventTimesQueue
Contains the times of recently fired events.
Definition: OgreRoot.h:201
PluginInstanceList mPlugins
List of Plugin instances registered.
Definition: OgreRoot.h:133
PMWorker * mPMWorker
Definition: OgreRoot.h:112
MovableObjectFactory * mRibbonTrailFactory
Definition: OgreRoot.h:144
bool isBlendWeightsGpuRedundant() const
Returns whether blend weights information needs to be passed to the GPU see setBlendWeightsGpuRedunda...
Definition: OgreRoot.h:1076
Real getDefaultMinPixelSize()
Get the default minimum pixel size for object to be rendered by.
Definition: OgreRoot.h:1086
void setBlendWeightsGpuRedundant(bool redundant)
Sets whether blend weights information needs to be passed to the GPU.
Definition: OgreRoot.h:1072
unsigned long mNextFrame
Definition: OgreRoot.h:121
MovableObjectFactory * getMovableObjectFactory(const String &typeName)
Get a MovableObjectFactory for the given type.
RenderSystem * getRenderSystem(void)
Retrieve a pointer to the currently selected render system.
RenderWindow * initialise(bool autoCreateWindow, const String &windowTitle="OGRE Render Window", const String &customCapabilitiesConfig=StringUtil::BLANK)
Initialises the renderer.
bool _updateAllRenderTargets(FrameEvent &evt)
Internal method used for updating all RenderTarget objects (windows, renderable textures etc) which a...
void removeFrameListener(FrameListener *oldListener)
Removes a FrameListener from the list of listening classes.
void unloadPlugins()
Unloads all loaded plugins.
Real getFrameSmoothingPeriod(void) const
Gets the period over which OGRE smooths out fluctuations in frame times.
Definition: OgreRoot.h:990
MovableObjectFactory * mBillboardSetFactory
Definition: OgreRoot.h:141
set< FrameListener * >::type mAddedFrameListeners
Definition: OgreRoot.h:188
RenderQueueInvocationSequence * getRenderQueueInvocationSequence(const String &name)
Get a RenderQueueInvocationSequence.
MeshManager * mMeshManager
Definition: OgreRoot.h:94
RenderSystem * mActiveRenderer
Definition: OgreRoot.h:78
Real mFrameSmoothingTime
Definition: OgreRoot.h:122
ControllerManager * mControllerManager
Definition: OgreRoot.h:87
void destroyRenderTarget(const String &name)
Destroys the given named RenderTarget.
void setRemoveRenderQueueStructuresOnClear(bool r)
Set whether the entire render queue structure should be emptied on clearing, or whether just the obje...
Definition: OgreRoot.h:356
MaterialManager * mMaterialManager
Definition: OgreRoot.h:93
void queueEndRendering(bool state=true)
Queues the end of rendering.
void destroyAllRenderQueueInvocationSequences(void)
Destroy all RenderQueueInvocationSequences.
bool mFirstTimePostWindowInit
In case multiple render windows are created, only once are the resources loaded.
Definition: OgreRoot.h:83
SceneManagerEnumerator::MetaDataIterator getSceneManagerMetaDataIterator(void) const
Iterate over all types of SceneManager available for construction, providing some information about e...
SceneManagerEnumerator::SceneManagerIterator getSceneManagerIterator(void)
Get an iterator over all the existing SceneManager instances.
RenderSystem * getRenderSystemByName(const String &name)
Retrieve a pointer to the render system by the given name.
void shutdown(void)
Shuts down the system manually.
void saveConfig(void)
Saves the details of the current configuration.
bool hasSceneManager(const String &instanceName) const
Determines if a given SceneManager already exists.
void addRenderSystem(RenderSystem *newRend)
Adds a new rendering subsystem to the list of available renderers.
DynLibManager * mDynLibManager
Definition: OgreRoot.h:91
String mConfigFileName
Definition: OgreRoot.h:80
Profiler * mProfiler
Definition: OgreRoot.h:117
MovableObjectFactory * mBillboardChainFactory
Definition: OgreRoot.h:143
bool renderOneFrame(void)
Render one frame.
Timer * mTimer
Definition: OgreRoot.h:115
void addFrameListener(FrameListener *newListener)
Registers a FrameListener which will be called back every frame.
bool createRenderWindows(const RenderWindowDescriptionList &renderWindowDescriptions, RenderWindowList &createdWindows)
Creates multiple rendering windows.
void loadPlugin(const String &pluginName)
Manually load a Plugin contained in a DLL / DSO.
bool mRemoveQueueStructuresOnClear
Definition: OgreRoot.h:123
void populateFrameEvent(FrameEventTimeType type, FrameEvent &evtToUpdate)
Update a set of event times (note, progressive, only call once for each type per frame)
bool _fireFrameStarted()
Method for raising frame started events.
void setRenderSystem(RenderSystem *system)
Sets the rendering subsystem to be used.
bool mIsBlendIndicesGpuRedundant
Tells whether blend indices information needs to be passed to the GPU.
Definition: OgreRoot.h:155
void setWorkQueue(WorkQueue *queue)
Replace the current work queue with an alternative.
void removeSceneManagerFactory(SceneManagerFactory *fact)
Unregister a SceneManagerFactory.
RenderTarget * detachRenderTarget(const String &name)
Detaches a named RenderTarget from the active render system and returns a pointer to it.
Enumerates the SceneManager classes available to applications.
Class which will create instances of a given SceneManager.
Manages the organisation and rendering of a 'scene' i.e.
Manages threaded compilation of scripts.
Class to manage the available shadow textures which may be shared between many SceneManager instances...
Template class for creating single-instance global classes.
Definition: OgreSingleton.h:65
Handles the management of skeleton resources.
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196
Class for loading & managing textures.
Timer class.
Interface to a general purpose request / response style background work queue.
Definition: OgreWorkQueue.h:71
vector< RenderWindow * >::type RenderWindowList
Render window container.
Definition: OgreCommon.h:764
vector< RenderWindowDescription >::type RenderWindowDescriptionList
Render window creation parameters container.
Definition: OgreCommon.h:761
vector< RenderSystem * >::type RenderSystemList
Definition: OgreRoot.h:56
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550
uint16 SceneTypeMask
Bitmask containing scene types.
float Real
Software floating point type.
unsigned int uint32
Definition: OgrePlatform.h:359
_StringBase String
Struct containing information about a frame event.
Structure containing information about a scene manager.
std::set< T, P, A > type

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.