ruby2d 0.12.0 → 1.0.0

data/lib/ruby2d/quad.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Ruby2D::Quad
 
 module Ruby2D
@@ -15,23 +13,68 @@ module Ruby2D
     attr_accessor :x1, :y1,
                   :x2, :y2,
                   :x3, :y3,
-                  :x4, :y4
-
-    # Create an quadrilateral
-    # @param [Numeric] x1
-    # @param [Numeric] y1
-    # @param [Numeric] x2
-    # @param [Numeric] y2
-    # @param [Numeric] x3
-    # @param [Numeric] y3
-    # @param [Numeric] x4
-    # @param [Numeric] y4
-    # @param [Numeric] z
-    # @param [String, Array] color A single colour or an array of exactly 4 colours
-    # @param [Numeric] opacity Opacity of the image when rendering
-    # @raise [ArgumentError] if an array of colours does not have 4 entries
+                  :x4, :y4,
+                  :rotate,
+                  :fill, :stroke_width
+    attr_reader :stroke_color
+    alias_method :stroke_colour, :stroke_color
+
+    # The x coordinate of the centroid (average of the four vertex x's)
+    def x
+      (@x1 + @x2 + @x3 + @x4) / 4.0
+    end
+
+    # The y coordinate of the centroid (average of the four vertex y's)
+    def y
+      (@y1 + @y2 + @y3 + @y4) / 4.0
+    end
+
+    # Set the x coordinate of the centroid, translating all vertices
+    def x=(new_x)
+      _require_numeric_position(:x, new_x)
+      dx = new_x - x
+      @x1 += dx
+      @x2 += dx
+      @x3 += dx
+      @x4 += dx
+    end
+
+    # Set the y coordinate of the centroid, translating all vertices
+    def y=(new_y)
+      _require_numeric_position(:y, new_y)
+      dy = new_y - y
+      @y1 += dy
+      @y2 += dy
+      @y3 += dy
+      @y4 += dy
+    end
+
+    # Bounding-box width and height (extent across the four vertices)
+    def width
+      xs = [@x1, @x2, @x3, @x4]
+      xs.max - xs.min
+    end
+
+    def height
+      ys = [@y1, @y2, @y3, @y4]
+      ys.max - ys.min
+    end
+
+    # Create a quadrilateral. Specify vertices via `points:` or via
+    # `x1:`/`y1:`/... `points:` takes precedence if both are given.
     def initialize(x1: 0, y1: 0, x2: 100, y2: 0, x3: 100, y3: 100, x4: 0, y4: 100,
-                   z: 0, color: nil, colour: nil, opacity: nil)
+                   points: nil,
+                   z: 0, rotate: 0, rx: nil, ry: nil,
+                   color: nil, colour: nil, opacity: nil,
+                   fill: true, stroke_width: 0, stroke_color: nil, stroke_colour: nil,
+                   add: true, visible: true)
+      if points
+        Quad.send(:validate_points, points)
+        x1, y1 = points[0]
+        x2, y2 = points[1]
+        x3, y3 = points[2]
+        x4, y4 = points[3]
+      end
       @x1 = x1
       @y1 = y1
       @x2 = x2
@@ -41,14 +84,32 @@ module Ruby2D
       @x4 = x4
       @y4 = y4
       @z  = z
+      @rotate = rotate
+      @_user_rx = rx
+      @_user_ry = ry
       self.color = color || colour || 'white'
-      self.color.opacity = opacity unless opacity.nil?
-      add
+      self.opacity = opacity unless opacity.nil?
+      @fill = fill
+      @stroke_width = stroke_width
+      self.stroke_color = stroke_color || stroke_colour || (color || colour)
+      self.stroke_color.opacity = opacity unless opacity.nil?
+      @visible = visible
+      self.add if add
     end
 
-    # Change the colour of the line
-    # @param [String, Array] color A single colour or an array of exactly 4 colours
-    # @raise [ArgumentError] if an array of colours does not have 4 entries
+    # Set the stroke color. Accepts a single color or a `Color::Set` of 4
+    # (one per vertex) interpolated around the perimeter. If nil, defaults to
+    # the fill color (preserving a per-vertex set when the fill is per-vertex).
+    def stroke_color=(c)
+      @stroke_color = Renderable.resolve_color_or_default(c, 4, label: self.class)
+      # A single stroke Color (not a per-vertex Set) takes the compact
+      # `stroke_quad_uniform` fast path.
+      @_stroke_color_uniform = !@stroke_color.is_a?(Color::Set)
+      @_stroke_cc = nil
+    end
+    alias_method :stroke_colour=, :stroke_color=
+
+    # Set the color of the quad
     def color=(color)
       # convert to Color or Color::Set
       color = Color.set(color)
