window_manager.h

#pragma once
 
#include <cstdint>
#include <string>
#include <utility>
 
#include "platform/window/frame_limiter.h"
#include "platform/input/input_handle.h"
 
struct GLFWwindow;
struct GLFWmonitor;
 
namespace Vkm::Engine {
 
// Window-creation defaults; the GL version is here because WindowManager creates the context.
inline constexpr int OPENGL_MAJOR_VERSION  = 4;
inline constexpr int OPENGL_MINOR_VERSION  = 3;
inline constexpr int OPENGL_GLSL_VERSION   = OPENGL_MAJOR_VERSION * 100 + OPENGL_MINOR_VERSION * 10;
inline constexpr int DEFAULT_WINDOW_WIDTH  = 1920;
inline constexpr int DEFAULT_WINDOW_HEIGHT = 1080;

enum class WindowMode {
    Fullscreen = 1,
    Windowed   = 2
};

enum class CursorMode {
    Normal   = 0,    
    Hidden   = 1,    
    Disabled = 2,    
    Captured = 3     
};

constexpr const char* toString(WindowMode type) {
    switch (type) {
        case WindowMode::Fullscreen: return "Fullscreen";
        case WindowMode::Windowed:   return "Windowed";
        default: return "UNKNOWN";
    }
}

class WindowManager {
    public:
        WindowManager();
        ~WindowManager();
 
        WindowManager(const WindowManager& other) = delete;
        WindowManager& operator=(const WindowManager& other) = delete;
 
        WindowManager(WindowManager && other) = delete;
        WindowManager& operator=(WindowManager && other) = delete;
 
    public:
        void createWindow(const std::string& title);

        void setIcon(const std::string& path);

        bool shouldClose() const;

        void requestClose();

        void cancelClose();

        void setTitle(const std::string& title);

        void swapBuffers();

        void saveScreenshot(std::string pngPath) { m_screenshotPath = std::move(pngPath); }

        std::string takeScreenshotRequest() { return std::exchange(m_screenshotPath, std::string()); }

        void updateMode(WindowMode windowMode);

        void updateInput();

        bool beginFrame();

        void setVSync(bool enabled);

        void setFramerate(int framerate);

        void setCursorMode(CursorMode mode);

        bool isOpen() const { return m_windowHandle != nullptr; }

        WindowMode mode() const { return m_windowMode; }

        bool vsync() const { return m_vsync; }

        int framerate() const { return m_frameLimiter.targetFramerate(); }

        CursorMode cursorMode() const { return m_cursorMode; }

        InputHandle& getInputHandle() { return m_inputHandle; }
        const InputHandle& getInputHandle() const { return m_inputHandle; }

        size_t getWidth() const;

        size_t getHeight() const;

        float framebufferScale() const;

        GLFWwindow* getWindowContext() const;

        int displayHeight() const;
 
    private:
        void setSize(int width, int height);

        int getRefreshRate() const;
 
    private:
        GLFWwindow* m_windowHandle = nullptr;
        std::string m_title;

        bool m_closeRequested = false;
 
        int m_width  = 0;    
        int m_height = 0;
 
        int    m_windowWidth = 0;    
        double m_cursorX     = 0.0;  
        double m_cursorY     = 0.0;
        CursorMode m_cursorMode = CursorMode::Normal;
 
        InputHandle  m_inputHandle;
        FrameLimiter m_frameLimiter;
 
        WindowMode m_windowMode = WindowMode::Windowed;
        bool       m_vsync      = false;
        std::string m_screenshotPath;  
};
 
} // namespace Vkm::Engine