GameInstance.h

#pragma once
 
// Standard.
#include <functional>
#include <optional>
#include <mutex>
#include <filesystem>
 
// Custom.
#include "input/KeyboardKey.hpp"
#include "input/MouseButton.hpp"
#include "misc/Timer.h"
#include "misc/Globals.h"
 
// External.
#include "GcPtr.h"
 
namespace ne {
    class Window;
    class InputManager;
    class GameManager;
    class Node;
    class CameraManager;
 
    class GameInstance {
        // Game will trigger input events.
        friend class GameManager;
 
    public:
        GameInstance() = delete;
 
        GameInstance(Window* pGameWindow, GameManager* pGameManager, InputManager* pInputManager);
 
        GameInstance(const GameInstance&) = delete;
        GameInstance& operator=(const GameInstance&) = delete;
 
        virtual ~GameInstance() = default;
 
        static float getTotalApplicationTimeInSec();
 
        void addDeferredTask(const std::function<void()>& task) const;
 
        void addTaskToThreadPool(const std::function<void()>& task) const;
 
        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());
 
        void queueGarbageCollection(bool bForce, const std::optional<std::function<void()>>& onFinished = {});
 
        void setGarbageCollectorRunInterval(long long iGcRunIntervalInSec);
 
        void executeShaderManagerSelfValidation() const;
 
        sgc::GcPtr<Node> getWorldRootNode() const;
 
        float getWorldTimeInSeconds() const;
 
        size_t getWorldSize() const;
 
        size_t getTotalSpawnedNodeCount();
 
        size_t getCalledEveryFrameNodeCount();
 
        Window* getWindow() const;
 
        CameraManager* getCameraManager() const;
 
        InputManager* getInputManager() const;
 
        long long getGarbageCollectorRunIntervalInSec();
 
    protected:
        Timer* createTimer(const std::string& sTimerName);
 
        void stopAndDisableCreatedTimers();
 
        virtual void onGameStarted() {}
 
        virtual void onBeforeNewFrame(float timeSincePrevCallInSec) {}
 
        virtual void onKeyboardInput(KeyboardKey key, KeyboardModifiers modifiers, bool bIsPressedDown) {}
 
        virtual void onMouseInput(MouseButton button, KeyboardModifiers modifiers, bool bIsPressedDown) {}
 
        virtual void onMouseMove(double xOffset, double yOffset) {};
 
        virtual void onMouseScrollMove(int iOffset) {}
 
        virtual void onWindowFocusChanged(bool bIsFocused) {}
 
        virtual void onFramebufferSizeChanged(int iWidth, int iHeight) {}
 
        virtual void onWindowClose() {}
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, bool)>>>*
        getActionEventBindings();
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, float)>>>*
        getAxisEventBindings();
 
    private:
        void onInputActionEvent(unsigned int iActionId, KeyboardModifiers modifiers, bool bIsPressedDown);
 
        void onInputAxisEvent(unsigned int iAxisEventId, KeyboardModifiers modifiers, float input);
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, bool)>>>
            mtxBindedActionEvents;
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, float)>>>
            mtxBindedAxisEvents;
 
        std::pair<std::recursive_mutex, std::vector<std::unique_ptr<Timer>>> mtxCreatedTimers;
 
        bool bAllowCreatingTimers = true;
 
        Window* pGameWindow = nullptr;
 
        GameManager* pGameManager = nullptr;
 
        InputManager* pInputManager = nullptr;
    };
} // namespace ne