gosu 1.1.1.1 → 1.4.1

data/src/Bitmap.cpp

@@ -31,20 +31,20 @@ void Gosu::Bitmap::resize(int width, int height, Color c)
 
 void Gosu::Bitmap::blend_pixel(int x, int y, Color c)
 {
-    if (c.alpha() == 0) return;
+    if (c.alpha == 0) return;
 
     Color out = get_pixel(x, y);
-    if (out.alpha() == 0) {
+    if (out.alpha == 0) {
         set_pixel(x, y, c);
         return;
     }
 
-    int inv_alpha = out.alpha() * (255 - c.alpha()) / 255;
+    int inv_alpha = out.alpha * (255 - c.alpha) / 255;
 
-    out.set_alpha(c.alpha() + inv_alpha);
-    out.set_red  ((c.red()   * c.alpha() + out.red()   * inv_alpha) / out.alpha());
-    out.set_green((c.green() * c.alpha() + out.green() * inv_alpha) / out.alpha());
-    out.set_blue ((c.blue()  * c.alpha() + out.blue()  * inv_alpha) / out.alpha());
+    out.alpha = (c.alpha + inv_alpha);
+    out.red =   ((c.red   * c.alpha + out.red   * inv_alpha) / out.alpha);
+    out.green = ((c.green * c.alpha + out.green * inv_alpha) / out.alpha);
+    out.blue =  ((c.blue  * c.alpha + out.blue  * inv_alpha) / out.alpha);
 
     set_pixel(x, y, out);
 }
@@ -108,9 +108,9 @@ void Gosu::apply_color_key(Bitmap& bitmap, Color key)
                 auto visit = [&](Color c) {
                   if (c != key) {
                       neighbors += 1;
-                      red += c.red();
-                      green += c.green();
-                      blue += c.blue();
+                      red += c.red;
+                      green += c.green;
+                      blue += c.blue;
                   }
                 };
 
@@ -121,9 +121,9 @@ void Gosu::apply_color_key(Bitmap& bitmap, Color key)
 
                 Color replacement = Color::NONE;
                 if (neighbors > 0) {
-                    replacement.set_red(red / neighbors);
-                    replacement.set_green(green / neighbors);
-                    replacement.set_blue(blue / neighbors);
+                    replacement.red = red / neighbors;
+                    replacement.green = green / neighbors;
+                    replacement.blue = blue / neighbors;
                 }
                 bitmap.set_pixel(x, y, replacement);
             }

data/src/BitmapIO.cpp

@@ -7,18 +7,8 @@
 #define STBI_NO_STDIO
 #define STBI_NO_LINEAR
 
-// Disable comma warnings in stb headers.
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcomma"
-#endif
-
 #include <stb_image.h>
 
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
 static int read_callback(void* user, char* data, int size)
 {
     Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
@@ -82,19 +72,9 @@ Gosu::Bitmap Gosu::load_image_file(Reader input)
     return bitmap;
 }
 
