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 #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