gosu 1.4.6 → 2.0.0.pre6

data/src/Input.cpp

@@ -8,21 +8,20 @@
 #include <SDL.h>
 #include <utf8proc.h>
 
-#include <cwctype>
 #include <cstdlib>
 #include <algorithm>
 #include <array>
-#include <mutex>
 #include <stdexcept>
 using namespace std;
 
 static void require_sdl_video()
 {
-    static std::once_flag initialized;
-
-    std::call_once(initialized, [] {
-        SDL_InitSubSystem(SDL_INIT_VIDEO);
-    });
+    // Don't bother shutting down the SDL video subsystem because OpenGLContext.cpp keeps it alive
+    // forever as well, and it is hard to know when to free things in a Ruby C extension.
+    static const int initialized = SDL_Init(SDL_INIT_VIDEO);
+    if (initialized < 0) {
+        throw std::runtime_error(SDL_GetError());
+    }
 }
 
 static const unsigned NUM_BUTTONS_PER_GAMEPAD =
@@ -602,7 +601,7 @@ bool Gosu::Input::down(Gosu::Button btn)
 
 double Gosu::Input::axis(Gosu::Button btn)
 {
-    unsigned axis_id = btn - GP_LEFT_STICK_X_AXIS;
+    unsigned axis_id = btn - static_cast<unsigned>(GP_LEFT_STICK_X_AXIS);
 
     if (axis_id >= axis_states.size()) {
         throw std::out_of_range("Invalid axis ID: " + std::to_string(btn));

data/src/Macro.cpp

@@ -132,7 +132,7 @@ struct Gosu::Macro::Impl : private Gosu::Noncopyable
         for (const auto& vertex_array : vertex_arrays) {
             glPushMatrix();
             vertex_array.render_state.apply();
-            glMultMatrixd(&transform[0]);
+            glMultMatrixd(transform.matrix.data());
             glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &vertex_array.vertices[0]);
             glDrawArrays(GL_QUADS, 0, (GLsizei) vertex_array.vertices.size());
             glPopMatrix();
@@ -169,7 +169,7 @@ void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Col
 
     normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
 
-    Gosu::Graphics::gl(z, [=] { pimpl->draw_vertex_arrays(x1, y1, x2, y2, x3, y3, x4, y4); });
+    Gosu::gl(z, [=, this] { pimpl->draw_vertex_arrays(x1, y1, x2, y2, x3, y3, x4, y4); });
 }
 
 const Gosu::GLTexInfo* Gosu::Macro::gl_tex_info() const
@@ -184,15 +184,15 @@ Gosu::Bitmap Gosu::Macro::to_bitmap() const
              pimpl->width, pimpl->height, Color::WHITE, 0, BM_DEFAULT);
     };
 
-    return Gosu::Graphics::render(pimpl->width, pimpl->height, render_this).data().to_bitmap();
+    return Gosu::render(pimpl->width, pimpl->height, render_this).drawable().to_bitmap();
 }
 
-std::unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::Drawable> Gosu::Macro::subimage(const Rect&) const
 {
-    return std::unique_ptr<ImageData>{};
+    return nullptr;
 }
 
-void Gosu::Macro::insert(const Bitmap& bitmap, int x, int y)
+void Gosu::Macro::insert(const Bitmap&, int, int)
 {
     throw std::logic_error{"Gosu::Macro cannot be updated with a Gosu::Bitmap yet"};
 }

data/src/Macro.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
 #include <Gosu/Fwd.hpp>
-#include <Gosu/ImageData.hpp>
+#include <Gosu/Drawable.hpp>
 #include "GraphicsImpl.hpp"
 #include <memory>
 