-// Disable comma warnings in stb headers.
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcomma"
-#endif
-
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include <stb_image_write.h>
 
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
 void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filename)
 {
     int ok;

data/src/BlockAllocator.cpp

@@ -1,9 +1,10 @@
+#include <Gosu/Utility.hpp>
 #include "BlockAllocator.hpp"
 #include <stdexcept>
 #include <vector>
 using namespace std;
 
-struct Gosu::BlockAllocator::Impl
+struct Gosu::BlockAllocator::Impl : Gosu::Noncopyable
 {
     unsigned width, height;
 

data/src/Channel.cpp

@@ -1,8 +1,8 @@
 #include <Gosu/Audio.hpp>
 #include "AudioImpl.hpp"
-using namespace std;
+#include <algorithm>
 
-// Returns the current state of a source
+/// Returns the current state of a source.
 static ALint state(int& channel)
 {
     ALint state;
@@ -14,41 +14,43 @@ static ALint state(int& channel)
 }
 
 Gosu::Channel::Channel()
-: channel(NO_CHANNEL), token(0)
+: m_channel{NO_CHANNEL},
+  m_token{0}
 {
 }
 
 Gosu::Channel::Channel(int channel, int token)
-: channel(channel), token(token)
+: m_channel{channel},
+  m_token{token}
 {
 }
 
 int Gosu::Channel::current_channel() const
 {
-    if (channel != NO_CHANNEL && channel_expired(channel, token)) {
-        channel = NO_CHANNEL;
+    if (m_channel != NO_CHANNEL && channel_expired(m_channel, m_token)) {
+        m_channel = NO_CHANNEL;
     }
-    return channel;
+    return m_channel;
 }
 
 bool Gosu::Channel::playing() const
 {
     if (current_channel() == NO_CHANNEL) return false;
-    
-    return state(channel) == AL_PLAYING;
+
+    return state(m_channel) == AL_PLAYING;
 }
 
 bool Gosu::Channel::paused() const
 {
     if (current_channel() == NO_CHANNEL) return false;
 
-    return state(channel) == AL_PAUSED;
+    return state(m_channel) == AL_PAUSED;
 }
 
 void Gosu::Channel::pause()
 {
     if (playing()) {
-        ALuint source = al_source_for_channel(channel);
+        ALuint source = al_source_for_channel(m_channel);
         alSourcePause(source);
     }
 }
@@ -56,7 +58,7 @@ void Gosu::Channel::pause()
 void Gosu::Channel::resume()
 {
     if (paused()) {
-        ALuint source = al_source_for_channel(channel);
+        ALuint source = al_source_for_channel(m_channel);
         alSourcePlay(source);
     }
 }
@@ -65,31 +67,31 @@ void Gosu::Channel::stop()
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
+    ALuint source = al_source_for_channel(m_channel);
     alSourceStop(source);
-    channel = NO_CHANNEL;
+    m_channel = NO_CHANNEL;
 }
 
 void Gosu::Channel::set_volume(double volume)
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
-    alSourcef(source, AL_GAIN, max(volume, 0.0));
+    ALuint source = al_source_for_channel(m_channel);
+    alSourcef(source, AL_GAIN, static_cast<ALfloat>(std::max(volume, 0.0)));
 }
 
 void Gosu::Channel::set_pan(double pan)
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
-    alSource3f(source, AL_POSITION, pan * 10, 0, 0);
+    ALuint source = al_source_for_channel(m_channel);
+    alSource3f(source, AL_POSITION, static_cast<ALfloat>(pan * 10), 0, 0);
 }
 
 void Gosu::Channel::set_speed(double speed)
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
-    alSourcef(source, AL_PITCH, speed);
+    ALuint source = al_source_for_channel(m_channel);
+    alSourcef(source, AL_PITCH, static_cast<ALfloat>(speed));
 }

data/src/Color.cpp

@@ -1,35 +1,38 @@
 #include <Gosu/Color.hpp>
 #include <Gosu/Math.hpp>
-#include <cmath>
 #include <algorithm>
+#include <cmath>
 
 namespace
 {
-    struct HSV { double h, s, v; };
-    
+    struct HSV
+    {
+        double h, s, v;
+    };
+
     HSV color_to_hsv(const Gosu::Color& c)
     {
-        double r = c.red() / 255.0;
-        double g = c.green() / 255.0;
-        double b = c.blue() / 255.0;
-        
+        double r = c.red / 255.0;
+        double g = c.green / 255.0;
+        double b = c.blue / 255.0;
+
         double min = std::min(std::min(r, g), b);
         double max = std::max(std::max(r, g), b);
         double delta = max - min;
 
         if (max == 0) {
-            HSV hsv = { 0, 0, 0 };
+            HSV hsv = {0, 0, 0};
             return hsv;
         }
-        
-        HSV hsv;
+
+        HSV hsv{};
 
         // Value.
         hsv.v = max;
-        
+
         // Saturation.
         hsv.s = delta / max;
-        
+
         // Hue.
         if (delta == 0) {
             hsv.h = 0;
@@ -44,44 +47,39 @@ namespace
             hsv.h = (r - g) / delta + 4;
         }
         hsv.h *= 60;
-        
+
         return hsv;
     }
 }
 
 Gosu::Color Gosu::Color::from_hsv(double h, double s, double v)
