OgreMain/src/OgreRoot.cpp

   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-2006 Torus Knot Software Ltd
   8 Also see acknowledgements in Readme.html
   9
  10 This program is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU Lesser General Public License as published by the Free Software
  12 Foundation; either version 2 of the License, or (at your option) any later
  13 version.
  14
  15 This program is distributed in the hope that it will be useful, but WITHOUT
  16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
  18
  19 You should have received a copy of the GNU Lesser General Public License along with
  20 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  21 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
  22 http://www.gnu.org/copyleft/lesser.txt.
  23
  24 You may alternatively use this source under the terms of a specific version of
  25 the OGRE Unrestricted License provided you have obtained such a license from
  26 Torus Knot Software Ltd.
  27 -----------------------------------------------------------------------------
  28 */
  29 // Ogre includes
  30 #include "OgreStableHeaders.h"
  31
  32 #include "OgreRoot.h"
  33
  34 #include "OgreRenderSystem.h"
  35 #include "OgreRenderWindow.h"
  36 #include "OgreException.h"
  37 #include "OgreControllerManager.h"
  38 #include "OgreLogManager.h"
  39 #include "OgreMath.h"
  40 #include "OgreDynLibManager.h"
  41 #include "OgreDynLib.h"
  42 #include "OgreConfigFile.h"
  43 #include "OgreMaterialManager.h"
  44 #include "OgreRenderSystemCapabilitiesManager.h"
  45 #include "OgreMeshManager.h"
  46 #include "OgreTextureManager.h"
  47 #include "OgreParticleSystemManager.h"
  48 #include "OgreSkeletonManager.h"
  49 #include "OgreOverlayElementFactory.h"
  50 #include "OgreOverlayManager.h"
  51 #include "OgreProfiler.h"
  52 #include "OgreErrorDialog.h"
  53 #include "OgreConfigDialog.h"
  54 #include "OgreStringConverter.h"
  55 #include "OgreArchiveManager.h"
  56 #include "OgrePlugin.h"
  57 #include "OgreZip.h"
  58 #include "OgreFileSystem.h"
  59 #include "OgreShadowVolumeExtrudeProgram.h"
  60 #include "OgreResourceBackgroundQueue.h"
  61 #include "OgreEntity.h"
  62 #include "OgreBillboardSet.h"
  63 #include "OgreBillboardChain.h"
  64 #include "OgreRibbonTrail.h"
  65 #include "OgreLight.h"
  66 #include "OgreManualObject.h"
  67 #include "OgreRenderQueueInvocation.h"
  68 #include "OgrePlatformInformation.h"
  69 #include "OgreConvexBody.h"
  70
  71 #if OGRE_NO_FREEIMAGE == 0
  72 #include "OgreFreeImageCodec.h"
  73 #endif
  74 #if OGRE_NO_DEVIL == 0
  75 #include "OgreILCodecs.h"
  76 #endif
  77 #if OGRE_NO_DDS_CODEC == 0
  78 #include "OgreDDSCodec.h"
  79 #endif
  80
  81 #include "OgreFontManager.h"
  82 #include "OgreHardwareBufferManager.h"
  83
  84 #include "OgreOverlay.h"
  85 #include "OgreHighLevelGpuProgramManager.h"
  86
  87 #include "OgreExternalTextureSourceManager.h"
  88 #include "OgreCompositorManager.h"
  89
  90 #include "OgreScriptCompiler.h"
  91
  92 #include "OgreWindowEventUtilities.h"
  93
  94 namespace Ogre {
  95     //-----------------------------------------------------------------------
  96     template<> Root* Singleton<Root>::ms_Singleton = 0;
  97     Root* Root::getSingletonPtr(void)
  98     {
  99         return ms_Singleton;
 100     }
 101     Root& Root::getSingleton(void)
 102     {
 103         assert( ms_Singleton );  return ( *ms_Singleton );
 104     }
 105
 106     typedef void (*DLL_START_PLUGIN)(void);
 107     typedef void (*DLL_STOP_PLUGIN)(void);
 108
 109
 110     //-----------------------------------------------------------------------
 111     Root::Root(const String& pluginFileName, const String& configFileName,
 112                 const String& logFileName)
 113       : mLogManager(0)
 114           , mRenderSystemCapabilitiesManager(0)
 115           , mNextFrame(0)
 116           , mFrameSmoothingTime(0.0f)
 117           , mNextMovableObjectTypeFlag(1)
 118           , mIsInitialised(false)
 119     {
 120         // superclass will do singleton checking
 121         String msg;
 122
 123         // Init
 124         mActiveRenderer = 0;
 125         mVersion = StringConverter::toString(OGRE_VERSION_MAJOR) + "." +
 126             StringConverter::toString(OGRE_VERSION_MINOR) + "." +
 127             StringConverter::toString(OGRE_VERSION_PATCH) +
 128                         OGRE_VERSION_SUFFIX + " " +
 129             "(" + OGRE_VERSION_NAME + ")";
 130                 mConfigFileName = configFileName;
 131
 132                 // Create log manager and default log file if there is no log manager yet
 133                 if(LogManager::getSingletonPtr() == 0)
 134                 {
 135                         mLogManager = OGRE_NEW LogManager();
 136                         mLogManager->createLog(logFileName, true, true);
 137                 }
 138
 139         // Dynamic library manager
 140         mDynLibManager = OGRE_NEW DynLibManager();
 141
 142         mArchiveManager = OGRE_NEW ArchiveManager();
 143
 144                 // ResourceGroupManager
 145                 mResourceGroupManager = OGRE_NEW ResourceGroupManager();
 146
 147                 // ResourceBackgroundQueue
 148                 mResourceBackgroundQueue = OGRE_NEW ResourceBackgroundQueue();
 149
 150                 // Create SceneManager enumerator (note - will be managed by singleton)
 151         mSceneManagerEnum = OGRE_NEW SceneManagerEnumerator();
 152         mCurrentSceneManager = NULL;
 153
 154                 mShadowTextureManager = OGRE_NEW ShadowTextureManager();
 155
 156                 mRenderSystemCapabilitiesManager = OGRE_NEW RenderSystemCapabilitiesManager();
 157
 158         // ..material manager
 159         mMaterialManager = OGRE_NEW MaterialManager();
 160
 161         // Mesh manager
 162         mMeshManager = OGRE_NEW MeshManager();
 163
 164         // Skeleton manager
 165         mSkeletonManager = OGRE_NEW SkeletonManager();
 166
 167         // ..particle system manager
 168         mParticleManager = OGRE_NEW ParticleSystemManager();
 169
 170                 // Compiler manager
 171                 //mCompilerManager = OGRE_NEW ScriptCompilerManager();
 172
 173         mTimer = OGRE_NEW Timer();
 174
 175         // Overlay manager
 176         mOverlayManager = OGRE_NEW OverlayManager();
 177
 178         mPanelFactory = OGRE_NEW PanelOverlayElementFactory();
 179         mOverlayManager->addOverlayElementFactory(mPanelFactory);
 180
 181         mBorderPanelFactory = OGRE_NEW BorderPanelOverlayElementFactory();
 182         mOverlayManager->addOverlayElementFactory(mBorderPanelFactory);
 183
 184         mTextAreaFactory = OGRE_NEW TextAreaOverlayElementFactory();
 185         mOverlayManager->addOverlayElementFactory(mTextAreaFactory);
 186         // Font manager
 187         mFontManager = OGRE_NEW FontManager();
 188
 189         // Lod strategy manager
 190         mLodStrategyManager = OGRE_NEW LodStrategyManager();
 191
 192 #if OGRE_PROFILING
 193         // Profiler
 194         mProfiler = OGRE_NEW Profiler();
 195                 Profiler::getSingleton().setTimer(mTimer);
 196 #endif
 197         mFileSystemArchiveFactory = OGRE_NEW FileSystemArchiveFactory();
 198         ArchiveManager::getSingleton().addArchiveFactory( mFileSystemArchiveFactory );
 199         mZipArchiveFactory = OGRE_NEW ZipArchiveFactory();
 200         ArchiveManager::getSingleton().addArchiveFactory( mZipArchiveFactory );
 201 #if OGRE_NO_FREEIMAGE == 0
 202                 // Register image codecs
 203                 FreeImageCodec::startup();
 204 #endif
 205 #if OGRE_NO_DEVIL == 0
 206             // Register image codecs
 207             ILCodecs::registerCodecs();
 208 #endif
 209 #if OGRE_NO_DDS_CODEC == 0
 210                 // Register image codecs
 211                 DDSCodec::startup();
 212 #endif
 213
 214         mHighLevelGpuProgramManager = OGRE_NEW HighLevelGpuProgramManager();
 215
 216                 mExternalTextureSourceManager = OGRE_NEW ExternalTextureSourceManager();
 217         mCompositorManager = OGRE_NEW CompositorManager();
 218
 219                 mCompilerManager = OGRE_NEW ScriptCompilerManager();
 220
 221         // Auto window
 222         mAutoWindow = 0;
 223
 224                 // instantiate and register base movable factories
 225                 mEntityFactory = OGRE_NEW EntityFactory();
 226                 addMovableObjectFactory(mEntityFactory);
 227                 mLightFactory = OGRE_NEW LightFactory();
 228                 addMovableObjectFactory(mLightFactory);
 229                 mBillboardSetFactory = OGRE_NEW BillboardSetFactory();
 230                 addMovableObjectFactory(mBillboardSetFactory);
 231                 mManualObjectFactory = OGRE_NEW ManualObjectFactory();
 232                 addMovableObjectFactory(mManualObjectFactory);
 233                 mBillboardChainFactory = OGRE_NEW BillboardChainFactory();
 234                 addMovableObjectFactory(mBillboardChainFactory);
 235                 mRibbonTrailFactory = OGRE_NEW RibbonTrailFactory();
 236                 addMovableObjectFactory(mRibbonTrailFactory);
 237
 238                 // Load plugins
 239         if (!pluginFileName.empty())
 240             loadPlugins(pluginFileName);
 241
 242                 LogManager::getSingleton().logMessage("*-*-* OGRE Initialising");
 243         msg = "*-*-* Version " + mVersion;
 244         LogManager::getSingleton().logMessage(msg);
 245
 246         // Can't create managers until initialised
 247         mControllerManager = 0;
 248
 249         mFirstTimePostWindowInit = false;
 250
 251     }
 252
 253     //-----------------------------------------------------------------------
 254     Root::~Root()
 255     {
 256         shutdown();
 257         OGRE_DELETE mSceneManagerEnum;
 258                 OGRE_DELETE mShadowTextureManager;
 259                 OGRE_DELETE mRenderSystemCapabilitiesManager;
 260
 261                 destroyAllRenderQueueInvocationSequences();
 262         OGRE_DELETE mCompositorManager;
 263                 OGRE_DELETE mExternalTextureSourceManager;
 264 #if OGRE_NO_FREEIMAGE == 0
 265                 FreeImageCodec::shutdown();
 266 #endif
 267 #if OGRE_NO_DEVIL == 0
 268         ILCodecs::deleteCodecs();
 269 #endif
 270 #if OGRE_NO_DDS_CODEC == 0
 271                 DDSCodec::shutdown();
 272 #endif
 273 #if OGRE_PROFILING
 274         OGRE_DELETE mProfiler;
 275 #endif
 276         OGRE_DELETE mOverlayManager;
 277         OGRE_DELETE mFontManager;
 278                 OGRE_DELETE mLodStrategyManager;
 279         OGRE_DELETE mArchiveManager;
 280         OGRE_DELETE mZipArchiveFactory;
 281         OGRE_DELETE mFileSystemArchiveFactory;
 282         OGRE_DELETE mSkeletonManager;
 283         OGRE_DELETE mMeshManager;
 284         OGRE_DELETE mParticleManager;
 285                 //OGRE_DELETE mCompilerManager;
 286
 287         if( mControllerManager )
 288             OGRE_DELETE mControllerManager;
 289         if (mHighLevelGpuProgramManager)
 290             OGRE_DELETE mHighLevelGpuProgramManager;
 291
 292         OGRE_DELETE mTextAreaFactory;
 293         OGRE_DELETE mBorderPanelFactory;
 294         OGRE_DELETE mPanelFactory;
 295
 296         unloadPlugins();
 297         OGRE_DELETE mMaterialManager;
 298         Pass::processPendingPassUpdates(); // make sure passes are cleaned
 299                 OGRE_DELETE mResourceBackgroundQueue;
 300         OGRE_DELETE mResourceGroupManager;
 301
 302                 OGRE_DELETE mEntityFactory;
 303                 OGRE_DELETE mLightFactory;
 304                 OGRE_DELETE mBillboardSetFactory;
 305                 OGRE_DELETE mManualObjectFactory;
 306                 OGRE_DELETE mBillboardChainFactory;
 307                 OGRE_DELETE mRibbonTrailFactory;
 308
 309                 OGRE_DELETE mTimer;
 310
 311         OGRE_DELETE mDynLibManager;
 312         OGRE_DELETE mLogManager;
 313
 314                 OGRE_DELETE mCompilerManager;
 315
 316                 mAutoWindow = 0;
 317                 mFirstTimePostWindowInit = false;
 318
 319
 320         StringInterface::cleanupDictionary ();
 321     }
 322
 323     //-----------------------------------------------------------------------
 324     void Root::saveConfig(void)
 325     {
 326         if (mConfigFileName.empty ())
 327             return;
 328
 329                 std::ofstream of(mConfigFileName.c_str());
 330
 331         if (!of)
 332             OGRE_EXCEPT(Exception::ERR_CANNOT_WRITE_TO_FILE, "Cannot create settings file.",
 333             "Root::saveConfig");
 334
 335         if (mActiveRenderer)
 336         {
 337             of << "Render System=" << mActiveRenderer->getName() << std::endl;
 338         }
 339         else
 340         {
 341             of << "Render System=" << std::endl;
 342         }
 343
 344         for (RenderSystemList::const_iterator pRend = getAvailableRenderers().begin(); pRend != getAvailableRenderers().end(); ++pRend)
 345         {
 346             RenderSystem* rs = *pRend;
 347             of << std::endl;
 348             of << "[" << rs->getName() << "]" << std::endl;
 349             const ConfigOptionMap& opts = rs->getConfigOptions();
 350             for (ConfigOptionMap::const_iterator pOpt = opts.begin(); pOpt != opts.end(); ++pOpt)
 351             {
 352                                 of << pOpt->first << "=" << pOpt->second.currentValue << std::endl;
 353             }
 354         }
 355
 356         of.close();
 357
 358     }
 359     //-----------------------------------------------------------------------
 360     bool Root::restoreConfig(void)
 361     {
 362         if (mConfigFileName.empty ())
 363             return true;
 364
 365         // Restores configuration from saved state
 366         // Returns true if a valid saved configuration is
 367         //   available, and false if no saved config is
 368         //   stored, or if there has been a problem
 369         ConfigFile cfg;
 370
 371         try {
 372             // Don't trim whitespace
 373             cfg.load(mConfigFileName, "\t:=", false);
 374         }
 375         catch (Exception& e)
 376         {
 377             if (e.getNumber() == Exception::ERR_FILE_NOT_FOUND)
 378             {
 379                 return false;
 380             }
 381             else
 382             {
 383                 throw;
 384             }
 385         }
 386
 387         ConfigFile::SectionIterator iSection = cfg.getSectionIterator();
 388         while (iSection.hasMoreElements())
 389         {
 390             const String& renderSystem = iSection.peekNextKey();
 391             const ConfigFile::SettingsMultiMap& settings = *iSection.getNext();
 392
 393             RenderSystem* rs = getRenderSystemByName(renderSystem);
 394             if (!rs)
 395             {
 396                 // Unrecognised render system
 397                 continue;
 398             }
 399
 400             ConfigFile::SettingsMultiMap::const_iterator i;
 401             for (i = settings.begin(); i != settings.end(); ++i)
 402             {
 403                 rs->setConfigOption(i->first, i->second);
 404             }
 405         }
 406
 407         RenderSystem* rs = getRenderSystemByName(cfg.getSetting("Render System"));
 408         if (!rs)
 409         {
 410             // Unrecognised render system
 411             return false;
 412         }
 413
 414         setRenderSystem(rs);
 415
 416         // Successful load
 417         return true;
 418
 419     }
 420
 421     //-----------------------------------------------------------------------
 422     bool Root::showConfigDialog(void)
 423     {
 424         // Displays the standard config dialog
 425         // Will use stored defaults if available
 426         ConfigDialog* dlg;
 427         bool isOk;
 428
 429         restoreConfig();
 430
 431         dlg = OGRE_NEW ConfigDialog();
 432
 433         if ((isOk = dlg->display()))
 434             saveConfig();
 435
 436         OGRE_DELETE dlg;
 437         return isOk;
 438     }
 439
 440     //-----------------------------------------------------------------------
 441     const RenderSystemList& Root::getAvailableRenderers(void)
 442     {
 443         // Returns a vector of renders
 444
 445         return mRenderers;
 446
 447     }
 448
 449     //-----------------------------------------------------------------------
 450     RenderSystem* Root::getRenderSystemByName(const String& name)
 451     {
 452         if (name.empty())
 453         {
 454             // No render system
 455             return NULL;
 456         }
 457
 458         RenderSystemList::const_iterator pRend;
 459         for (pRend = getAvailableRenderers().begin(); pRend != getAvailableRenderers().end(); ++pRend)
 460         {
 461             RenderSystem* rs = *pRend;
 462             if (rs->getName() == name)
 463                 return rs;
 464         }
 465
 466         // Unrecognised render system
 467         return NULL;
 468     }
 469
 470     //-----------------------------------------------------------------------
 471     void Root::setRenderSystem(RenderSystem* system)
 472     {
 473         // Sets the active rendering system
 474         // Can be called direct or will be called by
 475         //   standard config dialog
 476
 477         // Is there already an active renderer?
 478         // If so, disable it and init the new one
 479         if( mActiveRenderer && mActiveRenderer != system )
 480         {
 481             mActiveRenderer->shutdown();
 482         }
 483
 484         mActiveRenderer = system;
 485         // Tell scene managers
 486         SceneManagerEnumerator::getSingleton().setRenderSystem(system);
 487
 488     }
 489     //-----------------------------------------------------------------------
 490     void Root::addRenderSystem(RenderSystem *newRend)
 491     {
 492         mRenderers.push_back(newRend);
 493     }
 494     //-----------------------------------------------------------------------
 495         void Root::_setCurrentSceneManager(SceneManager* sm)
 496         {
 497                 mCurrentSceneManager = sm;
 498         }
 499     //-----------------------------------------------------------------------
 500     RenderSystem* Root::getRenderSystem(void)
 501     {
 502         // Gets the currently active renderer
 503         return mActiveRenderer;
 504
 505     }
 506
 507     //-----------------------------------------------------------------------
 508     RenderWindow* Root::initialise(bool autoCreateWindow, const String& windowTitle, const String& customCapabilitiesConfig)
 509     {
 510         if (!mActiveRenderer)
 511             OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
 512             "Cannot initialise - no render "
 513             "system has been selected.", "Root::initialise");
 514
 515         if (!mControllerManager)
 516                         mControllerManager = OGRE_NEW ControllerManager();
 517
 518         // .rendercaps manager
 519         RenderSystemCapabilitiesManager& rscManager = RenderSystemCapabilitiesManager::getSingleton();
 520         // caller wants to load custom RenderSystemCapabilities form a config file
 521         if(customCapabilitiesConfig != StringUtil::BLANK)
 522         {
 523             ConfigFile cfg;
 524             cfg.load(customCapabilitiesConfig, "\t:=", false);
 525
 526             // Capabilities Database setting must be in the same format as
 527             // resources.cfg in Ogre examples.
 528             ConfigFile::SettingsIterator iter = cfg.getSettingsIterator("Capabilities Database");
 529             while(iter.hasMoreElements())
 530             {
 531                 String archType = iter.peekNextKey();
 532                 String filename = iter.getNext();
 533
 534                 rscManager.parseCapabilitiesFromArchive(filename, archType, true);
 535             }
 536
 537             String capsName = cfg.getSetting("Custom Capabilities");
 538             // The custom capabilities have been parsed, let's retrieve them
 539             RenderSystemCapabilities* rsc = rscManager.loadParsedCapabilities(capsName);
 540                         if(rsc == 0)
 541                         {
 542                                 OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
 543                                         String("Cannot load a RenderSystemCapability named ") + capsName,
 544                                         "Root::initialise");
 545                         }
 546
 547             // Tell RenderSystem to use the comon rsc
 548             useCustomRenderSystemCapabilities(rsc);
 549         }
 550
 551
 552                 PlatformInformation::log(LogManager::getSingleton().getDefaultLog());
 553                 mAutoWindow =  mActiveRenderer->_initialise(autoCreateWindow, windowTitle);
 554
 555
 556         if (autoCreateWindow && !mFirstTimePostWindowInit)
 557         {
 558             oneTimePostWindowInit();
 559             mAutoWindow->_setPrimary();
 560         }
 561
 562         // Initialise timer
 563         mTimer->reset();
 564
 565                 // Init pools
 566                 ConvexBody::_initialisePool();
 567
 568                 mIsInitialised = true;
 569
 570         return mAutoWindow;
 571
 572     }
 573     //-----------------------------------------------------------------------
 574     void Root::useCustomRenderSystemCapabilities(RenderSystemCapabilities* capabilities)
 575     {
 576         mActiveRenderer->useCustomRenderSystemCapabilities(capabilities);
 577     }
 578     //-----------------------------------------------------------------------
 579     String Root::getErrorDescription(long errorNumber)
 580     {
 581
 582         // Pass to render system
 583         if (mActiveRenderer)
 584             return mActiveRenderer->getErrorDescription(errorNumber);
 585         else
 586             return "";
 587
 588     }
 589         //-----------------------------------------------------------------------
 590         void Root::addSceneManagerFactory(SceneManagerFactory* fact)
 591         {
 592                 mSceneManagerEnum->addFactory(fact);
 593         }
 594         //-----------------------------------------------------------------------
 595         void Root::removeSceneManagerFactory(SceneManagerFactory* fact)
 596         {
 597                 mSceneManagerEnum->removeFactory(fact);
 598         }
 599         //-----------------------------------------------------------------------
 600         const SceneManagerMetaData* Root::getSceneManagerMetaData(const String& typeName) const
 601         {
 602                 return mSceneManagerEnum->getMetaData(typeName);
 603         }
 604         //-----------------------------------------------------------------------
 605         SceneManagerEnumerator::MetaDataIterator
 606         Root::getSceneManagerMetaDataIterator(void) const
 607         {
 608                 return mSceneManagerEnum->getMetaDataIterator();
 609
 610         }
 611         //-----------------------------------------------------------------------
 612         SceneManager* Root::createSceneManager(const String& typeName,
 613                 const String& instanceName)
 614         {
 615                 return mSceneManagerEnum->createSceneManager(typeName, instanceName);
 616         }
 617         //-----------------------------------------------------------------------
 618         SceneManager* Root::createSceneManager(SceneTypeMask typeMask,
 619                 const String& instanceName)
 620         {
 621                 return mSceneManagerEnum->createSceneManager(typeMask, instanceName);
 622         }
 623         //-----------------------------------------------------------------------
 624         void Root::destroySceneManager(SceneManager* sm)
 625         {
 626                 mSceneManagerEnum->destroySceneManager(sm);
 627         }
 628         //-----------------------------------------------------------------------
 629         SceneManager* Root::getSceneManager(const String& instanceName) const
 630         {
 631                 return mSceneManagerEnum->getSceneManager(instanceName);
 632         }
 633         //-----------------------------------------------------------------------
 634         SceneManagerEnumerator::SceneManagerIterator Root::getSceneManagerIterator(void)
 635         {
 636                 return mSceneManagerEnum->getSceneManagerIterator();
 637         }
 638     //-----------------------------------------------------------------------
 639     TextureManager* Root::getTextureManager(void)
 640     {
 641         return &TextureManager::getSingleton();
 642     }
 643     //-----------------------------------------------------------------------
 644     MeshManager* Root::getMeshManager(void)
 645     {
 646         return &MeshManager::getSingleton();
 647     }
 648     //-----------------------------------------------------------------------
 649     void Root::addFrameListener(FrameListener* newListener)
 650     {
 651                 // Check if the specified listener is scheduled for removal
 652                 set<FrameListener *>::type::iterator i = mRemovedFrameListeners.find(newListener);
 653
 654                 // If yes, cancel the removal. Otherwise add it to other listeners.
 655                 if (i != mRemovedFrameListeners.end())
 656                         mRemovedFrameListeners.erase(*i);
 657                 else
 658                         mFrameListeners.insert(newListener); // Insert, unique only (set)
 659     }
 660
 661     //-----------------------------------------------------------------------
 662     void Root::removeFrameListener(FrameListener* oldListener)
 663     {
 664         // Remove, 1 only (set)
 665         mRemovedFrameListeners.insert(oldListener);
 666     }
 667     //-----------------------------------------------------------------------
 668     bool Root::_fireFrameStarted(FrameEvent& evt)
 669     {
 670                 OgreProfileBeginGroup("Frame", OGREPROF_GENERAL);
 671
 672         // Remove all marked listeners
 673         set<FrameListener*>::type::iterator i;
 674         for (i = mRemovedFrameListeners.begin();
 675             i != mRemovedFrameListeners.end(); i++)
 676         {
 677             mFrameListeners.erase(*i);
 678         }
 679         mRemovedFrameListeners.clear();
 680
 681         // Tell all listeners
 682         for (i= mFrameListeners.begin(); i != mFrameListeners.end(); ++i)
 683         {
 684             if (!(*i)->frameStarted(evt))
 685                 return false;
 686         }
 687
 688         return true;
 689
 690     }
 691         //-----------------------------------------------------------------------
 692     bool Root::_fireFrameRenderingQueued(FrameEvent& evt)
 693     {
 694                 // Increment next frame number
 695                 ++mNextFrame;
 696
 697         // Remove all marked listeners
 698         set<FrameListener*>::type::iterator i;
 699         for (i = mRemovedFrameListeners.begin();
 700             i != mRemovedFrameListeners.end(); i++)
 701         {
 702             mFrameListeners.erase(*i);
 703         }
 704         mRemovedFrameListeners.clear();
 705
 706         // Tell all listeners
 707         for (i= mFrameListeners.begin(); i != mFrameListeners.end(); ++i)
 708         {
 709             if (!(*i)->frameRenderingQueued(evt))
 710                 return false;
 711         }
 712
 713         return true;
 714
 715     }
 716     //-----------------------------------------------------------------------
 717     bool Root::_fireFrameEnded(FrameEvent& evt)
 718     {
 719         // Remove all marked listeners
 720         set<FrameListener*>::type::iterator i;
 721         for (i = mRemovedFrameListeners.begin();
 722             i != mRemovedFrameListeners.end(); i++)
 723         {
 724             mFrameListeners.erase(*i);
 725         }
 726         mRemovedFrameListeners.clear();
 727
 728         // Tell all listeners
 729                 bool ret = true;
 730         for (i= mFrameListeners.begin(); i != mFrameListeners.end(); ++i)
 731         {
 732             if (!(*i)->frameEnded(evt))
 733                         {
 734                 ret = false;
 735                                 break;
 736                         }
 737         }
 738
 739         // Tell buffer manager to free temp buffers used this frame
 740         if (HardwareBufferManager::getSingletonPtr())
 741             HardwareBufferManager::getSingleton()._releaseBufferCopies();
 742
 743                 // Also tell the ResourceBackgroundQueue to propagate background load events
 744                 ResourceBackgroundQueue::getSingleton()._fireOnFrameCallbacks();
 745
 746                 OgreProfileEndGroup("Frame", OGREPROF_GENERAL);
 747
 748         return ret;
 749     }
 750     //-----------------------------------------------------------------------
 751     bool Root::_fireFrameStarted()
 752     {
 753         FrameEvent evt;
 754                 populateFrameEvent(FETT_STARTED, evt);
 755
 756         return _fireFrameStarted(evt);
 757     }
 758     //-----------------------------------------------------------------------
 759     bool Root::_fireFrameRenderingQueued()
 760     {
 761                 FrameEvent evt;
 762                 populateFrameEvent(FETT_QUEUED, evt);
 763
 764         return _fireFrameRenderingQueued(evt);
 765     }
 766     //-----------------------------------------------------------------------
 767     bool Root::_fireFrameEnded()
 768     {
 769         FrameEvent evt;
 770                 populateFrameEvent(FETT_ENDED, evt);
 771         return _fireFrameEnded(evt);
 772     }
 773         //---------------------------------------------------------------------
 774         void Root::populateFrameEvent(FrameEventTimeType type, FrameEvent& evtToUpdate)
 775         {
 776                 unsigned long now = mTimer->getMilliseconds();
 777                 evtToUpdate.timeSinceLastEvent = calculateEventTime(now, FETT_ANY);
 778                 evtToUpdate.timeSinceLastFrame = calculateEventTime(now, type);
 779         }
 780     //-----------------------------------------------------------------------
 781     Real Root::calculateEventTime(unsigned long now, FrameEventTimeType type)
 782     {
 783         // Calculate the average time passed between events of the given type
 784         // during the last mFrameSmoothingTime seconds.
 785
 786         EventTimesQueue& times = mEventTimes[type];
 787         times.push_back(now);
 788
 789         if(times.size() == 1)
 790             return 0;
 791
 792         // Times up to mFrameSmoothingTime seconds old should be kept
 793         unsigned long discardThreshold =
 794                         static_cast<unsigned long>(mFrameSmoothingTime * 1000.0f);
 795
 796         // Find the oldest time to keep
 797         EventTimesQueue::iterator it = times.begin(),
 798             end = times.end()-2; // We need at least two times
 799         while(it != end)
 800         {
 801             if (now - *it > discardThreshold)
 802                 ++it;
 803             else
 804                 break;
 805         }
 806
 807         // Remove old times
 808         times.erase(times.begin(), it);
 809
 810         return Real(times.back() - times.front()) / ((times.size()-1) * 1000);
 811     }
 812     //-----------------------------------------------------------------------
 813     void Root::queueEndRendering(void)
 814     {
 815             mQueuedEnd = true;
 816     }
 817     //-----------------------------------------------------------------------
 818     void Root::startRendering(void)
 819     {
 820         assert(mActiveRenderer != 0);
 821
 822         mActiveRenderer->_initRenderTargets();
 823
 824         // Clear event times
 825                 clearEventTimes();
 826
 827         // Infinite loop, until broken out of by frame listeners
 828         // or break out by calling queueEndRendering()
 829         mQueuedEnd = false;
 830
 831         while( !mQueuedEnd )
 832         {
 833                         //Pump messages in all registered RenderWindow windows
 834                         WindowEventUtilities::messagePump();
 835
 836                         if (!renderOneFrame())
 837                 break;
 838         }
 839     }
 840     //-----------------------------------------------------------------------
 841     bool Root::renderOneFrame(void)
 842     {
 843         if(!_fireFrameStarted())
 844             return false;
 845
 846                 if (!_updateAllRenderTargets())
 847                         return false;
 848
 849         return _fireFrameEnded();
 850     }
 851         //---------------------------------------------------------------------
 852         bool Root::renderOneFrame(Real timeSinceLastFrame)
 853         {
 854                 FrameEvent evt;
 855                 evt.timeSinceLastFrame = timeSinceLastFrame;
 856
 857                 unsigned long now = mTimer->getMilliseconds();
 858                 evt.timeSinceLastEvent = calculateEventTime(now, FETT_ANY);
 859
 860                 if(!_fireFrameStarted(evt))
 861                         return false;
 862
 863                 if (!_updateAllRenderTargets(evt))
 864                         return false;
 865
 866                 now = mTimer->getMilliseconds();
 867                 evt.timeSinceLastEvent = calculateEventTime(now, FETT_ANY);
 868
 869                 return _fireFrameEnded(evt);
 870         }
 871     //-----------------------------------------------------------------------
 872     void Root::shutdown(void)
 873     {
 874                 SceneManagerEnumerator::getSingleton().shutdownAll();
 875                 shutdownPlugins();
 876
 877         ShadowVolumeExtrudeProgram::shutdown();
 878                 mResourceBackgroundQueue->shutdown();
 879         ResourceGroupManager::getSingleton().shutdownAll();
 880
 881                 // Destroy pools
 882                 ConvexBody::_destroyPool();
 883
 884
 885                 mIsInitialised = false;
 886
 887                 LogManager::getSingleton().logMessage("*-*-* OGRE Shutdown");
 888     }
 889     //-----------------------------------------------------------------------
 890     void Root::loadPlugins( const String& pluginsfile )
 891     {
 892         StringVector pluginList;
 893         String pluginDir;
 894         ConfigFile cfg;
 895
 896                 try {
 897                 cfg.load( pluginsfile );
 898                 }
 899                 catch (Exception)
 900                 {
 901                         LogManager::getSingleton().logMessage(pluginsfile + " not found, automatic plugin loading disabled.");
 902                         return;
 903                 }
 904
 905         pluginDir = cfg.getSetting("PluginFolder"); // Ignored on Mac OS X, uses Resources/ directory
 906         pluginList = cfg.getMultiSetting("Plugin");
 907
 908 #if OGRE_PLATFORM != OGRE_PLATFORM_APPLE
 909                 if (pluginDir.empty())
 910                 {
 911                         // User didn't specify plugins folder, try current one
 912                         pluginDir = ".";
 913                 }
 914 #endif
 915
 916         char last_char = pluginDir[pluginDir.length()-1];
 917         if (last_char != '/' && last_char != '\\')
 918         {
 919 #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
 920             pluginDir += "\\";
 921 #elif OGRE_PLATFORM == OGRE_PLATFORM_LINUX
 922             pluginDir += "/";
 923 #endif
 924         }
 925
 926         for( StringVector::iterator it = pluginList.begin(); it != pluginList.end(); ++it )
 927         {
 928                         loadPlugin(pluginDir + (*it));
 929         }
 930
 931     }
 932     //-----------------------------------------------------------------------
 933         void Root::shutdownPlugins(void)
 934         {
 935                 // NB Shutdown plugins in reverse order to enforce dependencies
 936                 for (PluginInstanceList::reverse_iterator i = mPlugins.rbegin(); i != mPlugins.rend(); ++i)
 937                 {
 938                         (*i)->shutdown();
 939                 }
 940         }
 941         //-----------------------------------------------------------------------
 942         void Root::initialisePlugins(void)
 943         {
 944                 for (PluginInstanceList::iterator i = mPlugins.begin(); i != mPlugins.end(); ++i)
 945                 {
 946                         (*i)->initialise();
 947                 }
 948         }
 949         //-----------------------------------------------------------------------
 950         void Root::unloadPlugins(void)
 951     {
 952                 // unload dynamic libs first
 953         for (PluginLibList::reverse_iterator i = mPluginLibs.rbegin(); i != mPluginLibs.rend(); ++i)
 954         {
 955             // Call plugin shutdown
 956             DLL_STOP_PLUGIN pFunc = (DLL_STOP_PLUGIN)(*i)->getSymbol("dllStopPlugin");
 957                         // this will call uninstallPlugin
 958             pFunc();
 959             // Unload library & destroy
 960             DynLibManager::getSingleton().unload(*i);
 961
 962         }
 963                 mPluginLibs.clear();
 964
 965                 // now deal with any remaining plugins that were registered through other means
 966                 for (PluginInstanceList::reverse_iterator i = mPlugins.rbegin(); i != mPlugins.rend(); ++i)
 967                 {
 968                         // Note this does NOT call uninstallPlugin - this shutdown is for the
 969                         // detail objects
 970                         (*i)->uninstall();
 971                 }
 972                 mPlugins.clear();
 973
 974     }
 975     //-----------------------------------------------------------------------
 976     void Root::addResourceLocation(const String& name, const String& locType,
 977                 const String& groupName, bool recursive)
 978     {
 979                 ResourceGroupManager::getSingleton().addResourceLocation(
 980                         name, locType, groupName, recursive);
 981     }
 982         //-----------------------------------------------------------------------
 983         void Root::removeResourceLocation(const String& name, const String& groupName)
 984         {
 985                 ResourceGroupManager::getSingleton().removeResourceLocation(
 986                         name, groupName);
 987         }
 988     //-----------------------------------------------------------------------
 989     void Root::convertColourValue(const ColourValue& colour, uint32* pDest)
 990     {
 991         assert(mActiveRenderer != 0);
 992         mActiveRenderer->convertColourValue(colour, pDest);
 993     }
 994     //-----------------------------------------------------------------------
 995     RenderWindow* Root::getAutoCreatedWindow(void)
 996     {
 997         return mAutoWindow;
 998     }
 999     //-----------------------------------------------------------------------
