gosu 1.4.1 → 1.4.4

data/src/DirectoriesApple.cpp

@@ -4,65 +4,66 @@
 #import <Gosu/Directories.hpp>
 #import <Foundation/Foundation.h>
 #import <unistd.h>
-using namespace std;
 
 void Gosu::use_resource_directory()
 {
     chdir(resource_prefix().c_str());
 }
 
-string Gosu::user_settings_prefix()
+const std::string& Gosu::user_settings_prefix()
 {
-    static string result = [] {
+    static const std::string user_settings_prefix = [] {
         @autoreleasepool {
             NSString* library =
-                NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES)[0];
+                    NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES)
+                            .firstObject;
             NSString* preferences = [library stringByAppendingPathComponent:@"Preferences"];
-            
-            return string(preferences.UTF8String ?: ".") + "/";
+
+            return std::string{preferences.UTF8String ?: "."} + "/";
         }
     }();
-    return result;
+    return user_settings_prefix;
 }
 
-string Gosu::user_documents_prefix()
+const std::string& Gosu::user_documents_prefix()
 {
-    static string result = [] {
+    static const std::string user_documents_prefix = [] {
         @autoreleasepool {
             NSString* documents =
-                NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0];
-            
-            return string(documents.UTF8String ?: ".") + "/";
+                    NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)
+                            .firstObject;
+
+            return std::string{documents.UTF8String ?: "."} + "/";
         }
     }();
-    return result;
+    return user_documents_prefix;
 }
 
-string Gosu::resource_prefix()
+const std::string& Gosu::resource_prefix()
 {
-    static string result = [] {
+    static const std::string resource_prefix = [] {
         @autoreleasepool {
             NSString* resources = [NSBundle mainBundle].resourcePath;
-            return string(resources.UTF8String ?: ".") + "/";
+            return std::string{resources.UTF8String ?: "."} + "/";
         }
     }();
-    return result;
+    return resource_prefix;
 }
 
-string Gosu::shared_resource_prefix()
+const std::string& Gosu::shared_resource_prefix()
 {
-    #ifdef GOSU_IS_IPHONE
+#ifdef GOSU_IS_IPHONE
     return resource_prefix();
-    #else
-    static string result = [] {
+#else
+    static const std::string shared_resource_prefix = [] {
         @autoreleasepool {
             NSString* bundle_path = [NSBundle mainBundle].bundlePath;
             NSString* containing_path = [bundle_path stringByDeletingLastPathComponent];
-            return string(containing_path.UTF8String ?: ".");
+            return std::string{containing_path.UTF8String ?: "."};
         }
     }();
-    return result;
-    #endif
+    return shared_resource_prefix;
+#endif
 }
 
 #endif

data/src/DirectoriesUnix.cpp

@@ -7,13 +7,11 @@
 #include <pwd.h>
 #include <sys/types.h>
 #include <unistd.h>
-using namespace std;
 
-static string home_dir()
+static std::string home_dir()
 {
     passwd* pwd = getpwuid(geteuid());
-    assert (pwd && pwd->pw_dir);
-    return pwd->pw_dir;
+    return pwd && pwd->pw_dir ? pwd->pw_dir : ".";
 }
 
 void Gosu::use_resource_directory()
@@ -21,24 +19,28 @@ void Gosu::use_resource_directory()
     // Do nothing, we expect the user to have the correct cwd on Linux.
 }
 
-string Gosu::resource_prefix()
+const std::string& Gosu::resource_prefix()
 {
-    return string();
+    static const std::string empty;
+    return empty;
 }
 
-string Gosu::shared_resource_prefix()
+const std::string& Gosu::shared_resource_prefix()
 {
-    return string();
+    static const std::string empty;
+    return empty;
 }
 
-string Gosu::user_settings_prefix()
+const std::string& Gosu::user_settings_prefix()
 {
-    return home_dir() + "/.";
+    static const std::string user_settings_prefix = home_dir() + "/.";
+    return user_settings_prefix;
 }
 
-string Gosu::user_documents_prefix()
+const std::string& Gosu::user_documents_prefix()
 {
-    return home_dir() + "/";
+    static const std::string user_documents_prefix = home_dir() + "/";
+    return user_documents_prefix;
 }
 
 #endif

data/src/DirectoriesWin.cpp

@@ -1,21 +1,19 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_WIN)
 
-#include "WinUtility.hpp"
 #include <Gosu/Directories.hpp>
 #include <Gosu/Utility.hpp>
