gosu 1.4.6 → 2.0.0.pre6

data/src/Buffer.cpp

@@ -0,0 +1,159 @@
+#include <Gosu/Buffer.hpp>
+#include <Gosu/Platform.hpp>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+
+#ifdef GOSU_IS_IPHONE
+#include <filesystem>
+#include <fstream>
+#else
+#include <SDL.h>
+#endif
+
+Gosu::Buffer::Buffer(void* buffer, std::size_t size, std::function<void(void*)> deleter)
+    : m_buffer(buffer),
+      m_size(size),
+      m_deleter(std::move(deleter))
+{
+    if (buffer == nullptr && size > 0) {
+        throw std::invalid_argument("Tried to create non-empty Gosu::Buffer from nullptr");
+    }
+    if (size >= std::numeric_limits<std::ptrdiff_t>::max()) {
+        throw std::length_error("Tried to create Gosu::Buffer with a negative size");
+    }
+}
+
+Gosu::Buffer::Buffer(Gosu::Buffer&& other) noexcept
+    : m_buffer(nullptr),
+      m_size(0),
+      m_deleter(nullptr)
+{
+    *this = std::move(other);
+}
+
+Gosu::Buffer& Gosu::Buffer::operator=(Gosu::Buffer&& other) noexcept
+{
+    if (this == &other) {
+        return *this;
+    }
+
+    if (m_buffer && m_deleter) {
+        m_deleter(m_buffer);
+    }
+
+    m_buffer = other.m_buffer;
+    m_size = other.m_size;
+    // In theory, this could throw. In that case, we are fine with a full crash of the current
+    // process (as this function is marked noexcept) because throwing deleters are a user error.
+    m_deleter = std::move(other.m_deleter);
+
+    other.m_buffer = nullptr;
+    other.m_size = 0;
+    other.m_deleter = nullptr;
+
+    return *this;
+}
+
+Gosu::Buffer::~Buffer()
+{
+    if (m_buffer && m_deleter) {
+        m_deleter(m_buffer);
+    }
+}
+
+Gosu::Buffer::Buffer(std::size_t size)
+    : m_buffer(nullptr),
+      m_size(size),
+      m_deleter([](void* p) {  delete[] static_cast<std::uint8_t*>(p); })
+{
+    if (size >= std::numeric_limits<std::ptrdiff_t>::max()) {
+        throw std::length_error("Tried to create Gosu::Buffer with a negative size");
+    }
+
+    if (m_size) {
+        m_buffer = new std::uint8_t[m_size];
+    }
+}
+
+Gosu::Buffer::Buffer(std::vector<std::uint8_t>&& vector) noexcept
+    : m_buffer(vector.data()),
+      m_size(vector.size()),
+      // Absorb the vector into this Gosu::Buffer by moving it into the deleter lambda.
+      // This is safe because the vector move constructor guarantees that pointers remain stable.
+      m_deleter([vector = std::move(vector)](void*) mutable { vector.clear(); })
+{
+}
+
+Gosu::Buffer::Buffer(const Gosu::Buffer& other)
+    : Buffer(std::vector<std::uint8_t>(other.data(), other.data() + other.size()))
+{
+}
+
+Gosu::Buffer& Gosu::Buffer::operator=(const Gosu::Buffer& other)
+{
+    if (this == &other) {
+        return *this;
+    }
+
+    // Delegate to copy constructor + move assignment operator.
+    return *this = Buffer(other);
+}
+
+#ifdef GOSU_IS_IPHONE
+Gosu::Buffer Gosu::load_file(const std::string& filename)
+{
+    Buffer buffer(std::filesystem::file_size(filename));
+    char* ptr = reinterpret_cast<char*>(buffer.data());
+    std::ifstream file(filename, std::ios::binary);
+    // GCOV_EXCL_START: It is hard to set up a file where file_size works but reading doesn't.
+    if (!file || !file.read(ptr, static_cast<std::streamoff>(buffer.size()))) {
+        throw std::runtime_error("Could not read file '" + filename + "'");
+    }
+    // GCOV_EXCL_END
+    return buffer;
+}
+
+void Gosu::save_file(const Buffer& buffer, const std::string& filename)
+{
+    std::ofstream file(filename, std::ios::binary | std::ios::trunc);
+    const char* ptr = reinterpret_cast<const char*>(buffer.data());
+    if (!file || !file.write(ptr, static_cast<std::streamoff>(buffer.size()))) {
+        throw std::runtime_error("Could not write file '" + filename + "'");
+    }
+}
+#else
+Gosu::Buffer Gosu::load_file(const std::string& filename)
+{
+    std::size_t size = 0;
+    void* contents = SDL_LoadFile(filename.c_str(), &size);
+    if (contents == nullptr) {
+        throw std::runtime_error("Could not read '" + filename + "', error: " + SDL_GetError());
+    }
+    return Buffer(contents, size, &SDL_free);
+}
+
+void Gosu::save_file(const Buffer& buffer, const std::string& filename)
+{
+    struct RWopsDeleter
+    {
+        void operator()(SDL_RWops* p) const
+        {
+            // SDL_RWclose will crash if given nullptr.
+            if (p) {
+                SDL_RWclose(p);
+            }
+        }
+    };
+    std::unique_ptr<SDL_RWops, RWopsDeleter> rwops(SDL_RWFromFile(filename.c_str(), "w"));
+    if (rwops == nullptr) {
+        throw std::runtime_error("Could not open '" + filename + "', error: " + SDL_GetError());
+    }
+    std::size_t written = SDL_RWwrite(rwops.get(), buffer.data(), buffer.size(), 1);
+    // GCOV_EXCL_START: It is hard to set up a file where opening works but writing doesn't.
+    if (written == 0) {
+        throw std::runtime_error("Could not write to '" + filename + "', error: " + SDL_GetError());
+    }
+    // GCOV_EXCL_END
+}
+#endif

