Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

OgreRoot.cpp

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004 (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://ogre.sourceforge.net/
00006 
00007 Copyright © 2000-2002 The OGRE Team
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 -----------------------------------------------------------------------------
00024 */
00025 // Ogre includes
00026 #include "OgreStableHeaders.h"
00027 
00028 #include "OgreRoot.h"
00029 
00030 #include "OgreRenderSystem.h"
00031 #include "OgreException.h"
00032 #include "OgreControllerManager.h"
00033 #include "OgreLogManager.h"
00034 #include "OgreMath.h"
00035 #include "OgreDynLibManager.h"
00036 #include "OgreDynLib.h"
00037 #include "OgreConfigFile.h"
00038 #include "OgreMaterialManager.h"
00039 #include "OgreResourceManager.h"
00040 #include "OgreMeshManager.h"
00041 #include "OgreTextureManager.h"
00042 #include "OgreParticleSystemManager.h"
00043 #include "OgreSkeletonManager.h"
00044 #include "OgreGuiManager.h"
00045 #include "OgreOverlayManager.h"
00046 #include "OgreZipArchiveFactory.h"
00047 #include "OgreProfiler.h"
00048 #include "OgreErrorDialog.h"
00049 #include "OgreConfigDialog.h"
00050 
00051 #include "OgrePNGCodec.h"
00052 #include "OgreBMPCodec.h"
00053 #include "OgreJPEGCodec.h"
00054 #include "OgreTGACodec.h"
00055 #include "OgreDDSCodec.h"
00056 
00057 #include "OgreFontManager.h"
00058 
00059 #include "OgreOverlay.h"
00060 #include "OgreHighLevelGpuProgramManager.h"
00061 
00062 #if OGRE_PLATFORM == PLATFORM_WIN32
00063 
00064 #   define WIN32_LEAN_AND_MEAN
00065 #   include <direct.h>
00066 #   include <windows.h>
00067 
00068 #endif
00069 
00070 
00071 namespace Ogre {    
00072 
00073     typedef void (*DLL_START_PLUGIN)(void);
00074     typedef void (*DLL_STOP_PLUGIN)(void);
00075 
00076 
00077     //-----------------------------------------------------------------------
00078     // Termination handler
00079     extern "C" _OgreExport void handleTerminate(void)
00080     {
00081         LogManager::getSingleton().logMessage(LML_CRITICAL, "Termination handler: uncaught exception!");
00082 
00083         Root::getSingleton().shutdown();
00084 
00085         ErrorDialog* dlg = PlatformManager::getSingleton().createErrorDialog();
00086 
00087         Exception* e = Exception::getLastException();
00088 
00089         if (e)
00090             dlg->display(e->getFullDescription());
00091         else
00092             dlg->display("Unknown");
00093 
00094         // Abort
00095         exit(-1);
00096 
00097     }
00098 
00099     void Root::termHandler()
00100     {
00101         handleTerminate();
00102     }
00103 
00104     //-----------------------------------------------------------------------
00105     template<> Root* Singleton<Root>::ms_Singleton = 0;
00106     //-----------------------------------------------------------------------
00107     Root::Root(const String& pluginFileName, const String& configFileName, const String& logFileName)
00108     {
00109         // First create new exception handler
00110         SET_TERM_HANDLER;
00111 
00112         // superclass will do singleton checking
00113         String msg;
00114 
00115         // Init
00116         mActiveRenderer = 0;
00117         mVersion = "0.13.0";
00118         mConfigFileName = configFileName;
00119 
00120         // Create log manager and default log file
00121         mLogManager = new LogManager();
00122         mLogManager->createLog(logFileName, true, true);
00123 
00124         // Dynamic library manager
00125         mDynLibManager = new DynLibManager();
00126 
00127         mArchiveManager = new ArchiveManager();
00128 
00129         // Create SceneManager enumerator (note - will be managed by singleton)
00130         mSceneManagerEnum = new SceneManagerEnumerator();
00131 
00132         // ..material manager
00133         mMaterialManager = new MaterialManager();
00134 
00135         // Mesh manager
00136         mMeshManager = new MeshManager();
00137 
00138         // Skeleton manager
00139         mSkeletonManager = new SkeletonManager();
00140 
00141         // ..particle system manager
00142         mParticleManager = new ParticleSystemManager();
00143 
00144         // Platform manager
00145         mPlatformManager = new PlatformManager();
00146 
00147         // Timer
00148         mTimer = mPlatformManager->createTimer();
00149 
00150         // Overlay manager
00151         mOverlayManager = new OverlayManager();
00152         // Gui Manager
00153         mGuiManager = new GuiManager();
00154         // Font manager
00155         mFontManager = new FontManager();
00156 
00157 #if OGRE_PROFILING
00158         // Profiler
00159         mProfiler = new Profiler();
00160         Profiler::getSingleton().setTimer(mTimer);
00161 #endif
00162         mZipArchiveFactory = new ZipArchiveFactory();
00163         ArchiveManager::getSingleton().addArchiveFactory( mZipArchiveFactory );
00164 
00165         mPNGCodec = new PNGCodec;
00166         Codec::registerCodec( mPNGCodec );
00167         mJPEGCodec = new JPEGCodec;
00168         Codec::registerCodec( mJPEGCodec );
00169         mTGACodec = new TGACodec;
00170         Codec::registerCodec( mTGACodec );
00171         mDDSCodec = new DDSCodec;
00172         Codec::registerCodec( mDDSCodec );
00173         mJPGCodec = new JPGCodec;
00174         Codec::registerCodec( mJPGCodec );
00175         mBMPCodec = new BMPCodec;
00176         Codec::registerCodec( mBMPCodec );
00177 
00178         mHighLevelGpuProgramManager = new HighLevelGpuProgramManager();
00179 
00180         // Auto window
00181         mAutoWindow = 0;
00182 
00183         // Load plugins
00184         if (!pluginFileName.empty())
00185             loadPlugins(pluginFileName);        
00186 
00187         mLogManager->logMessage("*-*-* OGRE Initialising");
00188         msg = "*-*-* Version " + mVersion;
00189         mLogManager->logMessage(msg);
00190 
00191         // Can't create managers until initialised
00192         mControllerManager = 0;
00193 
00194 
00195         // Seed random number generator for future use
00196         srand((unsigned)time(0));
00197 
00198 #if OGRE_COMPILER == COMPILER_MSVC
00199 #   if OGRE_COMP_VER < 1300
00200         // Instantiate templates for spooling to a String
00201         // This seems to be a crappy VC6 thing, it generates link errors if we use
00202         //  the templates from outside OgreMain, even when 'inline'.
00203         String str1, str2;
00204         Quaternion q;
00205         Vector3 v;
00206         Matrix4 m;
00207         float f = 0.0;
00208         int i = 0;
00209         char c = 'A';
00210         str1 = "";
00211         str2 = "aa";
00212         str1 << str2 << q << v << f << i << c;
00213         // Stop instantiating templates
00214 #   endif
00215 #endif
00216 
00217         
00218 
00219 
00220     }
00221 
00222     //-----------------------------------------------------------------------
00223     Root::~Root()
00224     {
00225         shutdown();
00226         delete mSceneManagerEnum;
00227 
00228 
00229         delete mBMPCodec;
00230         delete mDDSCodec;
00231         delete mTGACodec;
00232         delete mJPGCodec;
00233         delete mJPEGCodec;
00234         delete mPNGCodec;
00235         delete mZipArchiveFactory;
00236 #if OGRE_PROFILING
00237         delete mProfiler;
00238 #endif
00239         delete mGuiManager;
00240         delete mOverlayManager;
00241         delete mFontManager;
00242         delete mArchiveManager;
00243         delete mSkeletonManager;
00244         delete mMeshManager;
00245         delete mMaterialManager;        
00246         delete mParticleManager;
00247         if (mHighLevelGpuProgramManager)
00248             delete mHighLevelGpuProgramManager;
00249         if( mControllerManager )
00250             delete mControllerManager;
00251 
00252         unloadPlugins();
00253 
00254         mPlatformManager->destroyTimer(mTimer);
00255         delete mPlatformManager;
00256         delete mDynLibManager;
00257         delete mLogManager;
00258     }
00259 
00260     //-----------------------------------------------------------------------
00261     void Root::saveConfig(void)
00262     {
00263         ::FILE *fp;
00264         char rec[100];
00265 
00266         fp = fopen(mConfigFileName, "w");
00267         if (!fp)
00268             Except(Exception::ERR_CANNOT_WRITE_TO_FILE, "Cannot create settings file.",
00269             "Root::saveConfig");
00270 
00271         if (mActiveRenderer)
00272         {
00273             sprintf(rec, "Render System\t%s\n", mActiveRenderer->getName().c_str());
00274             fputs(rec, fp);
00275 
00276             ConfigOptionMap& opts = mActiveRenderer->getConfigOptions();
00277             for(  ConfigOptionMap::iterator pOpt = opts.begin(); pOpt != opts.end(); ++pOpt )
00278             {
00279                 sprintf(rec, "%s\t%s\n", pOpt->first.c_str(),
00280                     pOpt->second.currentValue.c_str());
00281                 fputs(rec, fp);
00282             }
00283         }
00284         else
00285         {
00286             strcpy(rec, "Render System\t ");
00287             fputs(rec, fp);
00288         }
00289 
00290         fclose(fp);
00291 
00292     }
00293     //-----------------------------------------------------------------------
00294     bool Root::restoreConfig(void)
00295     {
00296         // Restores configuration from saved state
00297         // Returns true if a valid saved configuration is
00298         //   available, and false if no saved config is
00299         //   stored, or if there has been a problem
00300         ConfigFile cfg;
00301         String renderSystem;
00302         RenderSystemList::iterator pRend;
00303 
00304         try {
00305             // Don't trim whitespace
00306             cfg.load(mConfigFileName, "\t:=", false);
00307         }
00308         catch (Exception& e)
00309         {
00310             if (e.getNumber() == Exception::ERR_FILE_NOT_FOUND)
00311             {
00312                 return false;
00313             }
00314             else
00315             {
00316                 throw;
00317             }
00318         }
00319 
00320         renderSystem = cfg.getSetting("Render System");
00321         if(!renderSystem)
00322         {
00323             // No render system entry - error
00324             return false;
00325         }
00326         
00327         pRend = getAvailableRenderers()->begin();
00328         while (pRend != getAvailableRenderers()->end())
00329         {
00330             String rName = (*pRend)->getName();
00331             if (rName == renderSystem)
00332                 break;
00333             pRend++;
00334         }
00335 
00336         if (pRend == getAvailableRenderers()->end())
00337         {
00338             // Unrecognised render system
00339             return false;
00340         }
00341 
00342         setRenderSystem(*pRend);
00343 
00344         ConfigFile::SettingsIterator i = cfg.getSettingsIterator();
00345 
00346         String optName, optVal;
00347         while (i.hasMoreElements())
00348         {
00349             optName = i.peekNextKey();
00350             optVal = i.getNext();
00351             if(optName != "Render System")
00352             {
00353                 mActiveRenderer->setConfigOption(optName, optVal);
00354             }
00355         }
00356 
00357         // Successful load
00358         return true;
00359 
00360     }
00361 
00362     //-----------------------------------------------------------------------
00363     bool Root::showConfigDialog(void)
00364     {
00365         // Displays the standard config dialog
00366         // Will use stored defaults if available
00367         ConfigDialog* dlg;
00368         bool isOk;
00369 
00370         dlg = mPlatformManager->createConfigDialog();
00371 
00372         isOk = dlg->display();
00373 
00374         mPlatformManager->destroyConfigDialog(dlg);
00375 
00376         return isOk;
00377 
00378     }
00379 
00380     //-----------------------------------------------------------------------
00381     RenderSystemList* Root::getAvailableRenderers(void)
00382     {
00383         // Returns a vector of renders
00384 
00385         return &mRenderers;
00386 
00387     }
00388 
00389     //-----------------------------------------------------------------------
00390     void Root::setRenderSystem(RenderSystem* system)
00391     {
00392         // Sets the active rendering system
00393         // Can be called direct or will be called by
00394         //   standard config dialog
00395 
00396         // Is there already an active renderer?
00397         // If so, disable it and init the new one
00398         if( mActiveRenderer && mActiveRenderer != system )
00399         {
00400             mActiveRenderer->shutdown();
00401         }
00402 
00403         mActiveRenderer = system;
00404         // Tell scene managers
00405         SceneManagerEnumerator::getSingleton().setRenderSystem(system);
00406 
00407     }
00408     //-----------------------------------------------------------------------
00409     void Root::addRenderSystem(RenderSystem *newRend)
00410     {
00411         mRenderers.push_back(newRend);
00412     }
00413     //-----------------------------------------------------------------------
00414     void Root::setSceneManager(SceneType sType, SceneManager *sm)
00415     {
00416         SceneManagerEnumerator::getSingleton().setSceneManager(sType, sm);
00417     }
00418 
00419     //-----------------------------------------------------------------------
00420     RenderSystem* Root::getRenderSystem(void)
00421     {
00422         // Gets the currently active renderer
00423         return mActiveRenderer;
00424 
00425     }
00426 
00427     //-----------------------------------------------------------------------
00428     RenderWindow* Root::initialise(bool autoCreateWindow)
00429     {
00430         if (!mActiveRenderer)
00431             Except(Exception::ERR_NO_RENDERSYSTEM_SELECTED,
00432             "Cannot initialise - no render "
00433             "system has been selected.", "Root::initialise");
00434 
00435         mControllerManager = new ControllerManager();
00436 
00437         mAutoWindow =  mActiveRenderer->initialise(autoCreateWindow);
00438 
00439         if (autoCreateWindow)
00440         {
00441             oneTimePostWindowInit();
00442         }
00443 
00444         // Initialise timer
00445         mTimer->reset();
00446         return mAutoWindow;
00447 
00448     }
00449     //-----------------------------------------------------------------------
00450     String Root::getErrorDescription(long errorNumber)
00451     {
00452 
00453         // Pass to render system
00454         if (mActiveRenderer)
00455             return mActiveRenderer->getErrorDescription(errorNumber);
00456         else
00457             return "";
00458 
00459     }
00460     //-----------------------------------------------------------------------
00461     SceneManager* Root::getSceneManager(SceneType sceneType)
00462     {
00463         // Delegate
00464         return mSceneManagerEnum->getSceneManager(sceneType);
00465     }
00466     //-----------------------------------------------------------------------
00467     TextureManager* Root::getTextureManager(void)
00468     {
00469         return &TextureManager::getSingleton();
00470     }
00471     //-----------------------------------------------------------------------
00472     MeshManager* Root::getMeshManager(void)
00473     {
00474         return &MeshManager::getSingleton();
00475     }
00476     //-----------------------------------------------------------------------
00477     void Root::addFrameListener(FrameListener* newListener)
00478     {
00479         // Insert, unique only (set)
00480         mFrameListeners.insert(newListener);
00481 
00482     }
00483 
00484     //-----------------------------------------------------------------------
00485     void Root::removeFrameListener(FrameListener* oldListener)
00486     {
00487         // Remove, 1 only (set)
00488         mFrameListeners.erase(oldListener);
00489     }
00490     //-----------------------------------------------------------------------
00491     bool Root::_fireFrameStarted(FrameEvent& evt)
00492     {
00493         // Tell all listeners
00494         std::set<FrameListener*>::iterator i;
00495         for (i= mFrameListeners.begin(); i != mFrameListeners.end(); ++i)
00496         {
00497             if (!(*i)->frameStarted(evt))
00498                 return false;
00499         }
00500 
00501         return true;
00502 
00503     }
00504     //-----------------------------------------------------------------------
00505     bool Root::_fireFrameEnded(FrameEvent& evt)
00506     {
00507         // Tell all listeners
00508         std::set<FrameListener*>::iterator i;
00509         for (i= mFrameListeners.begin(); i != mFrameListeners.end(); ++i)
00510         {
00511             if (!(*i)->frameEnded(evt))
00512                 return false;
00513         }
00514         return true;
00515     }
00516     //-----------------------------------------------------------------------
00517     bool Root::_fireFrameStarted()
00518     {
00519         unsigned long now = mTimer->getMilliseconds();
00520         FrameEvent evt;
00521         evt.timeSinceLastEvent = calculateEventTime(now, FETT_ANY);
00522         evt.timeSinceLastFrame = calculateEventTime(now, FETT_STARTED);
00523 
00524         return _fireFrameStarted(evt);
00525     }
00526     //-----------------------------------------------------------------------
00527     bool Root::_fireFrameEnded()
00528     {
00529         unsigned long now = mTimer->getMilliseconds();
00530         FrameEvent evt;
00531         evt.timeSinceLastEvent = calculateEventTime(now, FETT_ANY);
00532         evt.timeSinceLastFrame = calculateEventTime(now, FETT_ENDED);
00533 
00534         return _fireFrameEnded(evt);
00535     }
00536     //-----------------------------------------------------------------------
00537     Real Root::calculateEventTime(unsigned long now, FrameEventTimeType type)
00538     {
00539         // Calculate the average time passed between events of the given type
00540         // during the last 0.1 seconds.
00541 
00542         std::deque<unsigned long>& times = mEventTimes[type];
00543         times.push_back(now);
00544 
00545         if(times.size() == 1)
00546             return 0;
00547 
00548         // Times up to 0.1 seconds old should be kept
00549         unsigned long discardLimit = now - 100;
00550 
00551         // Find the oldest time to keep
00552         std::deque<unsigned long>::iterator it = times.begin(),
00553             end = times.end()-2; // We need at least two times
00554         while(it != end)
00555         {
00556             if(*it < discardLimit)
00557                 ++it;
00558             else
00559                 break;
00560         }
00561 
00562         // Remove old times
00563         times.erase(times.begin(), it);
00564 
00565         return Real(times.back() - times.front()) / ((times.size()-1) * 1000);
00566     }
00567     //-----------------------------------------------------------------------
00568     void Root::startRendering(void)
00569     {
00570         assert(mActiveRenderer != 0);
00571 
00572         mActiveRenderer->_initRenderTargets();
00573 
00574         // Clear event times
00575         for(int i=0; i!=3; ++i)
00576             mEventTimes[i].clear();
00577 
00578         // Infinite loop, until broken out of by frame listeners
00579         while( true )
00580         {
00581 #if OGRE_PLATFORM == PLATFORM_WIN32
00582             // Pump events on Win32
00583             MSG  msg;
00584             while( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
00585             {
00586                 TranslateMessage( &msg );
00587                 DispatchMessage( &msg );
00588             }
00589 #endif
00590 
00591             if(!_fireFrameStarted())
00592                 break;
00593 
00594             mActiveRenderer->_updateAllRenderTargets();
00595 
00596             if(!_fireFrameEnded())
00597                 break;
00598         }
00599 
00600 
00601     }
00602     //-----------------------------------------------------------------------
00603     void Root::shutdown(void)
00604     {
00605         SceneManagerEnumerator::getSingleton().shutdownAll();
00606 
00607         
00608         if (mActiveRenderer)
00609         {
00610             mActiveRenderer->shutdown();
00611             mActiveRenderer = 0;
00612         }
00613 
00614         mLogManager->logMessage("*-*-* OGRE Shutdown");
00615 
00616 
00617     }
00618     //-----------------------------------------------------------------------
00619     Root& Root::getSingleton(void)
00620     {
00621         return Singleton<Root>::getSingleton();
00622     }
00623     //-----------------------------------------------------------------------
00624     void Root::loadPlugins( const String& pluginsfile )
00625     {
00626         StringVector pluginList;
00627         String pluginDir;
00628         ConfigFile cfg;
00629 
00630         try {
00631             cfg.load( pluginsfile );
00632         }
00633         catch (Exception)
00634         {
00635             LogManager::getSingleton().logMessage(pluginsfile + " not found, automatic plugin loading disabled.");
00636             return;
00637         }
00638 
00639         pluginDir = cfg.getSetting("PluginFolder"); // Ignored on Mac OS X, uses Resources/ directory
00640         pluginList = cfg.getMultiSetting("Plugin");
00641 
00642         char last_char = pluginDir[pluginDir.length()-1];
00643         if (last_char != '/' || last_char != '\\')
00644         {
00645 #if OGRE_PLATFORM == PLATFORM_WIN32
00646             pluginDir += "\\";
00647 #elif OGRE_PLATFORM == PLATFORM_LINUX
00648             pluginDir += "/";
00649 #endif
00650         }
00651 
00652         for( StringVector::iterator it = pluginList.begin(); it != pluginList.end(); ++it )
00653         {
00654             loadPlugin(pluginDir + (*it));
00655         }
00656 
00657     }
00658     //-----------------------------------------------------------------------
00659     void Root::unloadPlugins(void)
00660     {
00661         std::vector<DynLib*>::reverse_iterator i;
00662 
00663         // NB Unload plugins in reverse order to enforce dependencies
00664         for (i = mPluginLibs.rbegin(); i != mPluginLibs.rend(); ++i)
00665         {
00666             // Call plugin shutdown
00667             DLL_STOP_PLUGIN pFunc = (DLL_STOP_PLUGIN)(*i)->getSymbol("dllStopPlugin");
00668             pFunc();
00669             // Unload library & destroy
00670             DynLibManager::getSingleton().unload((Resource*)*i);
00671             delete *i;
00672 
00673         }
00674 
00675         mPluginLibs.clear();
00676 
00677     }
00678     //-----------------------------------------------------------------------
00679     void Root::addResourceLocation(const String& name, const String& locType, ResourceType resType)
00680     {
00681         switch(resType)
00682         {
00683         case RESTYPE_ALL:
00684             ResourceManager::addCommonArchiveEx(name, locType);
00685             break;
00686         case RESTYPE_TEXTURES:
00687             TextureManager::getSingleton().addArchiveEx(name, locType);
00688             break;
00689         case RESTYPE_MODELS:
00690             MeshManager::getSingleton().addArchiveEx(name, locType);
00691             break;
00692 
00693         }
00694     }
00695     //-----------------------------------------------------------------------
00696     void Root::convertColourValue(const ColourValue& colour, unsigned long* pDest)
00697     {
00698         assert(mActiveRenderer != 0);
00699         mActiveRenderer->convertColourValue(colour, pDest);
00700     }
00701     //-----------------------------------------------------------------------
00702     RenderWindow* Root::getAutoCreatedWindow(void)
00703     {
00704         return mAutoWindow;
00705     }
00706     //-----------------------------------------------------------------------
00707     RenderWindow* Root::createRenderWindow(const String &name, unsigned int width, unsigned int height, unsigned int colourDepth,
00708                 bool fullScreen, int left, int top, bool depthBuffer,RenderWindow* parentWindowHandle)
00709     {
00710         if (!mActiveRenderer)
00711         {
00712             Except(Exception::ERR_NO_RENDERSYSTEM_SELECTED,
00713             "Cannot create window - no render "
00714             "system has been selected.", "Root::createRenderWindow");
00715         }
00716         RenderWindow* ret;
00717         ret = mActiveRenderer->createRenderWindow(name, width, height, colourDepth, fullScreen, left, top,
00718             depthBuffer, parentWindowHandle);
00719 
00720         // Initialisation for classes dependent on first window created
00721         oneTimePostWindowInit();
00722 
00723         return ret;
00724 
00725     }
00726     //-----------------------------------------------------------------------
00727     void Root::detachRenderTarget(RenderTarget* target)
00728     {
00729         if (!mActiveRenderer)
00730         {
00731             Except(Exception::ERR_NO_RENDERSYSTEM_SELECTED,
00732             "Cannot create window - no render "
00733             "system has been selected.", "Root::destroyRenderWindow");
00734         }
00735 
00736         mActiveRenderer->detachRenderTarget( target->getName() );
00737     }
00738     //-----------------------------------------------------------------------
00739     void Root::detachRenderTarget(const String &name)
00740     {
00741         if (!mActiveRenderer)
00742         {
00743             Except(Exception::ERR_NO_RENDERSYSTEM_SELECTED,
00744             "Cannot create window - no render "
00745             "system has been selected.", "Root::destroyRenderWindow");
00746         }
00747 
00748         mActiveRenderer->detachRenderTarget( name );
00749     }
00750     //-----------------------------------------------------------------------
00751     RenderTarget* Root::getRenderTarget(const String &name)
00752     {
00753         if (!mActiveRenderer)
00754         {
00755             Except(Exception::ERR_NO_RENDERSYSTEM_SELECTED,
00756             "Cannot create window - no render "
00757             "system has been selected.", "Root::getRenderWindow");
00758         }
00759 
00760         return mActiveRenderer->getRenderTarget(name);
00761     }
00762     //-----------------------------------------------------------------------
00763     /*
00764     void Root::showDebugOverlay(bool show)
00765     {
00766         Overlay* o = (Overlay*)OverlayManager::getSingleton().getByName("Core/DebugOverlay");
00767         if (!o)
00768             Except( Exception::ERR_ITEM_NOT_FOUND, "Could not find overlay Core/DebugOverlay",
00769                 "Root::showDebugOverlay" );
00770         if (show)
00771         {
00772             o->show();
00773         }
00774         else
00775         {
00776             o->hide();
00777         }
00778         
00779     }
00780     */
00781     //-----------------------------------------------------------------------
00782     void Root::loadPlugin(const String& pluginName)
00783     {
00784         // Load plugin library
00785         DynLib* lib = DynLibManager::getSingleton().load( pluginName );
00786         // Store for later unload
00787         mPluginLibs.push_back(lib);
00788 
00789         // Call startup function
00790         DLL_START_PLUGIN pFunc = (DLL_START_PLUGIN)lib->getSymbol("dllStartPlugin");
00791 
00792         if (!pFunc)
00793             Except(Exception::ERR_ITEM_NOT_FOUND, "Cannot find symbol dllStartPlugin in library " + pluginName,
00794                 "Root::loadPlugins");
00795         pFunc();
00796     }
00797     //-----------------------------------------------------------------------
00798     void Root::unloadPlugin(const String& pluginName)
00799     {
00800         std::vector<DynLib*>::iterator i;
00801 
00802         for (i = mPluginLibs.begin(); i != mPluginLibs.end(); ++i)
00803         {
00804             if ((*i)->getName() == pluginName)
00805             {
00806                 // Call plugin shutdown
00807                 DLL_STOP_PLUGIN pFunc = (DLL_STOP_PLUGIN)(*i)->getSymbol("dllStopPlugin");
00808                 pFunc();
00809                 // Unload library & destroy
00810                 DynLibManager::getSingleton().unload((Resource*)*i);
00811                 delete *i;
00812                 mPluginLibs.erase(i);
00813                 return;
00814             }
00815 
00816         }
00817     }
00818     //-----------------------------------------------------------------------
00819     Timer* Root::getTimer(void)
00820     {
00821         return mTimer;
00822     }
00823     //-----------------------------------------------------------------------
00824     void Root::oneTimePostWindowInit(void)
00825     {
00826         static bool firsttime = true;
00827         if (firsttime)
00828         {
00829             // Initialise material manager
00830             mMaterialManager->initialise();
00831             // Init particle systems manager
00832             mParticleManager->_initialise();
00833             // parse all font scripts
00834             mFontManager->parseAllSources();
00835             // init overlays
00836             mOverlayManager->parseAllSources();
00837             // Init mesh manager
00838             MeshManager::getSingleton()._initialise();
00839         }
00840 
00841         firsttime = false;
00842     }
00843 }

Copyright © 2002-2003 by The OGRE Team
Last modified Wed Jan 21 00:10:25 2004