@@ -60,86 +121,289 @@ module Ruby2D
       end
 
       @color = color # converted above
-      invalidate_color_components
+      # A single Color (not a per-vertex Set) is uniform across all four
+      # vertices, so it takes the compact `draw_quad_uniform` fast path.
+      @_color_uniform = !color.is_a?(Color::Set)
+      @_cc = nil # invalidate cached color components
     end
 
-    # The logic is the same as for a triangle
-    # See triangle.rb for reference
+    # Check if the quad contains the given point (inside the rendered fill).
+    # Ray-cast over the four vertices, so concave quads hit-test against what's
+    # actually drawn — unlike the old area method, which only held for convex
+    # quads. Self-intersecting (bow-tie) quads aren't fully supported by the fill
+    # renderer, so the test can diverge from the drawn pixels there.
     def contains?(x, y)
-      self_area = triangle_area(@x1, @y1, @x2, @y2, @x3, @y3) +
-                  triangle_area(@x1, @y1, @x3, @y3, @x4, @y4)
-
-      questioned_area = triangle_area(@x1, @y1, @x2, @y2, x, y) +
-                        triangle_area(@x2, @y2, @x3, @y3, x, y) +
-                        triangle_area(@x3, @y3, @x4, @y4, x, y) +
-                        triangle_area(@x4, @y4, @x1, @y1, x, y)
-
-      questioned_area <= self_area
-    end
-
-    # Draw a line without creating a Line
-    # @param [Numeric] x1
-    # @param [Numeric] y1
-    # @param [Numeric] x2
-    # @param [Numeric] y2
-    # @param [Numeric] x3
-    # @param [Numeric] y3
-    # @param [Numeric] x4
-    # @param [Numeric] y4
-    # @param color [Array<Array<float,float,float,float>>] An array of 4 array of colour components
-    #                                       (e.g. [[1.0, 0, 0, 1.0], ...])
-    def self.draw(x1:, y1:, x2:, y2:, x3:, y3:, x4:, y4:, color:)
+      x, y = _unrotate(x, y)
+      _point_in_polygon?([@x1, @y1, @x2, @y2, @x3, @y3, @x4, @y4], x, y)
+    end
+
+    # Get the rotation center x coordinate
+    def rx
+      @_user_rx.nil? ? (@x1 + @x2 + @x3 + @x4) / 4.0 : @_user_rx
+    end
+
+    # Get the rotation center y coordinate
+    def ry
+      @_user_ry.nil? ? (@y1 + @y2 + @y3 + @y4) / 4.0 : @_user_ry
+    end
+
+    # Set the rotation center x coordinate
+    def rx=(val)
+      @_user_rx = val
+    end
+
+    # Set the rotation center y coordinate
+    def ry=(val)
+      @_user_ry = val
+    end
+
+    # Render a quad without creating an instance
+    def self.render(x1: 0, y1: 0, x2: 100, y2: 0, x3: 100, y3: 100, x4: 0, y4: 100,
+                    points: nil,
+                    rotate: 0, rx: nil, ry: nil,
+                    color: nil, colour: nil, opacity: nil,
+                    fill: true, stroke_width: 0, stroke_color: nil, stroke_colour: nil)
+      if points
+        validate_points(points)
+        x1, y1 = points[0]
+        x2, y2 = points[1]
+        x3, y3 = points[2]
+        x4, y4 = points[3]
+      end
+      draw_immediate(x1, y1, x2, y2, x3, y3, x4, y4, rotate, rx, ry,
+                     color || colour, opacity, fill, stroke_width,
+                     stroke_color || stroke_colour)
+    end
+
+    # The immediate-mode draw shared by Quad, Rectangle, and Square. Takes
+    # positional arguments, and subclasses call it directly instead of
+    # forwarding through `super`: keyword dispatch is expensive on mruby
+    # (~17µs per hop of this many keywords on the web build), so each public
+    # `.render` pays for its own keywords exactly once. `rx`/`ry` may be nil
+    # (centroid default); `explicit_stroke` is the user's stroke color or nil.
+    def self.draw_immediate(x1, y1, x2, y2, x3, y3, x4, y4, rotate, rx, ry,
+                            fill_input, opacity, fill, stroke_width, explicit_stroke)
       Window.render_ready_check