-class Gosu::Macro : public Gosu::ImageData
+class Gosu::Macro : public Gosu::Drawable
 {
     struct Impl;
     std::shared_ptr<Impl> pimpl;
@@ -24,7 +24,7 @@ public:
 
     Gosu::Bitmap to_bitmap() const override;
 
-    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
+    std::unique_ptr<Drawable> subimage(const Rect&) const override;
 
-    void insert(const Bitmap& bitmap, int x, int y) override;
+    void insert(const Bitmap&, int x, int y) override;
 };

data/src/MarkupParser.cpp

@@ -157,29 +157,29 @@ void Gosu::MarkupParser::add_current_substring()
 void Gosu::MarkupParser::add_composed_substring(u32string&& substring)
 {
     FormattedString fstr;
-    fstr.text = substring;
+    fstr.text = std::move(substring);
     fstr.flags = flags();
     fstr.color = c.back();
 
     if (!substrings.empty() && substrings.back().can_be_merged_with(fstr)) {
-        substrings.back().text.append(move(fstr.text));
+        substrings.back().text.append(fstr.text);
     }
     else {
-        substrings.emplace_back(move(fstr));
+        substrings.emplace_back(std::move(fstr));
     }
 }
 
 void Gosu::MarkupParser::flush_to_consumer()
 {
     if (!substrings.empty()) {
-        consumer(move(substrings));
+        consumer(std::move(substrings));
         substrings.clear();
     }
 }
 
 Gosu::MarkupParser::MarkupParser(unsigned base_flags, bool split_words,
                                  function<void (vector<FormattedString>)> consumer)
