window.hpp

Go to the documentation of this file.

#pragma once

#include <SDL.h>
#include <SDL_syswm.h>
#include <string>

#include "renderer.hpp"
#include "vec2.hpp"

#ifdef CPP_SDL2_ENABLE_VULKAN
#include <SDL_vulkan.h>
#include <vulkan/vulkan.hpp>
#endif

namespace sdl
{
class Window
{
public:
    Window(std::string const& title, Vec2i const& size, Uint32 flags = SDL_WINDOW_SHOWN)
        : window_{SDL_CreateWindow(
            title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, size.x, size.y, flags)}
    {
        if (!window_) throw Exception{"SDL_CreateWindow"};
    }

    Window() = default;

    Window(Window&& other) noexcept { *this = std::move(other); }

    Window& operator=(Window&& other) noexcept
    {
        if (this->window_ != other.window_)
        {
            SDL_DestroyWindow(window_);
            window_       = other.window_;
            other.window_ = nullptr;
        }
        return *this;
    }

    // Non copyable class
    Window(Window&) = delete;
    Window& operator=(Window&) = delete;

    virtual ~Window() { SDL_DestroyWindow(window_); }

    SDL_Window* ptr() const { return window_; }

    Renderer make_renderer(Uint32 flags = SDL_RENDERER_ACCELERATED) const
    {
        const auto render = SDL_CreateRenderer(window_, -1, flags);
        if (!render) throw Exception{"SDL_CreateRenderer"};
        return Renderer{render};
    }

    int display_index() const
    {
        const auto r = SDL_GetWindowDisplayIndex(window_);
        if (r == -1) throw Exception{"SDL_GetWindowDisplayIndex"};
        return r;
    }

    void set_display_mode(SDL_DisplayMode const& mode) const
    {
        if (SDL_SetWindowDisplayMode(window_, &mode) != 0)
        {
            throw Exception{"SDL_SetWindowDisplayMode"};
        }
    }

    SDL_DisplayMode display_mode() const
    {
        SDL_DisplayMode mode;
        if (SDL_GetWindowDisplayMode(window_, &mode) != 0)
        {
            throw Exception{"SDL_GetWindowDisplayMode"};
        }
        return mode;
    }

    Uint32 flags() const { return SDL_GetWindowFlags(window_); }

    Window& grab(bool g = true)
    {
        SDL_SetWindowGrab(window_, static_cast<SDL_bool>(g));
        return *this;
    }

    Window& release(bool r = true) { return grab(!r); }

    bool grabbed() const { return SDL_GetWindowGrab(window_); }

    Window& move_to(Vec2i const& v)
    {
        SDL_SetWindowPosition(window_, v.x, v.y);
        return *this;
    }
    Window& move_by(Vec2i const& v) { return move_to(position() + v); }
    Vec2i position() const
    {
        Vec2i pos;
        SDL_GetWindowPosition(window_, &pos.x, &pos.y);
        return pos;
    }

    void resize(Vec2i const& newsize) const { SDL_SetWindowSize(window_, newsize.x, newsize.y); }
    Vec2i size() const
    {
        Vec2i s;
        SDL_GetWindowSize(window_, &s.x, &s.y);
        return s;
    }

    Window& rename(std::string const& t)
    {
        SDL_SetWindowTitle(window_, t.c_str());
        return *this;
    }
    std::string title() const { return std::string{SDL_GetWindowTitle(window_)}; }

    void set_icon(Surface const& icon) const { SDL_SetWindowIcon(window_, icon.ptr()); }

    void set_icon(std::string const& filename) const
    {
        auto icon = Surface{filename};
        SDL_SetWindowIcon(window_, icon.ptr());
    }

    Window& hide()
    {
        SDL_HideWindow(window_);
        return *this;
    }
    Window& maximize()
    {
        SDL_MaximizeWindow(window_);
        return *this;
    }
    Window& minimize()
    {
        SDL_MinimizeWindow(window_);
        return *this;
    }
    Window& raise()
    {
        SDL_RaiseWindow(window_);
        return *this;
    }
    Window& restore()
    {
        SDL_RestoreWindow(window_);
        return *this;
    }

    bool fullscreen() const
    {
        return flags() & (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP);
    }
    Window& set_fullscreen(bool fs)
    {
        if (SDL_SetWindowFullscreen(window_, fs ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0) != 0)
        {
            throw Exception{"SDL_SetWindowFullscreen"};
        }
        return *this;
    }

    Window& toggle_fullscreen() { return set_fullscreen(!fullscreen()); }