-      ext_draw([
-                 x1, y1, *color[0], # splat the colour components
-                 x2, y2, *color[1],
-                 x3, y3, *color[2],
-                 x4, y4, *color[3]
-               ])
+      # Resolve the fill color once. A single Color (not a per-vertex Set) with
+      # scalar opacity is uniform across all four vertices and draws via the
+      # compact `draw_quad_uniform`; otherwise build the per-vertex color array
+      # from the already-resolved color (no second parse). `for_render` returns
+      # a shared cached instance for string colors — read-only here.
+      # A per-vertex color flattens straight to floats, skipping the
+      # `Color::Set` the general path builds — that allocates and parses one
+      # `Color` per vertex on every call. `resolved` stays nil in that case
+      # and the stroke below resolves for itself if it ends up needing one.
+      # The `is_a?(Array)` guard is inline so the common single-color call
+      # doesn't pay for a method call that would only decline.
+      c = fill_input.is_a?(Array) ? Renderable.flatten_per_vertex(fill_input, 4, opacity) : nil
+      if c
+        resolved = nil
+        uniform = false
+      else
+        resolved = Color.for_render(fill_input.nil? ? 'white' : fill_input)
+        uniform = !resolved.is_a?(Color::Set) && !opacity.is_a?(Array)
+        c = uniform ? nil : Renderable.flatten_resolved_color(resolved, 4, opacity, label: self)
+      end
+
+      # Rotation is inlined into locals (as in `render` below and Line#render):
+      # a helper returning the rotated points would allocate an array per
+      # rotated shape per frame — measured 2.9µs vs 1.8µs per quad on wasm.
+      if rotate != 0
+        cx = rx || (x1 + x2 + x3 + x4) / 4.0
+        cy = ry || (y1 + y2 + y3 + y4) / 4.0
+        rad = rotate * Math::PI / 180.0
+        sa = Math.sin(rad)
+        ca = Math.cos(rad)
+        dx = x1 - cx; dy = y1 - cy
+        x1 = dx * ca - dy * sa + cx; y1 = dx * sa + dy * ca + cy
+        dx = x2 - cx; dy = y2 - cy
+        x2 = dx * ca - dy * sa + cx; y2 = dx * sa + dy * ca + cy
+        dx = x3 - cx; dy = y3 - cy
+        x3 = dx * ca - dy * sa + cx; y3 = dx * sa + dy * ca + cy
+        dx = x4 - cx; dy = y4 - cy
+        x4 = dx * ca - dy * sa + cx; y4 = dx * sa + dy * ca + cy
+      end
+
+      if fill
+        if uniform
+          a = opacity || resolved.a
+          Ext.draw_quad_uniform(x1, y1, x2, y2, x3, y3, x4, y4, resolved.r, resolved.g, resolved.b, a)
+        else
+          c1r, c1g, c1b, c1a, c2r, c2g, c2b, c2a,
+            c3r, c3g, c3b, c3a, c4r, c4g, c4b, c4a = c
+          Ext.draw_quad(
+            x1, y1, c1r, c1g, c1b, c1a,
+            x2, y2, c2r, c2g, c2b, c2a,
+            x3, y3, c3r, c3g, c3b, c3a,
+            x4, y4, c4r, c4g, c4b, c4a
+          )
+        end
+      end
+
+      # Resolve the stroke color only when actually stroking. A single stroke
+      # color draws via the compact `stroke_quad_uniform`; a per-vertex Set keeps
+      # the splatting path. When no explicit stroke is given the stroke reuses
+      # the already-resolved fill color. (An explicit stroke color is still
+      # validated at stroke_width 0 below, matching the instance constructor.)
+      if stroke_width > 0
+        stroke_input = explicit_stroke || fill_input
+        sresolved = if !stroke_input.equal?(fill_input)
+                      Color.for_render(stroke_input)
+                    else
+                      resolved || Color.for_render(fill_input.nil? ? 'white' : fill_input)
+                    end
+        if !sresolved.is_a?(Color::Set) && !opacity.is_a?(Array)
+          sa = opacity || sresolved.a
+          Ext.stroke_quad_uniform(x1, y1, x2, y2, x3, y3, x4, y4, stroke_width,
+                                  sresolved.r, sresolved.g, sresolved.b, sa)
+        else
+          s1r, s1g, s1b, s1a, s2r, s2g, s2b, s2a,
+            s3r, s3g, s3b, s3a, s4r, s4g, s4b, s4a =
+            Renderable.flatten_resolved_color(sresolved, 4, opacity, label: self)
+          Ext.stroke_quad(
+            x1, y1, x2, y2, x3, y3, x4, y4, stroke_width,
+            s1r, s1g, s1b, s1a,
+            s2r, s2g, s2b, s2a,
+            s3r, s3g, s3b, s3a,
+            s4r, s4g, s4b, s4a
+          )
+        end
+      elsif explicit_stroke
+        Renderable.flatten_color(explicit_stroke, 4, opacity, label: self)
+      end
     end
