gosu 1.3.0 → 1.4.0

data/src/Macro.cpp

@@ -1,10 +1,10 @@
 #include "Macro.hpp"
-#include "DrawOpQueue.hpp"
 #include <Gosu/Image.hpp>
+#include <Gosu/Utility.hpp>
+#include "DrawOpQueue.hpp"
 #include <stdexcept>
-using namespace std;
 
-struct Gosu::Macro::Impl
+struct Gosu::Macro::Impl : Gosu::Noncopyable
 {
     VertexArrays vertex_arrays;
     int width, height;
@@ -13,8 +13,8 @@ struct Gosu::Macro::Impl
     // (a11 a12) (x1) = (b1)
     // (a21 a22) (x2) = (b2)
     // x1, x2 are output parameters. Returns false if the matrix is singular.
-    static bool solve_2x2(double a11, double a12, double a21, double a22, double b1, double b2,
-                          double& x1, double& x2)
+    static bool solve_2x2(double a11, double a12, double a21, double a22, //
+                          double b1, double b2, double& x1, double& x2)
     {
         const double det = a11 * a22 - a21 * a12;
         if (det == 0) return false;
@@ -23,8 +23,8 @@ struct Gosu::Macro::Impl
         return true;
     }
 
-    Transform find_transform_for_target(double x1, double y1, double x2, double y2,
-        double x3, double y3, double x4, double y4) const
+    Transform find_transform_for_target(double x1, double y1, double x2, double y2, //
+                                        double x3, double y3, double x4, double y4) const
     {
         // Transformation logic follows a discussion on the ImageMagick mailing
         // list (on which ImageMagick's perspective_transform.pl is based).
@@ -100,37 +100,35 @@ struct Gosu::Macro::Impl
         // 0, 0, 0, 0, 0, 0, 0, 1 | qy
 
         double c[8];
-        c[0] = (x2 - x1) / width  + qx * x2;
+        c[0] = (x2 - x1) / width + qx * x2;
         c[1] = (x3 - x1) / height + qy * x3;
         c[2] = x1;
-        c[3] = (y2 - y1) / width  + qx * y2;
+        c[3] = (y2 - y1) / width + qx * y2;
         c[4] = (y3 - y1) / height + qy * y3;
         c[5] = y1;
         c[6] = qx;
         c[7] = qy;
 
-        Transform result = {{
-            c[0], c[3], 0, c[6],
-            c[1], c[4], 0, c[7],
-            0,    0,    1, 0,
-            c[2], c[5], 0, 1
-        }};
+        Transform result = {{c[0], c[3], 0, c[6], //
+                             c[1], c[4], 0, c[7], //
+                             0, 0, 1, 0,          //
+                             c[2], c[5], 0, 1}};
         return result;
     }
 
-    void draw_vertex_arrays(double x1, double y1, double x2, double y2, double x3, double y3,
-        double x4, double y4) const
+    void draw_vertex_arrays(double x1, double y1, double x2, double y2, //
+                            double x3, double y3, double x4, double y4) const
     {
         // TODO: Macros should not be split up just because they have different transforms.
         // They should be premultiplied and have the same transform by definition. Then the
         // transformation only has to be performed once.
-        
-    #ifndef GOSU_IS_OPENGLES
+
+#ifndef GOSU_IS_OPENGLES
         glEnable(GL_BLEND);
         glMatrixMode(GL_MODELVIEW);
-        
+
         Transform transform = find_transform_for_target(x1, y1, x2, y2, x3, y3, x4, y4);
-        
+
         for (const auto& vertex_array : vertex_arrays) {
             glPushMatrix();
             vertex_array.render_state.apply();
@@ -139,7 +137,7 @@ struct Gosu::Macro::Impl
             glDrawArrays(GL_QUADS, 0, (GLsizei) vertex_array.vertices.size());
             glPopMatrix();
         }
-    #endif
+#endif
     }
 };
 
@@ -161,15 +159,16 @@ int Gosu::Macro::height() const
     return pimpl->height;
 }
 
-void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
-    double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z, BlendMode mode) const
+void Gosu::Macro::draw(double x1, double y1, Color c1, double x2, double y2, Color c2, //
+                       double x3, double y3, Color c3, double x4, double y4, Color c4, //
+                       ZPos z, BlendMode mode) const
 {
     if (c1 != Color::WHITE || c2 != Color::WHITE || c3 != Color::WHITE || c4 != Color::WHITE) {
-        throw invalid_argument("Macros cannot be tinted with colors");
+        throw std::invalid_argument{"Macros cannot be tinted with colors"};
     }
-    
+
     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); });
 }
 
