gosu 1.4.6 → 2.0.0.pre6

data/src/Font.cpp

@@ -1,74 +1,94 @@
 #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 "GraphicsImpl.hpp"
 #include "MarkupParser.hpp"
-#include <array>
-#include <map>
+#include <cmath> // for std::ceil
+#include <mutex>
 #include <stdexcept>
-#include <utf8proc.h>
-
-static const int FONT_RENDER_SCALE = 2;
+#include <unordered_map>
 
 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
-    // languages begin, which don't really work with Gosu yet.)
-    std::array<std::array<Image, 0x58f>, FF_COMBINATIONS> fast_glyphs;
-    // Everything else is looked up through a map...
-    std::array<std::map<utf8proc_int32_t, Image>, FF_COMBINATIONS> other_glyphs;
-
-    Image& image(char32_t codepoint, unsigned font_flags)
+    const int height;
+    const std::string name;
+    const unsigned base_flags;
+    const unsigned image_flags;
+
+    Impl(int height, std::string_view name, unsigned base_flags, unsigned image_flags)
+        : height(height),
+          name(name),
+          base_flags(base_flags),
+          image_flags(image_flags)
     {
-        Image* image;
-        if (codepoint < fast_glyphs[font_flags].size()) {
-            image = &fast_glyphs[font_flags][codepoint];
+    }
+
+    struct GlyphKey
+    {
+        char32_t codepoint;
+        unsigned font_flags;
+        bool operator==(const GlyphKey&) const = default;
+    };
+
+    struct GlyphKeyHasher
+    {
+        std::size_t operator()(const GlyphKey& key) const noexcept
+        {
+            // The highest legal Unicode code point is 0x10FFFF, which is a 21-bit value, so we do
+            // not have to worry about overwriting any of the higher bits.
+            // This only works if unordered_map uses prime table sizes (which it should):
+            // https://www.reddit.com/r/cpp_questions/comments/us3nyb/comment/i937ulb/
+            return key.codepoint | (key.font_flags << 24);
         }
-        else {
-            image = &other_glyphs[font_flags][codepoint];
+    };
+
+    // Font implements copying through its shared_ptr, not by making a true copy. However, Fonts are
+    // not immutable: Glyphs are created and cashed on demand, and set_image() enables modifications
+    // to the shared data of a font. Having multiple references to the same object, but not being
+    // able to use it from two threads, seems counterintuitive, so introduce a mutex here, even
+    // though most Gosu games/programs will never really require it.
+    // (Could be a shared_mutex, but doesn't seem to be worth the trouble.)
+    std::mutex glyphs_mutex;
+    std::unordered_map<GlyphKey, Image, GlyphKeyHasher> glyphs;
+
+    const Image& image(char32_t codepoint, unsigned font_flags)
+    {
+        const GlyphKey key { codepoint, font_flags };
+        if (const auto iterator = glyphs.find(key); iterator != glyphs.end()) {
+            return iterator->second;
         }
 
         // 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);
-            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);
-            }
+        // By default, render each glyph at 200% its size so that we have some wiggle room for
+        // changing the font size dynamically without it appearing too blurry.
+        auto scaled_height = height * 2;
+        // Optimization: Don't render higher-resolution versions if we use
+        // next neighbor interpolation anyway.
+        if (image_flags & IF_RETRO) {
+            scaled_height = height;
+        }
 
-            *image = Image(bitmap, 0, 0, required_width, scaled_height, image_flags);
+        std::u32string string(1, codepoint);
+        Bitmap bitmap(scaled_height, scaled_height);
+        const int required_width = static_cast<int>(std::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 resized_bitmap(required_width, scaled_height);
+            std::swap(resized_bitmap, bitmap);
+            Gosu::draw_text(bitmap, 0, 0, Color::WHITE, string, name, scaled_height, font_flags);
         }
+        const Rect source_rect { 0, 0, required_width, bitmap.height() };
 
-        return *image;
+        return glyphs[key] = Image(bitmap, source_rect, image_flags);
     }
 };
 