data/src/Color.cpp

@@ -1,56 +1,8 @@
 #include <Gosu/Color.hpp>
 #include <Gosu/Math.hpp>
-#include <algorithm>
+#include <algorithm> // for std::min, std::max
 #include <cmath>
-
-namespace
-{
-    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 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};
-            return hsv;
-        }
-
-        HSV hsv{};
-
-        // Value.
-        hsv.v = max;
-
-        // Saturation.
-        hsv.s = delta / max;
-
-        // Hue.
-        if (delta == 0) {
-            hsv.h = 0;
-        }
-        else if (r == max) {
-            hsv.h = (g - b) / delta + (g < b ? 6 : 0);
-        }
-        else if (g == max) {
-            hsv.h = (b - r) / delta + 2;
-        }
-        else {
-            hsv.h = (r - g) / delta + 4;
-        }
-        hsv.h *= 60;
-
-        return hsv;
-    }
-}
+#include <iomanip> // for std::setw
 
 Gosu::Color Gosu::Color::from_hsv(double h, double s, double v)
 {
@@ -60,32 +12,51 @@ Gosu::Color Gosu::Color::from_hsv(double h, double s, double v)
     s = std::clamp(s, 0.0, 1.0);
     v = std::clamp(v, 0.0, 1.0);
 
+    const auto to_channel = [](double d) { return static_cast<Channel>(std::round(255.0 * d)); };
+
     int sector = static_cast<int>(h / 60);
-    double factorial = h / 60 - sector;
+    double remainder = h / 60 - sector;
 
-    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)));
+    Channel p = to_channel(v * (1 - s));
+    Channel q = to_channel(v * (1 - s * remainder));
+    Channel t = to_channel(v * (1 - s * (1 - remainder)));
 
     switch (sector) {
     case 0:
-        return Color{static_cast<Channel>(255 * v), t, p};
+        return Color { to_channel(v), t, p };
     case 1:
-        return Color{q, static_cast<Channel>(255 * v), p};
+        return Color { q, to_channel(v), p };
     case 2:
-        return Color{p, static_cast<Channel>(255 * v), t};
+        return Color { p, to_channel(v), t };
     case 3:
-        return Color{p, q, static_cast<Channel>(255 * v)};
+        return Color { p, q, to_channel(v) };
     case 4:
-        return Color{t, p, static_cast<Channel>(255 * v)};
+        return Color { t, p, to_channel(v) };
     default: // sector 5
-        return Color{static_cast<Channel>(255 * v), p, q};
+        return Color { to_channel(v), p, q };
     }
 }
 
 double Gosu::Color::hue() const
 {
-    return color_to_hsv(*this).h;
+    double max = std::max({ red, green, blue });
+    double min = std::min({ red, green, blue });
+
+    if (min == max) {
+        return 0;
+    }
+
+    double factor = 60 / (max - min);
+
+    if (green == max) {
+        return (blue - red) * factor + 120; // 60...180
+    } else if (blue == max) {
+        return (red - green) * factor + 240; // 180...300
+    } else if (blue > green) {
+        return (green - blue) * factor + 360; // 300...360
+    } else {
+        return (green - blue) * factor + 0; // 0...60
+    }
 }
 
 void Gosu::Color::set_hue(double h)