@@ -180,21 +179,20 @@ const Gosu::GLTexInfo* Gosu::Macro::gl_tex_info() const
 
 Gosu::Bitmap Gosu::Macro::to_bitmap() const
 {
-    return Gosu::Graphics::render(pimpl->width, pimpl->height, [this] {
-        draw(0,            0,             Color::WHITE,
-             pimpl->width, 0,             Color::WHITE,
-             0,            pimpl->height, Color::WHITE,
-             pimpl->width, pimpl->height, Color::WHITE,
-             0, BM_DEFAULT);
-    }).data().to_bitmap();
+    const auto render_this = [this] {
+        draw(0, 0, Color::WHITE, pimpl->width, 0, Color::WHITE, 0, pimpl->height, Color::WHITE,
+             pimpl->width, pimpl->height, Color::WHITE, 0, BM_DEFAULT);
+    };
+
+    return Gosu::Graphics::render(pimpl->width, pimpl->height, render_this).data().to_bitmap();
 }
 
-unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::ImageData> Gosu::Macro::subimage(int x, int y, int width, int height) const
 {
-    return unique_ptr<ImageData>();
+    return std::unique_ptr<ImageData>{};
 }
 
 void Gosu::Macro::insert(const Bitmap& bitmap, int x, int y)
 {
-    throw logic_error("Gosu::Macro cannot be updated with a Gosu::Bitmap yet");
+    throw std::logic_error{"Gosu::Macro cannot be updated with a Gosu::Bitmap yet"};
 }

data/src/Macro.hpp

@@ -1,30 +1,30 @@
 #pragma once
 
-#include "GraphicsImpl.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
+#include "GraphicsImpl.hpp"
 #include <memory>
 
 class Gosu::Macro : public Gosu::ImageData
 {
     struct Impl;
     std::shared_ptr<Impl> pimpl;
-    
+
 public:
     Macro(DrawOpQueue& queue, int width, int height);
-    
+
     int width() const override;
     int height() const override;
-    
-    void draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
-        double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z,
-        BlendMode mode) const override;
-    
+
+    void draw(double x1, double y1, Color c1, double x2, double y2, Color c2, //
+              double x3, double y3, Color c3, double x4, double y4, Color c4, //
+              ZPos z, BlendMode mode) const override;
+
     const Gosu::GLTexInfo* gl_tex_info() const override;
-    
+
     Gosu::Bitmap to_bitmap() const override;
-    
+
     std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
-    
+
     void insert(const Bitmap& bitmap, int x, int y) override;
 };

data/src/Math.cpp

@@ -23,7 +23,14 @@ double Gosu::angle(double from_x, double from_y, double to_x, double to_y, doubl
     double dist_x = to_x - from_x;
     double dist_y = to_y - from_y;
 
-    if (dist_x == 0 && dist_y == 0) return def;
+    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;
+    }
 
     return normalize_angle(radians_to_gosu(atan2(dist_y, dist_x)));
 }

data/src/Resolution.cpp

