gosu 1.4.6 → 2.0.0.pre6

data/src/BinPacker.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <Gosu/Platform.hpp>
+#include <Gosu/Utility.hpp>
+#include <mutex>
+#include <memory>
+#include <vector>
+
+namespace Gosu
+{
+    /// This implements an allocator for 2D rects in a given "bin", which is typically an OpenGL
+    /// texture. It uses the GUILLOTINE-LAS-RM-BSSF algorithm because it has the best worst-case
+    /// performance in the PDF paper found here: https://github.com/juj/RectangleBinPack
+    /// (The extra complexity of the MAXRECTS algorithm did not seem to be worth it, and the Skyline
+    /// algorithm does not seem well-suited for scenarios where images are occasionally deleted.)
+    ///
+    /// Note: This class cannot use stb_rect_pack.h because that uses an "offline" algorithm,
+    /// i.e. it requires all boxes to be allocated at the same time, which is not how Gosu games are
+    /// usually structured.
+    ///
+    /// (This class is non-copyable because alloc returns shared_ptrs that reference this object.
+    /// Moving a BinPacker instance would lead to dangling pointers.)
+    class BinPacker : private Noncopyable
+    {
+        const int m_width, m_height;
+        std::vector<Rect> m_free_rects;
+        std::mutex m_mutex;
+
+    public:
+        BinPacker(int width, int height);
+
+        int width() const { return m_width; }
+        int height() const { return m_height; }
+
+        /// Finds a free rectangle in the bin and marks it as used, or returns nullptr.
+        /// The returned shared_ptr will automatically mark the rectangle as freed through its
+        /// deleter. The shared_ptr must not outlive the BinPacker.
+        std::shared_ptr<const Rect> alloc(int width, int height);
+        /// Marks a previously allocated rectangle as free again. This must be called with one of
+        /// the rectangles previously returned by alloc().
+        void add_free_rect(const Rect& rect);
+
+    private:
+        /// Finds the best free rectangle using the "Best Short Side Fit" ("BSSF") metric, if any.
+        const Rect* best_free_rect(int width, int height) const;
+
+        /// Removes m_free_rects[index]. If a pointer to another index is given, it will be adjusted
+        /// to the new index of the previously pointed-to rectangle (if it has moved).
+        void remove_free_rect(int index, int* other_index = nullptr);
+
+        /// Performs the "Rectangle Merge Improvement" (-RM) by repeatedly merging adjacent free
+        /// rects into m_free_rects[index] if they can be replaced by a single, larger rectangle.
+        void merge_neighbors(int index);
+    };
+}

data/src/Bitmap.cpp

@@ -1,200 +1,222 @@
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/GraphicsBase.hpp>
+#include <algorithm> // for std::equal, std::fill_n
+#include <cstring> // for std::memcpy
+#include <limits>
 #include <stdexcept> // for std::invalid_argument
-#include <utility>   // for std::swap
+#include <utility> // for std::move, std::swap
 
-Gosu::Bitmap::Bitmap(int width, int height, Gosu::Color c)
+Gosu::Bitmap::Bitmap(int width, int height, Color c)
+    : m_width(width),
+      m_height(height)
 {
-    resize(width, height, c);
+    if (width < 0 || height < 0) {
+        throw std::invalid_argument("Negative Gosu::Bitmap size");
+    }
+
+    // Don't allow bitmaps where there are more than INT_MAX pixels.
+    if (height != 0 && width > std::numeric_limits<int>::max() / height) {
+        throw std::invalid_argument("Gosu::Bitmap size out of bounds");
+    }
+
+    const int size = width * height;
+    m_pixels = Buffer(size * sizeof(Color));
+    std::fill_n(data(), size, c);
 }
 
