GameManager.h

#pragma once
 
// Standard.
#include <memory>
#include <functional>
#include <queue>
#include <atomic>
#include <mutex>
 
// Custom.
#include "game/GameInstance.h"
#include "input/InputManager.h"
#include "input/KeyboardKey.hpp"
#include "input/MouseButton.hpp"
#include "misc/ThreadPool.h"
#include "game/World.h"
#include "render/RenderSettings.h"
 
// External.
#include "GcPtr.h"
 
namespace ne {
    class GameInstance;
    class Renderer;
    class Window;
    class CameraManager;
 
    class GameManager {
        // Objects of this class should only be created by a window instance.
        friend class Window;
 
    public:
        GameManager(const GameManager&) = delete;
        GameManager& operator=(const GameManager&) = delete;
 
        virtual ~GameManager();
 
        static GameManager* get();
 
        void setGarbageCollectorRunInterval(long long iGcRunIntervalInSec);
 
        void queueGarbageCollection(bool bForce, const std::optional<std::function<void()>>& onFinished = {});
 
        void addDeferredTask(const std::function<void()>& task);
 
        void addTaskToThreadPool(const std::function<void()>& task);
 
        void createWorld(
            const std::function<void(const std::optional<Error>&)>& onCreated,
            size_t iWorldSize = Globals::getDefaultWorldSize());
 
        void loadNodeTreeAsWorld(
            const std::function<void(const std::optional<Error>&)>& onLoaded,
            const std::filesystem::path& pathToNodeTree,
            size_t iWorldSize = Globals::getDefaultWorldSize());
 
        sgc::GcPtr<Node> getWorldRootNode();
 
        float getWorldTimeInSeconds();
 
        size_t getWorldSize();
 
        size_t getTotalSpawnedNodeCount();
 
        size_t getCalledEveryFrameNodeCount();
 
        Window* getWindow() const;
 
        GameInstance* getGameInstance() const;
 
        CameraManager* getCameraManager() const;
 
        float getTimeSincePrevFrameInSec() const;
 
        long long getGarbageCollectorRunIntervalInSec() const;
 
        bool isNodeSpawned(size_t iNodeId);
 
        bool isBeingDestroyed() const;
 
    private:
        GameManager(Window* pWindow);
 
        [[nodiscard]] std::optional<Error> initialize(std::optional<RendererType> preferredRenderer);
 
        void destroy();
 
        template <typename MyGameInstance>
            requires std::derived_from<MyGameInstance, GameInstance>
        void setGameInstance() {
            pGameInstance = std::make_unique<MyGameInstance>(pWindow, this, &inputManager);
        }
 
        void onGameStarted();
 
        void onBeforeNewFrame(float timeSincePrevCallInSec);
 
        void onKeyboardInput(KeyboardKey key, KeyboardModifiers modifiers, bool bIsPressedDown);
 
        void onMouseInput(MouseButton button, KeyboardModifiers modifiers, bool bIsPressedDown);
 
        void onMouseMove(double xOffset, double yOffset);
 
        void onMouseScrollMove(int iOffset);
 
        void onWindowFocusChanged(bool bIsFocused) const;
 
        void onFramebufferSizeChanged(int iWidth, int iHeight) const;
 
        void onWindowClose() const;
 
        void onTickFinished();
 
        void runGarbageCollection(bool bForce = false);
 
        void executeDeferredTasks();
 
        void triggerActionEvents(
            std::variant<KeyboardKey, MouseButton> key, KeyboardModifiers modifiers, bool bIsPressedDown);
 
        void triggerAxisEvents(KeyboardKey key, KeyboardModifiers modifiers, bool bIsPressedDown);
 
        void destroyAndCleanExistingWorld();
 
        Window* pWindow;
 
        std::unique_ptr<GameInstance> pGameInstance;
 
        std::pair<std::recursive_mutex, std::unique_ptr<World>> mtxWorld;
 
        std::unique_ptr<Renderer> pRenderer;
 
        std::unique_ptr<CameraManager> pCameraManager;
 
        ThreadPool threadPool;
 
        std::pair<std::recursive_mutex, std::queue<std::function<void()>>> mtxDeferredTasks;
 
        InputManager inputManager;
 
        std::chrono::steady_clock::time_point lastGcRunTime;
 
        float timeSincePrevFrameInSec = 0.0F;
 
        long long iGcRunIntervalInSec = 120;
 
        std::thread::id mainThreadId;
 
        bool bShouldAcceptNewDeferredTasks = true;
 
        bool bIsInitialized = false;
 
        bool bIsBeingDestroyed = false;
 
        inline static const char* sGcLeakReasons =
            "- you are switching a world but your game instance holds some non-nullptr gc pointers,\n"
            "- you are not using STL container wrappers for gc "
            "pointers (for example, you need to use `sgc::GcVector<sgc::GcPtr<T>>` instead of "
            "`std::vector<sgc::GcPtr<T>>`, and other `gc_*` containers when storing gc pointers),\n"
            "- you are capturing `sgc::GcPtr` pointer(s) in `std::function` (this might leak in some "
            "special),\n"
            "- for a more detailed list of possible issues see the \"README\" file at "
            "https://github.com/Flone-dnb/sgc";
    };
} // namespace ne