@@ -7,8 +7,9 @@
 
 static SDL_DisplayMode display_mode(Gosu::Window* window)
 {
-    static struct VideoSubsystem {
-        VideoSubsystem()  { SDL_InitSubSystem(SDL_INIT_VIDEO); };
+    static struct VideoSubsystem
+    {
+        VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
 
@@ -40,7 +41,8 @@ static SDL_Rect max_window_size(Gosu::Window* window)
         style = NSWindowStyleMaskBorderless;
     }
     else {
-        style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable;
+        style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
+                NSWindowStyleMaskMiniaturizable;
     }
     if (window && window->resizable()) {
         style |= NSWindowStyleMaskResizable;
@@ -61,10 +63,10 @@ static SDL_Rect max_window_size(Gosu::Window* window)
 
 // TODO: Remove this implementation and remove ifdef for GOSU_IS_X once WIN_GetWindowBordersSize is patched
 #ifdef GOSU_IS_WIN
-#include <windows.h>
 #include <SDL_syswm.h>
 #include <dwmapi.h>
-#pragma comment (lib, "Dwmapi.lib")
+#include <windows.h>
+#pragma comment(lib, "Dwmapi.lib")
 
 static SDL_Rect max_window_size(Gosu::Window* window)
 {
@@ -72,7 +74,8 @@ static SDL_Rect max_window_size(Gosu::Window* window)
     // until it's patched to ignore the window drop shadow (window border is 1px but with drop shadow it's reported as 8px)
     // REF: https://github.com/libsdl-org/SDL/issues/3835
 
-    static struct VideoSubsystem {
+    static struct VideoSubsystem
+    {
         VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
@@ -136,7 +139,8 @@ static SDL_Rect max_window_size(Gosu::Window* window)
 #ifdef GOSU_IS_X
 static SDL_Rect max_window_size(Gosu::Window* window)
 {
-    static struct VideoSubsystem {
+    static struct VideoSubsystem
+    {
         VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
@@ -163,4 +167,5 @@ int Gosu::available_height(Window* window)
 {
     return max_window_size(window).h;
 }
+
 #endif

data/src/RubyGosu.cxx

@@ -8217,8 +8217,8 @@ fail:
 SWIGINTERN VALUE
 _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
   Gosu::Sample *arg1 = (Gosu::Sample *) 0 ;
-  double arg2 = (double) 1 ;
-  double arg3 = (double) 1 ;
+  double arg2 = (double) 1.0 ;
+  double arg3 = (double) 1.0 ;
   bool arg4 = (bool) false ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -8279,8 +8279,8 @@ SWIGINTERN VALUE
 _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
   Gosu::Sample *arg1 = (Gosu::Sample *) 0 ;
   double arg2 ;
-  double arg3 = (double) 1 ;
-  double arg4 = (double) 1 ;
+  double arg3 = (double) 1.0 ;
+  double arg4 = (double) 1.0 ;
   bool arg5 = (bool) false ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12485,7 +12485,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "VERSION", SWIG_From_std_string(static_cast< std::string >(Gosu::VERSION)));
   rb_define_const(mGosu, "LICENSES", SWIG_From_std_string(static_cast< std::string >(Gosu::LICENSES)));
   rb_define_const(mGosu, "MAJOR_VERSION", SWIG_From_int(static_cast< int >(1)));
-  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(3)));
+  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(4)));
   rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(0)));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);

data/src/TexChunk.cpp

@@ -1,57 +1,66 @@
 #include "TexChunk.hpp"
-#include "DrawOpQueue.hpp"
-#include "Texture.hpp"
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
+#include "DrawOpQueue.hpp"
+#include "Texture.hpp"
 #include <stdexcept>
 
-using namespace std;
-
 void Gosu::TexChunk::set_tex_info()
 {
-    double width = texture->width(), height = texture->height();
+    double width = m_texture->width(), height = m_texture->height();
 
-    info.tex_name = texture->tex_name();
-    info.left   = x / width;
-    info.top    = y / height;
-    info.right  = (x + w) / width;
-    info.bottom = (y + h) / height;
+    m_info.tex_name = m_texture->tex_name();
+    m_info.left = m_x / width;
+    m_info.top = m_y / height;
+    m_info.right = (m_x + m_w) / width;
+    m_info.bottom = (m_y + m_h) / height;
 }
 
-Gosu::TexChunk::TexChunk(shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
-: texture(move(texture)), x(x), y(y), w(w), h(h), padding(padding)
+Gosu::TexChunk::TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
+: m_texture{move(texture)},
+  m_x{x},
+  m_y{y},
+  m_w{w},
+  m_h{h},
+  m_padding{padding}
 {
     set_tex_info();
 }
 
 Gosu::TexChunk::TexChunk(const TexChunk& parent, int x, int y, int w, int h)
-: texture(parent.texture), x(parent.x + x), y(parent.y + y), w(w), h(h), padding(0)
+: m_texture{parent.m_texture},
+  m_x{parent.m_x + x},
+  m_y{parent.m_y + y},
+  m_w{w},
+  m_h{h},
+  m_padding{0}
 {
-    if (x < 0 || y < 0 || x + w > parent.w || y + h > parent.h) {
-        throw invalid_argument("subimage bounds exceed those of its parent");
+    if (x < 0 || y < 0 || x + w > parent.m_w || y + h > parent.m_h) {
+        throw std::invalid_argument{"subimage bounds exceed those of its parent"};
     }
     if (w <= 0 || h <= 0) {
-        throw invalid_argument("cannot create empty image");
+        throw std::invalid_argument{"cannot create empty image"};
     }
-    
+
     set_tex_info();
-    texture->block(this->x, this->y, this->w, this->h);
+    m_texture->block(m_x, m_y, m_w, m_h);
 }
 
 Gosu::TexChunk::~TexChunk()
 {
-    texture->free(x - padding, y - padding, w + 2 * padding, h + 2 * padding);
+    m_texture->free(m_x - m_padding, m_y - m_padding, m_w + 2 * m_padding, m_h + 2 * m_padding);
 }
 
-void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
-    double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z, BlendMode mode) const
+void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2, Color c2, //
+                          double x3, double y3, Color c3, double x4, double y4, Color c4, //
+                          ZPos z, BlendMode mode) const
 {
     DrawOp op;
-    op.render_state.texture = texture;
+    op.render_state.texture = m_texture;
     op.render_state.mode = mode;
-    
+
     normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
-    
+
     op.vertices_or_block_index = 4;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
@@ -63,34 +72,34 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2,
     op.vertices[3] = DrawOp::Vertex(x3, y3, c3);
     op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
 #endif
-    op.left = info.left;
-    op.top = info.top;
-    op.right = info.right;
-    op.bottom = info.bottom;
-    
+    op.left = m_info.left;
+    op.top = m_info.top;
+    op.right = m_info.right;
+    op.bottom = m_info.bottom;
+
     op.z = z;
     Graphics::schedule_draw_op(op);
 }
 
-unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
+std::unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
 {
-    return unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
+    return std::unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
 }
 
 Gosu::Bitmap Gosu::TexChunk::to_bitmap() const
 {
-    return texture->to_bitmap(x, y, w, h);
+    return m_texture->to_bitmap(m_x, m_y, m_w, m_h);
 }
 
 void Gosu::TexChunk::insert(const Bitmap& original_bitmap, int x, int y)
 {
     Bitmap clipped_bitmap;
     const Bitmap* bitmap = &original_bitmap;
-    
+
     // If inserting the bitmap at the given position exceeds the boundaries of the space allocated
     // for this image on the texture, we need to clip the bitmap and insert the clipped version
     // instead.
-    if (x < 0 || y < 0 || x + original_bitmap.width() > w || y + original_bitmap.height() > h) {
+    if (x < 0 || y < 0 || x + original_bitmap.width() > m_w || y + original_bitmap.height() > m_h) {
         // How many pixels to remove at the top and left sides.
         int clip_left = 0, clip_top = 0;
         // How large the clipped version needs to be.
@@ -109,22 +118,22 @@ void Gosu::TexChunk::insert(const Bitmap& original_bitmap, int x, int y)
             y = 0;
         }
         // Clip away pixels on the right side, if necessary.
-        if (x + clipped_width > w) {
-            clipped_width = (w - x);
+        if (x + clipped_width > m_w) {
+            clipped_width = (m_w - x);
         }
         // Clip away pixels on the bottom, if necessary.
-        if (y + clipped_height > h) {
-            clipped_height = (h - y);
+        if (y + clipped_height > m_h) {
+            clipped_height = (m_h - y);
         }
 
         if (clipped_width <= 0 || clipped_height <= 0) return;
-        
+
         clipped_bitmap.resize(clipped_width, clipped_height);
         clipped_bitmap.insert(-clip_left, -clip_top, original_bitmap);
         bitmap = &clipped_bitmap;
     }
-    
+
     glBindTexture(GL_TEXTURE_2D, tex_name());
-    glTexSubImage2D(GL_TEXTURE_2D, 0, this->x + x, this->y + y, bitmap->width(), bitmap->height(),
+    glTexSubImage2D(GL_TEXTURE_2D, 0, m_x + x, m_y + y, bitmap->width(), bitmap->height(),
                     Color::GL_FORMAT, GL_UNSIGNED_BYTE, bitmap->data());
 }

data/src/TexChunk.hpp

@@ -1,41 +1,41 @@
 #pragma once
 
-#include "GraphicsImpl.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
+#include "GraphicsImpl.hpp"
 #include <memory>
 #include <stdexcept>
 
 class Gosu::TexChunk : public Gosu::ImageData
 {
-    std::shared_ptr<Texture> texture;
-    int x, y, w, h, padding;
-    
-    GLTexInfo info;
-    
+    std::shared_ptr<Texture> m_texture;
+    int m_x, m_y, m_w, m_h, m_padding;
+
+    GLTexInfo m_info;
+
     void set_tex_info();
-    
+
 public:
     TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
     TexChunk(const TexChunk& parent, int x, int y, int w, int h);
     ~TexChunk() override;
 
-    int width() const override  { return w; }
-    int height() const override { return h; }
-    
-    GLuint tex_name() const { return info.tex_name; }
-    
-    void draw(double x1, double y1, Color c1,
-        double x2, double y2, Color c2,
-        double x3, double y3, Color c3,
-        double x4, double y4, Color c4,
-        ZPos z, BlendMode mode) const override;
-
-    const GLTexInfo* gl_tex_info() const override { return &info; }
-    
+    int width() const override { return m_w; }
+    int height() const override { return m_h; }
+
+    GLuint tex_name() const { return m_info.tex_name; }
+
+    void draw(double x1, double y1, Color c1, //
+              double x2, double y2, Color c2, //
+              double x3, double y3, Color c3, //
+              double x4, double y4, Color c4, //
+              ZPos z, BlendMode mode) const override;
+
+    const GLTexInfo* gl_tex_info() const override { return &m_info; }
+
     std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const override;
-    
+
     Gosu::Bitmap to_bitmap() const override;
-    
+
     void insert(const Bitmap& bitmap, int x, int y) override;
 };