+    private_class_method :draw_immediate
 
     private
 
+    def self.validate_points(points)
+      raise ArgumentError, 'Quad requires exactly 4 points' unless points.length == 4
+      raise ArgumentError, 'points must be an array of [x, y] pairs' \
+        unless points.all? { |p| p.is_a?(Array) && p.length == 2 }
+    end
+    private_class_method :validate_points
+
     def render
-      color_comp_arrays = color_components
-      self.class.ext_draw([
-                            @x1, @y1, *color_comp_arrays[0], # splat the colour components
-                            @x2, @y2, *color_comp_arrays[1],
-                            @x3, @y3, *color_comp_arrays[2],
-                            @x4, @y4, *color_comp_arrays[3]
-                          ])
-    end
-
-    def triangle_area(x1, y1, x2, y2, x3, y3)
-      (x1 * y2 + x2 * y3 + x3 * y1 - x3 * y2 - x1 * y3 - x2 * y1).abs / 2
-    end
-
-    # Return colours as a memoized array of 4 x colour component arrays
-    def color_components
-      check_if_opacity_changed
-      @color_components ||= if @color.is_a? Color::Set
-                              # Extract colour component arrays; see +def color=+ where colour set
-                              # size is enforced
-                              [
-                                @color[0].to_a, @color[1].to_a, @color[2].to_a, @color[3].to_a
-                              ]
-                            else
-                              # All vertex colours are the same
-                              c_a = @color.to_a
-                              [
-                                c_a, c_a, c_a, c_a
-                              ]
-                            end
-    end
-
-    # Invalidate memoized colour components if opacity has been changed via +color=+
-    def check_if_opacity_changed
-      @color_components = nil if @color_components && @color_components.first[3] != @color.opacity
-    end
-
-    # Invalidate the memoized colour components. Called when Line's colour is changed
-    def invalidate_color_components
-      @color_components = nil
+      # Note: Quad does not support symbolic alignment — its `x`/`y` are the
+      # centroid, not a top-left origin, so `_resolve_alignment` (which assumes
+      # top-left) cannot position it coherently. Matches Triangle/Polygon.
+      ensure_cc
+      ensure_scc if @stroke_width && @stroke_width > 0
+
+      x1, y1, x2, y2, x3, y3, x4, y4 = @x1, @y1, @x2, @y2, @x3, @y3, @x4, @y4
+
+      # Rotation inlined into locals — see the `draw_immediate` note.
+      if @rotate != 0
+        cx = rx; cy = ry
+        rad = @rotate * Math::PI / 180.0
+        sa = Math.sin(rad)
+        ca = Math.cos(rad)
+        dx = x1 - cx; dy = y1 - cy
+        x1 = dx * ca - dy * sa + cx; y1 = dx * sa + dy * ca + cy
+        dx = x2 - cx; dy = y2 - cy
+        x2 = dx * ca - dy * sa + cx; y2 = dx * sa + dy * ca + cy
+        dx = x3 - cx; dy = y3 - cy
+        x3 = dx * ca - dy * sa + cx; y3 = dx * sa + dy * ca + cy
+        dx = x4 - cx; dy = y4 - cy
+        x4 = dx * ca - dy * sa + cx; y4 = dx * sa + dy * ca + cy
+      end
+
+      if @fill
+        cc = @_cc
+        if @_color_uniform
+          Ext.draw_quad_uniform(x1, y1, x2, y2, x3, y3, x4, y4, cc[0], cc[1], cc[2], cc[3])
+        else
+          Ext.draw_quad(
+            x1, y1, cc[0],  cc[1],  cc[2],  cc[3],
+            x2, y2, cc[4],  cc[5],  cc[6],  cc[7],
+            x3, y3, cc[8],  cc[9],  cc[10], cc[11],
+            x4, y4, cc[12], cc[13], cc[14], cc[15]
+          )
+        end
+      end
+
+      if @stroke_width && @stroke_width > 0
+        scc = @_stroke_cc
+        if @_stroke_color_uniform
+          Ext.stroke_quad_uniform(x1, y1, x2, y2, x3, y3, x4, y4, @stroke_width, scc[0], scc[1], scc[2], scc[3])
+        else
+          Ext.stroke_quad(
+            x1, y1, x2, y2, x3, y3, x4, y4, @stroke_width,
+            scc[0],  scc[1],  scc[2],  scc[3],
+            scc[4],  scc[5],  scc[6],  scc[7],
+            scc[8],  scc[9],  scc[10], scc[11],
+            scc[12], scc[13], scc[14], scc[15]
+          )
+        end
+      end
+    end
+
+    # Scene-graph draw hook (see Renderable#_render_scene). Quad's `render` is
+    # already zero-arg, so the hook is the same method under the scene name.
+    alias_method :_render_scene, :render
+    public :_render_scene
+
+    # Build/rebuild flat per-vertex stroke color cache (4 × rgba = 16 floats)
+    def ensure_scc
+      if @_stroke_color_uniform
+        c = @stroke_color
+        if @_stroke_cc.nil? || @_stroke_cc[0] != c.r || @_stroke_cc[1] != c.g || @_stroke_cc[2] != c.b || @_stroke_cc[3] != c.a
+          @_stroke_cc = [c.r, c.g, c.b, c.a]
+        end
+      elsif @_stroke_cc.nil? || !scc_matches?
+        @_stroke_cc = Array.new(16)
+        4.times do |i|
+          c = @stroke_color.vertex(i)
+          @_stroke_cc[i * 4]     = c.r
+          @_stroke_cc[i * 4 + 1] = c.g
+          @_stroke_cc[i * 4 + 2] = c.b
+          @_stroke_cc[i * 4 + 3] = c.a
+        end
+      end
+    end
+
+    def scc_matches?
+      4.times do |i|
+        c = @stroke_color.vertex(i)
+        return false if @_stroke_cc[i * 4]     != c.r
+        return false if @_stroke_cc[i * 4 + 1] != c.g
+        return false if @_stroke_cc[i * 4 + 2] != c.b
+        return false if @_stroke_cc[i * 4 + 3] != c.a
+      end
+      true
+    end
+
+    # Build/rebuild flat color cache for the native extension
+    def ensure_cc
+      # Solid fill: cache 4 floats and validity-check 4 comparisons (the
+      # per-frame check still catches in-place `color.opacity=` fades). Mirrors
+      # the Circle/Ellipse single-color cache.
+      if @_color_uniform
+        c = @color
+        if @_cc.nil? || @_cc[0] != c.r || @_cc[1] != c.g || @_cc[2] != c.b || @_cc[3] != c.a
+          @_cc = [c.r, c.g, c.b, c.a]
+        end
+      elsif @_cc.nil? || !cc_matches?
+        @_cc = Array.new(16)
+        4.times do |i|
+          c = @color.vertex(i)
+          @_cc[i * 4]     = c.r
+          @_cc[i * 4 + 1] = c.g
+          @_cc[i * 4 + 2] = c.b
+          @_cc[i * 4 + 3] = c.a
+        end
+      end
+    end
+
+    def cc_matches?
+      4.times do |i|
+        c = @color.vertex(i)
+        return false if @_cc[i * 4]     != c.r
+        return false if @_cc[i * 4 + 1] != c.g
+        return false if @_cc[i * 4 + 2] != c.b
+        return false if @_cc[i * 4 + 3] != c.a
+      end
+      true
     end
   end
 end

