new file mode 100644

@@ -0,0 +1,2 @@

+# SDL

+# leak:libX11

@@ -24,8 +24,12 @@ if(glfw3_FOUND)

     list(APPEND GLBACKEND_DEFINITIONS  GLBACKEND_GLFW)

 endif()

-## Cache

-set(GLBACKEND_DEFINITIONS "${GLBACKEND_DEFINITIONS}" CACHE INTERNAL "")

+## sdl

+find_package(SDL2)

+if(SDL2_FOUND)

+    list(APPEND GLBACKEND_DEPENDENCIES SDL2)

+    list(APPEND GLBACKEND_DEFINITIONS  GLBACKEND_SDL)

+endif()

 ## Common

 include(common.cmake)

@@ -7,6 +7,7 @@ Currently supported backends:

 | Name     | Category        | Define           | Include              | Class         |

 | --       | --              | --               | --                   | --            |

 | [GLFW][] | Windowing/input | `GLBACKEND_GLFW` | `glbackend_glfw.hpp` | `BackendGLFW` |

+| [SDL2][] | Multimedia      | `GLBACKEND_SDL`  | `glbackend_sdl.hpp`  | `BackendSDL`  |

 [`glbackend`]: https://git.rcrnstn.net/rcrnstn/glbackend

 [C++11]: https://en.wikipedia.org/wiki/C++11

@@ -14,6 +15,7 @@ Currently supported backends:

 [1.0]: https://en.wikipedia.org/wiki/OpenGL#Version_history

 [backend]: https://www.khronos.org/opengl/wiki/Related_toolkits_and_APIs#OpenGL_initialization

 [GLFW]: https://www.glfw.org

+[SDL2]: https://www.libsdl.org

 ## Usage

@@ -334,11 +336,13 @@ System dependencies that need to be installed:

     -   [OpenGL Extension Wrangler (GLEW)][] (e.g. [`libglew-dev`][]).

 -   Private (tests):

     -   [GLFW][] (e.g. [`libglfw3-dev`][]).

+    -   [SDL2][] (e.g. [`libsdl2-dev`][]).

 [OpenGL Extension Wrangler (GLEW)]: http://glew.sourceforge.net

 [`libgl1-mesa-dev`]: https://packages.debian.org/search?keywords=libgl1-mesa-dev

 [`libglew-dev`]: https://packages.debian.org/search?keywords=libglew-dev

 [`libglfw3-dev`]: https://packages.debian.org/search?keywords=libglfw3-dev

+[`libsdl2-dev`]: https://packages.debian.org/search?keywords=libsdl2-dev

 ## Build system

new file mode 100644

Binary files /dev/null and b/assets/tests/GLBackendSDL.tga differ

@@ -5,6 +5,9 @@

 #if defined(GLBACKEND_GLFW)

     #include "glbackend_glfw.hpp" // IWYU pragma: export

     using GLBackendDefault = GLBackendGLFW;

+#elif defined(GLBACKEND_SDL)

+    #include "glbackend_sdl.hpp" // IWYU pragma: export

+    using GLBackendDefault = GLBackendSDL;

 #else

     #error "No GLBackendDefault configured"

 #endif

new file mode 100644

@@ -0,0 +1,166 @@

+/// Guards

+

+#ifdef  GLBACKEND_SDL

+#ifndef GLBACKEND_SDL_HPP_

+#define GLBACKEND_SDL_HPP_

+

+

+/// Includes

+

+#include <array>

+#include <string>

+

+#include <glbackend.hpp>

+

+// #include <SDL2/SDL.h>

+#include <SDL2/SDL_keyboard.h>

+#include <SDL2/SDL_mouse.h>

+#include <SDL2/SDL_scancode.h>

+#include <SDL2/SDL_stdinc.h>

+#include <SDL2/SDL_timer.h>

+#include <SDL2/SDL_video.h>

+

+

+/// Class definition

+

+class GLBackendSDL final : public GLBackend