+#include "WinUtility.hpp"
 #include <cwchar>
-#include <stdexcept>
 #include <shlobj.h>
-using namespace std;
+#include <stdexcept>
 
-static string special_folder_path(int csidl)
+static std::string special_folder_path(int csidl)
 {
     WCHAR buf[MAX_PATH + 2];
-    if (FAILED(SHGetFolderPathW(nullptr, csidl | CSIDL_FLAG_CREATE, nullptr, 0, buf))) {
-        throw runtime_error("Error getting special folder path");
-    }
-    size_t len = wcslen(buf);
+    if (FAILED(SHGetFolderPathW(nullptr, csidl | CSIDL_FLAG_CREATE, nullptr, 0, buf)))
+        throw std::runtime_error{"Error getting special folder path"};
+    size_t len = std::wcslen(buf);
     if (buf[len - 1] != L'\\') {
         buf[len] = L'\\';
         buf[len + 1] = 0;
@@ -23,16 +21,12 @@ static string special_folder_path(int csidl)
     return Gosu::utf16_to_utf8(buf);
 }
 
-static string exe_filename()
+std::string exe_filename()
 {
-    static string result;
-    if (result.empty()) {
-        WCHAR buffer[MAX_PATH * 2];
-        Gosu::winapi_check(GetModuleFileNameW(nullptr, buffer, MAX_PATH * 2),
-                           "getting the module filename");
-        result = Gosu::utf16_to_utf8(buffer);
-    }
-    return result;
+    WCHAR buffer[MAX_PATH * 2];
+    Gosu::winapi_check(GetModuleFileNameW(nullptr, buffer, MAX_PATH * 2),
+                       "getting the module filename");
+    return Gosu::utf16_to_utf8(buffer);
 }
 
 void Gosu::use_resource_directory()
@@ -40,30 +34,32 @@ void Gosu::use_resource_directory()
     SetCurrentDirectory(utf8_to_utf16(resource_prefix()).c_str());
 }
 
-string Gosu::resource_prefix()
+const std::string& Gosu::resource_prefix()
 {
-    static string result;
-    if (result.empty()) {
-        result = exe_filename();
-        auto last_delim = result.find_last_of("\\/");
-        result.resize(last_delim == string::npos ? 0 : last_delim + 1);
-    }
-    return result;
+    static const std::string resource_prefix = [] {
+        std::string result = exe_filename();
+        const auto last_delim = result.find_last_of("\\/");
+        result.resize(last_delim == std::string::npos ? 0 : last_delim + 1);
+        return result;
+    }();
+    return resource_prefix;
 }
 
-string Gosu::shared_resource_prefix()
+const std::string& Gosu::shared_resource_prefix()
 {
     return resource_prefix();
 }
 
-string Gosu::user_settings_prefix()
+const std::string& Gosu::user_settings_prefix()
 {
-    return special_folder_path(CSIDL_APPDATA);
+    static const std::string user_settings_prefix = special_folder_path(CSIDL_APPDATA);
+    return user_settings_prefix;
 }
 
-string Gosu::user_documents_prefix()
+const std::string& Gosu::user_documents_prefix()
 {
-    return special_folder_path(CSIDL_PERSONAL);
+    static const std::string user_documents_prefix = special_folder_path(CSIDL_PERSONAL);
+    return user_documents_prefix;
 }
 
 #endif

data/src/FileUnix.cpp

@@ -16,7 +16,7 @@
 
 using namespace std;
 
-struct Gosu::File::Impl : Gosu::Noncopyable
+struct Gosu::File::Impl : private 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 : Gosu::Noncopyable
+struct Gosu::File::Impl : private Gosu::Noncopyable
 {
     HANDLE handle = INVALID_HANDLE_VALUE;
 

data/src/Font.cpp

@@ -13,11 +13,12 @@
 
 static const int FONT_RENDER_SCALE = 2;
 
-struct Gosu::Font::Impl : Gosu::Noncopyable
+struct Gosu::Font::Impl : private Gosu::Noncopyable
 {
     std::string name;
     int height;
     unsigned base_flags;
+    unsigned image_flags;
 
     // The most common characters are stored directly in an array for maximum performance.
     // (This is the start of the Basic Multilingual Plane, up until the part where right-to-left
@@ -39,6 +40,9 @@ struct Gosu::Font::Impl : Gosu::Noncopyable
         // If this codepoint has not been rendered before, do it now.
         if (image->width() == 0 && image->height() == 0) {
             auto scaled_height = height * FONT_RENDER_SCALE;
+            // Optimization: Don't render higher-resolution versions if we use
+            // next neighbor interpolation anyway.
+            if (image_flags & IF_RETRO) scaled_height = height;
 
             std::u32string string(1, codepoint);
             Bitmap bitmap(scaled_height, scaled_height);
@@ -51,19 +55,20 @@ struct Gosu::Font::Impl : Gosu::Noncopyable
                                 font_flags);
             }
 
-            *image = Image(bitmap, 0, 0, required_width, scaled_height);
+            *image = Image(bitmap, 0, 0, required_width, scaled_height, image_flags);
         }
 
         return *image;
     }
 };
 
