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;
        CompositorManager* mCompositorManager;      
        unsigned long mCurrentFrame;
        Real mFrameSmoothingTime;

        std::vector<DynLib*> mPluginLibs;

        typedef std::map<String, MovableObjectFactory*> MovableObjectFactoryMap;
        MovableObjectFactoryMap mMovableObjectFactoryMap;
        uint32 mNextMovableObjectTypeFlag;
        // stock movable factories
        MovableObjectFactory* mEntityFactory;
        MovableObjectFactory* mLightFactory;
        MovableObjectFactory* mBillboardSetFactory;
        MovableObjectFactory* mManualObjectFactory;
        MovableObjectFactory* mBillboardChainFactory;
        MovableObjectFactory* mRibbonTrailFactory;

        typedef std::map<String, RenderQueueInvocationSequence*> RenderQueueInvocationSequenceMap;
        RenderQueueInvocationSequenceMap mRQSequenceMap;

        bool mIsInitialised;

        void loadPlugins( const String& pluginsfile = "plugins.cfg" );
        void initialisePlugins();
        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);

        RenderSystemList* getAvailableRenderers(void);

        RenderSystem* getRenderSystemByName(const String& name);

        void setRenderSystem(RenderSystem* system);

        RenderSystem* getRenderSystem(void);

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

        bool isInitialised(void) const { return mIsInitialised; }

        void addSceneManagerFactory(SceneManagerFactory* fact);

        void removeSceneManagerFactory(SceneManagerFactory* fact);

        const SceneManagerMetaData* getSceneManagerMetaData(const String& typeName) const;

        SceneManagerEnumerator::MetaDataIterator getSceneManagerMetaDataIterator(void) const;

        SceneManager* createSceneManager(const String& typeName, 
            const String& instanceName = StringUtil::BLANK);

        SceneManager* createSceneManager(SceneTypeMask typeMask, 
            const String& instanceName = StringUtil::BLANK);

        void destroySceneManager(SceneManager* sm);

        SceneManager* getSceneManager(const String& instanceName) const;

        SceneManagerEnumerator::SceneManagerIterator getSceneManagerIterator(void);

        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);

        void _updateAllRenderTargets(void);

        RenderQueueInvocationSequence* createRenderQueueInvocationSequence(
            const String& name);

        RenderQueueInvocationSequence* getRenderQueueInvocationSequence(
            const String& name);

        void destroyRenderQueueInvocationSequence(
            const String& name);

        void destroyAllRenderQueueInvocationSequences(void);

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

        void clearEventTimes(void);

        void setFrameSmoothingPeriod(Real period) { mFrameSmoothingTime = period; }
        Real getFrameSmoothingPeriod(void) const { return mFrameSmoothingTime; }

        void addMovableObjectFactory(MovableObjectFactory* fact, 
            bool overrideExisting = false);
        void removeMovableObjectFactory(MovableObjectFactory* fact);
        bool hasMovableObjectFactory(const String& typeName) const;
        MovableObjectFactory* getMovableObjectFactory(const String& typeName);
        uint32 _allocateNextMovableObjectTypeFlag(void);

        typedef ConstMapIterator<MovableObjectFactoryMap> MovableObjectFactoryIterator;
        MovableObjectFactoryIterator getMovableObjectFactoryIterator(void) const;
    };
} // 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 Mar 12 14:37:48 2006