+{

+

+public:

+

+    //// Special member functions

+

+    explicit GLBackendSDL(

+        std::string const & title,

+        std::array<int, 2>  size        = {0, 0},

+        std::array<int, 2>  version     = {0, 0},

+        int                 samples     = 0,

+        bool                fullscreen  = false,

+        bool                transparent = false

+    );

+    ~GLBackendSDL();

+    GLBackendSDL(GLBackendSDL &&) noexcept;

+    GLBackendSDL(GLBackendSDL const &) = delete;

+    GLBackendSDL & operator=(GLBackendSDL &&) = delete;

+    GLBackendSDL & operator=(GLBackendSDL const &) = delete;

+

+    //// Context

+

+    void current() override;

+

+    //// Render loop

+

+    void swap() override;

+

+    void events() override;

+

+    bool running() const override;

+    bool running(bool running) override;

+

+    float time() const override;

+    float time(float time) override;

+

+    //// Input and output

+

+    void lock(bool lock) override;

+

+    bool key   (std::string const & key)    const override;

+    bool button(int                 button) const override;

+

+    //// Debug

+

+    std::string debug_info() const override;

+

+protected:

+

+    //// Special member functions

+

+    void destroy_();

+

+protected:

+

+    //// Context

+

+    SDL_Window    * window_;

+    SDL_GLContext   context_;

+

+    //// Render loop

+

+    bool  running_;

+    float time_;

+

+};

+

+

+/// Inline definitions

+

+inline void GLBackendSDL::current()

+{

+    SDL_GL_MakeCurrent(window_, context_);

+}

+

+inline void GLBackendSDL::swap()

+{

+    SDL_GL_SwapWindow(window_);

+}

+

+inline bool GLBackendSDL::running(bool running)

+{

+    running_ = running;

+    return running;

+}

+

+inline bool GLBackendSDL::running() const

+{

+    return running_;

+}

+

+inline float GLBackendSDL::time() const

+{

+    // return (float)SDL_GetTicks() / 1000.0F - time_;

+    return

+        (float)SDL_GetPerformanceCounter() /

+        (float)SDL_GetPerformanceFrequency()

+        - time_;

+}

+

+inline float GLBackendSDL::time(float time)

+{

+    // time_ = (float)SDL_GetTicks() / 1000.0F - time;

+    time_ =

+        (float)SDL_GetPerformanceCounter() /

+        (float)SDL_GetPerformanceFrequency()

+        - time;

+    return time;

+}

+

+inline void GLBackendSDL::lock(bool lock)

+{

+    SDL_SetRelativeMouseMode(lock ? SDL_TRUE : SDL_FALSE);

+}

+

+inline bool GLBackendSDL::key(std::string const & key) const

+{

+    auto * keys = SDL_GetKeyboardState(nullptr);

+    if (key == "Enter")

+        return keys[SDL_SCANCODE_RETURN];

+    else if (key == "Control")

+        return keys[SDL_SCANCODE_RCTRL] || keys[SDL_SCANCODE_LCTRL];

+    else if (key == "Shift")

+        return keys[SDL_SCANCODE_RSHIFT] || keys[SDL_SCANCODE_LSHIFT];

+    else if (key == "Alt")

+        return keys[SDL_SCANCODE_RALT] || keys[SDL_SCANCODE_LALT];

+    else

+        return keys[SDL_GetScancodeFromName(key.c_str())];

+}

+

+inline bool GLBackendSDL::button(int button) const

+{

+    return SDL_GetMouseState(nullptr, nullptr) & (Uint32)SDL_BUTTON(button);

+}

+

+

+/// Guards

+

+#endif

+#endif

new file mode 100644

@@ -0,0 +1,304 @@

+/// Guards

+

+

+#ifdef GLBACKEND_SDL

+

+

+/// Includes

+

+

+#include <glbackend_sdl.hpp>

+

+#include <functional>

+#include <sstream>

+#include <string>

+#include <type_traits>

+#include <utility>

+

+#include <glbase.hpp>

+#include <glbackend.hpp>

+

+#include <SDL2/SDL.h>

+#include <SDL2/SDL_error.h>

+#include <SDL2/SDL_events.h>

+#include <SDL2/SDL_keycode.h>

+#include <SDL2/SDL_version.h>

+

+// NOLINTNEXTLINE

+#define STR_EXCEPTION GLBase::Exception

+#include <str.hpp>

+

+

+/// Constants

+

+

+auto static constexpr sdl_subsystems_ =

+    SDL_INIT_VIDEO  |

+    SDL_INIT_EVENTS |

+    SDL_INIT_TIMER;

+

+

+/// Special member functions

+

+

