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