-: consumer(move(consumer))
+: consumer(std::move(consumer))
 {
     word_state = (split_words ? ADDING_WORD : IGNORE_WORDS);
 

data/src/Math.cpp

@@ -1,38 +1,55 @@
 #include <Gosu/Math.hpp>
-#include <cstdlib>
-using namespace std;
+#include <cmath>
+#include <limits> // for std::numeric_limits::quiet_NaN
+#include <random>
 
 double Gosu::random(double min, double max)
 {
-    double rnd = rand();
-    return rnd / (static_cast<double>(RAND_MAX) + 1) * (max - min) + min;
+    if (std::isnan(min) || std::isnan(max)) {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+
+    if (min == max) {
+        return min;
+    }
+
+    thread_local std::mt19937_64 generator(std::random_device {}());
+    std::uniform_real_distribution<double> distribution(min, max);
+    const double result = distribution(generator);
+    // Make sure that we do not return "max" even when uniform_real_distribution is buggy.
+    // See "Notes": https://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution
+    return result == max ? min : result;
 }
 
 double Gosu::offset_x(double angle, double radius)
 {
-    return +sin(angle / 180 * M_PI) * radius;
+    return +std::sin(angle / 180 * std::numbers::pi) * radius;
 }
 
 double Gosu::offset_y(double angle, double radius)
 {
-    return -cos(angle / 180 * M_PI) * radius;
+    return -std::cos(angle / 180 * std::numbers::pi) * radius;
 }
 
-double Gosu::angle(double from_x, double from_y, double to_x, double to_y, double def)
+double Gosu::angle(double from_x, double from_y, double to_x, double to_y, double fallback)
 {
     double dist_x = to_x - from_x;
     double dist_y = to_y - from_y;
 
+    // Special-case the four cardinal directions values so that we don't run into subtle rounding
+    // errors for these obvious values.
     if (dist_x == 0) {
-        // Special-case these values so that for a result of 0°/360° we  never 
-        // run into subtle precision errors by converting from radian to angles.
-        if (dist_y < 0) return 0;
-        if (dist_y > 0) return 180;
-        // dist_y == 0
-        return 0;
+        if (dist_y == 0) {
+            return fallback;
+        }
+
+        return dist_y < 0 ? 0 : 180;
+    }
+    else if (dist_y == 0) {
+        return dist_x < 0 ? 270 : 90;
     }
 
-    return normalize_angle(radians_to_gosu(atan2(dist_y, dist_x)));
+    return normalize_angle(radians_to_angle(std::atan2(dist_y, dist_x)));
 }
 
 double Gosu::angle_diff(double from, double to)
@@ -51,19 +68,15 @@ int Gosu::wrap(int value, int min, int max)
     return result < 0 ? result + max : result + min;
 }
 
-float Gosu::wrap(float value, float min, float max)
-{
-    float result = fmodf(value - min, max - min);
-    return result < 0 ? result + max : result + min;
-}
-
 double Gosu::wrap(double value, double min, double max)
 {
-    double result = fmod(value - min, max - min);
+    double result = std::fmod(value - min, max - min);
     return result < 0 ? result + max : result + min;
 }
 
 double Gosu::distance(double x1, double y1, double x2, double y2)
 {
-    return sqrt(distance_sqr(x1, y1, x2, y2));
+    double dist_x = (x2 - x1);
+    double dist_y = (y2 - y1);
+    return std::sqrt(dist_x * dist_x + dist_y * dist_y);
 }

data/src/OffScreenTarget.cpp

@@ -1,99 +1,103 @@
 #include "OffScreenTarget.hpp"
-#include "Texture.hpp"
 #include <Gosu/Image.hpp>
 #include <Gosu/Platform.hpp>
+#include "OpenGLContext.hpp"
+#include "Texture.hpp"
 #ifndef GOSU_IS_IPHONE
-#include <SDL.h>
+#include <SDL.h> // for SDL_GL_GetProcAddress
 #endif
-using namespace std;
 
 #ifdef GOSU_IS_OPENGLES
-    #define GOSU_LOAD_GL_EXT(fn, type) \
-        static auto fn = fn ## OES;
-
-    #define GOSU_GL_CONST(name) \
-        name ## _OES
-
-    #define GOSU_GL_DEPTH_COMPONENT \
-        GL_DEPTH_COMPONENT16_OES
+#define GOSU_LOAD_GL_EXT(fn, type) static auto fn = fn##OES
+#define GOSU_GL_CONST(name) name##_OES
+#define GOSU_GL_DEPTH_COMPONENT GL_DEPTH_COMPONENT16_OES
 #else
-    #define GOSU_LOAD_GL_EXT(fn, type) \
-        static auto fn = (type) SDL_GL_GetProcAddress(#fn); \
-        if (!fn) throw runtime_error("Unable to load " #fn);
-
-    #define GOSU_GL_CONST(name) \
-        name
-
-    #define GOSU_GL_DEPTH_COMPONENT \
-        GL_DEPTH_COMPONENT
+#define GOSU_LOAD_GL_EXT(fn, type)                                                                 \
+    static auto fn = reinterpret_cast<type>(SDL_GL_GetProcAddress(#fn));                           \
+    if ((fn) == nullptr) {                                                                         \
+        throw std::runtime_error("Unable to load " #fn);                                           \
+    }
+#define GOSU_GL_CONST(name) name
+#define GOSU_GL_DEPTH_COMPONENT GL_DEPTH_COMPONENT
 #endif
 
 Gosu::OffScreenTarget::OffScreenTarget(int width, int height, unsigned image_flags)
+    : r_renderbuffer(static_cast<GLuint>(-1)),
+      m_framebuffer(static_cast<GLuint>(-1))
 {
 #ifndef GOSU_IS_IPHONE
+    // GCOV_EXCL_START
     if (!SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
-        throw runtime_error("Missing GL_EXT_framebuffer_object extension");
+        throw std::runtime_error("Missing GL_EXT_framebuffer_object extension");
     }
+    // GCOV_EXCL_end
 #endif
-    
+
     // Create a new texture that will be our rendering target.
-    texture = make_shared<Texture>(width, height, image_flags & IF_RETRO);
-    // Mark the full texture as blocked for our TexChunk.
-    texture->block(0, 0, width, height);
-    
+    m_texture = std::make_shared<Texture>(width, height, image_flags & IF_RETRO);
+
     // Besides the texture, also create a renderbuffer for depth information.
-    // Gosu doesn't use this, but custom OpenGL code could might.
+    // Gosu doesn't use this, but custom OpenGL code might.
     GOSU_LOAD_GL_EXT(glGenRenderbuffers, PFNGLGENRENDERBUFFERSPROC);
-    glGenRenderbuffers(1, &renderbuffer);
-    
+    glGenRenderbuffers(1, &r_renderbuffer);
+
     GOSU_LOAD_GL_EXT(glBindRenderbuffer, PFNGLBINDRENDERBUFFERPROC);
-    glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), renderbuffer);
-    
+    glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), r_renderbuffer);
+
     GOSU_LOAD_GL_EXT(glRenderbufferStorage, PFNGLRENDERBUFFERSTORAGEPROC);
     glRenderbufferStorage(GOSU_GL_CONST(GL_RENDERBUFFER), GOSU_GL_DEPTH_COMPONENT, width, height);
     glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), 0);
-    
+
     // Now tie everything together.
     GOSU_LOAD_GL_EXT(glGenFramebuffers, PFNGLGENFRAMEBUFFERSPROC);
-    glGenFramebuffers(1, &framebuffer);
-    
+    glGenFramebuffers(1, &m_framebuffer);
+
     GOSU_LOAD_GL_EXT(glBindFramebuffer, PFNGLBINDFRAMEBUFFERPROC);
-    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), framebuffer);
-    
+    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), m_framebuffer);
+
     GOSU_LOAD_GL_EXT(glFramebufferTexture2D, PFNGLFRAMEBUFFERTEXTURE2DPROC);
     glFramebufferTexture2D(GOSU_GL_CONST(GL_FRAMEBUFFER), GOSU_GL_CONST(GL_COLOR_ATTACHMENT0),
-                           GL_TEXTURE_2D, texture->tex_name(), 0);
-    
+                           GL_TEXTURE_2D, m_texture->tex_name(), 0);
+
     GOSU_LOAD_GL_EXT(glFramebufferRenderbuffer, PFNGLFRAMEBUFFERRENDERBUFFERPROC);
     glFramebufferRenderbuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), GOSU_GL_CONST(GL_DEPTH_ATTACHMENT),