+GLBackendSDL::GLBackendSDL(

+    std::string const & title,

+    std::array<int, 2>  size,

+    std::array<int, 2>  version,

+    int                 samples,

+    bool                fullscreen,

+    bool                transparent

+)

+:

+    GLBackend(),

+    window_ {nullptr},

+    context_{nullptr},

+    running_{true},

+    time_   {0.0F}

+{

+    // Backend init

+    if (SDL_InitSubSystem(sdl_subsystems_) != 0)

+        STR_THROW(

+            "Failed to initialize SDL" << ":\n" <<

+            SDL_GetError()

+        );

+

+    // Window options

+    SDL_GL_ResetAttributes();

+    auto window_flags = Uint32{0};

+    window_flags |= SDL_WINDOW_OPENGL;

+    if (fullscreen)

+        window_flags |= SDL_WINDOW_FULLSCREEN;

+    if (transparent)

+    {

+        window_flags |= SDL_WINDOW_BORDERLESS;

+        window_flags |= SDL_WINDOW_ALWAYS_ON_TOP;

+    }

+    if (size[0] == 0 || size[1] == 0)

+    {

+        auto mode = SDL_DisplayMode{};

+        SDL_GetCurrentDisplayMode(0, &mode);

+        size[0] = mode.w;

+        size[1] = mode.h;

+    }

+    size_ = size;

+

+    // Context options

+    auto context_flags = int{0};

+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, SDL_TRUE);

+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,      8); // NOLINT

+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,    8); // NOLINT

+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,     8); // NOLINT

+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,    8); // NOLINT

+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,   24); // NOLINT

+    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE,  8); // NOLINT

+    if (samples)

+    {

+        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);

+        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, samples);

+    }

+    if (version[0])

+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, version[0]);

+    if (version[1])

+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, version[1]);

+    if ((version[0] == 3 && version[1] >= 2) || version[0] >= 4) // NOLINT

+    {

+        SDL_GL_SetAttribute(

+            SDL_GL_CONTEXT_PROFILE_MASK,

+            SDL_GL_CONTEXT_PROFILE_CORE

+        );

+        context_flags |= SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG; // NOLINT

+    }

+    if (debug() >= 1)

+        context_flags |= SDL_GL_CONTEXT_DEBUG_FLAG; // NOLINT

+    else if ((version[0] == 4 && version[1] >= 6) || version[0] >= 5) // NOLINT

+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_NO_ERROR, SDL_TRUE);

+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, context_flags);

+

+    try

+    {

+        // Window

+        window_ = SDL_CreateWindow(

+            title.c_str(),

+            SDL_WINDOWPOS_UNDEFINED, // NOLINT

+            SDL_WINDOWPOS_UNDEFINED, // NOLINT

+            size[0],

+            size[1],

+            window_flags

+        );

+        if (!window_)

+            STR_THROW(

+                "Failed to create SDL window" << ":\n" <<

+                SDL_GetError()

+            );

+

+        // Context

+        context_ = SDL_GL_CreateContext(window_);

+        if (!context_)

+            STR_THROW(

+                "Failed to create SDL context" << ":\n" <<

+                SDL_GetError()

+            );

+        SDL_GL_MakeCurrent(window_, context_);

+        if (debug() == 0)

+            SDL_GL_SetSwapInterval(1);

+        init_();

+

+        // Lock

+        if (fullscreen)

+            GLBackendSDL::lock(true);

+    }

+    catch (...)

+    {

+        destroy_();

+        throw;

+    }

+}

+

+

+GLBackendSDL::~GLBackendSDL()

+{

+    destroy_();

+}

+

+

+GLBackendSDL::GLBackendSDL(GLBackendSDL && other) noexcept

+:

+    GLBackend(std::move(other)),

+    window_ {other.window_},

+    context_{other.context_},

+    running_{other.running_},

+    time_   {other.time_}

+{

+    other.window_  = nullptr;

+    other.context_ = nullptr;

+}

+

+

+void GLBackendSDL::destroy_()

+{

+    GLBackendSDL::lock(false);

+    if (context_)

+        SDL_GL_DeleteContext(context_);

+    if (window_)

+        SDL_DestroyWindow(window_);

+    SDL_QuitSubSystem(sdl_subsystems_);

+}

+

+

+/// Render loop

+

+

+inline void GLBackendSDL::events()

