E:/Programming/MyProject/K_Game_hg/GameEngine/include/engine/EngineManager.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _ENGINE_MANAGER_H_
#define _ENGINE_MANAGER_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <core/Singleton.h>
#include <engine/Object.h>

#include <string>
#include <list>
#include <map>

namespace core
{
class ConfigFile;
}

namespace platform
{
class Timer;
class PlatformManager;
}

namespace input
{
class InputManager;
}

namespace resource
{
class ResourceManager;
}

namespace script
{
class ScriptManager;
}

namespace scene
{
class SceneManager;
}

namespace render
{
class RenderManager;
}

namespace sound
{
class SoundManager;
}

namespace physics
{
class PhysicsManager;
}

namespace engine
{

class Log;
class LogManager;
class PluginManager;
class EngineSettings;
class EngineEventReceiver;
struct EngineEvent;

class ENGINE_PUBLIC_EXPORT EngineManager: public Object, public core::Singleton<EngineManager>
{
public:
        EngineManager();

        ~EngineManager();

        LogManager* getLogManager();

        platform::PlatformManager* getPlatformManager();
        
        input::InputManager* getInputManager();

        resource::ResourceManager* getResourceManager();

        render::RenderManager* getRenderManager();

        sound::SoundManager* getSoundManager();

        physics::PhysicsManager* getPhysicsManager();

        scene::SceneManager* getSceneManager();

        script::ScriptManager* getScriptManager();

        void start();

        bool isRunning();

        void stopRunning();

        void stop();

        void addEngineEventReceiver(EngineEventReceiver* newEventReceiver);
        void removeEngineEventReceiver(EngineEventReceiver* oldEventReceiver);

        const std::string& getVersion() const;
        const std::string& getVersionString() const;

        void setOptionsFile(const std::string& optionsFile);
        void setPluginsFile(const std::string& pluginsFile);
        void setResourcesFile(const std::string& resourcesFile);

        static EngineManager* getInstance();

protected:

        void initializeImpl();
        void uninitializeImpl();
        void updateImpl(f32 elapsedTime);

        std::string mVersion;
        std::string mVersionString;

        static EngineEvent* mEngineEvent;
        static std::list<EngineEventReceiver*> mEngineEventReceivers;

        LogManager* mLogManager;

        PluginManager* mPluginManager;

        platform::PlatformManager* mPlatformManager;

        input::InputManager* mInputManager;

        resource::ResourceManager* mResourceManager;

        render::RenderManager* mRenderManager;

        sound::SoundManager* mSoundManager;

        physics::PhysicsManager* mPhysicsManager;

        scene::SceneManager* mSceneManager;

        script::ScriptManager* mScriptManager;

        EngineSettings* mEngineSettings;

        bool mUpdateGame;

        Log* mLog;

        std::string mPluginsFile;
        std::string mOptionsFile;
        std::string mResourcesFile;

        // Internal timer
        platform::Timer* mTimer;

        u32 mLastUpdateStartTime;
        u32 mLastUpdateEndTime;

        void fireEngineInitialized();

        void fireEngineUninitialized();

        void fireEngineStarted();

        void fireEngineStopped();

        void fireEngineUpdateStarted();

        void fireEngineUpdateEnded();

        void registerDefaultFactories();

        void removeDefaultFactories();

        void loadPlugins();

        void unloadPlugins();

        void loadOptions();
        
        void saveOptions();

        void setPaths();
};

} // end namespace engine

#endif