-Gosu::Font::Font(int font_height, const std::string& font_name, unsigned font_flags)
+Gosu::Font::Font(int font_height, const std::string& font_name, unsigned font_flags, unsigned image_flags)
 : m_impl{new Impl}
 {
     m_impl->name = font_name;
     m_impl->height = font_height;
     m_impl->base_flags = font_flags;
+    m_impl->image_flags = image_flags;
 }
 
 const std::string& Gosu::Font::name() const
@@ -81,6 +86,11 @@ unsigned Gosu::Font::flags() const
     return m_impl->base_flags;
 }
 
+unsigned Gosu::Font::image_flags() const
+{
+    return m_impl->image_flags;
+}
+
 double Gosu::Font::text_width(const std::string& text) const
 {
     return markup_width(escape_markup(text));

data/src/Graphics.cpp

@@ -42,7 +42,7 @@ namespace Gosu
     }
 }
 
-struct Gosu::Graphics::Impl : Gosu::Noncopyable
+struct Gosu::Graphics::Impl : private Gosu::Noncopyable
 {
     unsigned virt_width = 0, virt_height = 0;
     unsigned phys_width = 0, phys_height = 0;

data/src/Image.cpp

@@ -8,39 +8,34 @@
 #include <stdexcept>
 
 Gosu::Image::Image()
-: m_data(EmptyImageData::instance_ptr())
+: m_data{EmptyImageData::instance_ptr()}
 {
 }
 
 Gosu::Image::Image(const std::string& filename, unsigned image_flags)
+: Image(load_image_file(filename), image_flags)
 {
-    // Forward.
-    Bitmap bitmap = load_image_file(filename);
-    Image{bitmap, image_flags}.m_data.swap(m_data);
 }
 
 Gosu::Image::Image(const std::string& filename, int src_x, int src_y, int src_width, int src_height,
                    unsigned image_flags)
+: Image(load_image_file(filename), src_x, src_y, src_width, src_height, image_flags)
 {
-    // Forward.
-    Bitmap bitmap = load_image_file(filename);
-    Image{bitmap, src_x, src_y, src_width, src_height, image_flags}.m_data.swap(m_data);
 }
 
 Gosu::Image::Image(const Bitmap& source, unsigned image_flags)
+: Image(source, 0, 0, source.width(), source.height(), image_flags)
 {
-    // Forward.
-    Image{source, 0, 0, source.width(), source.height(), image_flags}.m_data.swap(m_data);
 }
 
 Gosu::Image::Image(const Bitmap& source, int src_x, int src_y, int src_width, int src_height,
                    unsigned image_flags)
-: m_data(Graphics::create_image(source, src_x, src_y, src_width, src_height, image_flags))
+: m_data{Graphics::create_image(source, src_x, src_y, src_width, src_height, image_flags)}
 {
 }
 
 Gosu::Image::Image(std::unique_ptr<ImageData>&& data)
-: m_data(data.release())
+: m_data{data.release()}
 {
     if (!m_data) throw std::invalid_argument("Gosu::Image cannot be initialized with nullptr");
 }
@@ -104,8 +99,8 @@ Gosu::ImageData& Gosu::Image::data() const
     return *m_data;
 }
 
