gosu 2.0.0.pre6 → 2.0.0.pre8

data/lib/gosu/image.rb

@@ -1,9 +1,8 @@
 module Gosu
   class Image
-    BlobHelper = Struct.new(:columns, :rows, :to_blob)
-
     def self.from_blob(width, height, rgba = "\0\0\0\0" * (width * height), retro: false, tileable: false)
-      self.new(BlobHelper.new(width, height, rgba), retro: retro, tileable: tileable)
+      @struct ||= Struct.new(:columns, :rows, :to_blob)
+      self.new(@struct.new(width, height, rgba), retro: retro, tileable: tileable)
     end
 
     def self.from_text(markup, line_height, font: Gosu.default_font_name, width: -1, spacing: 0, align: :left,
@@ -48,25 +47,38 @@ module Gosu
       return images
     end
 
-    def initialize(object, retro: false, tileable: false)
+    def initialize(object, retro: false, tileable: false, rect: nil)
+      if rect and rect.size != 4
+        raise ArgumentError, "Expected 4-element array as rect"
+      end
+
+      flags = GosuFFI.image_flags(retro: retro, tileable: tileable)
+
       if object.is_a? String
-        __image = GosuFFI.Gosu_Image_create(object, GosuFFI.image_flags(retro: retro, tileable: tileable))
+        if rect
+          __image = GosuFFI.Gosu_Image_create_from_rect(object, *rect, flags)
+        else
+          __image = GosuFFI.Gosu_Image_create(object, flags)
+        end
         GosuFFI.check_last_error
       elsif object.is_a?(FFI::Pointer)
         __image = object
-      elsif object.respond_to?(:to_blob) &&
-            object.respond_to?(:columns) &&
+      elsif object.respond_to?(:to_blob) and
+            object.respond_to?(:columns) and
             object.respond_to?(:rows)
-        blob_bytes = object.to_blob { self.format = "RGBA"; self.depth = 8 }.bytes
-        FFI::MemoryPointer.new(:uchar, blob_bytes.size) do |blob|
-          blob.write_array_of_type(:uchar, :put_uchar, blob_bytes)
-          __image = GosuFFI.Gosu_Image_create_from_blob(blob, blob_bytes.size, object.columns, object.rows, GosuFFI.image_flags(retro: retro, tileable: tileable))
-          GosuFFI.check_last_error
-        end
+      
+        blob = object.to_blob { self.format = "RGBA"; self.depth = 8 }
 
-        raise "Failed to load image from blob" if __image.null?
+        # This creates a copy of the Ruby string data, which shouldn't be necessary with CRuby.
+        ptr = FFI::MemoryPointer.from_string(blob)
+        rect ||= [0, 0, object.columns, object.rows]
+        # Do not consider the terminating null byte part of the ptr length.
+        __image = GosuFFI.Gosu_Image_create_from_blob(ptr, ptr.size - 1, object.columns, object.rows, *rect, flags)
+        ptr.free
+
+        GosuFFI.check_last_error
       else
-        raise ArgumentError
+        raise ArgumentError, "Expected String or RMagick::Image (or a type compatible with it)"
       end
 
       @managed_pointer = FFI::AutoPointer.new(__image, GosuFFI.method(:Gosu_Image_destroy))
@@ -95,7 +107,8 @@ module Gosu
     end
 
     def draw_as_quad(x1, y1, color1, x2, y2, color2, x3, y3, color3, x4, y4, color4, z = 0, mode = :default)
-      GosuFFI.Gosu_Image_draw_as_quad(x1, y1, GosuFFI.color_to_uint32(color1), x2, y2, GosuFFI.color_to_uint32(color2),
+      GosuFFI.Gosu_Image_draw_as_quad(__pointer,
+                                      x1, y1, GosuFFI.color_to_uint32(color1), x2, y2, GosuFFI.color_to_uint32(color2),
                                       x3, y3, GosuFFI.color_to_uint32(color3), x4, y4, GosuFFI.color_to_uint32(color4),
                                       z, GosuFFI.blend_mode(mode))
       GosuFFI.check_last_error
@@ -112,17 +125,17 @@ module Gosu
     end
 
     def subimage(left, top, width, height)
-      __pointer = GosuFFI.Gosu_Image_create_from_subimage(__pointer, left, top, width, height)
+      __subimage = GosuFFI.Gosu_Image_create_from_subimage(__pointer, left, top, width, height)
       GosuFFI.check_last_error
-      Gosu::Image.new(__pointer)
+      Gosu::Image.new(__subimage)
     end
 
     def insert(image, x, y)
       image_ = nil
       if image.is_a?(Gosu::Image)
         image_ = image.__pointer
-      elsif image.respond_to?(:to_blob) &&
-            image.respond_to?(:rows) &&
+      elsif image.respond_to?(:to_blob) and
+            image.respond_to?(:rows) and
             image.respond_to?(:columns)
         image_ = Gosu::Image.new(image).__pointer
       else

data/src/BinPacker.cpp

@@ -136,7 +136,7 @@ void Gosu::BinPacker::merge_neighbors(int index)
     //   ┃ ┣━━┻━┫
     //   ┗━┻━━━━┛
     // In this case, the texture gets stuck in this fragmented state. We assume that this is not an
-    // issue in practice, just like memory
+    // issue in practice, just like RAM fragmentation has never been problematic for us.
 
     // Merge any of the other rectangles in the list into the one with the given index if they share
     // any of their four sides.

data/src/ClipRectStack.cpp

@@ -0,0 +1,38 @@
+#include "ClipRectStack.hpp"
+#include <stdexcept>
+
+void Gosu::ClipRectStack::clear()
+{
+    m_stack.clear();
+    m_effective_rect = std::nullopt;
+}
+
+void Gosu::ClipRectStack::push(const Rect& rect)
+{
+    m_stack.push_back(rect);
+    if (m_effective_rect) {
+        m_effective_rect->clip_to(rect);
+    }
+    else {
+        m_effective_rect = rect;
+    }
+}
+
+void Gosu::ClipRectStack::pop()
+{
+    if (m_stack.empty()) {
+        throw std::logic_error("ClipRectStack is empty");
+    }
+    m_stack.pop_back();
+
+    // The clip rect is the intersection of all active clip rects (if any).
+    m_effective_rect = std::nullopt;
+    for (const auto& rect : m_stack) {
+        if (m_effective_rect) {
+            m_effective_rect->clip_to(rect);
+        }
+        else {
+            m_effective_rect = rect;
+        }
+    }
+}

data/src/ClipRectStack.hpp

@@ -1,90 +1,24 @@
 #pragma once
 
+#include <Gosu/Utility.hpp>
 #include "GraphicsImpl.hpp"
-#include <cassert>
+#include <limits>
+#include <optional>
+#include <stdexcept>
 #include <vector>
 
-class Gosu::ClipRectStack
+namespace Gosu
 {
-    std::vector<ClipRect> stack;
-    bool has_effective_rect; // is effective_rect valid?
-    ClipRect effective_rect;
-    
-    void update_effective_rect()
+    class ClipRectStack
     {
-        // Nothing to do, no clipping in place.
-        if (stack.empty()) {
-            has_effective_rect = false;
-            return;
-        }
-        
-        ClipRect result = { 0.0, 0.0, 1e10, 1e10 };
-        for (std::size_t i = 0, end = stack.size(); i < end; ++i) {
-            const ClipRect& rect = stack[i];
-            int result_right     = std::min(result.x + result.width, rect.x + rect.width);
-            int result_bottom    = std::min(result.y + result.height, rect.y + rect.height);
-            result.x             = std::max(result.x, rect.x);
-            result.y             = std::max(result.y, rect.y);
-            
-            if (result.x >= result_right || result.y >= result_bottom) {
-                // We have clipped the world away!
-                has_effective_rect = false;
-                return;
-            }
-            
-            result.width  = result_right - result.x;
-            result.height = result_bottom - result.y;
-        }
-        
-        // On the iPhone, we may have to multiply everything by 2 for Retina displays.
-        // TODO: Doesn't this affect Retina Macs as well?
-        // TODO: This should be handled by a global transform.
-        int fac = clip_rect_base_factor();
-        result.x *= fac;
-        result.y *= fac;
-        result.width *= fac;
-        result.height *= fac;
-        
-        // Normal clipping.
-        effective_rect     = result;
-        has_effective_rect = true;
-    }
-    
-public:
-    ClipRectStack()
-    : has_effective_rect(false)
-    {
-    }
-    
-    void clear()
-    {
-        stack.clear();
-        has_effective_rect = false;
-    }
-    
-    void begin_clipping(double x, double y, double width, double height)
-    {
-        ClipRect rect = { x, y, width, height };
-        stack.push_back(rect);
-        update_effective_rect();
-    }
-    
-    void end_clipping()
-    {
-        assert (!stack.empty());
-        stack.pop_back();
-        update_effective_rect();
-    }
-    
-    const ClipRect* maybe_effective_rect() const
-    {
-        return has_effective_rect ? &effective_rect : 0;
-    }
-    
-    bool clipped_world_away() const
-    {
-        // When we have no effective rect but the stack is not empty, we have clipped
-        // the whole world away and don't need to render things.
-        return !has_effective_rect && !stack.empty();
-    }
-};
+        std::vector<Rect> m_stack;
+        std::optional<Rect> m_effective_rect;
+
+    public:
+        void clear();
+        void push(const Rect& rect);
+        void pop();
+
+        const std::optional<Rect>& effective_rect() const { return m_effective_rect; }
+    };
+}

