EngineCore.hpp

#pragma once
 
#include <filesystem>
#include <functional>
#include <chrono>
 
#include <entt/entity/registry.hpp>
 
#include <EngineCore/Utils/DeferredDeletionQueue.hpp>
#include <EngineCore/Utils/MemoryAllocator.hpp>
#include <Common/Logging.hpp>
 
namespace Grindstone {
    namespace GraphicsAPI {
        class Core;
        class RenderPass;
    }
 
    namespace Input {
        class Interface;
    }
 
    namespace Plugins {
        class IPluginManager;
        class Interface;
    }
 
    namespace ECS {
        class ComponentRegistrar;
        class SystemRegistrar;
    }
 
    namespace SceneManagement {
        class SceneManager;
    }
 
    namespace Events {
        struct BaseEvent;
        class Dispatcher;
    }
 
    namespace Assets {
        class AssetManager;
        class AssetLoader;
    }
 
    namespace Profiler {
        class Manager;
    }
 
    namespace Renderer {
        class RenderingPipeline;
    }
 
    class Window;
    class DisplayManager;
    class WindowManager;
 
    class AssetRendererManager;
    class RenderPassRegistry;
    class WorldContextManager;
 
    class EngineCore {
    public:
        static EngineCore& GetInstance();
        static void SetInstance(EngineCore& engineCore);
 
        struct EarlyCreateInfo {
            bool isEditor = false;
            const char* applicationModuleName = nullptr;
            const char* applicationTitle = nullptr;
            const char* projectPath = nullptr;
            const char* engineBinaryPath = nullptr;
            Assets::AssetLoader* assetLoader = nullptr;
        };
 
        struct LateCreateInfo {
            Grindstone::Assets::AssetLoader* assetLoader = nullptr;
            Grindstone::Plugins::IPluginManager* pluginManagerOverride = nullptr;
        };
 
        virtual bool EarlyInitialize(EarlyCreateInfo& ci);
        virtual bool Initialize(LateCreateInfo& createInfo);
        virtual void InitializeScene(bool shouldLoadSceneFromDefaults, const char* scenePath = nullptr);
        virtual void ShowMainWindow();
 
        virtual ~EngineCore();
        virtual void Run();
        virtual void RunEditorLoopIteration();
        virtual void RunLoopIteration();
        virtual void UpdateWindows();
        void RegisterGraphicsCore(GraphicsAPI::Core*);
        virtual void RegisterInputManager(Input::Interface*);
        virtual Input::Interface* GetInputManager() const;
        virtual SceneManagement::SceneManager* GetSceneManager() const;
        virtual Plugins::IPluginManager* GetPluginManager() const;
        virtual Plugins::Interface* GetPluginInterface() const;
        virtual ECS::SystemRegistrar* GetSystemRegistrar() const;
        virtual Events::Dispatcher* GetEventDispatcher() const;
        virtual ECS::ComponentRegistrar* GetComponentRegistrar() const;
        virtual GraphicsAPI::Core* GetGraphicsCore() const;
        virtual Profiler::Manager* GetProfiler() const;
        virtual RenderPassRegistry* GetRenderPassRegistry() const;
        virtual WorldContextManager* GetWorldContextManager() const;
        virtual std::filesystem::path GetProjectPath() const;
        virtual std::filesystem::path GetBinaryPath() const;
        virtual std::filesystem::path GetEngineBinaryPath() const;
        virtual std::filesystem::path GetAssetsPath() const;
        virtual std::filesystem::path GetEngineAssetsPath() const;
        virtual std::filesystem::path GetAssetPath(std::string subPath) const;
        virtual entt::registry& GetEntityRegistry();
        virtual Renderer::RenderingPipeline* GetRenderingPipeline() const;
 
        virtual bool OnTryQuit(Grindstone::Events::BaseEvent* ev);
        virtual bool OnForceQuit(Grindstone::Events::BaseEvent* ev);
        virtual void CalculateDeltaTime();
        virtual double GetTimeSinceLaunch() const;
        virtual double GetDeltaTime() const;
        virtual void PushDeletion(std::function<void()> fn);
        virtual void ForceDeleteAllDeferred();
 
        template<typename T, typename... Args>
        void RegisterServiceEmplaced(Args&&... params) {
            const size_t hash = typeid(T).hash_code();
            auto it = services.find(hash);
            if (it == services.end()) {
                services[hash] = Grindstone::Memory::AllocatorCore::Allocate<T>(std::forward<Args>(params)...);
            }
        }
 
        template<typename T>
        void RegisterService(T* instance) {
            const size_t hash = typeid(T).hash_code();
            auto it = services.find(hash);
            if (it == services.end()) {
                services.emplace(hash, instance);
            }
        }
 
        template<typename T>
        void UnregisterService() {
            const size_t hash = typeid(T).hash_code();
            auto it = services.find(hash);
            if (it == services.end()) {
                services.erase(it);
            }
        }
 
        template<typename T>
        T* TryGetService() {
            const size_t hash = typeid(T).hash_code();
            auto it = services.find(hash);
            return (it != services.end())
                ? static_cast<T*>(it->second)
                : nullptr;
        }
    public:
        DisplayManager* displayManager = nullptr;
        WindowManager* windowManager = nullptr;
        Assets::AssetManager* assetManager = nullptr;
        AssetRendererManager* assetRendererManager = nullptr;
        WorldContextManager* worldContextManager = nullptr;
        Profiler::Manager* profiler = nullptr;
        bool isEditor = false;
    private:
        Grindstone::DeferredDeletionQueue deferredDeletionQueue;
        double currentTime = 0.0;
        double deltaTime = 0.0;
        std::chrono::steady_clock::time_point firstFrameTime;
        std::chrono::steady_clock::time_point lastFrameTime;
        SceneManagement::SceneManager* sceneManager = nullptr;
        ECS::ComponentRegistrar* componentRegistrar = nullptr;
        ECS::SystemRegistrar* systemRegistrar = nullptr;
        RenderPassRegistry* renderpassRegistry = nullptr;
        Events::Dispatcher* eventDispatcher = nullptr;
        Plugins::Interface* pluginInterface = nullptr;
        Plugins::IPluginManager* pluginManager = nullptr;
        Renderer::RenderingPipeline* renderingPipeline = nullptr;
        GraphicsAPI::Core* graphicsCore = nullptr;
        Input::Interface* inputManager = nullptr;
        std::unordered_map<std::size_t, void*> services;
        bool shouldClose = false;
        std::filesystem::path projectPath;
        std::filesystem::path binaryPath;
        std::filesystem::path engineBinaryPath;
        std::filesystem::path engineAssetsPath;
        std::filesystem::path assetsPath;
    };
}