-std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, int tile_width, int tile_height,
-                                          unsigned flags)
+std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, //
+                                          int tile_width, int tile_height, unsigned flags)
 {
     int tiles_x, tiles_y;
     std::vector<Image> images;
@@ -136,8 +131,8 @@ std::vector<Gosu::Image> Gosu::load_tiles(const Bitmap& bmp, int tile_width, int
     return images;
 }
 
-std::vector<Gosu::Image> Gosu::load_tiles(const std::string& filename, int tile_width,
-                                          int tile_height, unsigned flags)
+std::vector<Gosu::Image> Gosu::load_tiles(const std::string& filename, //
+                                          int tile_width, int tile_height, unsigned flags)
 {
     Bitmap bmp = load_image_file(filename);
     return load_tiles(bmp, tile_width, tile_height, flags);

data/src/Input.cpp

@@ -36,7 +36,7 @@ static vector<shared_ptr<SDL_GameController>> open_game_controllers;
 // Stores joystick instance id or -1 if empty
 static array<int, Gosu::NUM_GAMEPADS> gamepad_slots = {-1, -1, -1, -1};
 
-struct Gosu::Input::Impl : Gosu::Noncopyable
+struct Gosu::Input::Impl : private Gosu::Noncopyable
 {
     struct InputEvent
     {
@@ -678,4 +678,19 @@ void Gosu::Input::set_text_input(TextInput* text_input)
     pimpl->text_input = text_input;
 }
 
+std::string Gosu::Input::clipboard()
+{
+    require_sdl_video();
+
+    std::shared_ptr<char> clipboard{SDL_GetClipboardText(), SDL_free};
+    return std::string{clipboard.get()};
+}
+
+void Gosu::Input::set_clipboard(const std::string& text)
+{
+    require_sdl_video();
+
+    SDL_SetClipboardText(text.c_str());
+}
+
 #endif

data/src/InputUIKit.cpp

@@ -7,7 +7,7 @@
 #import <UIKit/UIKit.h>
 using namespace std;
 
-struct Gosu::Input::Impl : Gosu::Noncopyable
+struct Gosu::Input::Impl : private Gosu::Noncopyable
 {
     UIView* view = nil;
     TextInput* text_input = nullptr;

data/src/Macro.cpp

@@ -4,7 +4,7 @@
 #include "DrawOpQueue.hpp"
 #include <stdexcept>
 
-struct Gosu::Macro::Impl : Gosu::Noncopyable
+struct Gosu::Macro::Impl : private Gosu::Noncopyable
 {
     VertexArrays vertex_arrays;
     int width, height;

data/src/RubyGosu.cxx

@@ -2345,6 +2345,16 @@ namespace Gosu
     {
         return Gosu::Input::axis(btn);
     }
+
+    std::string clipboard()
+    {
+        return Gosu::Input::clipboard();
+    }
+
+    void set_clipboard(const std::string& text)
+    {
+        return Gosu::Input::set_clipboard(text);
+    }
 }
 
 // Global graphics functions
@@ -2806,6 +2816,7 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_0(Gosu::Window &window,std::string co
 SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
         std::string font_name = Gosu::default_font_name();
         unsigned font_flags = 0;
+        unsigned image_flags = 0;
         
         if (options) {
             Check_Type(options, T_HASH);
@@ -2831,6 +2842,9 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
                 else if (!strcmp(key_string, "underline")) {
                     if (RTEST(value)) font_flags |= Gosu::FF_UNDERLINE;
                 }
+                else if (!strcmp(key_string, "retro")) {
+                    if (RTEST(value)) image_flags |= Gosu::IF_RETRO;
+                }
                 else {
                     static bool issued_warning = false;
                     if (!issued_warning) {
@@ -2841,7 +2855,7 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
             }
         }
         
-        return new Gosu::Font(height, font_name, font_flags);
+        return new Gosu::Font(height, font_name, font_flags, image_flags);
     }
 SWIGINTERN double Gosu_Font_text_width(Gosu::Font *self,std::string const &markup,double scale_x=1.0){
       static bool issued_warning = false;
@@ -5258,37 +5272,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_Font_flags(int argc, VALUE *argv, VALUE self) {
-  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  unsigned int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","flags", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
-  {
-    try {
-      result = (unsigned int)((Gosu::Font const *)arg1)->flags();
-    }
-    catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 SWIGINTERN VALUE
 _wrap_Font_draw_text(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
@@ -10945,6 +10928,64 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_clipboard(int argc, VALUE *argv, VALUE self) {
+  std::string result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    try {
+      result = Gosu::clipboard();
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_std_string(static_cast< std::string >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_clipboarde___(int argc, VALUE *argv, VALUE self) {
+  std::string *arg1 = 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","Gosu::set_clipboard", 1, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Gosu::set_clipboard", 1, argv[0])); 
+    }
+    arg1 = ptr;
+  }
+  {
+    try {
+      Gosu::set_clipboard((std::string const &)*arg1);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return Qnil;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_draw_line(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
@@ -12486,7 +12527,7 @@ SWIGEXPORT void Init_gosu(void) {
   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 >(4)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(1)));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(4)));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);
   rb_define_module_function(mGosu, "degrees_to_radians", VALUEFUNC(_wrap_degrees_to_radians), -1);
@@ -12544,7 +12585,6 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassFont.klass, "initialize", VALUEFUNC(_wrap_new_Font), -1);
   rb_define_method(SwigClassFont.klass, "name", VALUEFUNC(_wrap_Font_name), -1);
   rb_define_method(SwigClassFont.klass, "height", VALUEFUNC(_wrap_Font_height), -1);
-  rb_define_method(SwigClassFont.klass, "flags", VALUEFUNC(_wrap_Font_flags), -1);
   rb_define_method(SwigClassFont.klass, "draw_text", VALUEFUNC(_wrap_Font_draw_text), -1);
   rb_define_method(SwigClassFont.klass, "draw_markup", VALUEFUNC(_wrap_Font_draw_markup), -1);
   rb_define_method(SwigClassFont.klass, "draw_text_rel", VALUEFUNC(_wrap_Font_draw_text_rel), -1);
@@ -12988,6 +13028,8 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_module_function(mGosu, "button_name", VALUEFUNC(_wrap_button_name), -1);
   rb_define_module_function(mGosu, "gamepad_name", VALUEFUNC(_wrap_gamepad_name), -1);
   rb_define_module_function(mGosu, "axis", VALUEFUNC(_wrap_axis), -1);
+  rb_define_module_function(mGosu, "clipboard", VALUEFUNC(_wrap_clipboard), -1);
+  rb_define_module_function(mGosu, "clipboard=", VALUEFUNC(_wrap_clipboarde___), -1);
   rb_define_module_function(mGosu, "draw_line", VALUEFUNC(_wrap_draw_line), -1);
   rb_define_module_function(mGosu, "draw_triangle", VALUEFUNC(_wrap_draw_triangle), -1);
   rb_define_module_function(mGosu, "draw_quad", VALUEFUNC(_wrap_draw_quad), -1);

data/src/TextInput.cpp

@@ -7,7 +7,7 @@
 #include <SDL.h>
 #endif
 
-struct Gosu::TextInput::Impl : Gosu::Noncopyable
+struct Gosu::TextInput::Impl : private Gosu::Noncopyable
 {
     std::string text;
 

data/src/TimingApple.cpp

@@ -17,11 +17,11 @@ void Gosu::sleep(unsigned milliseconds)
 unsigned long Gosu::milliseconds()
 {
     static mach_timebase_info_data_t info;
-    static uint64_t first_tick = [] {
+    static const uint64_t first_tick = [] {
         mach_timebase_info(&info);
         return mach_absolute_time();
     }();
-    
+
     uint64_t runtime = mach_absolute_time() - first_tick;
     return runtime * info.numer / info.denom / 1000000;
 }

data/src/TimingUnix.cpp

@@ -12,16 +12,12 @@ void Gosu::sleep(unsigned milliseconds)
 
 unsigned long Gosu::milliseconds()
 {
-    static unsigned long start = 0;
-
     timeval tp;
     gettimeofday(&tp, nullptr);
+    unsigned long ms = tp.tv_usec / 1000UL + tp.tv_sec * 1000UL;
 
-    if (start == 0) {
-        start = tp.tv_usec / 1000UL + tp.tv_sec * 1000UL;
-    }
-
-    return tp.tv_usec / 1000UL + tp.tv_sec * 1000UL - start;
+    static unsigned long start = ms;
+    return ms - start;
 }
 
 #endif

data/src/TimingWin.cpp

@@ -2,7 +2,6 @@
 #if defined(GOSU_IS_WIN)
 
 #include <Gosu/Timing.hpp>
-#include <cstdlib>
 #include <windows.h>
 
 void Gosu::sleep(unsigned milliseconds)
@@ -12,7 +11,7 @@ void Gosu::sleep(unsigned milliseconds)
 
 unsigned long Gosu::milliseconds()
 {
-    static unsigned long start = [] {
+    static const unsigned long start = [] {
         timeBeginPeriod(1);
         return timeGetTime();
     }();