OgreRoot.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef __ROOT__
#define __ROOT__

// Precompiler options
#include "OgrePrerequisites.h"

#include "OgreSingleton.h"
#include "OgreString.h"
#include "OgreSceneManagerEnumerator.h"
#include "OgreResourceGroupManager.h"

#include <exception>

#if OGRE_COMPILER == OGRE_COMPILER_MSVC || OGRE_COMPILER == OGRE_COMPILER_BORL
#   define SET_TERM_HANDLER { set_terminate( &Ogre::Root::termHandler ); }
#else
#   define SET_TERM_HANDLER { std::set_terminate( &Ogre::Root::termHandler ); }
#endif

namespace Ogre
{
    typedef std::vector<RenderSystem*> RenderSystemList;

    class _OgreExport Root : public Singleton<Root>
    {
        // To allow update of active renderer if
        // RenderSystem::initialise is used directly
        friend class RenderSystem;
    private:
        RenderSystemList mRenderers;
        RenderSystem* mActiveRenderer;
        String mVersion;
        String mConfigFileName;
        bool mQueuedEnd;
        // In case multiple render windows are created, only once are the resources loaded.
        bool mFirstTimePostWindowInit;

        // Singletons
        LogManager* mLogManager;
        ControllerManager* mControllerManager;
        SceneManagerEnumerator* mSceneManagerEnum;
        SceneManager* mCurrentSceneManager;
        DynLibManager* mDynLibManager;
        PlatformManager* mPlatformManager;
        ArchiveManager* mArchiveManager;
        MaterialManager* mMaterialManager;
        MeshManager* mMeshManager;
        ParticleSystemManager* mParticleManager;
        SkeletonManager* mSkeletonManager;
        OverlayElementFactory* mPanelFactory;
        OverlayElementFactory* mBorderPanelFactory;
        OverlayElementFactory* mTextAreaFactory;
        OverlayManager* mOverlayManager;
        FontManager* mFontManager;
        ArchiveFactory *mZipArchiveFactory;
        ArchiveFactory *mFileSystemArchiveFactory;
        ResourceGroupManager* mResourceGroupManager;
        ResourceBackgroundQueue* mResourceBackgroundQueue;

        Timer* mTimer;
        RenderWindow* mAutoWindow;
        Profiler* mProfiler;
        HighLevelGpuProgramManager* mHighLevelGpuProgramManager;
        ExternalTextureSourceManager* mExternalTextureSourceManager;
        unsigned long mCurrentFrame;

        std::vector<DynLib*> mPluginLibs;
        void loadPlugins( const String& pluginsfile = "plugins.cfg" );
        void shutdownPlugins();

        void unloadPlugins();

        // Internal method for one-time tasks after first window creation
        void oneTimePostWindowInit(void);

        std::set<FrameListener*> mFrameListeners;

        std::set<FrameListener*> mRemovedFrameListeners;

        enum FrameEventTimeType {
            FETT_ANY, FETT_STARTED, FETT_ENDED
        };

        std::deque<unsigned long> mEventTimes[3];

        Real calculateEventTime(unsigned long now, FrameEventTimeType type);
    public:

        static void termHandler();

        Root(const String& pluginFileName = "plugins.cfg", const String& configFileName = "ogre.cfg", const String& logFileName = "Ogre.log");
        ~Root();

        void saveConfig(void);

        bool restoreConfig(void);

        bool showConfigDialog(void);

        void addRenderSystem(RenderSystem* newRend);

        void setSceneManager(SceneType sType, SceneManager* sm);

        RenderSystemList* getAvailableRenderers(void);

        void setRenderSystem(RenderSystem* system);

        RenderSystem* getRenderSystem(void);

        RenderWindow* initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");

        SceneManager* getSceneManager(SceneType sceneType);

        TextureManager* getTextureManager(void);

        MeshManager* getMeshManager(void);

        String getErrorDescription(long errorNumber);

        void addFrameListener(FrameListener* newListener);

        void removeFrameListener(FrameListener* oldListener);

        void queueEndRendering(void);

        void startRendering(void);

        bool renderOneFrame(void);
        void shutdown(void);

        void addResourceLocation(const String& name, const String& locType, 
            const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, 
            bool recursive = false);

        void removeResourceLocation(const String& name, 
            const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

        void convertColourValue(const ColourValue& colour, uint32* pDest);

        RenderWindow* getAutoCreatedWindow(void);

        RenderWindow* createRenderWindow(const String &name, unsigned int width, unsigned int height, 
            bool fullScreen, const NameValuePairList *miscParams = 0) ;

        void detachRenderTarget( RenderTarget* pWin );

        void detachRenderTarget( const String & name );

        RenderTarget * getRenderTarget(const String &name);

        void loadPlugin(const String& pluginName);

        void unloadPlugin(const String& pluginName);

        Timer* getTimer(void);

        bool _fireFrameStarted(FrameEvent& evt);
        bool _fireFrameEnded(FrameEvent& evt);
        bool _fireFrameStarted();
        bool _fireFrameEnded();

        unsigned long getCurrentFrameNumber(void) const { return mCurrentFrame; }

        SceneManager* _getCurrentSceneManager(void) const { return mCurrentSceneManager; }
        void _setCurrentSceneManager(SceneManager* sm) { mCurrentSceneManager = sm; }

        void _updateAllRenderTargets(void);

        static Root& getSingleton(void);
        static Root* getSingletonPtr(void);

        void clearEventTimes(void);

    };
} // Namespace Ogre
#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:51 2006