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