gosu 2.0.0.pre6 → 2.0.0.pre7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c216718d8cc417f4136f1231d7a845bfab4a5308900243750d218d1ba433a6b
-  data.tar.gz: 326fccc87ec22ee599c0536a744356423abf70e921f2e3bc247067b120a834a6
+  metadata.gz: de41d69b5cfd72bea1af496ef95e39cf80d89268d640548c73aeb421d9b05428
+  data.tar.gz: d2196d8e0a7f65e9c0d77fdfe5c56026570a807a15b4c46a7066c16bc296fcb0
 SHA512:
-  metadata.gz: aaf8dce2376755bd906ff3598599941337544e489153ca691e68cd86bf773a0a7aeed6db2e27aedf591399d694bd3e67fa2e2e9aad62116371e8f3a51d06a00f
-  data.tar.gz: 19f7f2dff02d74c44292218234fad7cab148f139f0e1cc04475428f1c8200812075a073cb0663d221aac769d91eb87ab6a2894c7052a94f7190a1727226495d6
+  metadata.gz: c809f58dd0e31ec02bd3c596e2dab1de6795d70eee53aa5226389815f8b37089289055222ed3f1a4eed3a1f2e4952e452a42042a14385e97737007adbf1dff78
+  data.tar.gz: 744c254d6ad35c6ceb9acbda0ac26d1d6f4531df389b38c13afea1775bf271be65941076fdc40d707c55a1c1a8a6ac3ae6ed95231c0a7de5bd11dc041bc0cce8

data/dependencies/SDL/include/SDL_assert.h

@@ -55,6 +55,8 @@ assert can have unique static variables associated with it.
     #define SDL_TriggerBreakpoint() __builtin_debugtrap()
 #elif ( (!defined(__NACL__)) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))) )
     #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )
+#elif (defined(__GNUC__) || defined(__clang__)) && defined(__riscv)
+    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "ebreak\n\t" )
 #elif ( defined(__APPLE__) && (defined(__arm64__) || defined(__aarch64__)) )  /* this might work on other ARM targets, but this is a known quantity... */
     #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "brk #22\n\t" )
 #elif defined(__APPLE__) && defined(__arm__)

data/dependencies/SDL/include/SDL_hints.h