@@ -95,7 +66,15 @@ void Gosu::Color::set_hue(double h)
 
 double Gosu::Color::saturation() const
 {
-    return color_to_hsv(*this).s;
+    double max = std::max({ red, green, blue });
+
+    if (max == 0) {
+        return 0;
+    }
+
+    double min = std::min({ red, green, blue });
+
+    return 1 - (min / max);
 }
 
 void Gosu::Color::set_saturation(double s)
@@ -105,7 +84,7 @@ void Gosu::Color::set_saturation(double s)
 
 double Gosu::Color::value() const
 {
-    return color_to_hsv(*this).v;
+    return std::max({ red, green, blue }) / 255.0;
 }
 
 void Gosu::Color::set_value(double v)
@@ -113,10 +92,23 @@ void Gosu::Color::set_value(double v)
     *this = from_hsv(hue(), saturation(), v).with_alpha(alpha);
 }
 
+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 };
+
 Gosu::Color Gosu::lerp(Color a, Color b, double t)
 {
     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));
+        return static_cast<Color::Channel>(std::clamp(std::round(std::lerp(a, b, t)), 0.0, 255.0));
     };
 
     Color result;
@@ -129,23 +121,26 @@ Gosu::Color Gosu::lerp(Color a, Color b, double t)
 
 Gosu::Color Gosu::multiply(Color a, Color b)
 {
+    const auto multiply_channel = [](Color::Channel a, Color::Channel b) {
+        return static_cast<Color::Channel>(std::round(a * b / 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));
+    result.red = multiply_channel(a.red, b.red);
+    result.green = multiply_channel(a.green, b.green);
+    result.blue = multiply_channel(a.blue, b.blue);
+    result.alpha = multiply_channel(a.alpha, b.alpha);
     return result;
 }
 
-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};
+std::ostream& Gosu::operator<<(std::ostream& stream, Gosu::Color color)
+{
+    const auto previous_flags = stream.flags();
+    const char previous_fill = stream.fill();
+    stream << std::setfill('0');
+    stream << "0x" << std::hex << std::setw(2) << static_cast<int>(color.alpha);
+    stream << '\'' << std::setw(6) << static_cast<int>(color.argb() & 0x00'ffffff);
+    stream.flags(previous_flags);
+    stream.fill(previous_fill);
+    return stream;
+}

data/src/Directories.cpp

@@ -0,0 +1,47 @@
+#include <Gosu/Directories.hpp>
+#include <Gosu/Platform.hpp>
+
+#ifdef GOSU_IS_WIN
+#include <Gosu/Utility.hpp>
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+void Gosu::use_resource_directory()
+{
+#ifdef GOSU_IS_WIN
+    SetCurrentDirectoryW(utf8_to_utf16(resource_path()).c_str());
+#else
+    chdir(resource_path().c_str());
+#endif
+}
+
+#ifndef GOSU_IS_IPHONE
+#include <SDL.h>
+#include <memory>
+#include <stdexcept>
+#endif
+
+#ifndef GOSU_IS_IPHONE
+std::string Gosu::resource_path(const std::string& relative_filename)
+{
+    static const char* resource_prefix = SDL_GetBasePath(); // never freed, doesn't matter
+    return relative_filename.empty() ? resource_prefix : resource_prefix + relative_filename;
+}
+
+std::string Gosu::user_settings_path(const std::string& organization,
+                                     const std::string& application,
+                                     const std::string& relative_filename)
+{
+    char* settings_prefix = SDL_GetPrefPath(organization.c_str(), application.c_str());
+    // GCOV_EXCL_START: Hard to simulate errors here because even creating "/:\\/:\\" works (macOS).
+    if (!settings_prefix) {
+        throw std::runtime_error("Could not create settings directory: "
+                                 + std::string(SDL_GetError()));
+    }
+    // GCOV_EXCL_END
+    const std::unique_ptr<char, decltype(&SDL_free)> guard(settings_prefix, &SDL_free);
+    return relative_filename.empty() ? settings_prefix : settings_prefix + relative_filename;
+}
+#endif

data/src/DirectoriesUIKit.cpp

@@ -0,0 +1,50 @@
+#include <Gosu/Directories.hpp>
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_IPHONE)
+
+#import <Foundation/Foundation.h>
+#include <filesystem>
+
+std::string Gosu::resource_path(const std::string& relative_filename)
+{
+    static const std::string resource_prefix = [] {
+        @autoreleasepool {
+            NSString* resources = [NSBundle mainBundle].resourcePath;
+            return std::string(resources.UTF8String ?: ".");
+        }
+    }();
+
+    return relative_filename.empty() ? resource_prefix : resource_prefix + "/" + relative_filename;
+}
+
+std::string Gosu::user_settings_path(const std::string& organization,
+                                     const std::string& application,
+                                     const std::string& relative_filename)
+{
+    static const std::string user_settings_prefix = [] {
+        @autoreleasepool {
+            NSString* library
+                = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES)
+                      .firstObject;
+            NSString* preferences = [library stringByAppendingPathComponent:@"Application Support"];
+            return std::string(preferences.UTF8String ?: ".");
+        }
+    }();
+
+    std::string directory = user_settings_prefix;
+    if (!organization.empty()) {
+        directory += '/';
+        directory += organization;
+    }
+    if (!application.empty()) {
+        directory += '/';
+        directory += application;
+    }
+    if (!std::filesystem::is_directory(directory)) {
+        std::filesystem::create_directories(directory);
+    }
+
+    return relative_filename.empty() ? directory : directory + '/' + relative_filename;
+}
+
+#endif