-void Gosu::Bitmap::swap(Bitmap& other)
+Gosu::Bitmap::Bitmap(int width, int height, Gosu::Buffer&& buffer)
+    : m_width(width),
+      m_height(height),
+      m_pixels(std::move(buffer))
 {
-    std::swap(m_pixels, other.m_pixels);
-    std::swap(m_width, other.m_width);
-    std::swap(m_height, other.m_height);
+    int pixels = width * height;
+    if (static_cast<std::size_t>(pixels) * sizeof(Color) != m_pixels.size()) {
+        throw std::length_error("Gosu::Bitmap given Gosu::Buffer of wrong size, expected "
+                                + std::to_string(pixels * sizeof(Color)) + ", given "
+                                + std::to_string(m_pixels.size()));
+    }
 }
 
 void Gosu::Bitmap::resize(int width, int height, Color c)
 {
-    if (width < 0 || height < 0) throw std::invalid_argument{"negative bitmap size"};
-
-    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);
+    if (width != m_width || height != m_height) {
+        Bitmap temp(width, height, c);
+        temp.insert(*this, 0, 0);
+        std::swap(*this, temp);
+    }
 }
 
 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) {
-        set_pixel(x, y, c);
+    Color& out = pixel(x, y);
+    if (out.alpha == 0 || c.alpha == 255) {
+        out = c;
         return;
     }
 
     int inv_alpha = out.alpha * (255 - c.alpha) / 255;
 
     out.alpha = (c.alpha + inv_alpha);
-    out.red =   ((c.red   * c.alpha + out.red   * inv_alpha) / out.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);
+    out.blue = ((c.blue * c.alpha + out.blue * inv_alpha) / out.alpha);
 }
 
-void Gosu::Bitmap::insert(int x, int y, const Bitmap& source)
+void Gosu::Bitmap::insert(const Bitmap& source, int x, int y)
 {
-    insert(x, y, source, 0, 0, source.width(), source.height());
+    insert(source, x, y, Rect::covering(source));
 }
 
-void Gosu::Bitmap::insert(int x, int y, const Bitmap& source,
-                          int src_x, int src_y, int src_width, int src_height)
+void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, Rect source_rect)
 {
-    // TODO: This should use memcpy if possible (x == 0 && src_width == this->width())
-
-    if (x < 0) {
-        int clip_left = -x;
-
-        if (clip_left >= src_width) return;
-
-        src_x += clip_left;
-        src_width -= clip_left;
-        x = 0;
+    if (&source == this) {
+        throw std::invalid_argument("Gosu::Bitmap::insert cannot copy parts of itself");
     }
 
-    if (y < 0) {
-        int clip_top = -y;
-
-        if (clip_top >= src_height) return;
+    // Make sure that the source area does not exceed the source image.
+    // If we need to move the source_rect origin, then also move the target rectangle origin.
+    source_rect.clip_to(Rect::covering(source), &x, &y);
 
-        src_y += clip_top;
-        src_height -= clip_top;
-        y = 0;
-    }
-
-    if (x + src_width > m_width) {
-        if (x >= m_width) return;
+    // Set up the target area and make sure that it does not exceed this image.
+    Rect target_rect { .x = x, .y = y, .width = source_rect.width, .height = source_rect.height };
+    // If we need to move the target_rect origin, then also move the source_rect origin.
+    target_rect.clip_to(Rect::covering(*this), &source_rect.x, &source_rect.y);
 
-        src_width = m_width - x;
-    }
+    // These are the first source and first destination pixels/rows.
+    Color* target_ptr = &pixel(target_rect.x, target_rect.y);
+    const Color* source_ptr = &source.pixel(source_rect.x, source_rect.y);
 
-    if (y + src_height > m_height) {
-        if (y >= m_height) return;
+    // target_rect might be smaller than source_rect now, so use its width/height for copying.
 
-        src_height = m_height - y;
+    if (width() == source.width() && width() == target_rect.width) {
+        // If both images have the same width, and we want to copy full lines, then we can use a
+        // single memcpy for the whole operation. This is especially likely if we vertically resize
+        // a bitmap.
+        const int size = target_rect.width * target_rect.height;
+        std::memcpy(target_ptr, source_ptr, static_cast<std::size_t>(size) * sizeof(Color));
     }
-
-    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));
+    else {
+        // Otherwise, we need to copy line by line.
+        for (int row = 0; row < target_rect.height; ++row) {
+            std::memcpy(target_ptr, source_ptr, target_rect.width * sizeof(Color));
+            target_ptr += width();
+            source_ptr += source.width();
         }
     }
 }
 
