engine.h

#pragma once
 
#include <array>
#include <cstdint>
#include <memory>
#include <vector>
 
#include "ecs/scene.h"
#include "resource/resource_manager.h"
#include "platform/window/window_manager.h"
#include "core/system.h"
#include "system/render/render_settings.h"
#include "core/clock.h"
#include "core/event/event_bus.h"
#include "core/host_chrome.h"
#include "platform/input/input_map.h"
#include "net/net_session.h"
 
namespace Vkm::Engine {

class Engine {
    public:
        Engine();
        ~Engine();
 
        Engine(const Engine& other) = delete;
        Engine& operator=(const Engine& other) = delete;
 
        Engine(Engine && other) = delete;
        Engine& operator=(Engine && other) = delete;
 
    public:
        void setFPSLog(bool enabled = true) { m_fpsLog = enabled; }

        void run();

        template<typename T, typename... Args>
        T& addSystem(SystemStage stage, Args&&... args) {
            auto system = std::make_unique<T>(std::forward<Args>(args)...);
            T& ref = *system;
            m_systemsByStage[static_cast<size_t>(stage)].push_back(std::move(system));
            return ref;
        }
 
        Scene& getScene()             { return m_scene; }
        const Scene& getScene() const { return m_scene; }
 
        ResourceManager& getResources()             { return m_resources; }
        const ResourceManager& getResources() const { return m_resources; }
 
        Clock& getClock()             { return m_clock; }
        const Clock& getClock() const { return m_clock; }
 
        EventBus& getEvents()             { return m_events; }
        const EventBus& getEvents() const { return m_events; }

        InputMap& getInput()             { return m_input; }
        const InputMap& getInput() const { return m_input; }
 
        WindowManager& getWindow()             { return m_window; }
        const WindowManager& getWindow() const { return m_window; }

        HostChrome& getChrome()             { return m_chrome; }
        const HostChrome& getChrome() const { return m_chrome; }

        RenderSettings& getRenderSettings()             { return m_render; }
        const RenderSettings& getRenderSettings() const { return m_render; }

        NetSession& getNet()             { return m_net; }
        const NetSession& getNet() const { return m_net; }
 
    private:
        using SystemList = std::vector<std::unique_ptr<System>>;
 
        void initSystems(FrameContext& ctx);
        void shutdownSystems();
 
    private:
        EventBus m_events;
 
        Scene m_scene;
        ResourceManager m_resources;
 
        Clock          m_clock;
        InputMap       m_input;
        WindowManager  m_window;
        NetSession     m_net;
        HostChrome     m_chrome;
        RenderSettings m_render;
 
        std::array<SystemList, static_cast<size_t>(SystemStage::Count)> m_systemsByStage;
 
        bool m_initialized = false;
        bool m_fpsLog      = false;
};
 
} // namespace Vkm::Engine