data/src/DrawOp.hpp

@@ -17,7 +17,9 @@ namespace Gosu
         RenderState render_state;
         // Only valid if render_state.tex_name != NO_TEXTURE
         GLfloat top, left, bottom, right;
-        
+        // Used to keep TexChunk rectangles on shared textures alive until the end of the frame.
+        std::shared_ptr<const Rect> rect_handle;
+
         // TODO: Merge with Gosu::ArrayVertex.
         struct Vertex
         {
@@ -30,7 +32,7 @@ namespace Gosu
         
         // Number of vertices used, or: complement index of code block
         int vertices_or_block_index;
-        
+
         void perform(const DrawOp* next) const
         {
             // This should not be called on GL code ops.
@@ -141,8 +143,11 @@ namespace Gosu
                 result[i].vertices[1] = vertices[i].y;
                 result[i].vertices[2] = 0;
                 result[i].color       = vertices[i].c.abgr();
-                apply_transform(*render_state.transform,
-                                result[i].vertices[0], result[i].vertices[1]);
+                double x = result[i].vertices[0];
+                double y = result[i].vertices[1];
+                render_state.transform->apply(x, y);
+                result[i].vertices[0] = static_cast<float>(x);
+                result[i].vertices[1] = static_cast<float>(y);
             }
             RenderState va_render_state = render_state;
             va_render_state.transform   = 0;

data/src/DrawOpQueue.hpp

@@ -77,8 +77,8 @@ public:
         double left = x, right = x + width;
         double top = y, bottom = y + height;
 
-        apply_transform(transform_stack.current(), left, top);
-        apply_transform(transform_stack.current(), right, bottom);
+        transform_stack.current().apply(left, top);
+        transform_stack.current().apply(right, bottom);
 
         double phys_x      = std::min(left, right);
         double phys_y      = std::min(top, bottom);

data/src/Drawable.cpp

@@ -0,0 +1,95 @@
+#include <Gosu/Drawable.hpp>
+#include <Gosu/Utility.hpp>
+#include "EmptyDrawable.hpp"
+#include "Texture.hpp"
+#include "TiledDrawable.hpp"
+#include <list>
+#include <mutex>
+
+namespace Gosu
+{
+    // This variable has been declared in multiple places. Define it here, where it will be used.
+    // This is a compatibility hack for old versions of Ruby/Gosu that didn't yet support :retro.
+    bool undocumented_retrofication = false; // NOLINT(*-avoid-non-const-global-variables)
+}
+
+std::unique_ptr<Gosu::Drawable> Gosu::create_drawable(const Bitmap& source, const Rect& source_rect,
+                                                      unsigned image_flags)
+{
+    if (!Rect::covering(source).contains(source_rect)) {
+        throw std::invalid_argument("Source rectangle exceeds bitmap");
+    }
+
+    if (source_rect.empty()) {
+        // It can happen that Gosu::Font wants us to create an empty drawable when rendering
+        // invisible characters (e.g. '\r'). In this case, return an empty drawable that is not
+        // backed by any kind of OpenGL texture.
+        return std::make_unique<EmptyDrawable>(source_rect.width, source_rect.height);
+    }
+
+    // Backward compatibility: This used to be 'bool tileable', help users that still pass 'true'.
+    if (image_flags == 1) {
+        image_flags = IF_TILEABLE;
+    }
+
+    bool wants_retro = (image_flags & IF_RETRO) || undocumented_retrofication;
+
+    // Special case: If the texture is supposed to be tileable, is quadratic, has a size that is at
+    // least 64 pixels but no more than MAX_TEXTURE_SIZE pixels and a power of two, create a single
+    // texture just for this image.
+    // This is not just an optimization, but a feature of Gosu so that one can use Gosu for loading
+    // textures for use in 3D scenes, where it is important that the full u/v range is dedicated to
+    // a single image so that texture repetition works as expected.
+    if ((image_flags & IF_TILEABLE) == IF_TILEABLE && source_rect.width == source_rect.height
+        && (source_rect.width & (source_rect.width - 1)) == 0 && source_rect.width >= 64
+        && source_rect.width <= MAX_TEXTURE_SIZE) {
+
+        const std::shared_ptr<Texture> texture
+            = std::make_shared<Texture>(source_rect.width, source_rect.height, wants_retro);
+
+        // Use the source bitmap directly if the source area completely covers it.
+        if (source_rect == Rect::covering(source)) {
+            return texture->try_alloc(source, 0);
+        }
+        else {
+            Bitmap trimmed_source(source_rect.width, source_rect.height);
+            trimmed_source.insert(source, 0, 0, source_rect);
+            return texture->try_alloc(trimmed_source, 0);
+        }
+    }
+
+    const int max_size = MAX_TEXTURE_SIZE;
+
+    // Too large to fit on a single texture? -> Create a tiled representation.
+    if (source_rect.width > max_size - 2 || source_rect.height > max_size - 2) {
+        return std::make_unique<TiledDrawable>(source, source_rect, max_size - 2, image_flags);
+    }
+
+    Bitmap source_with_borders = apply_border_flags(image_flags, source, source_rect);
+
+    // Try to put the bitmap into one of the already allocated textures.
+    static std::list<std::weak_ptr<Texture>> texture_pool;
+    static std::mutex mutex;
+    std::scoped_lock lock(mutex);
+
+    texture_pool.remove_if([](const auto& weak_ptr) { return weak_ptr.expired(); });
+
+    for (const std::weak_ptr<Texture>& weak_texture : texture_pool) {
+        const auto texture = weak_texture.lock();
+        if (!texture || texture->retro() != wants_retro) {
+            continue;
+        }
+
+        std::unique_ptr<Drawable> data = texture->try_alloc(source_with_borders, 1);
+        if (data) {
+            return data;
+        }
+    }
+
+    // All textures are full: Create a new one.
+
+    std::shared_ptr<Texture> texture
+        = std::make_shared<Texture>(MAX_TEXTURE_SIZE, MAX_TEXTURE_SIZE, wants_retro);
+    texture_pool.push_back(texture);
+    return texture->try_alloc(source_with_borders, 1);
+}

data/src/EmptyDrawable.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Drawable.hpp>
+#include <memory>
+
+namespace Gosu
+{
+    class EmptyDrawable : public Drawable
+    {
+        int m_width, m_height;
+
+    public:
+        EmptyDrawable(int width, int height)
+            : m_width(width),
+              m_height(height)
+        {
+        }
+
+        int width() const override { return m_width; }
+
+        int height() const override { return m_height; }
+
+        void draw(double, double, Color, double, double, Color, //
+                  double, double, Color, double, double, Color, //
+                  ZPos, BlendMode) const override
+        {
+        }
+
+        GLTexInfo* gl_tex_info() const override { return nullptr; }
+
+        Bitmap to_bitmap() const override { return Bitmap(m_width, m_height); }
+
+        std::unique_ptr<Drawable> subimage(const Rect&) const override { return nullptr; }
+
+        void insert(const Bitmap&, int, int) override { }
+    };
+}

data/src/FPS.cpp

@@ -0,0 +1,31 @@
+#include <Gosu/Timing.hpp>
+#include "GraphicsImpl.hpp"
+
+namespace Gosu
+{
+    namespace
+    {
+        int current_fps = 0;
+    }
+
+    void register_frame()
+    {
+        static unsigned long current_second = Gosu::milliseconds() / 1000;
+        static int frames_in_current_second = 0;
+
+        unsigned long new_sec = Gosu::milliseconds() / 1000;
+        if (current_second != new_sec) {
+            current_second = new_sec;
+            current_fps = frames_in_current_second;
+            frames_in_current_second = 0;
+        }
+        else {
+            ++frames_in_current_second;
+        }
+    }
+
+    int fps()
+    {
+        return current_fps;
+    }
+}