data/lib/ruby2d/rectangle.rb

@@ -1,64 +1,122 @@
-# frozen_string_literal: true
-
 # Ruby2D::Rectangle
 
 module Ruby2D
   # A rectangle
   class Rectangle < Quad
-    # Create an rectangle
-    # @param [Numeric] x
-    # @param [Numeric] y
-    # @param [Numeric] width
-    # @param [Numeric] height
-    # @param [Numeric] z
-    # @param [String, Array] color A single colour or an array of exactly 4 colours
-    # @param [Numeric] opacity Opacity of the image when rendering
-    # @raise [ArgumentError] if an array of colours does not have 4 entries
-    def initialize(x: 0, y: 0, width: 200, height: 100, z: 0, color: nil, colour: nil, opacity: nil)
+    # Create a rectangle
+    def initialize(x: 0, y: 0, width: 200, height: 100, z: 0, rotate: 0,
+                   rx: nil, ry: nil, color: nil, colour: nil, opacity: nil,
+                   fill: true, stroke_width: 0, stroke_color: nil, stroke_colour: nil,
+                   add: true, visible: true,
+                   padding: nil, padding_top: nil, padding_right: nil,
+                   padding_bottom: nil, padding_left: nil)
+      x, y = _extract_alignment(x, y)
+      _apply_padding(padding, padding_top, padding_right, padding_bottom, padding_left)
+      _validate_dimensions(width: width, height: height)
       @width = width
       @height = height
       super(x1: @x = x, y1: @y = y,
             x2: x + width, y2: y,
             x3: x + width, y3: y + height,
-            x4: x, y4: y + height, z: z, color: color, colour: colour, opacity: opacity)
+            x4: x, y4: y + height, z: z, rotate: rotate,
+            rx: rx, ry: ry,
+            color: color, colour: colour, opacity: opacity,
+            fill: fill, stroke_width: stroke_width,
+            stroke_color: stroke_color, stroke_colour: stroke_colour,
+            add: add, visible: visible)
+    end
+
+    # The x position (top-left). Rectangles are anchored at their top-left
+    # corner, not the centroid like a general Quad.
+    def x
+      @x1
+    end
+
+    # The y position (top-left).
+    def y
+      @y1
+    end
+
+    # Get the rotation center x coordinate
+    def rx
+      @_user_rx.nil? ? (@x1 + @width / 2.0) : @_user_rx
     end
 