+{

+    auto event = SDL_Event{};

+    while (SDL_PollEvent(&event))

+    {

+        switch (event.type)

+        {

+            case SDL_KEYDOWN:

+                if (event.key.repeat)

+                    break;

+                if (callback_key_)

+                {

+                    auto key = event.key.keysym.sym;

+                    if (key == SDLK_RETURN)

+                        callback_key_("Enter");

+                    else if (key == SDLK_LCTRL  || key == SDLK_RCTRL)

+                        callback_key_("Control");

+                    else if (key == SDLK_LSHIFT || key == SDLK_RSHIFT)

+                        callback_key_("Shift");

+                    else if (key == SDLK_LALT   || key == SDLK_RALT)

+                        callback_key_("Alt");

+                    else

+                        callback_key_(SDL_GetKeyName(key));

+                }

+                break;

+            case SDL_MOUSEBUTTONDOWN:

+                if (callback_button_)

+                    callback_button_(event.button.button);

+                break;

+            case SDL_MOUSEWHEEL:

+                scroll_ = {

+                    (float)event.wheel.x,

+                    (float)event.wheel.y,

+                };

+                if (callback_scroll_)

+                    callback_scroll_(scroll_);

+                break;

+            case SDL_MOUSEMOTION:

+                position_ = {

+                    (float)event.motion.x,

+                    (float)event.motion.y,

+                };

+                move_ = {

+                    (float)event.motion.xrel,

+                    (float)event.motion.yrel,

+                };

+                if (callback_position_)

+                    callback_position_(position_);

+                if (callback_move_)

+                    callback_move_(move_);

+                break;

+            case SDL_WINDOWEVENT:

+                switch (event.window.event)

+                {

+                    case SDL_WINDOWEVENT_SIZE_CHANGED:

+                        // size_ = {

+                        //     event.window.data1,

+                        //     event.window.data2,

+                        // };

+                        SDL_GL_GetDrawableSize(

+                            window_,

+                            &size_[0],

+                            &size_[1]

+                        );

+                        if (callback_size_)

+                            callback_size_(size_);

+                        break;

+                    case SDL_WINDOWEVENT_CLOSE:

+                            running_ = false;

+                        break;

+                }

+                break;

+        }

+    }

+}

+

+

+/// Debug

+

+

+std::string GLBackendSDL::debug_info() const

+{

+    auto ostream = std::ostringstream{};

+

+    auto version_compiled = SDL_version{};

+    auto version_linked   = SDL_version{};

+    SDL_VERSION(&version_compiled);

+    SDL_GetVersion(&version_linked);

+    debug_info_(ostream, "SDL", {

+        {

+            "VERSION_COMPILED",

+                std::to_string(version_compiled.major) + "." +

+                std::to_string(version_compiled.minor) + "." +

+                std::to_string(version_compiled.patch),

+        },

+        {

+            "VERSION_LINKED",

+                std::to_string(version_linked.major) + "." +

+                std::to_string(version_linked.minor) + "." +

+                std::to_string(version_linked.patch),

+        },

+    });

+

+    ostream << GLBackend::debug_info();

+

+    return ostream.str();

+}

+

+

+/// Guards

+

+

+#endif

new file mode 100644

@@ -0,0 +1,31 @@

+#ifdef GLBACKEND_SDL

+

+

+#include <SDL2/SDL.h>

+#include <SDL2/SDL_video.h>

+

+

+constexpr auto width = 640;

+constexpr auto height = 480;

+

+

+int main()

+{

+    if (SDL_Init(SDL_INIT_VIDEO) < 0)

+        return 1;

+    auto * window = SDL_CreateWindow(

+        "baseline_sdl",

+        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, // NOLINT

+        width, height,

+        SDL_WINDOW_OPENGL

+    );

+    if (!window)

+        return 1;

+    SDL_DestroyWindow(window);

+    SDL_Quit();

+}

+

+

+#else

+int main() {}

+#endif

new file mode 100644

@@ -0,0 +1,17 @@

+#ifdef GLBACKEND_SDL

+

+

+#include <glbackend_sdl.hpp>

+

+#include "common/run.hpp"

+

+

+int main()

+{

+    GLBACKEND_TESTS_COMMON_RUN(GLBackendSDL)

+}

+

+

+#else

+int main() {}

+#endif