EngineController.h

Go to the documentation of this file.

/*
 * i6engine
 * Copyright (2016) Daniel Bonrath, Michael Baer, All rights reserved.
 *
 * This file is part of i6engine; i6engine 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.1 of the License, or (at your option) any later version.
 *
 * This library 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 library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __I6ENGINE_API_ENGINECONTROLLER_H__
#define __I6ENGINE_API_ENGINECONTROLLER_H__

#include <map>
#include <set>
#include <thread>

#include "i6engine/utils/i6eSystemParameters.h"

#if ISIXE_MPLATFORM == ISIXE_MPLATFORM_WIN32
        #include <tchar.h>
        #include <Windows.h>
#endif

#include "i6engine/utils/ExceptionQueue.h"
#include "i6engine/utils/Logger.h"

#include "i6engine/core/configs/JobPriorities.h"

#include "boost/function.hpp"

#include "clockUtils/iniParser/iniParser.h"

namespace i6e {
namespace core {
        class EngineCoreController;
        class MessagingController;
        class ModuleController;
        class SubSystemController;
        enum class Subsystem;
} /* namespace core */
namespace api {

        class Application;
        class AudioFacade;
        class GraphicsFacade;
        class GUIFacade;
        class IDManager;
        class InputFacade;
        class LanguageManager;
        class MessagingFacade;
        class NetworkFacade;
        class ObjectFacade;
        class PhysicsFacade;
        class ScriptingFacade;
        class TextManager;
        class WaynetManager;

        enum class GameType {
                SINGLEPLAYER,
                CLIENT,
                SERVER
        };

#ifdef ISIXE_WITH_LOGGING
        class ISIXE_MODULES_API EngineController : public utils::Singleton<EngineController, utils::Logger, utils::exceptions::ExceptionQueue> {
                friend class utils::Singleton<EngineController, utils::Logger, utils::exceptions::ExceptionQueue>;
#else
        class ISIXE_MODULES_API EngineController : public utils::Singleton<EngineController, utils::exceptions::ExceptionQueue> {
                friend class utils::Singleton<EngineController, utils::exceptions::ExceptionQueue>;
#endif

        public:
                ~EngineController();

                void registerSubSystem(const std::string & name, core::ModuleController * module, uint32_t frameTime);
                void registerSubSystem(const std::string & name, core::ModuleController * module, const std::set<core::Subsystem> & waitingFor);

                inline AudioFacade * getAudioFacade() const {
                        return _audioFacade;
                }

                inline GraphicsFacade * getGraphicsFacade() const {
                        return _graphicsFacade;
                }

                inline GUIFacade * getGUIFacade() const {
                        return _guiFacade;
                }

                inline InputFacade * getInputFacade() const {
                        return _inputFacade;
                }

                inline MessagingFacade * getMessagingFacade() const {
                        return _messagingFacade;
                }

                inline NetworkFacade * getNetworkFacade() const {
                        return _networkFacade;
                }

                inline ObjectFacade * getObjectFacade() const {
                        return _objectFacade;
                }

                inline PhysicsFacade * getPhysicsFacade() const {
                        return _physicsFacade;
                }

                inline ScriptingFacade * getScriptingFacade() const {
                        return _scriptingFacade;
                }

                IDManager * getIDManager() const {
                        return _idManager;
                }

                LanguageManager * getLanguageManager() const {
                        return _languageManager;
                }

                TextManager * getTextManager() const {
                        return _textManager;
                }

                WaynetManager * getWaynetManager() const {
                        return _waynetManager;
                }

                void registerApplication(Application & app);

                void start();

                inline void setType(GameType type) {
                        _type = type;
                }

                inline void setDebugdrawer(const uint8_t dd) {
                        _debugdrawer = dd;
                }

                inline uint8_t getDebugdrawer() const {
                        return _debugdrawer;
                }

                inline Application * getAppl() const { return _appl; }

                void registerDefault(const bool ds) {
                        registerDefault(ds, nullptr);
                }

                void registerDefault(const bool ds, HWND hWnd);

                void stop();

                void reset();

                inline core::EngineCoreController * getController() const {
                        return _coreController;
                }

                uint64_t registerTimer(uint64_t time, const boost::function<bool(void)> & func, bool looping, core::JobPriorities priority);

                void removeTimer(core::JobPriorities priority);

                bool removeTimerID(uint64_t id);

                uint64_t getTimeLeft(uint64_t id) const;

                uint64_t getCurrentTime() const;

                void setCurrentTime(uint64_t time);

                inline uint64_t getUUID() const {
                        return _uuid;
                }

                uint64_t getNewUUID() const;

                inline clockUtils::iniParser::IniParser & getIniParser() {
                        return _iParser;
                }

                GameType getType() const {
                        return _type;
                }

#if ISIXE_MPLATFORM == ISIXE_MPLATFORM_WIN32

                HWND createWindow(HINSTANCE hInstance);
#endif

                void enableCommandLineReader();

        private:
                std::map<std::string, std::pair<core::ModuleController *, uint32_t>> _queuedModules;
                std::map<std::string, std::pair<core::ModuleController *, std::set<core::Subsystem>>> _queuedModulesWaiting;
                core::SubSystemController * _subsystemController;
                core::EngineCoreController * _coreController;
                IDManager * _idManager;
                LanguageManager * _languageManager;
                TextManager * _textManager;
                WaynetManager * _waynetManager;
                Application * _appl;
                uint8_t _debugdrawer;

                AudioFacade * _audioFacade;
                GraphicsFacade * _graphicsFacade;
                GUIFacade * _guiFacade;
                InputFacade * _inputFacade;
                MessagingFacade * _messagingFacade;
                NetworkFacade * _networkFacade;
                ObjectFacade * _objectFacade;
                PhysicsFacade * _physicsFacade;
                ScriptingFacade * _scriptingFacade;

                core::MessagingController * _messagingController;

                uint64_t _uuid;

                clockUtils::iniParser::IniParser _iParser;

                GameType _type;

                bool _running;
                std::thread _commandLineReadThread;

                EngineController();

                void runEngine();

                void ShutDown();

                EngineController(const EngineController &) = delete;

                EngineController & operator=(const EngineController &) = delete;
        };

} /* namespace api */
} /* namespace i6e */

#define i6eEngineController i6e::api::EngineController::GetSingletonPtr()
#define i6eAppl i6e::api::EngineController::GetSingletonPtr()->getAppl()
#define i6eAudioFacade i6e::api::EngineController::GetSingletonPtr()->getAudioFacade()
#define i6eGraphicsFacade i6e::api::EngineController::GetSingletonPtr()->getGraphicsFacade()
#define i6eGUIFacade i6e::api::EngineController::GetSingletonPtr()->getGUIFacade()
#define i6eInputFacade i6e::api::EngineController::GetSingletonPtr()->getInputFacade()
#define i6eMessagingFacade i6e::api::EngineController::GetSingletonPtr()->getMessagingFacade()
#define i6eNetworkFacade i6e::api::EngineController::GetSingletonPtr()->getNetworkFacade()
#define i6eObjectFacade i6e::api::EngineController::GetSingletonPtr()->getObjectFacade()
#define i6ePhysicsFacade i6e::api::EngineController::GetSingletonPtr()->getPhysicsFacade()
#define i6eScriptingFacade i6e::api::EngineController::GetSingletonPtr()->getScriptingFacade()

#endif /* __I6ENGINE_API_ENGINECONTROLLER_H__ */