gosu 1.4.1 → 1.4.3

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/Font.cpp

@@ -18,6 +18,7 @@ struct Gosu::Font::Impl : 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/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/RubyGosu.cxx

@@ -2806,6 +2806,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 +2832,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 +2845,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 +5262,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 ;
@@ -12486,7 +12459,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 >(3)));
   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 +12517,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);

data/src/TimingApple.cpp

@@ -2,12 +2,6 @@
 #if defined(GOSU_IS_MAC)
 
 #include <Gosu/Timing.hpp>
-#include <unistd.h>
-
-void Gosu::sleep(unsigned milliseconds)
-{
-    usleep(milliseconds * 1000);
-}
 
 // Thanks to this blog for the unconvoluted code example:
 // http://shiftedbits.org/2008/10/01/mach_absolute_time-on-the-iphone/
@@ -21,7 +15,7 @@ unsigned long Gosu::milliseconds()
         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

@@ -3,12 +3,6 @@
 
 #include <Gosu/Timing.hpp>
 #include <sys/time.h>
-#include <unistd.h>
-
-void Gosu::sleep(unsigned milliseconds)
-{
-    usleep(milliseconds * 1000);
-}
 
 unsigned long Gosu::milliseconds()
 {

data/src/TimingWin.cpp

@@ -2,14 +2,8 @@
 #if defined(GOSU_IS_WIN)
 
 #include <Gosu/Timing.hpp>
-#include <cstdlib>
 #include <windows.h>
 
-void Gosu::sleep(unsigned milliseconds)
-{
-    Sleep(milliseconds);
-}
-
 unsigned long Gosu::milliseconds()
 {
     static unsigned long start = [] {

data/src/Window.cpp

@@ -11,6 +11,7 @@
 #include <SDL.h>
 #include <algorithm>
 #include <stdexcept>
+#include <thread>
 
 namespace Gosu
 {
@@ -272,10 +273,10 @@ void Gosu::Window::show()
     try {
         while (tick()) {
             // Sleep to keep this loop from eating 100% CPU.
-            unsigned long tick_time = milliseconds() - time_before_tick;
-            double sleep_time = update_interval() - tick_time;
+            long tick_time = milliseconds() - time_before_tick;
+            long sleep_time = static_cast<long>(update_interval() - tick_time);
             if (sleep_time >= 1) {
-                sleep(static_cast<unsigned long>(sleep_time));
+                std::this_thread::sleep_for(std::chrono::milliseconds{sleep_time});
             }
 
             time_before_tick = milliseconds();

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosu
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.3
 platform: ruby
 authors:
 - Julian Raschke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-30 00:00:00.000000000 Z
+date: 2022-03-27 00:00:00.000000000 Z
 dependencies: []
 description: |2
       2D game development library.