@@ -17,6 +17,16 @@ add_library(${PROJECT_NAME})

 set(GLBACKEND_DEPENDENCIES)

 set(GLBACKEND_DEFINITIONS)

+## glfw

+find_package(glfw3)

+if(glfw3_FOUND)

+    list(APPEND GLBACKEND_DEPENDENCIES glfw)

+    list(APPEND GLBACKEND_DEFINITIONS  GLBACKEND_GLFW)

+endif()

+

+## Cache

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

+

 ## Common

 include(common.cmake)

 common(

@@ -4,14 +4,16 @@ A [C++11][]/[OpenGL][] \>=[1.0][] [backend][] library.

 Currently supported backends:

-| Name | Category | Define | Include | Class |

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

+| Name     | Category        | Define           | Include              | Class         |

+| --       | --              | --               | --                   | --            |

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

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

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

 [OpenGL]: https://en.wikipedia.org/wiki/OpenGL

 [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

 ## Usage

@@ -330,10 +332,13 @@ System dependencies that need to be installed:

 -   Public (interface):

     -   [OpenGL][] (e.g. [`libgl1-mesa-dev`][]).

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

+-   Private (tests):

+    -   [GLFW][] (e.g. [`libglfw3-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

 ## Build system

new file mode 100644

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

@@ -2,7 +2,10 @@

 #define GLBACKEND_DEFAULT_HPP_

-#if 1

+#if defined(GLBACKEND_GLFW)

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

+    using GLBackendDefault = GLBackendGLFW;

+#else

     #error "No GLBackendDefault configured"

 #endif

new file mode 100644

@@ -0,0 +1,182 @@

+/// Guards

+

+#ifdef  GLBACKEND_GLFW

+#ifndef GLBACKEND_GLFW_HPP_

+#define GLBACKEND_GLFW_HPP_

+

+

+/// Includes

+

+#include <array>

+#include <string>

+

+#include <glbackend.hpp>

+

+#include <GLFW/glfw3.h>

+

+

+/// Class definition

+

+class GLBackendGLFW final : public GLBackend

+{

+

+public:

+

+    //// Special member functions

+

+    explicit GLBackendGLFW(

+        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

+    );

+    ~GLBackendGLFW();

+    GLBackendGLFW(GLBackendGLFW &&) noexcept;

+    GLBackendGLFW(GLBackendGLFW const &) = delete;

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

+    GLBackendGLFW & operator=(GLBackendGLFW 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_();

+

+    //// Debug

+

+    void static debug_glfw_error_callback_(

+        int          error,

+        char const * message

+    );

+

+protected:

+

+    //// Context

+

+    int static thread_local init_count_;

+

+    GLFWwindow * window_;

+

+};

+

+

+/// Inline definitions

+

+inline void GLBackendGLFW::current()

+{

+    glfwMakeContextCurrent(window_);

+}

+

+inline void GLBackendGLFW::events()

+{

+    glfwPollEvents();

+}

+

+inline void GLBackendGLFW::swap()

+{

+    glfwSwapBuffers(window_);

+}

+

+inline bool GLBackendGLFW::running(bool running)

+{

+    glfwSetWindowShouldClose(window_, !running);

+    return running;

+}

+

+inline bool GLBackendGLFW::running() const

+{

+    return !glfwWindowShouldClose(window_);

+}

+

+inline float GLBackendGLFW::time() const

+{

+    return (float)glfwGetTime();

+}

+

+inline float GLBackendGLFW::time(float time)

+{

+    glfwSetTime((double)time);

+    return time;

+}

+

+inline void GLBackendGLFW::lock(bool lock)

+{

+    glfwSetInputMode(

+        window_, GLFW_CURSOR, lock ? GLFW_CURSOR_DISABLED : GLFW_CURSOR_NORMAL

+    );

+}

+

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

+{

+    if (key == "Left")

+        return glfwGetKey(window_, GLFW_KEY_LEFT) == GLFW_PRESS;

+    else if (key == "Right")

+        return glfwGetKey(window_, GLFW_KEY_RIGHT) == GLFW_PRESS;

+    else if (key == "Up")

+        return glfwGetKey(window_, GLFW_KEY_UP) == GLFW_PRESS;

+    else if (key == "Down")

+        return glfwGetKey(window_, GLFW_KEY_DOWN) == GLFW_PRESS;

+    else if (key == "Enter")

+        return glfwGetKey(window_, GLFW_KEY_ENTER) == GLFW_PRESS;

+    else if (key == "Escape")

+        return glfwGetKey(window_, GLFW_KEY_ESCAPE) == GLFW_PRESS;

+    else if (key == "Tab")

+        return glfwGetKey(window_, GLFW_KEY_TAB) == GLFW_PRESS;

+    else if (key == "Backspace")

+        return glfwGetKey(window_, GLFW_KEY_BACKSPACE) == GLFW_PRESS;

+    else if (key == "Control")

+        return

+            glfwGetKey(window_, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS ||

+            glfwGetKey(window_, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS;

+    else if (key == "Shift")

+        return

+            glfwGetKey(window_, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS ||

+            glfwGetKey(window_, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS;

+    else if (key == "Alt")

+        return

+            glfwGetKey(window_, GLFW_KEY_LEFT_ALT) == GLFW_PRESS ||

+            glfwGetKey(window_, GLFW_KEY_RIGHT_ALT) == GLFW_PRESS;

+    else if (key.length() == 1)

+        return glfwGetKey(window_, key[0]) == GLFW_PRESS;

+    return false;

+}

+

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

+{

+    return glfwGetMouseButton(window_, button - 1) == GLFW_PRESS;

+}

+

+

+/// Guards

+

+#endif

+#endif

new file mode 100644

@@ -0,0 +1,380 @@

+/// Guards

+

+

+#ifdef GLBACKEND_GLFW

+

+

+/// Includes

+

+

+#include <glbackend_glfw.hpp>

+

+#include <array>

+#include <functional>

+#include <limits>

+#include <sstream>

+#include <string>

+#include <type_traits>

+#include <utility>

+

+#include <glbase.hpp>

+#include <glbackend.hpp>

+

+#include <GLFW/glfw3.h>

+

+// NOLINTNEXTLINE

+#define STR_EXCEPTION GLBase::Exception

+#include <str.hpp>

+

+

+/// Special member functions

+

+

+GLBackendGLFW::GLBackendGLFW(

+    std::string const & title,

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

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

+    int                 samples,

+    bool                fullscreen,

+    bool                transparent

+)

+:

+    GLBackend(),

+    window_{nullptr}

+{

+    //// Backend errors

+    glfwSetErrorCallback(debug_glfw_error_callback_);

+    auto const glfw_get_error_description = []()

+    {

+        char const * description{};

+        glfwGetError(&description);

+        return description;

+    };

+

+    //// Backend init

+    if (!glfwInit())

+        STR_THROW(

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

+            glfw_get_error_description()

+        );

+    ++init_count_;

+

+    //// Window options

+    glfwDefaultWindowHints();

+    glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);

+    GLFWmonitor * monitor = nullptr;

+    if (fullscreen)

+        monitor = glfwGetPrimaryMonitor();

+    if (transparent)

+    {

+        glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);

+        glfwWindowHint(GLFW_DECORATED, GLFW_FALSE);

+        glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);

+    }

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

+    {

+        auto const * mode = glfwGetVideoMode(glfwGetPrimaryMonitor());

+        size[0] = mode->width;

+        size[1] = mode->height;

+    }

+    size_ = size;

+

+    //// Context options

+    glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_TRUE);

+    glfwWindowHint(GLFW_RED_BITS,      8); // NOLINT

+    glfwWindowHint(GLFW_GREEN_BITS,    8); // NOLINT

+    glfwWindowHint(GLFW_BLUE_BITS,     8); // NOLINT

+    glfwWindowHint(GLFW_ALPHA_BITS,    8); // NOLINT

+    glfwWindowHint(GLFW_DEPTH_BITS,   24); // NOLINT

+    glfwWindowHint(GLFW_STENCIL_BITS,  8); // NOLINT

+    if (samples)

+        glfwWindowHint(GLFW_SAMPLES, samples);

+    if (version[0])

+        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, version[0]);

+    if (version[1])

+        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, version[1]);

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

+    {

+        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

+        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);

+    }

+    if (debug() >= 1)

+        glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE);

+    else if (version[0] >= 2) // NOLINT

+        glfwWindowHint(GLFW_CONTEXT_NO_ERROR, GLFW_TRUE);

+

+    try

+    {

+        //// Window

+        window_ = glfwCreateWindow(

+            size[0],

+            size[1],

+            title.c_str(),

+            monitor,

+            nullptr

+        );

+        if (!window_)

+            STR_THROW(

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

+                glfw_get_error_description()

+            );

+

+        //// Context

+        glfwMakeContextCurrent(window_);

+        if (debug() == 0)

+            glfwSwapInterval(1);

+        init_();

+

+        //// Lock

+        if (fullscreen)

+            lock(true);

+    }

+    catch (...)

+    {

+        destroy_();

+        throw;

+    }

+

+    //// Callbacks

+    // NOLINTNEXTLINE

+    #define GLBACKEND_GLFW_SELF_(WINDOW) \

+        (*static_cast<GLBackendGLFW *>(glfwGetWindowUserPointer(WINDOW)))

+    glfwSetWindowUserPointer(window_, this);

+    glfwSetKeyCallback(

+        window_,

+        [](

+            GLFWwindow * window,

+            int key,

+            int scancode,

+            int action,

+            int mods

+        )

+        {

+            (void)scancode;

+            (void)mods;

+            if (action != GLFW_PRESS)

+                return;

+            auto & self = GLBACKEND_GLFW_SELF_(window);

+            if (self.callback_key_)

+            {

+                if(key == GLFW_KEY_LEFT)

+                    self.callback_key_("Left");

+                else if (key == GLFW_KEY_RIGHT)

+                    self.callback_key_("Right");

+                else if (key == GLFW_KEY_UP)

+                    self.callback_key_("Up");

+                else if (key == GLFW_KEY_DOWN)

+                    self.callback_key_("Down");

+                else if (key == GLFW_KEY_ENTER)

+                    self.callback_key_("Enter");

+                else if (key == GLFW_KEY_ESCAPE)

+                    self.callback_key_("Escape");

+                else if (key == GLFW_KEY_TAB)

+                    self.callback_key_("Tab");

+                else if (key == GLFW_KEY_BACKSPACE)

+                    self.callback_key_("Backspace");

+                else if (

+                    key == GLFW_KEY_RIGHT_CONTROL ||

+                    key == GLFW_KEY_LEFT_CONTROL

+                )

+                    self.callback_key_("Control");

+                else if (

+                    key == GLFW_KEY_RIGHT_SHIFT ||

+                    key == GLFW_KEY_LEFT_SHIFT

+                )

+                    self.callback_key_("Shift");

+                else if (

+                    key == GLFW_KEY_RIGHT_ALT ||

+                    key == GLFW_KEY_LEFT_ALT

+                )

+                    self.callback_key_("Alt");

+                else if (

+                    0 <= key && key <= std::numeric_limits<char>::max()

+                )

+                    self.callback_key_(std::string(1, (char)key));

+            }

+        }

+    );

+    glfwSetMouseButtonCallback(

+        window_,

+        [](

+            GLFWwindow * window,

+            int button,

+            int action,

+            int mods

+        )

+        {

+            (void)mods;

+            if (action != GLFW_PRESS)

+                return;

+            auto & self = GLBACKEND_GLFW_SELF_(window);

+            if (self.callback_button_)

+                self.callback_button_(button);

+        }

+    );

+    glfwSetScrollCallback(

+        window_,

+        [](

+            GLFWwindow * window,

+            double scroll_x,

+            double scroll_y

+        )

+        {

+            auto & self = GLBACKEND_GLFW_SELF_(window);

+            self.scroll_ = {

+                (float)scroll_x,

+                (float)scroll_y,

+            };

+            if (self.callback_scroll_)

+                self.callback_scroll_(self.scroll_);

+        }

+    );

+    glfwSetCursorPosCallback(

+        window_,

+        [](

+            GLFWwindow * window,

+            double x,

+            double y

+        )

+        {

+            auto & self = GLBACKEND_GLFW_SELF_(window);

+            self.move_ = {

+                (float)x - self.position_[0],

+                (float)y - self.position_[1],

+            };

+            self.position_ = {

+                (float)x,

+                (float)y,

+            };

+            if (self.callback_position_)

+                self.callback_position_(self.position_);

+            if (self.callback_move_)

+                self.callback_move_(self.move_);

+        }

+    );

+    glfwSetFramebufferSizeCallback(

+        window_,

+        [](

+            GLFWwindow * window,

+            int width,

+            int height

+        )

+        {

+            auto & self = GLBACKEND_GLFW_SELF_(window);

+            self.size_ = {

+                width,

+                height,

+            };

+            if (self.callback_size_)

+                self.callback_size_(self.size_);

+        }

+    );

+}

+

+

+GLBackendGLFW::GLBackendGLFW(GLBackendGLFW && other) noexcept

+:

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

+    window_{other.window_}

+{

+    other.window_ = nullptr;

+}

+

+

+GLBackendGLFW::~GLBackendGLFW()

+{

+    destroy_();

+}

+

+

+void GLBackendGLFW::destroy_()

+{

+    if (window_)

+    {

+        lock(false);

+        glfwDestroyWindow(window_);

+    }

+    if (--init_count_ == 0)

+        glfwTerminate();

+}

+

+

+GLBASE_GLOBAL(GLBackendGLFW::init_count_, {0})

+

+

+/// Debug

+

+

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

+{

+    auto ostream = std::ostringstream{};

+

+    auto version_major = int{};

+    auto version_minor = int{};

+    auto version_rev   = int{};

+    glfwGetVersion(

+        &version_major,

+        &version_minor,

+        &version_rev

+    );

+    debug_info_(ostream, "GLFW", {

+        {

+            "VERSION_COMPILED",

+                glfwGetVersionString()

+        },

+        {

+            "VERSION_LINKED",

+                std::to_string(version_major) + "." +

+                std::to_string(version_minor) + "." +

+                std::to_string(version_rev),

+        },

+    });

+

+    ostream << GLBackend::debug_info();

+

+    return ostream.str();

+}

+

+

+void GLBackendGLFW::debug_glfw_error_callback_(

+    int          error,

+    char const * message

+)

+{

+    auto ostream = std::ostringstream{};

+    ostream << std::hex << std::showbase;

+

+    // https://www.glfw.org/docs/3.3/group__errors.html

+    ostream << "GLFW error ";

+    // NOLINTNEXTLINE

+    #define GLBACKEND_GLFW_CALLBACK_CASE_(VALUE) \

+        case GLFW_ ## VALUE: \

+            ostream << #VALUE; \

+            break;

+    switch(error)

+    {

+        GLBACKEND_GLFW_CALLBACK_CASE_(NOT_INITIALIZED)

+        GLBACKEND_GLFW_CALLBACK_CASE_(NO_CURRENT_CONTEXT)

+        GLBACKEND_GLFW_CALLBACK_CASE_(INVALID_ENUM)

+        GLBACKEND_GLFW_CALLBACK_CASE_(INVALID_VALUE)

+        GLBACKEND_GLFW_CALLBACK_CASE_(OUT_OF_MEMORY)

+        GLBACKEND_GLFW_CALLBACK_CASE_(API_UNAVAILABLE)

+        GLBACKEND_GLFW_CALLBACK_CASE_(VERSION_UNAVAILABLE)

+        GLBACKEND_GLFW_CALLBACK_CASE_(PLATFORM_ERROR)

+        GLBACKEND_GLFW_CALLBACK_CASE_(FORMAT_UNAVAILABLE)

+        GLBACKEND_GLFW_CALLBACK_CASE_(NO_WINDOW_CONTEXT)

+        default:

+            ostream << error;

+    }

+    ostream << ":\n";

+

+    ostream << message;

+

+    debug_callback()(ostream.str());

+}

+

+

+/// Guards

+

+

+#endif

new file mode 100644

@@ -0,0 +1,29 @@

+#ifdef GLBACKEND_GLFW

+

+

+#include <GLFW/glfw3.h>

+

+

+constexpr auto width = 640;

+constexpr auto height = 480;

+

+

+int main()

+{

+    if (!glfwInit())

+        return 1;

+    auto * window = glfwCreateWindow(

+        width, height,

+        "baseline_glfw",

+        nullptr, nullptr

+    );

+    if (!window)

+        return 1;

+    glfwDestroyWindow(window);

+    glfwTerminate();

+}

+

+

+#else

+int main() {}

+#endif

new file mode 100644

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

+#ifdef GLBACKEND_GLFW

+

+

+#include <glbackend_glfw.hpp>

+

+#include "common/run.hpp"

+

+

+int main()

+{

+    GLBACKEND_TESTS_COMMON_RUN(GLBackendGLFW)

+}

+

+

+#else

+int main() {}

+#endif