gosu 1.3.0 → 1.4.3

data/src/Color.cpp

@@ -1,35 +1,38 @@
 #include <Gosu/Color.hpp>
 #include <Gosu/Math.hpp>
-#include <cmath>
 #include <algorithm>
+#include <cmath>
 
 namespace
 {
-    struct HSV { double h, s, v; };
-    
+    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 };
+            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;
@@ -44,7 +47,7 @@ namespace
             hsv.h = (r - g) / delta + 4;
         }
         hsv.h *= 60;
-        
+
         return hsv;
     }
 }

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/EmptyImageData.hpp

@@ -8,43 +8,41 @@ namespace Gosu
     class EmptyImageData : public ImageData
     {
     public:
-        int width() const override
+        int width() const override //
         {
             return 0;
         }
-        
-        int height() const override
+
+        int height() const override //
         {
             return 0;
         }
-        
-        void draw(double, double, Color,
-                  double, double, Color,
-                  double, double, Color,
-                  double, double, Color,
+
+        void draw(double, double, Color, double, double, Color, //
+                  double, double, Color, double, double, Color, //
                   ZPos, BlendMode) const override
         {
         }
-        
-        GLTexInfo* gl_tex_info() const override
+
+        GLTexInfo* gl_tex_info() const override //
         {
             return nullptr;
         }
-        
-        Bitmap to_bitmap() const override
+
+        Bitmap to_bitmap() const override //
         {
             return Bitmap();
         }
-        
-        virtual std::unique_ptr<ImageData> subimage(int, int, int, int) const override
+
+        std::unique_ptr<ImageData> subimage(int, int, int, int) const override //
         {
             return nullptr;
         }
-        
-        virtual void insert(const Bitmap&, int x, int y) override
+
+        void insert(const Bitmap&, int x, int y) override //
         {
         }
-        
+
         static const std::shared_ptr<EmptyImageData>& instance_ptr()
         {
             static std::shared_ptr<EmptyImageData> instance = std::make_shared<EmptyImageData>();

data/src/FileUnix.cpp

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

data/src/Font.cpp

@@ -1,35 +1,32 @@
-#include "MarkupParser.hpp"
-#include "GraphicsImpl.hpp"
 #include <Gosu/Font.hpp>
 #include <Gosu/Graphics.hpp>
 #include <Gosu/Image.hpp>
 #include <Gosu/Math.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
-
-#include <utf8proc.h>
-
+#include "GraphicsImpl.hpp"
+#include "MarkupParser.hpp"
 #include <array>
-#include <cassert>
 #include <map>
 #include <stdexcept>
-using namespace std;
+#include <utf8proc.h>
 
 static const int FONT_RENDER_SCALE = 2;
 
-struct Gosu::Font::Impl
+struct Gosu::Font::Impl : Gosu::Noncopyable
 {
-    string name;
+    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
     // languages begin, which don't really work with Gosu yet.)
-    array<array<Image, 0x58f>, FF_COMBINATIONS> fast_glyphs;
+    std::array<std::array<Image, 0x58f>, FF_COMBINATIONS> fast_glyphs;
     // Everything else is looked up through a map...
-    array<map<utf8proc_int32_t, Image>, FF_COMBINATIONS> other_glyphs;
-    
+    std::array<std::map<utf8proc_int32_t, Image>, FF_COMBINATIONS> other_glyphs;
+
     Image& image(char32_t codepoint, unsigned font_flags)
     {
         Image* image;
@@ -39,98 +36,106 @@ struct Gosu::Font::Impl
         else {
             image = &other_glyphs[font_flags][codepoint];
         }
-        
+
         // 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;
-            
-            u32string string(1, codepoint);
+            // 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);
-            auto required_width = ceil(Gosu::draw_text(bitmap, 0, 0, Color::WHITE, string,
-                                                       name, scaled_height, font_flags));
+            auto required_width = ceil(Gosu::draw_text(bitmap, 0, 0, Color::WHITE, string, name,
+                                                       scaled_height, font_flags));
             if (required_width > bitmap.width()) {
                 // If the character was wider than high, we need to render it again.
                 Bitmap(required_width, scaled_height).swap(bitmap);
-                Gosu::draw_text(bitmap, 0, 0, Color::WHITE, string,
-                                name, scaled_height, font_flags);
+                Gosu::draw_text(bitmap, 0, 0, Color::WHITE, string, name, scaled_height,
+                                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 string& font_name, unsigned font_flags)
-: pimpl(new Impl)
+Gosu::Font::Font(int font_height, const std::string& font_name, unsigned font_flags, unsigned image_flags)
+: m_impl{new Impl}
 {
-    pimpl->name = font_name;
-    pimpl->height = font_height;
-    pimpl->base_flags = font_flags;
+    m_impl->name = font_name;
+    m_impl->height = font_height;
+    m_impl->base_flags = font_flags;
+    m_impl->image_flags = image_flags;
 }
 
-const string& Gosu::Font::name() const
+const std::string& Gosu::Font::name() const
 {
-    return pimpl->name;
+    return m_impl->name;
 }
 
 int Gosu::Font::height() const
 {
-    return pimpl->height;
+    return m_impl->height;
 }
 
 unsigned Gosu::Font::flags() const
 {
-    return pimpl->base_flags;
+    return m_impl->base_flags;
+}
+
+unsigned Gosu::Font::image_flags() const
+{
+    return m_impl->image_flags;
 }
 
-double Gosu::Font::text_width(const string& text) const
+double Gosu::Font::text_width(const std::string& text) const
 {
     return markup_width(escape_markup(text));
 }
 
-double Gosu::Font::markup_width(const string& markup) const
+double Gosu::Font::markup_width(const std::string& markup) const
 {
     double width = 0;
 
     // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
-    MarkupParser parser(pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
+    MarkupParser parser(m_impl->base_flags, false, [&](std::vector<FormattedString>&& line) {
         double line_width = 0;
         for (auto& part : line) {
             for (auto codepoint : part.text) {
-                auto& image = pimpl->image(codepoint, part.flags);
+                auto& image = m_impl->image(codepoint, part.flags);
                 double image_scale = 1.0 * height() / image.height();
                 line_width += image_scale * image.width();
             }
         }
-        width = max(width, line_width);
+        width = std::max(width, line_width);
     });
     parser.parse(markup);
-    
+
     return width;
 }
 
-void Gosu::Font::draw_text(const string& text, double x, double y, ZPos z,
+void Gosu::Font::draw_text(const std::string& text, double x, double y, ZPos z, //
                            double scale_x, double scale_y, Color c, BlendMode mode) const
 {
     draw_markup(escape_markup(text), x, y, z, scale_x, scale_y, c, mode);
 }
 
-void Gosu::Font::draw_markup(const string& markup, double x, double y, ZPos z,
+void Gosu::Font::draw_markup(const std::string& markup, double x, double y, ZPos z, //
                              double scale_x, double scale_y, Color c, BlendMode mode) const
 {
     double current_y = y;
-    
+
     // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
-    MarkupParser parser(pimpl->base_flags, false, [&](vector<FormattedString>&& line) {
+    MarkupParser parser(m_impl->base_flags, false, [&](std::vector<FormattedString>&& line) {
         double current_x = x;
         for (auto& part : line) {
             for (auto codepoint : part.text) {
-                auto& image = pimpl->image(codepoint, part.flags);
+                auto& image = m_impl->image(codepoint, part.flags);
                 double image_scale = 1.0 * height() / image.height();
-                image.draw(current_x, current_y, z,
-                           image_scale * scale_x, image_scale * scale_y,
+                image.draw(current_x, current_y, z, image_scale * scale_x, image_scale * scale_y,
                            multiply(c, part.color), mode);
                 current_x += image_scale * scale_x * image.width();
             }
@@ -140,23 +145,23 @@ void Gosu::Font::draw_markup(const string& markup, double x, double y, ZPos z,
     parser.parse(markup);
 }
 
-void Gosu::Font::draw_text_rel(const string& text, double x, double y, ZPos z,
-                               double rel_x, double rel_y, double scale_x, double scale_y,
+void Gosu::Font::draw_text_rel(const std::string& text, double x, double y, ZPos z,        //
+                               double rel_x, double rel_y, double scale_x, double scale_y, //
                                Color c, BlendMode mode) const
 {
     if (rel_x) x -= text_width(text) * scale_x * rel_x;
     if (rel_y) y -= height() * scale_y * rel_y;
-    
+
     draw_text(text, x, y, z, scale_x, scale_y, c, mode);
 }
 
-void Gosu::Font::draw_markup_rel(const string& markup, double x, double y, ZPos z,
+void Gosu::Font::draw_markup_rel(const std::string& markup, double x, double y, ZPos z, //
                                  double rel_x, double rel_y, double scale_x, double scale_y,
                                  Color c, BlendMode mode) const
 {
     if (rel_x) x -= markup_width(markup) * scale_x * rel_x;
     if (rel_y) y -= height() * scale_y * rel_y;
-    
+
     draw_markup(markup, x, y, z, scale_x, scale_y, c, mode);
 }
 
@@ -164,14 +169,14 @@ void Gosu::Font::set_image(std::string codepoint, unsigned font_flags, const Gos
 {
     auto utc4 = utf8_to_composed_utc4(codepoint);
     if (utc4.length() != 1) {
-        throw invalid_argument("Could not compose '" + codepoint + "' into a single codepoint");
+        throw std::invalid_argument{"Could not compose '" + codepoint + "' into single codepoint"};
     }
-    
-    if (utc4[0] < pimpl->fast_glyphs[font_flags].size()) {
-        pimpl->fast_glyphs[font_flags][utc4[0]] = image;
+
+    if (utc4[0] < m_impl->fast_glyphs[font_flags].size()) {
+        m_impl->fast_glyphs[font_flags][utc4[0]] = image;
     }
     else {
-        pimpl->other_glyphs[font_flags][utc4[0]] = image;
+        m_impl->other_glyphs[font_flags][utc4[0]] = image;
     }
 }