1000         RenderWindow* Root::createRenderWindow(const String &name, unsigned int width, unsigned int height,
1001                         bool fullScreen, const NameValuePairList *miscParams)
1002         {
1003         if (!mActiveRenderer)
1004         {
1005             OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
1006             "Cannot create window - no render "
1007             "system has been selected.", "Root::createRenderWindow");
1008         }
1009         RenderWindow* ret;
1010         ret = mActiveRenderer->_createRenderWindow(name, width, height, fullScreen, miscParams);
1011
1012         // Initialisation for classes dependent on first window created
1013         if(!mFirstTimePostWindowInit)
1014         {
1015             oneTimePostWindowInit();
1016             ret->_setPrimary();
1017         }
1018
1019         return ret;
1020
1021     }
1022         //-----------------------------------------------------------------------
1023         bool Root::createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
1024                 RenderWindowList& createdWindows)
1025         {
1026                 if (!mActiveRenderer)
1027                 {
1028                         OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
1029                                 "Cannot create render windows - no render "
1030                                 "system has been selected.", "Root::createRenderWindows");
1031                 }
1032
1033                 bool success;
1034
1035                 success = mActiveRenderer->_createRenderWindows(renderWindowDescriptions, createdWindows);
1036                 if(success && !mFirstTimePostWindowInit)
1037                 {
1038                         oneTimePostWindowInit();
1039                         createdWindows[0]->_setPrimary();
1040                 }
1041
1042                 return success;
1043         }
1044     //-----------------------------------------------------------------------
1045     void Root::detachRenderTarget(RenderTarget* target)
1046     {
1047         if (!mActiveRenderer)
1048         {
1049             OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
1050             "Cannot create window - no render "
1051             "system has been selected.", "Root::destroyRenderWindow");
1052         }
1053
1054         mActiveRenderer->detachRenderTarget( target->getName() );
1055     }
1056     //-----------------------------------------------------------------------
1057     void Root::detachRenderTarget(const String &name)
1058     {
1059         if (!mActiveRenderer)
1060         {
1061             OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
1062             "Cannot create window - no render "
1063             "system has been selected.", "Root::destroyRenderWindow");
1064         }
1065
1066         mActiveRenderer->detachRenderTarget( name );
1067     }
1068     //-----------------------------------------------------------------------
1069     RenderTarget* Root::getRenderTarget(const String &name)
1070     {
1071         if (!mActiveRenderer)
1072         {
1073             OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
1074             "Cannot create window - no render "
1075             "system has been selected.", "Root::getRenderWindow");
1076         }
1077
1078         return mActiveRenderer->getRenderTarget(name);
1079     }
1080         //---------------------------------------------------------------------
1081         void Root::installPlugin(Plugin* plugin)
1082         {
1083                 LogManager::getSingleton().logMessage("Installing plugin: " + plugin->getName());
1084
1085                 mPlugins.push_back(plugin);
1086                 plugin->install();
1087
1088                 // if rendersystem is already initialised, call rendersystem init too
1089                 if (mIsInitialised)
1090                 {
1091                         plugin->initialise();
1092                 }
1093
1094                 LogManager::getSingleton().logMessage("Plugin successfully installed");
1095         }
1096         //---------------------------------------------------------------------
1097         void Root::uninstallPlugin(Plugin* plugin)
1098         {
1099                 LogManager::getSingleton().logMessage("Uninstalling plugin: " + plugin->getName());
1100                 PluginInstanceList::iterator i =
1101                         std::find(mPlugins.begin(), mPlugins.end(), plugin);
1102                 if (i != mPlugins.end())
1103                 {
1104                         if (mIsInitialised)
1105                                 plugin->shutdown();
1106                         plugin->uninstall();
1107                         mPlugins.erase(i);
1108                 }
1109                 LogManager::getSingleton().logMessage("Plugin successfully uninstalled");
1110
1111         }
1112     //-----------------------------------------------------------------------
1113         void Root::loadPlugin(const String& pluginName)
1114         {
1115                 // Load plugin library
1116         DynLib* lib = DynLibManager::getSingleton().load( pluginName );
1117                 // Store for later unload
1118                 // Check for existence, because if called 2+ times DynLibManager returns existing entry
1119                 if (std::find(mPluginLibs.begin(), mPluginLibs.end(), lib) == mPluginLibs.end())
1120                 {
1121                         mPluginLibs.push_back(lib);
1122
1123                         // Call startup function
1124                         DLL_START_PLUGIN pFunc = (DLL_START_PLUGIN)lib->getSymbol("dllStartPlugin");
1125
1126                         if (!pFunc)
1127                                 OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot find symbol dllStartPlugin in library " + pluginName,
1128                                         "Root::loadPlugin");
1129
1130                         // This must call installPlugin
1131                         pFunc();
1132                 }
1133
1134         }
1135     //-----------------------------------------------------------------------
1136         void Root::unloadPlugin(const String& pluginName)
1137         {
1138         PluginLibList::iterator i;
1139
1140         for (i = mPluginLibs.begin(); i != mPluginLibs.end(); ++i)
1141         {
1142                         if ((*i)->getName() == pluginName)
1143                         {
1144                                 // Call plugin shutdown
1145                                 DLL_STOP_PLUGIN pFunc = (DLL_STOP_PLUGIN)(*i)->getSymbol("dllStopPlugin");
1146                                 // this must call uninstallPlugin
1147                                 pFunc();
1148                                 // Unload library (destroyed by DynLibManager)
1149                                 DynLibManager::getSingleton().unload(*i);
1150                                 mPluginLibs.erase(i);
1151                                 return;
1152                         }
1153
1154         }
1155         }
1156     //-----------------------------------------------------------------------
1157     Timer* Root::getTimer(void)
1158     {
1159         return mTimer;
1160     }
1161     //-----------------------------------------------------------------------
1162     void Root::oneTimePostWindowInit(void)
1163     {
1164         if (!mFirstTimePostWindowInit)
1165         {
1166                         // Background loader
1167                         mResourceBackgroundQueue->initialise();
1168                         // Initialise material manager
1169                         mMaterialManager->initialise();
1170             // Init particle systems manager
1171             mParticleManager->_initialise();
1172                         // Init mesh manager
1173                         MeshManager::getSingleton()._initialise();
1174                         // Init plugins - after window creation so rsys resources available
1175                         initialisePlugins();
1176             mFirstTimePostWindowInit = true;
1177         }
1178
1179     }
1180     //-----------------------------------------------------------------------
1181     bool Root::_updateAllRenderTargets(void)
1182     {
1183         // update all targets but don't swap buffers
1184         mActiveRenderer->_updateAllRenderTargets(false);
1185                 // give client app opportunity to use queued GPU time
1186                 bool ret = _fireFrameRenderingQueued();
1187                 // block for final swap
1188                 mActiveRenderer->_swapAllRenderTargetBuffers(mActiveRenderer->getWaitForVerticalBlank());
1189
1190         // This belongs here, as all render targets must be updated before events are
1191         // triggered, otherwise targets could be mismatched.  This could produce artifacts,
1192         // for instance, with shadows.
1193         for (SceneManagerEnumerator::SceneManagerIterator it = getSceneManagerIterator(); it.hasMoreElements(); it.moveNext())
1194             it.peekNextValue()->_handleLodEvents();
1195
1196                 return ret;
1197         }
1198         //---------------------------------------------------------------------
1199         bool Root::_updateAllRenderTargets(FrameEvent& evt)
1200         {
1201                 // update all targets but don't swap buffers
1202                 mActiveRenderer->_updateAllRenderTargets(false);
1203                 // give client app opportunity to use queued GPU time
1204                 bool ret = _fireFrameRenderingQueued(evt);
1205                 // block for final swap
1206                 mActiveRenderer->_swapAllRenderTargetBuffers(mActiveRenderer->getWaitForVerticalBlank());
1207
1208                 // This belongs here, as all render targets must be updated before events are
1209                 // triggered, otherwise targets could be mismatched.  This could produce artifacts,
1210                 // for instance, with shadows.
1211                 for (SceneManagerEnumerator::SceneManagerIterator it = getSceneManagerIterator(); it.hasMoreElements(); it.moveNext())
1212                         it.peekNextValue()->_handleLodEvents();
1213
1214                 return ret;
1215         }
1216         //-----------------------------------------------------------------------
1217         void Root::clearEventTimes(void)
1218         {
1219                 // Clear event times
1220                 for(int i=0; i<FETT_COUNT; ++i)
1221                         mEventTimes[i].clear();
1222         }
1223         //---------------------------------------------------------------------
1224         void Root::addMovableObjectFactory(MovableObjectFactory* fact,
1225                 bool overrideExisting)
1226         {
1227                 MovableObjectFactoryMap::iterator facti = mMovableObjectFactoryMap.find(
1228                         fact->getType());
1229                 if (!overrideExisting && facti != mMovableObjectFactoryMap.end())
1230                 {
1231                         OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
1232                                 "A factory of type '" + fact->getType() + "' already exists.",
1233                                 "Root::addMovableObjectFactory");
1234                 }
1235
1236                 if (fact->requestTypeFlags())
1237                 {
1238                         if (facti != mMovableObjectFactoryMap.end() && facti->second->requestTypeFlags())
1239                         {
1240                                 // Copy type flags from the factory we're replacing
1241                                 fact->_notifyTypeFlags(facti->second->getTypeFlags());
1242                         }
1243                         else
1244                         {
1245                                 // Allocate new
1246                                 fact->_notifyTypeFlags(_allocateNextMovableObjectTypeFlag());
1247                         }
1248                 }
1249
1250                 // Save
1251                 mMovableObjectFactoryMap[fact->getType()] = fact;
1252
1253                 LogManager::getSingleton().logMessage("MovableObjectFactory for type '" +
1254                         fact->getType() + "' registered.");
1255
1256         }
1257         //---------------------------------------------------------------------
1258         bool Root::hasMovableObjectFactory(const String& typeName) const
1259         {
1260                 return !(mMovableObjectFactoryMap.find(typeName) == mMovableObjectFactoryMap.end());
1261         }
1262         //---------------------------------------------------------------------
1263         MovableObjectFactory* Root::getMovableObjectFactory(const String& typeName)
1264         {
1265                 MovableObjectFactoryMap::iterator i =
1266                         mMovableObjectFactoryMap.find(typeName);
1267                 if (i == mMovableObjectFactoryMap.end())
1268                 {
1269                         OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
1270                                 "MovableObjectFactory of type " + typeName + " does not exist",
1271                                 "Root::getMovableObjectFactory");
1272                 }
1273                 return i->second;
1274         }
1275         //---------------------------------------------------------------------
1276         uint32 Root::_allocateNextMovableObjectTypeFlag(void)
1277         {
1278                 if (mNextMovableObjectTypeFlag == SceneManager::USER_TYPE_MASK_LIMIT)
1279                 {
1280                         OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
1281                                 "Cannot allocate a type flag since "
1282                                 "all the available flags have been used.",
1283                                 "Root::_allocateNextMovableObjectTypeFlag");
1284
1285                 }
1286                 uint32 ret = mNextMovableObjectTypeFlag;
1287                 mNextMovableObjectTypeFlag <<= 1;
1288                 return ret;
1289
1290         }
1291         //---------------------------------------------------------------------
1292         void Root::removeMovableObjectFactory(MovableObjectFactory* fact)
1293         {
1294                 MovableObjectFactoryMap::iterator i = mMovableObjectFactoryMap.find(
1295                         fact->getType());
1296                 if (i != mMovableObjectFactoryMap.end())
1297                 {
1298                         mMovableObjectFactoryMap.erase(i);
1299                 }
1300
1301         }
1302         //---------------------------------------------------------------------
1303         Root::MovableObjectFactoryIterator
1304         Root::getMovableObjectFactoryIterator(void) const
1305         {
1306                 return MovableObjectFactoryIterator(mMovableObjectFactoryMap.begin(),
1307                         mMovableObjectFactoryMap.end());
1308
1309         }
1310         //---------------------------------------------------------------------
1311         RenderQueueInvocationSequence* Root::createRenderQueueInvocationSequence(
1312                 const String& name)
1313         {
1314                 RenderQueueInvocationSequenceMap::iterator i =
1315                         mRQSequenceMap.find(name);
1316                 if (i != mRQSequenceMap.end())
1317                 {
1318                         OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
1319                                 "RenderQueueInvocationSequence with the name " + name +
1320                                         " already exists.",
1321                                 "Root::createRenderQueueInvocationSequence");
1322                 }
1323                 RenderQueueInvocationSequence* ret = OGRE_NEW RenderQueueInvocationSequence(name);
1324                 mRQSequenceMap[name] = ret;
1325                 return ret;
1326         }
1327         //---------------------------------------------------------------------
1328         RenderQueueInvocationSequence* Root::getRenderQueueInvocationSequence(
1329                 const String& name)
1330         {
1331                 RenderQueueInvocationSequenceMap::iterator i =
1332                         mRQSequenceMap.find(name);
1333                 if (i == mRQSequenceMap.end())
1334                 {
1335                         OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
1336                                 "RenderQueueInvocationSequence with the name " + name +
1337                                 " not found.",
1338                                 "Root::getRenderQueueInvocationSequence");
1339                 }
1340                 return i->second;
1341         }
1342         //---------------------------------------------------------------------
1343         void Root::destroyRenderQueueInvocationSequence(
1344                 const String& name)
1345         {
1346                 RenderQueueInvocationSequenceMap::iterator i =
1347                         mRQSequenceMap.find(name);
1348                 if (i != mRQSequenceMap.end())
1349                 {
1350                         OGRE_DELETE i->second;
1351                         mRQSequenceMap.erase(i);
1352                 }
1353         }
1354         //---------------------------------------------------------------------
1355         void Root::destroyAllRenderQueueInvocationSequences(void)
1356         {
1357                 for (RenderQueueInvocationSequenceMap::iterator i = mRQSequenceMap.begin();
1358                         i != mRQSequenceMap.end(); ++i)
1359                 {
1360                         OGRE_DELETE i->second;
1361                 }
1362                 mRQSequenceMap.clear();
1363         }
1364
1365         //---------------------------------------------------------------------
1366         unsigned int Root::getDisplayMonitorCount() const
1367         {
1368                 if (!mActiveRenderer)
1369                 {
1370                         OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
1371                                 "Cannot get display monitor count "
1372                                 "No render system has been selected.", "Root::getDisplayMonitorCount");
1373                 }
1374
1375                 return mActiveRenderer->getDisplayMonitorCount();
1376
1377         }
1378         //---------------------------------------------------------------------
1379
1380
1381
1382 }