-                              GOSU_GL_CONST(GL_RENDERBUFFER), renderbuffer);
+                              GOSU_GL_CONST(GL_RENDERBUFFER), r_renderbuffer);
 }
 
 Gosu::OffScreenTarget::~OffScreenTarget()
 {
     try {
         GOSU_LOAD_GL_EXT(glDeleteRenderbuffers, PFNGLDELETERENDERBUFFERSPROC);
-        glDeleteRenderbuffers(1, &renderbuffer);
-        
+        glDeleteRenderbuffers(1, &r_renderbuffer);
+
         GOSU_LOAD_GL_EXT(glDeleteFramebuffers, PFNGLDELETEFRAMEBUFFERSPROC);
-        glDeleteFramebuffers(1, &framebuffer);
+        glDeleteFramebuffers(1, &m_framebuffer);
+        // GCOV_EXCL_START
     } catch (...) {
         // If we can't load these functions, just accept the resource leak.
     }
+    // GCOV_EXCL_END
 }
 
 Gosu::Image Gosu::OffScreenTarget::render(const std::function<void ()>& f)
 {
     GOSU_LOAD_GL_EXT(glBindFramebuffer, PFNGLBINDFRAMEBUFFERPROC);
-    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), framebuffer);
-    
+    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), m_framebuffer);
+
     GOSU_LOAD_GL_EXT(glCheckFramebufferStatus, PFNGLCHECKFRAMEBUFFERSTATUSPROC);
     GLenum status = glCheckFramebufferStatus(GOSU_GL_CONST(GL_FRAMEBUFFER));