-{
-    return from_ahsv(255, h, s, v);
-}
-
-Gosu::Color Gosu::Color::from_ahsv(Channel alpha, double h, double s, double v)
 {
     // Normalize hue so that is always in the [0, 360) range and wraps around.
     h = normalize_angle(h);
     // Clamp s and v for consistency with the Ruby/Gosu ARGB getters/setters.
-    s = clamp(s, 0.0, 1.0);
-    v = clamp(v, 0.0, 1.0);
-    
+    s = std::clamp(s, 0.0, 1.0);
+    v = std::clamp(v, 0.0, 1.0);
+
     int sector = static_cast<int>(h / 60);
     double factorial = h / 60 - sector;
-    
-    double p = v * (1 - s);
-    double q = v * (1 - s * factorial);
-    double t = v * (1 - s * (1 - factorial));
-    
+
+    Channel p = static_cast<Channel>(255 * v * (1 - s));
+    Channel q = static_cast<Channel>(255 * v * (1 - s * factorial));
+    Channel t = static_cast<Channel>(255 * v * (1 - s * (1 - factorial)));
+
     switch (sector) {
     case 0:
-        return Color(alpha, v * 255, t * 255, p * 255);
+        return Color{static_cast<Channel>(255 * v), t, p};
     case 1:
-        return Color(alpha, q * 255, v * 255, p * 255);
+        return Color{q, static_cast<Channel>(255 * v), p};
     case 2:
-        return Color(alpha, p * 255, v * 255, t * 255);
+        return Color{p, static_cast<Channel>(255 * v), t};
     case 3:
-        return Color(alpha, p * 255, q * 255, v * 255);
+        return Color{p, q, static_cast<Channel>(255 * v)};
     case 4:
-        return Color(alpha, t * 255, p * 255, v * 255);
+        return Color{t, p, static_cast<Channel>(255 * v)};
     default: // sector 5
-        return Color(alpha, v * 255, p * 255, q * 255);
+        return Color{static_cast<Channel>(255 * v), p, q};
     }
 }
 
@@ -92,7 +90,7 @@ double Gosu::Color::hue() const
 
 void Gosu::Color::set_hue(double h)
 {
-    *this = from_ahsv(alpha(), h, saturation(), value());
+    *this = from_hsv(h, saturation(), value()).with_alpha(alpha);
 }
 
 double Gosu::Color::saturation() const
@@ -102,7 +100,7 @@ double Gosu::Color::saturation() const
 
 void Gosu::Color::set_saturation(double s)
 {
-    *this = from_ahsv(alpha(), hue(), s, value());
+    *this = from_hsv(hue(), s, value()).with_alpha(alpha);
 }
 
 double Gosu::Color::value() const
@@ -112,33 +110,42 @@ double Gosu::Color::value() const
 
 void Gosu::Color::set_value(double v)
 {
-    *this = from_ahsv(alpha(), hue(), saturation(), v);
+    *this = from_hsv(hue(), saturation(), v).with_alpha(alpha);
 }
 
-Gosu::Color Gosu::interpolate(Color a, Color b, double weight)
+Gosu::Color Gosu::lerp(Color a, Color b, double t)
 {
-    return Color(clamp<long>(round(interpolate(a.alpha(), b.alpha(), weight)), 0, 255),
-                 clamp<long>(round(interpolate(a.red(),   b.red(),   weight)), 0, 255),
-                 clamp<long>(round(interpolate(a.green(), b.green(), weight)), 0, 255),
-                 clamp<long>(round(interpolate(a.blue(),  b.blue(),  weight)), 0, 255));
+    const auto lerp_channel = [](Color::Channel a, Color::Channel b, double t) {
+        return static_cast<Color::Channel>(std::clamp(std::round(lerp(a, b, t)), 0.0, 255.0));
+    };
+
+    Color result;
+    result.red = lerp_channel(a.red, b.red, t);
+    result.green = lerp_channel(a.green, b.green, t);
+    result.blue = lerp_channel(a.blue, b.blue, t);
+    result.alpha = lerp_channel(a.alpha, b.alpha, t);
+    return result;
 }
 
 Gosu::Color Gosu::multiply(Color a, Color b)
 {
-    return Color(round(a.alpha() * b.alpha() / 255.0),
-                 round(a.red()   * b.red()   / 255.0),
-                 round(a.green() * b.green() / 255.0),
-                 round(a.blue()  * b.blue()  / 255.0));
+    Color result;
+    result.red = static_cast<Color::Channel>(std::round(a.red * b.red / 255.0));
+    result.green = static_cast<Color::Channel>(std::round(a.green * b.green / 255.0));
+    result.blue = static_cast<Color::Channel>(std::round(a.blue * b.blue / 255.0));
+    result.alpha = static_cast<Color::Channel>(std::round(a.alpha * b.alpha / 255.0));
+    return result;
 }
 
