window.h

#pragma once
 
#include "pixelbullet/input/input.h"
 
#include <glm/glm.hpp>
#include <volk.h>
 
#include <cstdint>
#include <functional>
#include <string>
#include <utility>
 
struct GLFWwindow;
 
namespace pixelbullet
{
class Event;
class Filesystem;
class VirtualPath;
struct ApplicationSpecification;
 
class Window final
{
public:
    enum class WindowState
    {
        Normal,
        Minimized,
        Maximized
    };
 
    explicit Window(const ApplicationSpecification& props, bool startHidden = false);
    ~Window();
 
    void OnUpdate() noexcept;
 
    void SetIcon(const Filesystem& filesystem, const VirtualPath& iconPath);
 
    unsigned int GetWidth() const noexcept
    {
        return width_;
    }
    unsigned int GetHeight() const noexcept
    {
        return height_;
    }
    glm::ivec2 GetSize() const noexcept
    {
        return { width_, height_ };
    }
    glm::ivec2 GetPosition() const noexcept
    {
        return position_;
    }
    unsigned int GetFramebufferWidth() const noexcept
    {
        return static_cast<unsigned int>(GetFramebufferSize().x);
    }
    unsigned int GetFramebufferHeight() const noexcept
    {
        return static_cast<unsigned int>(GetFramebufferSize().y);
    }
    glm::ivec2 GetFramebufferSize() const noexcept
    {
        const auto size = fullscreen_ ? fullscreen_size_ : size_;
 
        if (size.x > 0 && size.y > 0)
        {
            return size;
        }
 
        return GetSize();
    }
 
    void SetEventCallback(const std::function<void(Event&)>& callback)
    {
        event_callback_ = callback;
    }
    void SetFramebufferResizeCallback(const std::function<void(uint32_t)>& callback)
    {
        framebuffer_resize_callback_ = callback;
    }
 
    [[nodiscard]] const input::InputState& GetInputState() const noexcept
    {
        return input_state_;
    }
 
    void* GetNativeWindow() const noexcept
    {
        return window_;
    }
 
    std::pair<const char**, uint32_t> GetInstanceExtensions() const;
 
    VkResult CreateSurface(VkInstance instance, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface) const;
 
    void Minimize() noexcept;
 
    void Maximize() noexcept;
 
    void Restore() noexcept;
 
    bool IsMinimized() const noexcept;
 
    bool IsFocused() const noexcept
    {
        return focused_;
    }
 
    bool IsMaximized() const noexcept;
 
    WindowState GetWindowState() const noexcept;
 
private:
    void Init(const ApplicationSpecification& props, bool startHidden);
    void Shutdown();
 
private:
    GLFWwindow* window_ = nullptr;
    std::string title_;
    unsigned int width_ = 0, height_ = 0;
    std::function<void(Event&)> event_callback_;
    std::function<void(uint32_t)> framebuffer_resize_callback_;
 
    bool fullscreen_ = false;
    bool focused_ = false;
    glm::ivec2 size_{ 0, 0 };            
    glm::ivec2 fullscreen_size_{ 0, 0 }; 
    glm::ivec2 position_{ 0, 0 };
    input::InputState input_state_;
    uint32_t id_ = 0; 
};
} // namespace pixelbullet