-    if (status != GOSU_GL_CONST(GL_FRAMEBUFFER_COMPLETE)) throw runtime_error("Incomplete framebuffer");
-    
-    f();
+    if (status != GOSU_GL_CONST(GL_FRAMEBUFFER_COMPLETE)) {
+        throw std::runtime_error("Incomplete framebuffer");
+    }
+
+    try {
+        f();
+
+    } catch (...) {
+        glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), 0);
+        throw;
+    }
     glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), 0);
 
-    unique_ptr<ImageData> tex_chunk(new TexChunk(texture, 0, 0, texture->width(), texture->height(), 0));
-    return Image(move(tex_chunk));
+    return Image(std::make_unique<TexChunk>(m_texture, Rect::covering(*m_texture), nullptr));
 }

data/src/OffScreenTarget.hpp

@@ -1,23 +1,25 @@
 #pragma once
 
-#include "GraphicsImpl.hpp"
+#include <Gosu/Utility.hpp>
+#include <cstdint>
+#include <functional>
+#include <memory>
 
 namespace Gosu
 {
-    class OffScreenTarget
+    class Image;
+    class Texture;
+
+    class OffScreenTarget : private Noncopyable
     {
-        std::shared_ptr<Texture> texture;
-        GLuint renderbuffer;
-        GLuint framebuffer;
-        
-        OffScreenTarget(const OffScreenTarget& other) = delete;
-        OffScreenTarget& operator=(const OffScreenTarget& other) = delete;
-        OffScreenTarget(OffScreenTarget&& other) = delete;
-        OffScreenTarget& operator=(OffScreenTarget&& other) = delete;
-        
+        std::shared_ptr<Texture> m_texture;
+        std::uint32_t r_renderbuffer;
+        std::uint32_t m_framebuffer;
+
     public:
         OffScreenTarget(int width, int height, unsigned image_flags);
         ~OffScreenTarget();
+
         Gosu::Image render(const std::function<void ()>& f);
     };
 }

data/src/OpenGLContext.cpp