-void Gosu::apply_color_key(Bitmap& bitmap, Color key)
+bool Gosu::Bitmap::operator==(const Gosu::Bitmap& other) const
 {
-    for (int y = 0; y < bitmap.height(); ++y) {
-        for (int x = 0; x < bitmap.width(); ++x) {
-            if (bitmap.get_pixel(x, y) == key) {
-                // 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.red = red / neighbors;
-                    replacement.green = green / neighbors;
-                    replacement.blue = blue / neighbors;
-                }
-                bitmap.set_pixel(x, y, replacement);
-            }
-        }
-    }
+    int pixels = width() * height();
+    return pixels == other.width() * other.height()
+        && std::equal(data(), data() + pixels, other.data());
 }
 
-Gosu::Bitmap Gosu::apply_border_flags(unsigned image_flags, const Bitmap& source,
-                                      int src_x, int src_y, int src_width, int src_height)
+void Gosu::Bitmap::apply_color_key(Color key)
 {
-    // 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.
-
-    // Backward compatibility: This used to be 'bool tileable'.
-    if (image_flags == 1) image_flags = IF_TILEABLE;
+    // The valid memory range from which the loop below can read.
+    const int pixels = width() * height();
+    Color* begin = data();
+    Color* end = begin + pixels;
+
+    for (Color* c = begin; c != end;) {
+        for (int x = 0; x < width(); ++x, ++c) {
+            // All colors except the color key should stay as they are.
+            if (*c != key) {
+                continue;
+            }
 
-    Gosu::Bitmap dest{src_width + 2, src_height + 2};
+            unsigned neighbors = 0, red = 0, green = 0, blue = 0;
 
-    // The borders are made "harder" by duplicating the original bitmap's
-    // borders.
+            const auto visit = [&](const Color* neighbor) {
+                if (neighbor >= begin && neighbor < end && *neighbor != key && neighbor->alpha) {
+                    // Ignore other pixels that are or were equal to the color key.
+                    neighbors += 1;
+                    red += neighbor->red;
+                    green += neighbor->green;
+                    blue += neighbor->blue;
+                }
+            };
+            // Don't look at (x-1) pixels in the first column because we might accidentally use
+            // the pixels of the last column through wraparound.
+            if (x != 0) {
+                visit(c - width() - 1);
+                visit(c - 1);
+                visit(c + width() - 1);
+            }
+            visit(c - width());
+            visit(c + width());
+            // Don't look at (x+1) pixels in the last column because we might accidentally use
+            // the pixels of the first column through wraparound.
+            if (x != width() - 1) {
+                visit(c - width() + 1);
+                visit(c + 1);
+                visit(c + width() + 1);
+            }
 
-    // Top.
-    if (image_flags & IF_TILEABLE_TOP) {
-        dest.insert(1, 0,
-                    source, src_x, src_y, src_width, 1);
-    }
-    // Bottom.
-    if (image_flags & IF_TILEABLE_BOTTOM) {
-        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(0, 1,
-                    source, src_x, src_y, 1, src_height);
-    }
-    // Right.
-    if (image_flags & IF_TILEABLE_RIGHT) {
-        dest.insert(dest.width() - 1, 1,
-                    source, src_x + src_width - 1, src_y, 1, src_height);
+            *c = Color::NONE;
+            if (neighbors > 0) {
+                c->red = red / neighbors;
+                c->green = green / neighbors;
+                c->blue = blue / neighbors;
+            }
+        }
     }
+}
 
-    // Top left.
-    if ((image_flags & IF_TILEABLE_TOP) && (image_flags & IF_TILEABLE_LEFT)) {
-        dest.set_pixel(0, 0,
-                       source.get_pixel(src_x, src_y));
+Gosu::Bitmap Gosu::apply_border_flags(unsigned image_flags, const Bitmap& source, Rect source_rect)
+{
+    // Add one extra pixel around all four sides of the image.
+    Gosu::Bitmap result(source_rect.width + 2, source_rect.height + 2);
+    result.insert(source, 1, 1, source_rect);
+
+    // Now duplicate the edges of the image on all four sides.
+    const Rect top { source_rect.x, source_rect.y, source_rect.width, 1 };
+    result.insert(source, 1, 0, top);
+    const Rect bottom { source_rect.x, source_rect.bottom() - 1, source_rect.width, 1 };
+    result.insert(source, 1, result.height() - 1, bottom);
+    const Rect left { source_rect.x, source_rect.y, 1, source_rect.height };
+    result.insert(source, 0, 1, left);
+    const Rect right { source_rect.right() - 1, source_rect.y, 1, source_rect.height };
+    result.insert(source, result.width() - 1, 1, right);
+    // Also duplicate the corners of each size.
+    const Rect top_left { source_rect.x, source_rect.y, 1, 1 };
+    result.insert(source, 0, 0, top_left);
+    const Rect top_right { source_rect.right() - 1, source_rect.y, 1, 1 };
+    result.insert(source, result.width() - 1, 0, top_right);
+    const Rect bottom_left { source_rect.x, source_rect.bottom() - 1, 1, 1 };
+    result.insert(source, 0, result.height() - 1, bottom_left);
+    const Rect bottom_right { source_rect.right() - 1, source_rect.bottom() - 1, 1, 1 };
+    result.insert(source, result.width() - 1, result.height() - 1, bottom_right);
+
+    // On edges which are supposed to have tileable borders, we are now finished.
+    // Where soft borders are desired, we need to make all pixels on a side fully transparent.
+    if ((image_flags & IF_TILEABLE_TOP) == 0) {
+        for (int x = 0; x < result.width(); ++x) {
+            result.pixel(x, 0).alpha = 0;
+        }
     }
-    // Top right.
-    if ((image_flags & IF_TILEABLE_TOP) && (image_flags & IF_TILEABLE_RIGHT)) {
-        dest.set_pixel(dest.width() - 1, 0,
-                       source.get_pixel(src_x + src_width - 1, src_y));
+    if ((image_flags & IF_TILEABLE_BOTTOM) == 0) {
+        const int y = result.height() - 1;
+        for (int x = 0; x < result.width(); ++x) {
+            result.pixel(x, y).alpha = 0;
+        }
     }
-    // Bottom left.
-    if ((image_flags & IF_TILEABLE_BOTTOM) && (image_flags & IF_TILEABLE_LEFT)) {
-        dest.set_pixel(0, dest.height() - 1,
-                       source.get_pixel(src_x, src_y + src_height - 1));
+    if ((image_flags & IF_TILEABLE_LEFT) == 0) {
+        for (int y = 0; y < result.height(); ++y) {
+            result.pixel(0, y).alpha = 0;
+        }
     }
-    // Bottom right.
-    if ((image_flags & IF_TILEABLE_BOTTOM) && (image_flags & IF_TILEABLE_RIGHT)) {
-        dest.set_pixel(dest.width() - 1, dest.height() - 1,
-                       source.get_pixel(src_x + src_width - 1, src_y + src_height - 1));
+    if ((image_flags & IF_TILEABLE_RIGHT) == 0) {
+        const int x = result.width() - 1;
+        for (int y = 0; y < result.height(); ++y) {
+            result.pixel(x, y).alpha = 0;
+        }
     }
 
-    // Now put the final image into the prepared borders.
-    dest.insert(1, 1,
-                source, src_x, src_y, src_width, src_height);
-    return dest;
+    return result;
 }

data/src/BitmapIO.cpp

@@ -1,94 +1,63 @@
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Utility.hpp>
-#include <cstring>   // for std::memcpy, std::size_t
 #include <stdexcept> // for std::runtime_error
 
 #define STB_IMAGE_IMPLEMENTATION
 #define STBI_NO_STDIO
-#define STBI_NO_LINEAR
+#define STBI_NO_LINEAR // we don't really care about this, but it avoids warnings
 
 #include <stb_image.h>
 
-static int read_callback(void* user, char* data, int size)
+namespace
 {
-    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);
-}
-
-static void skip_callback(void* user, int n)
-{
-    Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
-    reader->set_position(reader->position() + n);
-}
-
-static int eof_callback(void* user)
-{
-    Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
-    return reader->position() == reader->resource().size();
-}
-
-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';
-}
-
-/// Returns a copy of the given Gosu::Image with the alpha channel removed.
-/// Every pixel with alpha==0 will be replaced by Gosu::Color::FUCHSIA.
-static std::vector<Gosu::Color::Channel> bitmap_to_rgb(const Gosu::Bitmap& bmp)
-{
-    std::vector<Gosu::Color::Channel> rgb(static_cast<std::size_t>(bmp.width() * bmp.height() * 3));
-    for (std::size_t offset = 0; offset < rgb.size(); offset += 3) {
-        const Gosu::Color& color = bmp.data()[offset / 3];
-        if (color.alpha == 0) {
-            rgb[offset + 0] = 0xff;
-            rgb[offset + 1] = 0x00;
-            rgb[offset + 2] = 0xff;
-        } else {
-            rgb[offset + 0] = color.red;
-            rgb[offset + 1] = color.green;
-            rgb[offset + 2] = color.blue;
+    constexpr int JPEG_QUALITY = 80;
+
+    /// Returns a copy of the given Gosu::Image with the alpha channel removed.
+    /// Every pixel with alpha==0 will be replaced by Gosu::Color::FUCHSIA.
+    std::vector<Gosu::Color::Channel> remove_alpha_channel(const Gosu::Bitmap& bmp)
+    {
+        std::vector<Gosu::Color::Channel> rgb(
+            static_cast<std::size_t>(bmp.width() * bmp.height() * 3));
+        for (std::size_t offset = 0; offset < rgb.size(); offset += 3) {
+            const Gosu::Color& color = bmp.data()[offset / 3];
+            if (color.alpha == 0) {
+                rgb[offset + 0] = 0xff;
+                rgb[offset + 1] = 0x00;
+                rgb[offset + 2] = 0xff;
+            }
+            else {
+                rgb[offset + 0] = color.red;
+                rgb[offset + 1] = color.green;
+                rgb[offset + 2] = color.blue;
+            }
         }
+        return rgb;
     }
-    return rgb;
 }
 
 Gosu::Bitmap Gosu::load_image_file(const std::string& filename)
 {
-    Buffer buffer;
-    load_file(buffer, filename);
-    return load_image_file(buffer.front_reader());
+    return load_image(load_file(filename));
 }
 
-Gosu::Bitmap Gosu::load_image_file(Reader input)
+Gosu::Bitmap Gosu::load_image(const Buffer& buffer)
 {
-    bool needs_color_key = is_bmp(input);
-
-    stbi_io_callbacks callbacks{};
-    callbacks.read = read_callback;
-    callbacks.skip = skip_callback;
-    callbacks.eof = eof_callback;
     int x = 0, y = 0, n = 0;
-
-    stbi_uc* bytes = stbi_load_from_callbacks(&callbacks, &input, &x, &y, &n, STBI_rgb_alpha);
+    stbi_uc* bytes = stbi_load_from_memory(buffer.data(), static_cast<int>(buffer.size()), &x, &y,
+                                           &n, STBI_rgb_alpha);
     if (bytes == nullptr) {
-        throw std::runtime_error{"Cannot load image: " + std::string(stbi_failure_reason())};
+        throw std::runtime_error("Cannot load image: " + std::string(stbi_failure_reason()));
     }
 
-    Gosu::Bitmap bitmap{x, y};
-    std::memcpy(bitmap.data(), bytes, x * y * sizeof(Gosu::Color));
-
-    stbi_image_free(bytes);
+    int pixels = x * y;
+    Buffer pixel_buffer(bytes, static_cast<std::size_t>(pixels) * sizeof(Color), &stbi_image_free);
+    Gosu::Bitmap bitmap(x, y, std::move(pixel_buffer));
 
-    if (needs_color_key) {
-        apply_color_key(bitmap, Gosu::Color::FUCHSIA);
+    // If we just read a BMP file, we want to apply a color key.
+    if (buffer.size() > 2 && buffer.data()[0] == 'B' && buffer.data()[1] == 'M') {
+        bitmap.apply_color_key(Gosu::Color::FUCHSIA);
     }
+
     return bitmap;
 }
 
@@ -101,10 +70,11 @@ void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filena
 
     if (has_extension(filename, "bmp")) {
         ok = stbi_write_bmp(filename.c_str(), bitmap.width(), bitmap.height(), 3,
-                            bitmap_to_rgb(bitmap).data());
+                            remove_alpha_channel(bitmap).data());
     }
-    else if (has_extension(filename, "tga")) {
-        ok = stbi_write_tga(filename.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data());
+    else if (has_extension(filename, "jpg") || has_extension(filename, "jpeg")) {
+        ok = stbi_write_jpg(filename.c_str(), bitmap.width(), bitmap.height(), 3,
+                            remove_alpha_channel(bitmap).data(), JPEG_QUALITY);
     }
     else {
         ok = stbi_write_png(filename.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data(), 0);
@@ -115,32 +85,36 @@ void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filena
     }
 }
 
-static void stbi_write_to_writer(void* context, void* data, int size)
-{
-    static_cast<Gosu::Writer*>(context)->write(data, size);
-}
-
-void Gosu::save_image_file(const Gosu::Bitmap& bitmap, Gosu::Writer writer,
-                           const std::string_view& format_hint)
+Gosu::Buffer Gosu::save_image(const Gosu::Bitmap& bitmap, std::string_view format_hint)
 {
+    const auto stbi_write_to_vector = [](void* context, void* data, int size) {
+        auto* vec = static_cast<std::vector<std::uint8_t>*>(context);
+        const auto* begin = static_cast<const std::uint8_t*>(data);
+        const auto* end = begin + size;
+        vec->insert(vec->end(), begin, end);
+    };
+
+    std::vector<std::uint8_t> vector;
     int ok;
 
-    if (has_extension(format_hint, "bmp")) {
-        ok = stbi_write_bmp_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
-                                    3, bitmap_to_rgb(bitmap).data());
+    if (format_hint == "bmp" || has_extension(format_hint, "bmp")) {
+        ok = stbi_write_bmp_to_func(stbi_write_to_vector, &vector, bitmap.width(), bitmap.height(),
+                                    3, remove_alpha_channel(bitmap).data());
     }
-    else if (has_extension(format_hint, "tga")) {
-        stbi_write_tga_with_rle = 0;
-        ok = stbi_write_tga_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
-                                    4, bitmap.data());
+    else if (format_hint == "jpg" || format_hint == "jpeg" || has_extension(format_hint, "jpg")
+             || has_extension(format_hint, "jpeg")) {
+        ok = stbi_write_jpg_to_func(stbi_write_to_vector, &vector, bitmap.width(), bitmap.height(),
+                                    3, remove_alpha_channel(bitmap).data(), JPEG_QUALITY);
     }
     else {
-        ok = stbi_write_png_to_func(stbi_write_to_writer, &writer, bitmap.width(), bitmap.height(),
+        ok = stbi_write_png_to_func(stbi_write_to_vector, &vector, bitmap.width(), bitmap.height(),
                                     4, bitmap.data(), 0);
     }
 
     if (ok == 0) {
-        throw std::runtime_error("Could not save image data to memory (format hint = '" +
-                                 std::string{format_hint} + "'");
+        throw std::runtime_error("Could not save image data to memory (format hint = '"
+                                 + std::string(format_hint) + "'");
     }
+
+    return Buffer(std::move(vector));
 }