window_internal.h

#pragma once
 
#include "pixelbullet/assets/bitmap.h"
#include "pixelbullet/input/key_codes.h"
#include "pixelbullet/window/window_chrome.h"
 
#include <glm/glm.hpp>
#include <volk.h>
 
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <utility>
 
struct GLFWimage;
struct GLFWwindow;
 
namespace pixelbullet
{
class Filesystem;
class Event;
class VirtualPath;
class Window;
struct ApplicationSpecification;
namespace input
{
class InputState;
}
} // namespace pixelbullet
 
namespace pixelbullet::window_internal
{
struct WindowSnapshot
{
    glm::ivec2 framebuffer_size{ 0, 0 };
    glm::ivec2 position{ 0, 0 };
    bool focused = false;
    glm::vec2 content_scale{ 1.0f, 1.0f };
};
 
class GlfwApi
{
public:
    virtual ~GlfwApi() = default;
 
    virtual void AcquireRuntime() = 0;
    virtual void ReleaseRuntime() noexcept = 0;
    [[nodiscard]] virtual unsigned int NextWindowId() noexcept = 0;
    virtual void WindowHint(int hint, int value) = 0;
    [[nodiscard]] virtual GLFWwindow* CreateWindow(int width, int height, const char* title) = 0;
    virtual void DestroyWindow(GLFWwindow* window) = 0;
    virtual void SetWindowUserPointer(GLFWwindow* window, void* pointer) = 0;
    [[nodiscard]] virtual WindowSnapshot CaptureWindowSnapshot(GLFWwindow* window) = 0;
    virtual void RegisterCallbacks(GLFWwindow* window) = 0;
    virtual void PollEvents() noexcept = 0;
    virtual void SetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images) = 0;
    [[nodiscard]] virtual const char** GetRequiredInstanceExtensions(uint32_t* count) = 0;
    [[nodiscard]] virtual VkResult CreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator,
                                                       VkSurfaceKHR* surface) = 0;
    virtual void IconifyWindow(GLFWwindow* window) noexcept = 0;
    virtual void MaximizeWindow(GLFWwindow* window) noexcept = 0;
    virtual void RestoreWindow(GLFWwindow* window) noexcept = 0;
    virtual void SetInputMode(GLFWwindow* window, int mode, int value) noexcept = 0;
    [[nodiscard]] virtual int GetWindowAttrib(GLFWwindow* window, int attrib) const noexcept = 0;
    [[nodiscard]] virtual int GetKey(GLFWwindow* window, int key) const noexcept = 0;
};
 
class WindowChromeApi
{
public:
    virtual ~WindowChromeApi() = default;
 
    [[nodiscard]] virtual bool PlatformSupportsCustomChrome() const noexcept = 0;
    [[nodiscard]] virtual bool AttachCustomChrome(Window& window) = 0;
    virtual void DetachCustomChrome(Window& window) noexcept = 0;
    virtual void OnLayoutChanged(Window& window) noexcept = 0;
    virtual void ShowSystemMenuAt(Window& window, WindowPoint client_point) noexcept = 0;
};
 
struct WindowAccess
{
    [[nodiscard]] static GLFWwindow*& NativeWindow(Window& window) noexcept;
    [[nodiscard]] static const GLFWwindow* NativeWindow(const Window& window) noexcept;
    [[nodiscard]] static std::string& Title(Window& window) noexcept;
    [[nodiscard]] static unsigned int& Width(Window& window) noexcept;
    [[nodiscard]] static unsigned int& Height(Window& window) noexcept;
    [[nodiscard]] static bool& Focused(Window& window) noexcept;
    [[nodiscard]] static bool& Fullscreen(Window& window) noexcept;
    [[nodiscard]] static glm::ivec2& Size(Window& window) noexcept;
    [[nodiscard]] static glm::ivec2& FullscreenSize(Window& window) noexcept;
    [[nodiscard]] static glm::ivec2& Position(Window& window) noexcept;
    [[nodiscard]] static glm::vec2& ContentScale(Window& window) noexcept;
    [[nodiscard]] static input::InputState& InputState(Window& window) noexcept;
    [[nodiscard]] static std::function<void(Event&)>& EventCallback(Window& window) noexcept;
    [[nodiscard]] static std::function<void(uint32_t)>& FramebufferResizeCallback(Window& window) noexcept;
    [[nodiscard]] static uint32_t& Id(Window& window) noexcept;
    [[nodiscard]] static bool& CursorCaptured(Window& window) noexcept;
    [[nodiscard]] static WindowFrameMode& FrameMode(Window& window) noexcept;
    [[nodiscard]] static bool& CustomChromeSupported(Window& window) noexcept;
    [[nodiscard]] static bool& CustomChromeAttached(Window& window) noexcept;
    [[nodiscard]] static WindowChromeLayout& CustomChromeLayout(Window& window) noexcept;
};
 