@@ -0,0 +1,117 @@
+#include "OpenGLContext.hpp"
+#if !defined(GOSU_IS_IPHONE) // on iPhone, GosuGLView.cpp implements OpenGLContext.
+
+#if defined(GOSU_IS_MAC)
+#include <Foundation/Foundation.h> // for -[NSThread isMainThread]
+#endif
+
+#include <stdexcept>
+#include <thread>
+
+namespace
+{
+    [[noreturn]] void throw_sdl_error(const std::string& operation)
+    {
+        throw std::runtime_error(operation + ": " + SDL_GetError());
+    }
+
+    /// Groups the global SDL variables into a single struct so that they all either exist, or not.
+    struct SDLWindowAndGLContext : Gosu::Noncopyable
+    {
+        SDL_Window* window;
+        /// We only use one OpenGL context, even from background threads. It would be possible to
+        /// set up shared OpenGL contexts here (c.f. git history of this file), but according to
+        /// various sources on the internet, sharing OpenGL contexts does not help performance.
+        /// https://discourse.libsdl.org/t/feasibility-correctness-of-calling-gl-in-another-thread/20292/6
+        SDL_GLContext gl_context;
+
+        SDLWindowAndGLContext()
+        {
+            static const int initialized = SDL_Init(SDL_INIT_VIDEO);
+            if (initialized < 0) {
+                throw_sdl_error("Could not initialize SDL");
+            }
+
+#ifdef GOSU_IS_MAC
+            if (![NSThread isMainThread]) {
+                throw std::logic_error("Gosu::Window/OpenGL must be initialized on main thread");
+            }
+#endif
+#ifdef GOSU_IS_OPENGLES
+            // We want to use OpenGL ES 1.1, which does not yet require us to use shaders.
+            SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
+            SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+#endif
+
+            window = //
+                SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64,
+                                 SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN | SDL_WINDOW_ALLOW_HIGHDPI);
+            if (!window) {
+                throw_sdl_error("Could not create SDL window");
+            }
+
+            gl_context = SDL_GL_CreateContext(window);
+            if (!gl_context) {
+                SDL_DestroyWindow(window);
+                throw_sdl_error("Could not create main OpenGL context");
+            }
+        }
+
+        static SDLWindowAndGLContext& instance()
+        {
+            static SDLWindowAndGLContext instance;
+            return instance;
+        }
+    };
+
+    /// The current nesting level of OpenGLContext objects.
+    thread_local int current_nesting_depth = 0; // NOLINT(*-avoid-non-const-global-variables)
+}
+
+Gosu::OpenGLContext::OpenGLContext(bool for_rendering_to_window)
+{
+    static const auto& window = SDLWindowAndGLContext::instance();
+
+    // All threads use a single mutex to coordinate access to their OpenGL context.
+    static std::mutex mutex;
+    if (current_nesting_depth == 0) {
+        // ...but only the innermost OpenGLContext in a thread owns the lock.
+        m_lock = std::unique_lock(mutex);
+    }
+
+    // Explicitly make the context current every time for_rendering_to_window is set, so that we set
+    // the current SDL_Window even if we are somehow nested into something else.
+    if (for_rendering_to_window) {
+        if (SDL_GL_MakeCurrent(window.window, window.gl_context) != 0) {
+            throw_sdl_error("Could not set current GL context for rendering to the window");
+        }
+    }
+    else if (current_nesting_depth == 0) {
+        // Making a GL context current on a background thread, but with a window, causes a deadlock
+        // on macOS because SDL tries to use dispatch_sync onto the main thread.
+        // -> Try without a window first (for macOS), then with a window (for other platforms).
+        if (SDL_GL_MakeCurrent(nullptr, window.gl_context) != 0
+            && SDL_GL_MakeCurrent(window.window, window.gl_context) != 0) {
+            throw_sdl_error("Could not set current GL context");
+        }
+    }
+
+    ++current_nesting_depth;
+}
+
+Gosu::OpenGLContext::~OpenGLContext()
+{
+    --current_nesting_depth;
+
+    if (m_lock) {
+        SDL_GL_MakeCurrent(nullptr, nullptr);
+    }
+}
+
+SDL_Window* Gosu::OpenGLContext::shared_sdl_window()
+{
+    static const auto& window = SDLWindowAndGLContext::instance();
+    return window.window;
+}
+
+#endif

data/src/OpenGLContext.hpp

@@ -0,0 +1,41 @@
+#ifndef GOSU_OPENGLCONTEXT_HPP
+#define GOSU_OPENGLCONTEXT_HPP
+
+#include <Gosu/Platform.hpp>
+#include <Gosu/Utility.hpp>
+
+#if defined(GOSU_IS_IPHONE) || defined(GOSU_IS_OPENGLES)
+#include <OpenGLES/ES1/gl.h>
+#include <OpenGLES/ES1/glext.h>
+#else
+#include <SDL.h>
+#include <SDL_opengl.h>
+#endif
+
+#include <mutex>
+
+namespace Gosu
+{
+    /// Recursive lock/RAII class that makes an OpenGL context the current context, and prevents
+    /// other threads from taking over the context until this instance is destroyed.
+    class OpenGLContext : Noncopyable
+    {
+        std::unique_lock<std::mutex> m_lock;
+
+    public:
+        /// Makes an OpenGL context current. The very first call of this constructor may throw, all
+        /// other calls can only block.
+        explicit OpenGLContext(bool for_rendering_to_window = false);
+        ~OpenGLContext();
+
+#ifndef GOSU_IS_IPHONE
+        // SDL does not allow creation of OpenGL contexts without creating an SDL_Window first.
+        // Therefore, this class internally creates a global SDL_Window, and derives OpenGL contexts
+        // from it. The Gosu::Window implementation can then show and hide this single SDL_Window
+        // to simulate the window lifecycle.
+        static SDL_Window* shared_sdl_window();
+#endif
+    };
+}
+
+#endif