Window.h

#pragma once
 
// Standard.
#include <variant>
#include <memory>
#include <optional>
#include <utility>
 
// Custom.
#include "misc/Error.h"
#include "game/GameManager.h"
#include "render/Renderer.h"
#include "window/GLFW.hpp"
#include "game/GameInstance.h"
#include "input/KeyboardKey.hpp"
#include "input/MouseButton.hpp"
 
namespace ne {
    class Error;
    class GameInstance;
 
    class WindowCursor {
        // Only Window can directly create instances of this class.
        // For users we provide a separate function.
        friend class Window;
 
    public:
        WindowCursor() = delete;
        WindowCursor(const WindowCursor&) = delete;
        WindowCursor& operator=(const WindowCursor&) = delete;
 
        ~WindowCursor();
 
    protected:
        static std::variant<std::unique_ptr<WindowCursor>, Error>
        create(const std::filesystem::path& pathToIcon);
 
        void releaseCursor();
 
        GLFWcursor* getCursor() const;
 
    private:
        WindowCursor(GLFWcursor* pCursor);
 
        GLFWcursor* pCursor = nullptr;
    };
 
    struct WindowBuilderParameters {
        int iWindowWidth = 800;
        int iWindowHeight = 600;
        std::string_view sWindowTitle;
        std::filesystem::path pathToWindowIcon;
        bool bShowWindow = true;
        bool bMaximized = false;
        bool bFullscreen = false;
        bool bIsSplashScreen = false;
    };
 
    class Window;
 
    class WindowBuilder {
    public:
        WindowBuilder() = default;
 
        WindowBuilder& withSize(int iWidth, int iHeight);
 
        WindowBuilder& withTitle(std::string_view sWindowTitle);
 
        WindowBuilder& withIcon(const std::filesystem::path& pathToIcon);
 
        WindowBuilder& withVisibility(bool bShow);
 
        WindowBuilder& withMaximizedState(bool bMaximized);
 
        WindowBuilder& withSplashScreenMode(bool bIsSplashScreen);
 
        WindowBuilder& withFullscreenMode(bool bEnableFullscreen);
 
        std::variant<std::unique_ptr<Window>, Error> build();
 
    private:
        WindowBuilderParameters params;
    };
 
    class Window {
        // Builder will create new instances.
        friend class WindowBuilder;
 
    public:
        Window() = delete;
        Window(const Window&) = delete;
        Window& operator=(const Window&) = delete;
 
        virtual ~Window();
 
        static WindowBuilder getBuilder();
 
        void setPreferredRenderer(const std::optional<RendererType>& preferredRenderer);
 
        template <typename MyGameInstance>
            requires std::derived_from<MyGameInstance, GameInstance>
        void processEvents();
 
        void setOpacity(float opacity) const;
 
        void setTitle(const std::string& sNewTitle);
 
        [[nodiscard]] std::optional<Error> setIcon(const std::filesystem::path& pathToIcon) const;
 
        std::variant<WindowCursor*, Error> createCursor(const std::filesystem::path& pathToIcon);
 
        void setCursor(WindowCursor* pCursor);
 
        void setDefaultCursor();
 
        void setCursorVisibility(bool bIsVisible) const;
 
        void minimize() const;
 
        void maximize() const;
 
        void restore() const;
 
        void hide() const;
 
        void show() const;
 
        void close() const;
 
        std::pair<int, int> getSize() const;
 
        std::pair<double, double> getCursorPosition() const;
 
        std::string getTitle() const;
 
        float getOpacity() const;
 
        Renderer* getRenderer() const;
 
#if defined(WIN32)
        HWND getWindowHandle() const;
#endif
 
        GLFWwindow* getGlfwWindow() const;
 
        void onKeyboardInput(KeyboardKey key, KeyboardModifiers modifiers, bool bIsPressedDown) const;
 
        void onMouseInput(MouseButton button, KeyboardModifiers modifiers, bool bIsPressedDown) const;
 
        void onMouseScrollMove(int iOffset) const;
 