-const Gosu::Color Gosu::Color::NONE      (0x00000000);
-const Gosu::Color Gosu::Color::BLACK     (0xff000000);
-const Gosu::Color Gosu::Color::GRAY      (0xff808080);
-const Gosu::Color Gosu::Color::WHITE     (0xffffffff);
-const Gosu::Color Gosu::Color::AQUA      (0xff00ffff);
-const Gosu::Color Gosu::Color::RED       (0xffff0000);
-const Gosu::Color Gosu::Color::GREEN     (0xff00ff00);
-const Gosu::Color Gosu::Color::BLUE      (0xff0000ff);
-const Gosu::Color Gosu::Color::YELLOW    (0xffffff00);
-const Gosu::Color Gosu::Color::FUCHSIA   (0xffff00ff);
-const Gosu::Color Gosu::Color::CYAN      (0xff00ffff);
+const Gosu::Color Gosu::Color::NONE{0x00'000000};
+const Gosu::Color Gosu::Color::BLACK{0, 0, 0};
+const Gosu::Color Gosu::Color::GRAY{128, 128, 128};
+const Gosu::Color Gosu::Color::WHITE{255, 255, 255};
+
+const Gosu::Color Gosu::Color::AQUA{0, 255, 255};
+const Gosu::Color Gosu::Color::RED{255, 0, 0};
+const Gosu::Color Gosu::Color::GREEN{0, 255, 0};
+const Gosu::Color Gosu::Color::BLUE{0, 0, 255};
+const Gosu::Color Gosu::Color::YELLOW{255, 255, 0};
+const Gosu::Color Gosu::Color::FUCHSIA{255, 0, 255};
+const Gosu::Color Gosu::Color::CYAN{0, 255, 255};

data/src/EmptyImageData.hpp

@@ -8,43 +8,41 @@ namespace Gosu
     class EmptyImageData : public ImageData
     {
     public:
-        int width() const override
+        int width() const override //
         {
             return 0;
         }
-        
-        int height() const override
+
+        int height() const override //
         {
             return 0;
         }
-        
-        void draw(double, double, Color,
-                  double, double, Color,
-                  double, double, Color,
-                  double, double, Color,
-                  ZPos, AlphaMode) const override
+
+        void draw(double, double, Color, double, double, Color, //
+                  double, double, Color, double, double, Color, //
+                  ZPos, BlendMode) const override
         {
         }
-        
-        GLTexInfo* gl_tex_info() const override
+
+        GLTexInfo* gl_tex_info() const override //
         {
             return nullptr;
         }
-        
-        Bitmap to_bitmap() const override
+
+        Bitmap to_bitmap() const override //
         {
             return Bitmap();
         }
-        
-        virtual std::unique_ptr<ImageData> subimage(int, int, int, int) const override
+
+        std::unique_ptr<ImageData> subimage(int, int, int, int) const override //
         {
             return nullptr;
         }
-        
-        virtual void insert(const Bitmap&, int x, int y) override
+
+        void insert(const Bitmap&, int x, int y) override //
         {
         }
-        
+
         static const std::shared_ptr<EmptyImageData>& instance_ptr()
         {
             static std::shared_ptr<EmptyImageData> instance = std::make_shared<EmptyImageData>();

data/src/FileUnix.cpp

@@ -16,7 +16,7 @@
 
 using namespace std;
 
-struct Gosu::File::Impl
+struct Gosu::File::Impl : Gosu::Noncopyable
 {
     int fd = -1;
     void* mapping = MAP_FAILED;

data/src/FileWin.cpp

@@ -9,7 +9,7 @@ using namespace std;
 
 // TODO: Error checking
 
-struct Gosu::File::Impl
+struct Gosu::File::Impl : Gosu::Noncopyable
 {
     HANDLE handle = INVALID_HANDLE_VALUE;