gosu 1.4.6 → 2.0.0.pre7

data/src/DrawOpQueue.hpp

@@ -9,6 +9,7 @@
 #include <cmath>
 #include <functional>
 #include <map>
+#include <utility>
 #include <vector>
 
 class Gosu::DrawOpQueue
@@ -22,7 +23,7 @@ class Gosu::DrawOpQueue
     std::vector<std::function<void ()>> gl_blocks;
 
 public:
-    DrawOpQueue(QueueMode mode)
+    explicit DrawOpQueue(QueueMode mode)
     : queue_mode(mode)
     {
     }
@@ -34,39 +35,31 @@ public:
     
     void schedule_draw_op(DrawOp op)
     {
-        if (clip_rect_stack.clipped_world_away()) return;
-
-    #ifdef GOSU_IS_OPENGLES
+#ifdef GOSU_IS_OPENGLES
         // No triangles, no lines supported
-        assert (op.vertices_or_block_index == 4);
-    #endif
+        assert(op.vertices_or_block_index == 4);
+#endif
 
         op.render_state.transform = &transform_stack.current();
-        if (const ClipRect* cr = clip_rect_stack.maybe_effective_rect()) {
-            op.render_state.clip_rect = *cr;
-        }
+        op.render_state.clip_rect = clip_rect_stack.effective_rect();
         ops.push_back(op);
     }
 
     void gl(std::function<void ()> gl_block, ZPos z)
     {
-        // TODO: Document this case: Clipped-away GL blocks are *not* being run.
-        if (clip_rect_stack.clipped_world_away()) return;
-
         int complement_of_block_index = ~(int)gl_blocks.size();
-        gl_blocks.push_back(gl_block);
+        gl_blocks.push_back(std::move(gl_block));
 
         DrawOp op;
         op.vertices_or_block_index = complement_of_block_index;
         op.render_state.transform = &transform_stack.current();
-        if (const ClipRect* cr = clip_rect_stack.maybe_effective_rect()) {
-            op.render_state.clip_rect = *cr;
-        }
+        op.render_state.clip_rect = clip_rect_stack.effective_rect();
         op.z = z;
         ops.push_back(op);
     }
 
-    void begin_clipping(double x, double y, double width, double height, double screen_height)
+    void begin_clipping(double x, double y, double width, double height,
+                        std::optional<int> viewport_height)
     {
         if (mode() == QM_RECORD_MACRO) {
             throw std::logic_error("Clipping is not allowed while creating a macro");
@@ -77,24 +70,24 @@ 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);
-
-        double phys_x      = std::min(left, right);
-        double phys_y      = std::min(top, bottom);
-        double phys_width  = std::abs(left - right);
-        double phys_height = std::abs(top - bottom);
+        transform_stack.current().apply(left, top);
+        transform_stack.current().apply(right, bottom);
 
+        Rect clip_rect {
+            .x = static_cast<int>(std::min(left, right)),
+            .y = static_cast<int>(std::min(top, bottom)),
+            .width = static_cast<int>(std::abs(left - right)),
+            .height = static_cast<int>(std::abs(top - bottom)),
+        };
         // Adjust for OpenGL having the wrong idea of where y=0 is.
-        phys_y = screen_height - phys_y - phys_height;
+        if (viewport_height && mode() == QM_RENDER_TO_SCREEN) {
+            clip_rect.y = *viewport_height - clip_rect.y - clip_rect.height;
+        }
 
-        clip_rect_stack.begin_clipping(phys_x, phys_y, phys_width, phys_height);
+        clip_rect_stack.push(clip_rect);
     }
 
-    void end_clipping()
-    {
-        clip_rect_stack.end_clipping();
-    }
+    void end_clipping() { clip_rect_stack.pop(); }
 
     void set_base_transform(const Transform& base_transform)
     {
@@ -118,7 +111,8 @@ public:
         }
         
         // Apply Z-Ordering.
-        std::stable_sort(ops.begin(), ops.end());
+        std::stable_sort(ops.begin(), ops.end(),
+                         [](const DrawOp& lhs, const DrawOp& rhs) { return lhs.z < rhs.z; });
 
         RenderStateManager manager;
         
@@ -156,7 +150,7 @@ public:
             throw std::logic_error("Custom OpenGL code cannot be recorded as a macro");
         }
 
-        std::stable_sort(ops.begin(), ops.end());
+        std::stable_sort(ops.begin(), ops.end(), [](const DrawOp& lhs, const DrawOp& rhs) { return lhs.z < rhs.z; });
         for (const auto& op : ops) {
             op.compile_to(vas);
         }

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;
+    }
+}

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,30 +1,32 @@
 #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];
     }
-    
-    int clip_rect_base_factor()
+
+    OpenGLContext::~OpenGLContext()
     {
-        static int result = [UIScreen mainScreen].scale;
-        return result;
+        // Don't bother unsetting anything.
     }
 }
 
@@ -89,7 +91,7 @@ namespace Gosu
     [EAGLContext setCurrentContext:_context];
     [self destroyFramebuffer];
     [self createFramebuffer];
-    self.contentScaleFactor = Gosu::clip_rect_base_factor();
+    self.contentScaleFactor = [UIScreen mainScreen].scale;
 }
 
 - (BOOL)createFramebuffer

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();
             });
         }];
     }