context.hpp

Go to the documentation of this file.

#pragma once
#include "le2d/asset/asset_loader.hpp"
#include "le2d/audio_mixer.hpp"
#include "le2d/build_version.hpp"
#include "le2d/data_loader.hpp"
#include "le2d/event.hpp"
#include "le2d/frame_stats.hpp"
#include "le2d/render_pass.hpp"
#include "le2d/resource/resource_factory.hpp"
#include "le2d/unprojector.hpp"
#include "le2d/vsync.hpp"
#include <GLFW/glfw3.h>
#include <klib/enum_ops.hpp>
#include <kvf/render_device.hpp>
#include <kvf/window.hpp>
#include <variant>
 
namespace le {
enum class PlatformFlag : std::uint8_t {
    None = 0,
    ForceX11,
    NoLibdecor,
};
constexpr auto enable_enum_bitops(PlatformFlag /*unused*/) -> bool { return true; }
 
enum class WindowFlag : std::uint8_t {
    None = 0,
    Decorated = 1 << 0,
    Resizeable = 1 << 1,
    Visible = 1 << 2,
    Maximized = 1 << 3,
    FocusOnShow = 1 << 4,
    ScaleToMonitor = 1 << 5,
    ScaleFramebuffer = 1 << 6,
};
constexpr auto enable_enum_bitops(WindowFlag /*unused*/) -> bool { return true; }
 
inline constexpr auto default_window_flags_v = WindowFlag::Decorated | WindowFlag::Resizeable | WindowFlag::Visible;
 
struct WindowInfo {
    glm::ivec2 size{600};
    klib::CString title;
    WindowFlag flags{default_window_flags_v};
};
 
struct FullscreenInfo {
    klib::CString title;
};
 
using WindowCreateInfo = std::variant<WindowInfo, FullscreenInfo>;
 
struct ContextCreateInfo {
    PlatformFlag platform_flags{PlatformFlag::None};
    WindowCreateInfo window{WindowInfo{}};
    kvf::RenderDeviceCreateInfo render_device{};
    vk::SampleCountFlagBits framebuffer_samples{vk::SampleCountFlagBits::e2};
    int sfx_buffers{16};
};
 
class Context : public klib::Polymorphic {
  public:
    class Waiter;
 
    using SpirV = std::span<std::uint32_t const>;
    using CreateInfo = ContextCreateInfo;
 
    static constexpr auto min_render_scale_v{0.2f};
    static constexpr auto max_render_scale_v{8.0f};
 
    [[nodiscard]] static auto create(CreateInfo const& create_info = {}) -> std::unique_ptr<Context>;
 
    [[nodiscard]] virtual auto get_window() const -> GLFWwindow* = 0;
    [[nodiscard]] virtual auto get_render_device() const -> kvf::RenderDevice const& = 0;
    [[nodiscard]] virtual auto get_resource_factory() const -> IResourceFactory const& = 0;
    [[nodiscard]] virtual auto get_audio_mixer() const -> IAudioMixer& = 0;
    [[nodiscard]] virtual auto get_default_shader() const -> IShader const& = 0;
    [[nodiscard]] virtual auto get_renderer() const -> IRenderer const& = 0;
 
    [[nodiscard]] auto window_size() const -> glm::ivec2;
    [[nodiscard]] auto framebuffer_size() const -> glm::ivec2;
    [[nodiscard]] auto swapchain_extent() const -> vk::Extent2D;
    [[nodiscard]] auto main_pass_size() const -> glm::ivec2;
    [[nodiscard]] auto display_ratio() const -> glm::vec2;
 
    [[nodiscard]] auto unprojector(Viewport const& viewport, Transform const& view) const -> Unprojector {
        return Unprojector{viewport, view, main_pass_size()};
    }
 
    [[nodiscard]] auto get_title() const -> klib::CString;
    void set_title(klib::CString title);
 
    [[nodiscard]] auto get_refresh_rate() const -> std::int32_t;
 
    [[nodiscard]] auto is_fullscreen() const -> bool;
    auto set_fullscreen(GLFWmonitor* target = nullptr) -> bool;
    void set_windowed(glm::ivec2 size = {1280, 720});
    void set_visible(bool visible);
    void lock_aspect_ratio(bool lock);
 
    [[nodiscard]] auto is_running() const -> bool;
    void set_window_close();
    void cancel_window_close();
 
    void wait_idle();
 
    [[nodiscard]] virtual auto get_render_scale() const -> float = 0;
    virtual auto set_render_scale(float scale) -> bool = 0;
 
    [[nodiscard]] virtual auto get_supported_vsync() const -> std::span<Vsync const> = 0;
    [[nodiscard]] virtual auto get_vsync() const -> Vsync = 0;
    virtual auto set_vsync(Vsync vsync) -> bool = 0;
 
    [[nodiscard]] virtual auto get_samples() const -> vk::SampleCountFlagBits = 0;
    [[nodiscard]] virtual auto get_supported_samples() const -> vk::SampleCountFlags = 0;
    virtual auto set_samples(vk::SampleCountFlagBits samples) -> bool = 0;
 
    virtual auto next_frame() -> vk::CommandBuffer = 0;
    [[nodiscard]] virtual auto event_queue() const -> std::span<Event const> = 0;
    [[nodiscard]] virtual auto begin_render(kvf::Color clear = kvf::black_v) -> IRenderer& = 0;
    virtual void present() = 0;
 
    [[nodiscard]] virtual auto get_frame_stats() const -> FrameStats const& = 0;
 
    [[nodiscard]] auto create_waiter() -> Waiter;
    [[nodiscard]] virtual auto create_render_pass(vk::SampleCountFlagBits samples) const -> std::unique_ptr<IRenderPass> = 0;
    [[nodiscard]] virtual auto create_asset_loader(gsl::not_null<IDataLoader const*> data_loader) const -> AssetLoader = 0;
};
 
class Context::Waiter {
  public:
    Waiter() = default;
 
    explicit(false) Waiter(gsl::not_null<Context*> context) : m_context(context) {}
 
    [[nodiscard]] auto is_active() const -> bool { return m_context != nullptr; }
 
    [[nodiscard]] auto get_context() const -> Context* { return m_context.get(); }
 
  private:
    struct Deleter {
        void operator()(Context* ptr) const {
            if (!ptr) { return; }
            ptr->wait_idle();
        }
    };
 
    std::unique_ptr<Context, Deleter> m_context{};
};
} // namespace le