data/src/DrawOp.hpp

@@ -168,10 +168,5 @@ namespace Gosu
             
             vas.back().vertices.insert(vas.back().vertices.end(), result, result + 4);
         }
-        
-        bool operator<(const DrawOp& other) const
-        {
-            return z < other.z;
-        }
     };
 }

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");
@@ -80,21 +73,21 @@ public:
         transform_stack.current().apply(left, top);
         transform_stack.current().apply(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);
-
+        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/GosuGLView.cpp

@@ -28,12 +28,6 @@ namespace Gosu
     {
         // Don't bother unsetting anything.
     }
-    
-    int clip_rect_base_factor()
-    {
-        static int result = [UIScreen mainScreen].scale;
-        return result;
-    }
 }
 
 @implementation GosuGLView
@@ -97,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/Graphics.cpp

@@ -247,17 +247,20 @@ void Gosu::gl(Gosu::ZPos z, const std::function<void()>& f)
 #endif
 }
 
-void Gosu::clip_to(double x, double y, double width, double height,
-                             const std::function<void()>& f)
+void Gosu::clip_to(double x, double y, double width, double height, const std::function<void()>& f)
 {
-    double screen_height = current_viewport().m_impl->phys_height;
-    current_queue().begin_clipping(x, y, width, height, screen_height);
+    std::optional<int> viewport_height;
+    if (current_viewport_pointer) {
+        viewport_height = current_viewport_pointer->m_impl->phys_height;
+    }
+
+    current_queue().begin_clipping(x, y, width, height, viewport_height);
     f();
     current_queue().end_clipping();
 }
 
 Gosu::Image Gosu::render(int width, int height, const std::function<void()>& f,
-                                   unsigned image_flags)
+                         unsigned image_flags)
 {
     const OpenGLContext current_context;
 

data/src/GraphicsImpl.hpp

@@ -13,23 +13,6 @@ namespace Gosu
     struct RenderState;
     class RenderStateManager;
 
-    const unsigned NO_CLIPPING = 0xffffffff;
-
-    // In various places in Gosu, width==NO_CLIPPING by convention means
-    // that no clipping should happen.
-    struct ClipRect
-    {
-        double x, y, width, height;
-
-        bool operator==(const ClipRect& other) const
-        {
-            // No clipping
-            return (width == NO_CLIPPING && other.width == NO_CLIPPING) ||
-                // Clipping, but same
-                (x == other.x && y == other.y && width == other.width && height == other.height);
-        }
-    };
-
     enum QueueMode
     {
         QM_RENDER_TO_SCREEN,
@@ -71,12 +54,6 @@ namespace Gosu
 
     void schedule_draw_op(const DrawOp& op);
 
-#ifdef GOSU_IS_IPHONE
-    int clip_rect_base_factor();
-#else
-    inline int clip_rect_base_factor() { return 1; }
-#endif
-
     void register_frame();
 
     inline std::string escape_markup(const std::string& text) {

data/src/RenderState.hpp

@@ -1,9 +1,11 @@
 #pragma once
 
 #include <Gosu/Transform.hpp>
+#include "ClipRectStack.hpp"
 #include "GraphicsImpl.hpp"
 #include "OpenGLContext.hpp"
 #include "Texture.hpp"
+#include <optional>
 
 // Properties that potentially need to be changed between each draw operation.
 // This does not include the color or vertex data of the actual quads.
@@ -11,13 +13,12 @@ struct Gosu::RenderState
 {
     std::shared_ptr<Texture> texture;
     const Transform* transform;
-    ClipRect clip_rect;
+    std::optional<Rect> clip_rect;
     BlendMode mode;
 
     RenderState()
     : transform(0), mode(BM_DEFAULT)
     {
-        clip_rect.width = NO_CLIPPING;
     }
 
     bool operator==(const RenderState& rhs) const
@@ -54,12 +55,12 @@ struct Gosu::RenderState
 
     void apply_clip_rect() const
     {
-        if (clip_rect.width == NO_CLIPPING) {
-            glDisable(GL_SCISSOR_TEST);
+        if (clip_rect.has_value()) {
+            glEnable(GL_SCISSOR_TEST);
+            glScissor(clip_rect->x, clip_rect->y, clip_rect->width, clip_rect->height);
         }
         else {
-            glEnable(GL_SCISSOR_TEST);
-            glScissor(clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
+            glDisable(GL_SCISSOR_TEST);
         }
     }
 
@@ -76,12 +77,8 @@ struct Gosu::RenderState
 
 // Manages the OpenGL rendering state. It caches the current state, only forwarding the
 // changes to OpenGL if the new state is really different.
-class Gosu::RenderStateManager : private Gosu::RenderState
+class Gosu::RenderStateManager : private Gosu::RenderState, private Gosu::Noncopyable
 {
-    // Not copyable
-    RenderStateManager(const RenderStateManager&);
-    RenderStateManager& operator=(const RenderStateManager&);
-
     void apply_transform() const
     {
         glMatrixMode(GL_MODELVIEW);
@@ -110,9 +107,7 @@ public:
 
     ~RenderStateManager()
     {
-        ClipRect no_clipping;
-        no_clipping.width = NO_CLIPPING;
-        set_clip_rect(no_clipping);
+        set_clip_rect(std::nullopt);
         set_texture(std::shared_ptr<Texture>());
         // Return to previous MV matrix
         glMatrixMode(GL_MODELVIEW);
@@ -127,9 +122,11 @@ public:
         set_alpha_mode(rs.mode);
     }
 
-    void set_texture(std::shared_ptr<Texture> new_texture)
+    void set_texture(const std::shared_ptr<Texture>& new_texture)
     {
-        if (new_texture == texture) return;
+        if (new_texture == texture) {
+            return;
+        }
 
         if (new_texture) {
             if (!texture) {
@@ -146,39 +143,29 @@ public:
 
     void set_transform(const Transform* new_transform)
     {
-        if (new_transform == transform) return;
+        if (new_transform == transform) {
+            return;
+        }
 
         transform = new_transform;
         apply_transform();
     }
 
-    void set_clip_rect(const ClipRect& new_clip_rect)
+    void set_clip_rect(const std::optional<Rect>& new_clip_rect)
     {
-        if (new_clip_rect.width == NO_CLIPPING) {
-            // Disable clipping
-            if (clip_rect.width != NO_CLIPPING) {
-                glDisable(GL_SCISSOR_TEST);
-                clip_rect.width = NO_CLIPPING;
-            }
-        }
-        else {
-            // Enable clipping if off
-            if (clip_rect.width == NO_CLIPPING) {
-                glEnable(GL_SCISSOR_TEST);
-                clip_rect = new_clip_rect;
-                glScissor(clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
-            }
-            // Adjust clipping if necessary
-            else if (!(clip_rect == new_clip_rect)) {
-                clip_rect = new_clip_rect;
-                glScissor(clip_rect.x, clip_rect.y, clip_rect.width, clip_rect.height);
-            }
+        if (clip_rect == new_clip_rect) {
+            return;
         }
+
+        clip_rect = new_clip_rect;
+        apply_clip_rect();
     }
 
     void set_alpha_mode(BlendMode new_mode)
     {
-        if (new_mode == mode) return;
+        if (new_mode == mode) {
+            return;
+        }
 
         mode = new_mode;
         apply_alpha_mode();

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosu
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre6
+  version: 2.0.0.pre8
 platform: ruby
 authors:
 - Julian Raschke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -258,6 +258,7 @@ files:
 - src/BitmapIO.cpp
 - src/Buffer.cpp
 - src/Channel.cpp
+- src/ClipRectStack.cpp
 - src/ClipRectStack.hpp
 - src/Color.cpp
 - src/Directories.cpp
@@ -332,11 +333,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.5.4
 signing_key:
 specification_version: 4
 summary: 2D game development library.