    SDL_SysWMinfo wm_info() const
    {
        SDL_SysWMinfo info;
        SDL_VERSION(&info.version);
        if (SDL_GetWindowWMInfo(window_, &info) == SDL_FALSE)
        {
            throw Exception("SDL_GetWindowWMInfo");
        }
        return info;
    }

#ifdef CPP_SDL2_ENABLE_VULKAN
    std::vector<const char*> vk_get_instance_extensions()
    {
        std::vector<const char*> extensions;
        Uint32                   count;

        if (!SDL_Vulkan_GetInstanceExtensions(window_, &count, nullptr))
            throw Exception("SDL_Vulkan_GetInstanceExtensions");

        extensions.resize(count);

        if (!SDL_Vulkan_GetInstanceExtensions(window_, &count, extensions.data()))
            throw Exception("SDL_Vulkan_GetInstaceExtensions");

        return extensions; // Benefit from enforced RVO
    }

    VkSurfaceKHR vk_create_surface(VkInstance instance)
    {
        VkSurfaceKHR surface;
        if (!SDL_Vulkan_CreateSurface(window_, instance, &surface))
            throw Exception("SDL_Vulkan_CreateSurface");

        return surface;
    }

    vk::UniqueSurfaceKHR vk_create_unique_surface(vk::Instance instance)
    {
        auto nakedSurface = vk_create_surface(instance);
        return vk::UniqueSurfaceKHR(nakedSurface, instance);
    }

    Vec2i vk_get_drawable_size()
    {
        Vec2i size;
        SDL_Vulkan_GetDrawableSize(window_, &size.x, &size.y);
        return size;
    }
#endif // vulkan methods

#ifdef CPP_SDL2_ENABLE_OPENGL

    // This function is mostly used to set values regarding SDL GL context, and
    // is intertwined with window creation. However, this can be called before
    // creation the window. This wrapping is mostly for API consistency and for
    // automatic error checking.
    static void gl_set_attribute(SDL_GLattr attr, int val)
    {
        if (SDL_GL_SetAttribute(attr, val) < 0) throw Exception("SDL_GL_SetAttribute");
    }

    static void gl_set_attribute(SDL_GLattr attr, bool val) { gl_set_attribute(attr, val ? 1 : 0); }

    static int gl_get_attribute(SDL_GLattr attr)
    {
        int value;
        if (SDL_GL_GetAttribute(attr, &value) != 0) throw Exception("SDL_GL_GetAttribute");
        return value;
    }

    static void gl_reset_attribute() { SDL_GL_ResetAttributes(); }

    static bool gl_is_extension_supported(std::string const& ext_name)
    {
        return SDL_GL_ExtensionSupported(ext_name.c_str()) == SDL_TRUE;
    }

    enum class gl_swap_interval
    {
        immediate,
        vsync,
        adaptive_vsync
    };

    static void gl_set_swap_interval(gl_swap_interval swap_mode)
    {
        auto result = 0;
        switch (swap_mode)
        {
        case gl_swap_interval::immediate: result = SDL_GL_SetSwapInterval(0); break;
        case gl_swap_interval::vsync: result = SDL_GL_SetSwapInterval(1); break;
        case gl_swap_interval::adaptive_vsync: result = SDL_GL_SetSwapInterval(-1); break;
        }

        if (result != 0) throw Exception("SDL_GL_SetSwapInterval");
    }

    static gl_swap_interval gl_get_swap_interval()
    {
        const auto value = SDL_GL_GetSwapInterval();
        if (value == 1) return gl_swap_interval::vsync;
        if (value == -1) return gl_swap_interval::adaptive_vsync;
        return gl_swap_interval::immediate;
    }

    class GlContext
    {
    public:
        GlContext(SDL_Window* w) : context_{SDL_GL_CreateContext(w)}, owner_{w}
        {
            if (!context_) throw Exception("SDL_GL_CreateContext");
        }

        GlContext() = default;

        ~GlContext() { SDL_GL_DeleteContext(context_); }

        // Only movable, not copyable
        GlContext(GlContext const&) = delete;
        GlContext& operator=(GlContext const&) = delete;

        GlContext(GlContext&& other) noexcept { *this = std::move(other); }

        GlContext& operator=(GlContext&& other) noexcept
        {
            if (context_ != other.context_)
            {
                context_       = other.context_;
                owner_         = other.owner_;
                other.context_ = nullptr;
            }
            return *this;
        }

        void make_current() const
        {
            if (SDL_GL_MakeCurrent(owner_, context_) < 0) throw Exception("SDL_GL_MakeCurrent");
        }

        SDL_GLContext ptr() const { return context_; }

    private:
        SDL_GLContext context_ = nullptr;
        SDL_Window*   owner_   = nullptr;
    };

    GlContext create_context() const { return GlContext{window_}; }

    void gl_swap() const { SDL_GL_SwapWindow(window_); }

    Vec2i gl_get_drawable_size() const
    {
        Vec2i size{};
        SDL_GL_GetDrawableSize(window_, &size.x, &size.y);
        return size;
    }

#endif

private:
    SDL_Window* window_ = nullptr;
};

} // namespace sdl