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