+    # Get the rotation center y coordinate
+    def ry
+      @_user_ry.nil? ? (@y1 + @height / 2.0) : @_user_ry
+    end
+
+    # Set the x position (top-left), updating all four vertices. Pass a
+    # symbol (`:left`, `:center`, `:right`) to set alignment intent.
     def x=(x)
+      return self.x_align = x if x.is_a?(Symbol)
+      @x_align = nil unless @_resolving_alignment
       @x = @x1 = x
       @x2 = x + @width
       @x3 = x + @width
       @x4 = x
     end
 
+    # Set the y position (top-left), updating all four vertices. Pass a
+    # symbol (`:top`, `:center`, `:bottom`) to set alignment intent.
     def y=(y)
+      return self.y_align = y if y.is_a?(Symbol)
+      @y_align = nil unless @_resolving_alignment
       @y = @y1 = y
       @y2 = y
       @y3 = y + @height
       @y4 = y + @height
     end
 
+    # Set the width
     def width=(width)
       @width = width
       @x2 = @x1 + width
       @x3 = @x1 + width
     end
 
+    # Set the height
     def height=(height)
       @height = height
       @y3 = @y1 + height
       @y4 = @y1 + height
     end
 
-    def self.draw(x:, y:, width:, height:, color:)
-      super(x1: x, y1: y,
-            x2: x + width, y2: y,
-            x3: x + width, y3: y + height,
-            x4: x, y4: y + height, color: color)
+    # Render a rectangle without creating an instance. Calls the positional
+    # internal directly rather than `super` — see `Quad.draw_immediate`.
+    def self.render(x: 0, y: 0, width: 200, height: 100, rotate: 0,
+                    rx: nil, ry: nil, color: nil, colour: nil, opacity: nil,
+                    fill: true, stroke_width: 0, stroke_color: nil, stroke_colour: nil)
+      draw_immediate(x, y,
+                     x + width, y,
+                     x + width, y + height,
+                     x, y + height,
+                     rotate, rx || x + width / 2.0, ry || y + height / 2.0,
+                     color || colour, opacity, fill, stroke_width,
+                     stroke_color || stroke_colour)
     end
 
+    # Check if the rectangle contains the given point
     def contains?(x, y)
-      # Override the check from Quad since this is faster
+      x, y = _unrotate(x, y)
       x >= @x && x <= (@x + @width) && y >= @y && y <= (@y + @height)
     end
+
+    private
+
+    # Resolve symbolic alignment (e.g. `x: :center`) against the window before
+    # drawing, then draw via Quad. Rectangle/Square are top-left-anchored and
+    # support alignment; a bare Quad (centroid-anchored) does not, so the call
+    # lives here rather than in Quad#render.
+    def render
+      _resolve_alignment
+      super
+    end
+
+    # Scene-graph draw hook (see Renderable#_render_scene). Re-aliased here so
+    # the hook picks up Rectangle's alignment-resolving `render`, not Quad's.
+    alias_method :_render_scene, :render
+    public :_render_scene
   end
 end