    private:
        static void
        glfwWindowKeyboardCallback(GLFWwindow* pGlfwWindow, int iKey, int iScancode, int iAction, int iMods);
 
        static void glfwWindowMouseCallback(GLFWwindow* pGlfwWindow, int iButton, int iAction, int iMods);
 
        static void glfwWindowFocusCallback(GLFWwindow* pGlfwWindow, int iFocused);
 
        static void glfwWindowMouseCursorPosCallback(GLFWwindow* pGlfwWindow, double xPos, double yPos);
 
        static void glfwWindowMouseScrollCallback(GLFWwindow* pGlfwWindow, double xOffset, double yOffset);
 
        static void glfwFramebufferResizeCallback(GLFWwindow* pGlfwWindow, int iWidth, int iHeight);
 
        void bindToWindowEvents();
 
        void unbindFromWindowEvents();
 
        void showErrorIfNotOnMainThread() const;
 
        void onMouseMove(double xPos, double yPos);
 
        void onWindowFocusChanged(bool bIsFocused) const;
 
        void onFramebufferSizeChanged(int iWidth, int iHeight) const;
 
        static std::variant<std::unique_ptr<Window>, Error> create(WindowBuilderParameters& params);
 
        Window(GLFWwindow* pGlfwWindow, const std::string& sWindowTitle);
 
        std::unique_ptr<GameManager> pGameManager;
 
        GLFWwindow* pGlfwWindow = nullptr;
 
        std::vector<std::unique_ptr<WindowCursor>> vCreatedCursors;
 
        std::thread::id mainThreadId;
 
        std::string sWindowTitle;
 
        std::optional<RendererType> preferredRenderer;
 
        double lastMouseXPos = 0.0;
 
        double lastMouseYPos = 0.0;
    };
 
    template <typename MyGameInstance>
        requires std::derived_from<MyGameInstance, GameInstance>
    void Window::processEvents() {
        // Create game manager.
        pGameManager = std::unique_ptr<GameManager>(new GameManager(this));
        auto optionalError = pGameManager->initialize(preferredRenderer);
        if (optionalError.has_value()) [[unlikely]] {
            optionalError->addCurrentLocationToErrorStack();
            optionalError->showError();
            throw std::runtime_error(optionalError->getFullErrorMessage());
        }
 
        // ... initialize other GameManager fields here ...
 
        // Finally create Game Instance when engine (GameManager) is fully initialized.
        // So that the user can call engine functions in Game Instance constructor.
        pGameManager->setGameInstance<MyGameInstance>();
 
        // Now bind to window events because game manager/instance is created.
        bindToWindowEvents();
 
        // After enabling window events notify game instance about game being ready to start.
        pGameManager->onGameStarted();
 
        // Prepare reference to renderer.
        const auto pRenderer = getRenderer();
 
        // Used for tick.
        float currentTimeInSec = 0.0f;
        float prevTimeInSec = static_cast<float>(glfwGetTime());
 
        while (!glfwWindowShouldClose(pGlfwWindow)) {
            // Execute deferred tasks before processing input and ticking
            // because some deferred tasks are used to remove despawned nodes from world,
            // this way we won't trigger input events/tick on despawned nodes.
            pGameManager->executeDeferredTasks();
 
            // Process window events.
            glfwPollEvents();
 
            // Tick.
            currentTimeInSec = static_cast<float>(glfwGetTime());
            pGameManager->onBeforeNewFrame(currentTimeInSec - prevTimeInSec);
            prevTimeInSec = currentTimeInSec;
 
            // Draw next frame.
            pRenderer->drawNextFrame();
 
            // Notify game manager about tick finish.
            pGameManager->onTickFinished();
        }
 
        // Notify game manager about window closed.
        pGameManager->onWindowClose();
 
        // Unbind from callbacks before destroying the game manager/game instance.
        unbindFromWindowEvents();
 
        // Destroy game manager.
        pGameManager->destroy(); // explicitly destroy here to run GC for the last time (before everything
        pGameManager = nullptr;  // else is destroyed)
        Logger::get().info("game manager is destroyed");
    }
} // namespace ne