Engine.hpp

/*
** EPITECH PROJECT, 2022
** gameEngine2
** File description:
** Engine
*/
 
#ifndef KENGINE_HPP_
#define KENGINE_HPP_
 
#include "Errors.hpp"
#include "SceneManager.hpp"
#include "PrefabManager.hpp"
#include "GraphicalLibManager.hpp"
#include "SplashScreen.hpp"
#include "EClock.hpp"
 
#include "KapEngineSettings.hpp"
 
#if KAPENGINE_THREAD_ACTIVE
    #include <thread>
    #include <mutex>
#endif
 
namespace KapEngine {
    namespace SceneManagement {
        class SceneManager;
        class SplashScreen;
    }
 
    namespace Prefabs {
        class PrefabManager;
    }
 
    namespace Graphical {
        class GraphicalLibManager;
        class GraphicalLib;
    }
 
    namespace Time {
        class ETime;
        class EClock;
    }
 
    namespace Events {
        class EventManager;
    }
}
 
namespace KapEngine {
 
    class KEngine {
        public:
            #if !KAPENGINE_BETA_ACTIVE
 
                KEngine(bool debug = false, std::string const& gameName = "Game", std::string const& version = "1.0.0", std::string const& company = "Default Company");
            #else
 
                KEngine(std::string const& gameName = "Game", std::string const& version = "1.0.0", std::string const& company = "Default Company");
            #endif
            ~KEngine();
 
            void setMaxFps(int fps) {
                PROFILER_FUNC_START();
                _fpsLock = fps;
                PROFILER_FUNC_END();
            }
 
            void run();
            void stop();
            bool isRunning() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _run;
            }
            #if !KAPENGINE_BETA_ACTIVE
 
                bool debugMode() const {
                    PROFILER_FUNC_START();
                    PROFILER_FUNC_END();
                    return _debug;
                }
                void setDebugMod(bool b) {
                    PROFILER_FUNC_START();
                    _debug = b;
                    PROFILER_FUNC_END();
                }
            #endif
 
            std::shared_ptr<Graphical::GraphicalLib> getCurrentGraphicalLib();
 
            bool isGraphicalLibExists(std::size_t const& index) const;
 
            bool isGraphicalLibExists(std::string const& name) const;
 
            std::size_t getCurrentGraphicalLibIndex() const;
 
            std::string getGameName() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _gameName;
            }
 
            std::string getGameVersion() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _gameVersion;
            }
 
            std::string getGameCompany() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _gameCompany;
            }
 
            std::shared_ptr<SceneManagement::SceneManager> getSceneManager() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _sceneManager;
            }
 
            std::shared_ptr<Prefabs::PrefabManager> getPrefabManager() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _prefabManager;
            }
 
            Time::ETime getElapsedTime() {
                PROFILER_FUNC_START();
                float f = _elapsed.asMilliSecond() * deltaTime;
                Time::ETime res;
 
                res.setMilliseconds(f);
                PROFILER_FUNC_END();
                return res;
            }
 
            Events::EventManager &getEventManager();
 
            void setDeltaTime(float dTime) {
                PROFILER_FUNC_START();
                deltaTime = dTime;
                PROFILER_FUNC_END();
            }
 
            std::shared_ptr<Graphical::GraphicalLibManager> getGraphicalLibManager() const {
                return _libManager;
            }
 
            void setScreenSize(float width, float heigth);
 
            void setScreenSize(Tools::Vector2 size);
 
            Tools::Vector2 getScreenSize() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return screenSize;
            }
 
            float getMaxFps() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _fpsLock;
            }
 
            bool __canRunFixed() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _runFixed;
            }
 
            std::shared_ptr<SceneManagement::SplashScreen> getSplashScreen() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _splashsScreen;
            }
 
            void setFixedTime(Time::ETime time) {
                PROFILER_FUNC_START();
                _fixedTime = time;
                PROFILER_FUNC_END();
            }
 
            Time::ETime getFixedTime() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _fixedTime;
            }
 
            void setIconGame(std::string const &iconPath) {
                PROFILER_FUNC_START();
                _icon = iconPath;
                PROFILER_FUNC_END();
            }
 
            std::string getIconPath() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _icon;
            }
 
            #if !KAPENGINE_BETA_ACTIVE
 
                void setEngineThread(bool b) {
                    PROFILER_FUNC_START();
                    _threaded = b;
                    PROFILER_FUNC_END();
                }
 
                bool isEngineThreaded() const {
                    PROFILER_FUNC_START();
                    PROFILER_FUNC_END();
                    return _threaded;
                }
 
            #else
                #if KAPENGINE_THREAD_ACTIVE
                    std::mutex &getMutex() {
                        return _mutex;
                    }
                #endif
            #endif
 
            void setTitle(std::string const& title) {
                PROFILER_FUNC_START();
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.lock();
                    #endif
                #endif
                _gameName = title;
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.unlock();
                    #endif
                #endif
                PROFILER_FUNC_END();
            }
 
            void displayFPS(bool b) {
                PROFILER_FUNC_START();
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.lock();
                    #endif
                #endif
                _displayFps = b;
                #if KAPENGINE_BETA_ACTIVE
                    #if KAPENGINE_THREAD_ACTIVE
                        _mutex.unlock();
                    #endif
                #endif
                PROFILER_FUNC_END();
            }
 
            bool isDisplayFPS() const {
                PROFILER_FUNC_START();
                PROFILER_FUNC_END();
                return _displayFps;
            }
 
        protected:
        private:
            bool _run = false;
            #if !KAPENGINE_BETA_ACTIVE
                bool _debug = false;
                bool _threaded = false;
            #else
                #if KAPENGINE_THREAD_ACTIVE
                    std::mutex _mutex;
                #endif
            #endif
            bool _runFixed = false;
            bool _displayFps = false;
 
            int _fpsLock = 60;
 
            float deltaTime = 1.0f;
 
            Tools::Vector2 screenSize;
 
            Time::EClock _internalClock;
            Time::ETime _elapsed;
            Time::ETime _fixedTime;
 
            //all game intels
            std::string _gameName;
            std::string _gameVersion;
            std::string _gameCompany;
            std::string _icon = "Library/KapEngine/Documentation/images/KapEngineLogo100x100.png";
 
            //scene manager
            std::shared_ptr<SceneManagement::SceneManager> _sceneManager;
 
            //prefab manager
            std::shared_ptr<Prefabs::PrefabManager> _prefabManager;
 
            //graphical libs
            std::shared_ptr<Graphical::GraphicalLibManager> _libManager;
 
            //input events
            std::shared_ptr<Events::EventManager> _eventManager;
 
            //splash screens
            std::shared_ptr<SceneManagement::SplashScreen> _splashsScreen;
 
            //functions
            void __init();
 
            bool __canRunUpdate();
    };
 
}
 
#endif /* !ENGINE_HPP_ */