class ScopedGlfwApiOverride
{
public:
    explicit ScopedGlfwApiOverride(GlfwApi& api) noexcept;
    ~ScopedGlfwApiOverride();
 
    ScopedGlfwApiOverride(const ScopedGlfwApiOverride&) = delete;
    ScopedGlfwApiOverride& operator=(const ScopedGlfwApiOverride&) = delete;
 
private:
    GlfwApi* previous_api_ = nullptr;
};
 
class ScopedWindowChromeApiOverride
{
public:
    explicit ScopedWindowChromeApiOverride(WindowChromeApi& api) noexcept;
    ~ScopedWindowChromeApiOverride();
 
    ScopedWindowChromeApiOverride(const ScopedWindowChromeApiOverride&) = delete;
    ScopedWindowChromeApiOverride& operator=(const ScopedWindowChromeApiOverride&) = delete;
 
private:
    WindowChromeApi* previous_api_ = nullptr;
};
 
using IconBitmapLoader = std::function<Bitmap(const Filesystem&, const VirtualPath&)>;
 
class ScopedIconBitmapLoaderOverride
{
public:
    explicit ScopedIconBitmapLoaderOverride(IconBitmapLoader loader);
    ~ScopedIconBitmapLoaderOverride();
 
    ScopedIconBitmapLoaderOverride(const ScopedIconBitmapLoaderOverride&) = delete;
    ScopedIconBitmapLoaderOverride& operator=(const ScopedIconBitmapLoaderOverride&) = delete;
 
private:
    IconBitmapLoader previous_loader_;
};
 
[[nodiscard]] GlfwApi& GetGlfwApi();
[[nodiscard]] WindowChromeApi& GetWindowChromeApi();
[[nodiscard]] Bitmap LoadIconBitmap(const Filesystem& filesystem, const VirtualPath& icon_path);
 
void InitializeWindow(Window& window, const ApplicationSpecification& props, bool start_hidden);
void ShutdownWindow(Window& window) noexcept;
void PollEvents() noexcept;
void SetIcon(Window& window, const Filesystem& filesystem, const VirtualPath& icon_path);
[[nodiscard]] std::pair<const char**, uint32_t> GetInstanceExtensions();
[[nodiscard]] VkResult CreateSurface(const Window& window, VkInstance instance, const VkAllocationCallbacks* allocator,
                                     VkSurfaceKHR* surface);
void Minimize(Window& window) noexcept;
void Maximize(Window& window) noexcept;
void Restore(Window& window) noexcept;
void RequestClose(Window& window) noexcept;
void ShowSystemMenuAt(Window& window, WindowPoint client_point) noexcept;
[[nodiscard]] bool SupportsCustomChrome(const Window& window) noexcept;
void SetCustomChromeLayout(Window& window, const WindowChromeLayout& layout);
void ClearCustomChromeLayout(Window& window);
void SetCursorCaptured(Window& window, bool captured) noexcept;
[[nodiscard]] bool IsKeyDown(const Window& window, input::KeyCode key) noexcept;
[[nodiscard]] bool IsMinimized(const Window& window) noexcept;
[[nodiscard]] bool IsMaximized(const Window& window) noexcept;
} // namespace pixelbullet::window_internal