@@ -1474,6 +1474,17 @@ extern "C" {
  */
 #define SDL_HINT_RENDER_VSYNC               "SDL_RENDER_VSYNC"
 
+/**
+ *  \brief  A variable controlling whether the Metal render driver select low power device over default one
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - Use the prefered OS device
+ *    "1"       - Select a low power one
+ *
+ *  By default the prefered OS device is used.
+ */
+#define SDL_HINT_RENDER_METAL_PREFER_LOW_POWER_DEVICE "SDL_RENDER_METAL_PREFER_LOW_POWER_DEVICE"
+
 /**
  *  \brief  A variable controlling if VSYNC is automatically disable if doesn't reach the enough FPS
  *

data/dependencies/SDL/include/SDL_render.h

@@ -1890,7 +1890,7 @@ extern DECLSPEC void *SDLCALL SDL_RenderGetMetalLayer(SDL_Renderer * renderer);
  * Note that as of SDL 2.0.18, this will return NULL if Metal refuses to give
  * SDL a drawable to render to, which might happen if the window is
  * hidden/minimized/offscreen. This doesn't apply to command encoders for
- * render targets, just the window's backbacker. Check your return values!
+ * render targets, just the window's backbuffer. Check your return values!
  *
  * \param renderer The renderer to query
  * \returns an `id<MTLRenderCommandEncoder>` on success, or NULL if the

data/dependencies/SDL/include/SDL_revision.h

@@ -1,7 +1,7 @@
 /* Generated by updaterev.sh, do not edit */
 #ifdef SDL_VENDOR_INFO
-#define SDL_REVISION "SDL-release-2.28.2-0-g031912c4b (" SDL_VENDOR_INFO ")"
+#define SDL_REVISION "SDL-release-2.28.3-0-g8a5ba43d0 (" SDL_VENDOR_INFO ")"
 #else
-#define SDL_REVISION "SDL-release-2.28.2-0-g031912c4b"
+#define SDL_REVISION "SDL-release-2.28.3-0-g8a5ba43d0"
 #endif
 #define SDL_REVISION_NUMBER 0

data/dependencies/SDL/include/SDL_version.h

@@ -59,7 +59,7 @@ typedef struct SDL_version
 */
 #define SDL_MAJOR_VERSION   2
 #define SDL_MINOR_VERSION   28
-#define SDL_PATCHLEVEL      2
+#define SDL_PATCHLEVEL      3
 
 /**
  * Macro to determine SDL version program was compiled against.

data/ext/gosu-ffi/gosu-ffi.def

@@ -213,6 +213,7 @@ Gosu_IF_TILEABLE_TOP
 Gosu_Image_create
 Gosu_Image_create_from_blob
 Gosu_Image_create_from_markup
+Gosu_Image_create_from_rect
 Gosu_Image_create_from_subimage
 Gosu_Image_create_from_text
 Gosu_Image_create_from_tiles

data/ffi/Gosu_FFI_internal.h

@@ -26,7 +26,7 @@ auto Gosu_translate_exceptions(Functor functor)
     }
 }
 
-// C-compatible wrapper structs for Gosu classes
+// C-compatible wrapper structs for Gosu classes. (No inheritance because of missing virtual dtors.)
 
 struct Gosu_Channel
 {
@@ -48,7 +48,7 @@ struct Gosu_Sample
     Gosu::Sample sample;
 };
 
-// Use inheritance where composition is not feasible
+// Use inheritance where composition is not feasible (because we want to compare pointers).
 
 struct Gosu_Song : Gosu::Song
 {

data/ffi/Gosu_Image.cpp

@@ -2,9 +2,18 @@
 #include <cstring> // for std::memcpy
 
 GOSU_FFI_API Gosu_Image* Gosu_Image_create(const char* filename, unsigned image_flags)
+{
+    return Gosu_translate_exceptions([=] { //
+        return new Gosu_Image { Gosu::Image(filename, image_flags) };
+    });
+}
+
+GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_rect(const char* filename, //
+                                                int x, int y, int width, int height,
+                                                unsigned image_flags)
 {
     return Gosu_translate_exceptions([=] {
-        return new Gosu_Image{Gosu::Image{filename, image_flags}};
+        return new Gosu_Image { Gosu::Image(filename, { x, y, width, height }, image_flags) };
     });
 }
 
@@ -32,32 +41,35 @@ GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_text(const char* text, const cha
     });
 }
 
-GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_blob(void* blob, int byte_count, int columns,
-                                                     int rows, unsigned image_flags)
+GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_blob(void* blob, size_t byte_count, //
+                                                     int columns, int rows, //
+                                                     int x, int y, int width, int height,
+                                                     unsigned image_flags)
 {
     return Gosu_translate_exceptions([=] {
-        std::size_t size = columns * rows * 4;
-        Gosu::Bitmap bitmap{columns, rows};
+        const int pixels = columns * rows * 4;
+        Gosu::Bitmap bitmap;
 
-        if (byte_count == size) {
+        if (byte_count == pixels) {
             // 32 bit per pixel, assume R8G8B8A8
-            std::memcpy(bitmap.data(), blob, size);
+            bitmap = Gosu::Bitmap(columns, rows, Gosu::Buffer(blob, byte_count, nullptr));
         }
-        else if (byte_count == size * sizeof(float)) {
-            // 128 bit per channel, assume float/float/float/float - for Texplay compatibility.
+        else if (byte_count == pixels * 4UL * sizeof(float)) {
+            bitmap.resize(columns, rows);
+            // 128 bit per channel, assume float/float/float/float RGBA - for Texplay compatibility.
             const float* in = static_cast<const float*>(blob);
             Gosu::Color::Channel* out = reinterpret_cast<Gosu::Color::Channel*>(bitmap.data());
-            for (std::size_t i = 0; i < size; ++i) {
+            for (std::size_t i = 0; i < pixels; ++i) {
                 out[i] = static_cast<Gosu::Color::Channel>(in[i] * 255);
             }
         }
         else {
-            throw std::invalid_argument{"Invalid byte_count " + std::to_string(byte_count) +
-                                        "for image of size " + std::to_string(columns) + "x" +
-                                        std::to_string(rows)};
+            throw std::invalid_argument("Invalid byte_count " + std::to_string(byte_count)
+                                        + " for image of size " + std::to_string(columns) + "x"
+                                        + std::to_string(rows));
         }
 
-        return new Gosu_Image{Gosu::Image{bitmap, image_flags}};
+        return new Gosu_Image { Gosu::Image(bitmap, { x, y, width, height }, image_flags) };
     });
 }
 

data/ffi/Gosu_Image.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Gosu_FFI.h"
+#include <stddef.h> // for size_t
 #include <stdint.h>
 
 typedef struct Gosu_Image Gosu_Image;
@@ -13,8 +14,13 @@ typedef struct Gosu_GLTexInfo
 
 // Constructor
 GOSU_FFI_API Gosu_Image* Gosu_Image_create(const char* filename, unsigned image_flags);
-GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_blob(void* blob, int byte_count, int width,
-                                                     int height, unsigned image_flags);
+GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_rect(const char* filename, //
+                                                int x, int y, int width, int height,
+                                                unsigned image_flags);
+GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_blob(void* blob, size_t byte_count, //
+                                                     int columns, int rows, //
+                                                     int x, int y, int width, int height,
+                                                     unsigned image_flags);
 GOSU_FFI_API Gosu_Image* Gosu_Image_create_from_markup(const char* markup, const char* font,
                                                        double font_height, int width,
                                                        double spacing, unsigned align,

data/include/Gosu/Image.hpp

@@ -24,7 +24,7 @@ namespace Gosu
         /// For more flexibility, use the corresponding constructor that uses a Bitmap object.
         explicit Image(const std::string& filename, unsigned image_flags = IF_SMOOTH);
 
-        //! Loads a portion of the the image at the given filename..
+        /// Loads a portion of the the image at the given filename..
         ///
         /// A color key of #ff00ff is automatically applied to BMP image files.
         /// For more flexibility, use the corresponding constructor that uses a Bitmap object.

data/lib/gosu/ffi.rb

@@ -134,11 +134,12 @@ module GosuFFI
   attach_function :Gosu_Font_set_image, [:pointer, :string, :uint32, :pointer], :void
 
   attach_function :Gosu_Image_create, [:string, :uint32], :pointer
+  attach_function :Gosu_Image_create_from_rect, [:string, :int, :int, :int, :int, :uint32], :pointer
   attach_function :Gosu_Image_destroy, [:pointer], :void
 
   attach_function :Gosu_Image_create_from_markup, [:string, :string, :double, :int, :double, :uint32, :uint32, :uint32], :pointer
   attach_function :Gosu_Image_create_from_text, [:string, :string, :double, :int, :double, :uint32, :uint32, :uint32], :pointer
-  attach_function :Gosu_Image_create_from_blob, [:pointer, :ulong, :int, :int, :uint32], :pointer
+  attach_function :Gosu_Image_create_from_blob, [:pointer, :size_t, :int, :int, :int, :int, :int, :int, :uint32], :pointer
   attach_function :Gosu_Image_create_from_subimage, [:pointer, :int, :int, :int, :int], :pointer
   attach_function :Gosu_Image_create_from_tiles, [:string, :int, :int, :_callback_with_image, :pointer, :uint32], :void
   attach_function :Gosu_Image_create_tiles_from_image, [:pointer, :int, :int, :_callback_with_image, :pointer, :uint32], :void

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))
@@ -112,17 +124,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.pre7
 platform: ruby
 authors:
 - Julian Raschke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-09-14 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
@@ -336,7 +337,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.4.3
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: 2D game development library.