gosu 0.15.2 → 1.0.0.pre1

data/src/AudioImpl.cpp

@@ -23,6 +23,9 @@ void Gosu::al_initialize()
     _context = alcCreateContext(_device, nullptr);
     alcMakeContextCurrent(_context);
     alGenSources(CHANNELS, _sources);
+
+    // Don't worry about ever closing the OpenAL device; it's hard to know when to clean up within
+    // the scope of a Ruby C extension. Let the operating system clean up after us.
 }
 
 bool Gosu::al_initialized()
@@ -30,18 +33,6 @@ bool Gosu::al_initialized()
     return _device != nullptr;
 }
 
-void Gosu::al_shutdown()
-{
-    if (_device == nullptr) return;
-    
-    alDeleteSources(CHANNELS, _sources);
-    alcMakeContextCurrent(nullptr);
-    alcDestroyContext(_context);
-    _context = nullptr;
-    alcCloseDevice(_device);
-    _device = nullptr;
-}
-
 ALCdevice* Gosu::al_device()
 {
     al_initialize();

data/src/AudioImpl.hpp

@@ -3,6 +3,9 @@
 #include <Gosu/Audio.hpp>
 #include <Gosu/Platform.hpp>
 #ifdef GOSU_IS_MAC
+// Ignore OpenAL deprecation warnings. If macOS stops shipping OpenAL, it's more likely that we bundle our own version
+// of it than that we switch to another audio API.
+#define OPENAL_DEPRECATED
 #include <OpenAL/al.h>
 #include <OpenAL/alc.h>
 #else
@@ -14,7 +17,6 @@ namespace Gosu
 {
     void al_initialize();
     bool al_initialized();
-    void al_shutdown();
     
     // Will initialize OpenAL if necessary.
     ALCdevice* al_device();

data/src/Bitmap.cpp

@@ -1,57 +1,66 @@
 #include <Gosu/Bitmap.hpp>
-#include <cassert>
-#include <algorithm>
-#include <vector>
-using namespace std;
+#include <Gosu/GraphicsBase.hpp>
+#include <stdexcept> // for std::invalid_argument
+#include <utility>   // for std::swap
+
+Gosu::Bitmap::Bitmap(int width, int height, Gosu::Color c)
+{
+    resize(width, height, c);
+}
 
 void Gosu::Bitmap::swap(Bitmap& other)
 {
-    std::swap(pixels, other.pixels);
-    std::swap(w, other.w);
-    std::swap(h, other.h);
+    std::swap(m_pixels, other.m_pixels);
+    std::swap(m_width, other.m_width);
+    std::swap(m_height, other.m_height);
 }
 
-void Gosu::Bitmap::resize(unsigned width, unsigned height, Color c)
+void Gosu::Bitmap::resize(int width, int height, Color c)
 {
-    if (width == w && height == h) return;
+    if (width < 0 || height < 0) throw std::invalid_argument{"negative bitmap size"};
 
-    Bitmap temp(width, height, c);
-    temp.insert(*this, 0, 0);
+    if (width == m_width && height == m_height) return;
+
+    Bitmap temp;
+    temp.m_width = width;
+    temp.m_height = height;
+    temp.m_pixels.resize(width * height, c);
+    temp.insert(0, 0, *this);
     swap(temp);
 }
 
-void Gosu::Bitmap::blend_pixel(unsigned x, unsigned y, Color c)
+void Gosu::Bitmap::blend_pixel(int x, int y, Color c)
 {
     if (c.alpha() == 0) return;
-    
+
     Color out = get_pixel(x, y);
     if (out.alpha() == 0) {
         set_pixel(x, y, c);
         return;
     }
-    
+
     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());
-    
+
     set_pixel(x, y, out);
 }
 
-void Gosu::Bitmap::insert(const Bitmap& source, int x, int y)
+void Gosu::Bitmap::insert(int x, int y, const Bitmap& source)
 {
-    insert(source, x, y, 0, 0, source.width(), source.height());
+    insert(x, y, source, 0, 0, source.width(), source.height());
 }
 
-void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, unsigned src_y,
-                          unsigned src_width, unsigned src_height)
+void Gosu::Bitmap::insert(int x, int y, const Bitmap& source,
+                          int src_x, int src_y, int src_width, int src_height)
 {
     // TODO: This should use memcpy if possible (x == 0 && src_width == this->width())
 
     if (x < 0) {
-        unsigned clip_left = -x;
+        int clip_left = -x;
 
         if (clip_left >= src_width) return;
 
@@ -61,7 +70,7 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, un
     }
 
     if (y < 0) {
-        unsigned clip_top = -y;
+        int clip_top = -y;
 
         if (clip_top >= src_height) return;
 
@@ -70,20 +79,20 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, un
         y = 0;
     }
 
-    if (x + src_width > w) {
-        if (static_cast<unsigned>(x) >= w) return;
+    if (x + src_width > m_width) {
+        if (x >= m_width) return;
 
-        src_width = w - x;
+        src_width = m_width - x;
     }
 
-    if (y + src_height > h) {
-        if (static_cast<unsigned>(y) >= h) return;
+    if (y + src_height > m_height) {
+        if (y >= m_height) return;
 
-        src_height = h - y;
+        src_height = m_height - y;
     }
 
-    for (unsigned rel_y = 0; rel_y < src_height; ++rel_y) {
-        for (unsigned rel_x = 0; rel_x < src_width; ++rel_x) {
+    for (int rel_y = 0; rel_y < src_height; ++rel_y) {
+        for (int rel_x = 0; rel_x < src_width; ++rel_x) {
             set_pixel(x + rel_x, y + rel_y, source.get_pixel(src_x + rel_x, src_y + rel_y));
         }
     }
@@ -91,85 +100,76 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned src_x, un
 
 void Gosu::apply_color_key(Bitmap& bitmap, Color key)
 {
-    vector<Color> surrounding_colors;
-    surrounding_colors.reserve(4);
-
-    for (unsigned y = 0; y < bitmap.height(); ++y) {
-        for (unsigned x = 0; x < bitmap.width(); ++x) {
+    for (int y = 0; y < bitmap.height(); ++y) {
+        for (int x = 0; x < bitmap.width(); ++x) {
             if (bitmap.get_pixel(x, y) == key) {
-                surrounding_colors.clear();
-                if (x > 0 && bitmap.get_pixel(x - 1, y) != key) {
-                    surrounding_colors.push_back(bitmap.get_pixel(x - 1, y));
-                }
-                if (x < bitmap.width() - 1 && bitmap.get_pixel(x + 1, y) != key) {
-                    surrounding_colors.push_back(bitmap.get_pixel(x + 1, y));
-                }
-                if (y > 0 && bitmap.get_pixel(x, y - 1) != key) {
-                    surrounding_colors.push_back(bitmap.get_pixel(x, y - 1));
+                // Calculate the average R/G/B of adjacent, non-transparent pixels.
+                unsigned neighbors = 0, red = 0, green = 0, blue = 0;
+                auto visit = [&](Color c) {
+                  if (c != key) {
+                      neighbors += 1;
+                      red += c.red();
+                      green += c.green();
+                      blue += c.blue();
+                  }
+                };
+
+                if (x > 0) visit(bitmap.get_pixel(x - 1, y));
+                if (x < bitmap.width() - 1) visit(bitmap.get_pixel(x + 1, y));
+                if (y > 0) visit(bitmap.get_pixel(x, y - 1));
+                if (y < bitmap.height() - 1) visit(bitmap.get_pixel(x, y + 1));
+
+                Color replacement = Color::NONE;
+                if (neighbors > 0) {
+                    replacement.set_red(red / neighbors);
+                    replacement.set_green(green / neighbors);
+                    replacement.set_blue(blue / neighbors);
                 }
-                if (y < bitmap.height() - 1 && bitmap.get_pixel(x, y + 1) != key) {
-                    surrounding_colors.push_back(bitmap.get_pixel(x, y + 1));
-                }
-
-                if (surrounding_colors.empty()) {
-                    bitmap.set_pixel(x, y, Color::NONE);
-                    continue;
-                }
-
-                unsigned red = 0, green = 0, blue = 0;
-                for (auto& color : surrounding_colors) {
-                    red   += color.red();
-                    green += color.green();
-                    blue  += color.blue();
-                }
-                bitmap.set_pixel(x, y, Color(0,
-                                             red   / surrounding_colors.size(),
-                                             green / surrounding_colors.size(),
-                                             blue  / surrounding_colors.size()));
+                bitmap.set_pixel(x, y, replacement);
             }
         }
     }
 }
 
-void Gosu::unapply_color_key(Bitmap& bitmap, Color color)
+Gosu::Bitmap Gosu::apply_border_flags(unsigned image_flags, const Bitmap& source,
+                                      int src_x, int src_y, int src_width, int src_height)
 {
-    Color* p = bitmap.data();
-    for (int i = bitmap.width() * bitmap.height(); i > 0; --i, ++p) {
-        if (p->alpha() == 0) {
-            *p = color;
-        }
-        else {
-            p->set_alpha(255);
-        }
-    }
-}
+    // By default, we add one pixel of transparent data around the whole image to so that during
+    // interpolation, the image just fades out, instead of bleeding into adjacent image data on
+    // whatever shared texture atlas it ends up on.
+    // However, if a border is marked as "tileable", we instead repeat the outermost pixels, which
+    // leads to a nice sharp/hard border with no interpolation at all.
+
+    // TODO: Instead of using Color::NONE (transparent black) for non-tileable image, still repeat
+    // the border pixel colors, but turn them fully transparent.
 
-void Gosu::apply_border_flags(Bitmap& dest, const Bitmap& source, unsigned src_x, unsigned src_y,
-                              unsigned src_width, unsigned src_height, unsigned image_flags)
-{
     // Backward compatibility: This used to be 'bool tileable'.
     if (image_flags == 1) image_flags = IF_TILEABLE;
 
-    dest.resize(src_width + 2, src_height + 2);
+    Gosu::Bitmap dest{src_width + 2, src_height + 2};
 
     // The borders are made "harder" by duplicating the original bitmap's
     // borders.
 
     // Top.
     if (image_flags & IF_TILEABLE_TOP) {
-        dest.insert(source, 1, 0, src_x, src_y, src_width, 1);
+        dest.insert(1, 0,
+                    source, src_x, src_y, src_width, 1);
     }
     // Bottom.
     if (image_flags & IF_TILEABLE_BOTTOM) {
-        dest.insert(source, 1, dest.height() - 1, src_x, src_y + src_height - 1, src_width, 1);
+        dest.insert(1, dest.height() - 1,
+                    source, src_x, src_y + src_height - 1, src_width, 1);
     }
     // Left.
     if (image_flags & IF_TILEABLE_LEFT) {
-        dest.insert(source, 0, 1, src_x, src_y, 1, src_height);
+        dest.insert(0, 1,
+                    source, src_x, src_y, 1, src_height);
     }
     // Right.
     if (image_flags & IF_TILEABLE_RIGHT) {
-        dest.insert(source, dest.width() - 1, 1, src_x + src_width - 1, src_y, 1, src_height);
+        dest.insert(dest.width() - 1, 1,
+                    source, src_x + src_width - 1, src_y, 1, src_height);
     }
 
     // Top left.
@@ -194,5 +194,7 @@ void Gosu::apply_border_flags(Bitmap& dest, const Bitmap& source, unsigned src_x
     }
 
     // Now put the final image into the prepared borders.
-    dest.insert(source, 1, 1, src_x, src_y, src_width, src_height);
+    dest.insert(1, 1,
+                source, src_x, src_y, src_width, src_height);
+    return dest;
 }

data/src/BitmapIO.cpp

@@ -1,9 +1,7 @@
 #include <Gosu/Bitmap.hpp>
-#include <Gosu/IO.hpp>
-#include <Gosu/Platform.hpp>
 #include <Gosu/Utility.hpp>
-#include <cstring>
-#include <stdexcept>
+#include <cstring>   // for std::memcpy, std::size_t
+#include <stdexcept> // for std::runtime_error
 
 #define STB_IMAGE_IMPLEMENTATION
 #define STBI_NO_STDIO
@@ -15,79 +13,73 @@
 #pragma GCC diagnostic ignored "-Wcomma"
 #endif
 
-#include "stb_image.h"
+#include <stb_image.h>
 
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
 
-using namespace std;
-
-namespace
+static int read_callback(void* user, char* data, int size)
 {
-    int read_callback(void* user, char* data, int size)
-    {
-        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
-        size_t remaining = reader->resource().size() - reader->position();
-        size_t actual_size = (size < remaining ? size : remaining);
-        reader->read(data, actual_size);
-        return static_cast<int>(actual_size);
-    }
+    Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+    std::size_t remaining = reader->resource().size() - reader->position();
+    std::size_t adjusted_size = (size < remaining ? size : remaining);
+    reader->read(data, adjusted_size);
+    return static_cast<int>(adjusted_size);
+}
 
-    void skip_callback(void* user, int n)
-    {
-        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
-        reader->set_position(reader->position() + n);
-    }
+static void skip_callback(void* user, int n)
+{
+    Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+    reader->set_position(reader->position() + n);
+}
 
-    int eof_callback(void* user)
-    {
-        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
-        return reader->position() == reader->resource().size();
-    }
+static int eof_callback(void* user)
+{
+    Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+    return reader->position() == reader->resource().size();
+}
 
-    bool is_bmp(Gosu::Reader reader)
-    {
-        size_t remaining = reader.resource().size() - reader.position();
-        if (remaining < 2) return false;
-        char magic_bytes[2];
-        reader.read(magic_bytes, sizeof magic_bytes);
-        return magic_bytes[0] == 'B' && magic_bytes[1] == 'M';
-    }
+static bool is_bmp(Gosu::Reader reader)
+{
+    std::size_t remaining = reader.resource().size() - reader.position();
+    if (remaining < 2) return false;
+    char magic_bytes[2];
+    reader.read(&magic_bytes, sizeof magic_bytes);
+    return magic_bytes[0] == 'B' && magic_bytes[1] == 'M';
 }
 
-void Gosu::load_image_file(Gosu::Bitmap& bitmap, const string& filename)
+Gosu::Bitmap Gosu::load_image_file(const std::string& filename)
 {
     Buffer buffer;
     load_file(buffer, filename);
-    load_image_file(bitmap, buffer.front_reader());
+    return load_image_file(buffer.front_reader());
 }
 
-void Gosu::load_image_file(Gosu::Bitmap& bitmap, Reader input)
+Gosu::Bitmap Gosu::load_image_file(Reader input)
 {
     bool needs_color_key = is_bmp(input);
-    
-    stbi_io_callbacks callbacks;
+
+    stbi_io_callbacks callbacks{};
     callbacks.read = read_callback;
     callbacks.skip = skip_callback;
     callbacks.eof = eof_callback;
-    int x, y, n;
-    stbi_uc* bytes = stbi_load_from_callbacks(&callbacks, &input, &x, &y, &n, STBI_rgb_alpha);
+    int x = 0, y = 0, n = 0;
 
+    stbi_uc* bytes = stbi_load_from_callbacks(&callbacks, &input, &x, &y, &n, STBI_rgb_alpha);
     if (bytes == nullptr) {
-        // TODO - stbi_failure_reason is not thread safe. Everything here should be wrapped in a
-        // mutex.
-        throw runtime_error("Cannot load image: " + string(stbi_failure_reason()));
+        throw std::runtime_error{"Cannot load image: " + std::string(stbi_failure_reason())};
     }
 
-    bitmap.resize(x, y);
-    memcpy(bitmap.data(), bytes, x * y * sizeof(Gosu::Color));
+    Gosu::Bitmap bitmap{x, y};
+    std::memcpy(bitmap.data(), bytes, x * y * sizeof(Gosu::Color));
 
     stbi_image_free(bytes);
-    
+
     if (needs_color_key) {
         apply_color_key(bitmap, Gosu::Color::FUCHSIA);
     }
+    return bitmap;
 }
 
 // Disable comma warnings in stb headers.
@@ -97,16 +89,16 @@ void Gosu::load_image_file(Gosu::Bitmap& bitmap, Reader input)
 #endif
 
 #define STB_IMAGE_WRITE_IMPLEMENTATION
-#include "stb_image_write.h"
+#include <stb_image_write.h>
 
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
 
-void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const string& filename)
+void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filename)
 {
     int ok;
-    
+
     if (has_extension(filename, "bmp")) {
         ok = stbi_write_bmp(filename.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data());
     }
@@ -116,20 +108,22 @@ void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const string& filename)
     else {
         ok = stbi_write_png(filename.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data(), 0);
     }
-    
-    if (ok == 0) throw runtime_error("Could not save image data to file: " + filename);
+
+    if (ok == 0) {
+        throw std::runtime_error("Could not save image data to file: " + filename);
+    }
 }
 
 static void stbi_write_to_writer(void* context, void* data, int size)
 {
-    reinterpret_cast<Gosu::Writer*>(context)->write(data, size);
+    static_cast<Gosu::Writer*>(context)->write(data, size);
 }
 
 void Gosu::save_image_file(const Gosu::Bitmap& bitmap, Gosu::Writer writer,
-                           const string& format_hint)
+                           const std::string_view& format_hint)
 {
     int ok;
-    
+
     if (has_extension(format_hint, "bmp")) {
         ok = stbi_write_bmp_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
                                     4, bitmap.data());
@@ -143,9 +137,9 @@ void Gosu::save_image_file(const Gosu::Bitmap& bitmap, Gosu::Writer writer,
         ok = stbi_write_png_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
                                     4, bitmap.data(), 0);
     }
-    
+
     if (ok == 0) {
-        throw runtime_error("Could not save image data to memory (format hint = '" +
-                            format_hint + "'");
+        throw std::runtime_error("Could not save image data to memory (format hint = '" +
+                                 std::string{format_hint} + "'");
     }
 }