-Gosu::Font::Font(int font_height, const std::string& font_name, unsigned font_flags, unsigned image_flags)
-: m_impl{new Impl}
+Gosu::Font::Font(int font_height, std::string_view font_name, unsigned font_flags,
+                 unsigned image_flags)
+    : m_impl(new Impl(font_height, font_name, font_flags, image_flags))
 {
-    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
@@ -98,15 +118,17 @@ double Gosu::Font::text_width(const std::string& text) const
 
 double Gosu::Font::markup_width(const std::string& markup) const
 {
+    const std::unique_lock lock(m_impl->glyphs_mutex);
+
     double width = 0;
 
     // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
-    MarkupParser parser(m_impl->base_flags, false, [&](std::vector<FormattedString>&& line) {
+    MarkupParser parser(m_impl->base_flags, false, [&](const std::vector<FormattedString>& line) {
         double line_width = 0;
-        for (auto& part : line) {
-            for (auto codepoint : part.text) {
-                auto& image = m_impl->image(codepoint, part.flags);
-                double image_scale = 1.0 * height() / image.height();
+        for (const auto& part : line) {
+            for (const auto codepoint : part.text) {
+                const auto& image = m_impl->image(codepoint, part.flags);
+                double image_scale = image.height() ? 1.0 * height() / image.height() : 1.0;
                 line_width += image_scale * image.width();
             }
         }
@@ -126,15 +148,17 @@ void Gosu::Font::draw_text(const std::string& text, 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
 {
+    const std::unique_lock lock(m_impl->glyphs_mutex);
+
     double current_y = y;
 
     // Split the text into lines (split_words = false) because Font doesn't implement word-wrapping.
-    MarkupParser parser(m_impl->base_flags, false, [&](std::vector<FormattedString>&& line) {
+    MarkupParser parser(m_impl->base_flags, false, [&](const std::vector<FormattedString>& line) {
         double current_x = x;
-        for (auto& part : line) {
-            for (auto codepoint : part.text) {
-                auto& image = m_impl->image(codepoint, part.flags);
-                double image_scale = 1.0 * height() / image.height();
+        for (const auto& part : line) {
+            for (const auto codepoint : part.text) {
+                const auto& image = m_impl->image(codepoint, part.flags);
+                double image_scale = image.height() ? 1.0 * height() / image.height() : 1.0;
                 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();
@@ -145,12 +169,16 @@ void Gosu::Font::draw_markup(const std::string& markup, double x, double y, ZPos
     parser.parse(markup);
 }
 
-void Gosu::Font::draw_text_rel(const std::string& text, double x, double y, ZPos z,        //
+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;
+    if (rel_x != 0) {
+        x -= text_width(text) * scale_x * rel_x;
+    }
+    if (rel_y != 0) {
+        y -= height() * scale_y * rel_y;
+    }
 
     draw_text(text, x, y, z, scale_x, scale_y, c, mode);
 }
@@ -159,28 +187,30 @@ void Gosu::Font::draw_markup_rel(const std::string& markup, double x, double y,
                                  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;
+    if (rel_x != 0) {
+        x -= markup_width(markup) * scale_x * rel_x;
+    }
+    if (rel_y != 0) {
+        y -= height() * scale_y * rel_y;
+    }
 
     draw_markup(markup, x, y, z, scale_x, scale_y, c, mode);
 }
 
-void Gosu::Font::set_image(std::string codepoint, unsigned font_flags, const Gosu::Image& image)
+void Gosu::Font::set_image(std::string_view codepoint, unsigned font_flags,
+                           const Gosu::Image& image)
 {
-    auto utc4 = utf8_to_composed_utc4(codepoint);
+    const std::u32string utc4 = utf8_to_composed_utc4(codepoint);
     if (utc4.length() != 1) {
-        throw std::invalid_argument{"Could not compose '" + codepoint + "' into single codepoint"};
+        throw std::invalid_argument("Could not compose '" + std::string(codepoint)
+                                    + "' into single codepoint");
     }
 
-    if (utc4[0] < m_impl->fast_glyphs[font_flags].size()) {
-        m_impl->fast_glyphs[font_flags][utc4[0]] = image;
-    }
-    else {
-        m_impl->other_glyphs[font_flags][utc4[0]] = image;
-    }
+    const std::unique_lock lock(m_impl->glyphs_mutex);
+    m_impl->glyphs.insert_or_assign({ .codepoint = utc4[0], .font_flags = font_flags }, image);
 }
 
-void Gosu::Font::set_image(std::string codepoint, const Gosu::Image& image)
+void Gosu::Font::set_image(std::string_view codepoint, const Gosu::Image& image)
 {
     for (unsigned font_flags = 0; font_flags < FF_COMBINATIONS; ++font_flags) {
         set_image(codepoint, font_flags, image);

data/src/GosuGLView.cpp

@@ -1,25 +1,33 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_IPHONE)
 
-#import "GosuGLView.hpp"
 #import <Gosu/Input.hpp>
 #import <Gosu/TextInput.hpp>
-
+#import "GosuGLView.hpp"
+#import "GraphicsImpl.hpp"
+#import "OpenGLContext.hpp"
 #import <OpenGLES/EAGL.h>
 #import <OpenGLES/EAGLDrawable.h>
-#import <OpenGLES/ES1/gl.h>
-#import <OpenGLES/ES1/glext.h>
 #import <QuartzCore/QuartzCore.h>
 
-
 static EAGLContext __weak* globalContext;
 
 namespace Gosu
 {
-    void ensure_current_context()
+    OpenGLContext::OpenGLContext(bool)
     {
+        // Gosu does not support multithreading on iOS.
+        if (![NSThread isMainThread]) {
+            throw std::logic_error("Multi-threaded OpenGL access is not supported on iOS");
+        }
+
         [EAGLContext setCurrentContext:globalContext];
     }
+
+    OpenGLContext::~OpenGLContext()
+    {
+        // Don't bother unsetting anything.
+    }
     
     int clip_rect_base_factor()
     {

data/src/GosuViewController.cpp

@@ -10,14 +10,6 @@
 #import <AudioToolbox/AudioSession.h>
 #import <OpenAL/alc.h>
 
-namespace Gosu
-{
-    namespace FPS
-    {
-        void register_frame();
-    }
-}
-
 static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
 {
     if (inInterruptionState == kAudioSessionBeginInterruption) {
@@ -180,9 +172,9 @@ static void handle_audio_interruption(void* unused, UInt32 inInterruptionState)
     
     if (window.needs_redraw()) {
         [(GosuGLView*)self.view redrawGL:^{
-            window.graphics().frame([&window] {
+            window.viewport().frame([&window] {
                 window.draw();
-                Gosu::FPS::register_frame();
+                Gosu::register_frame();
             });
         }];
     }