ruby2d 0.12.0 → 1.0.0

data/lib/ruby2d/json_parser.rb

@@ -0,0 +1,268 @@
+# Ruby2D::JsonParser
+
+module Ruby2D
+  # Internal recursive-descent JSON parser. Hand-rolled so Ruby 2D pulls in no
+  # stdlib `require 'json'` and stays mruby-compatible without an mrbgem
+  # dependency. Public API: `Ruby2D::JsonParser.parse(str)`.
+  module JsonParser
+    class ParseError < StandardError; end
+
+    def self.parse(str)
+      Parser.new(str).parse
+    end
+
+    class Parser
+      # Cap nesting depth so pathological input fails with a ParseError rather
+      # than overflowing the Ruby stack with a SystemStackError. Real texture
+      # atlases nest only a handful of levels deep.
+      MAX_DEPTH = 500
+
+      def initialize(str)
+        @s = str
+        @i = 0
+        @depth = 0
+      end
+
+      def parse
+        skip_ws
+        value = parse_value
+        skip_ws
+        raise ParseError, "unexpected trailing data at offset #{@i}" if @i < @s.length
+
+        value
+      end
+
+      private
+
+      def parse_value
+        @depth += 1
+        raise ParseError, "nesting too deep (over #{MAX_DEPTH} levels)" if @depth > MAX_DEPTH
+
+        skip_ws
+        c = @s[@i]
+        case c
+        when '{' then parse_object
+        when '[' then parse_array
+        when '"' then parse_string
+        when 't', 'f' then parse_bool
+        when 'n' then parse_null
+        when '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' then parse_number
+        else
+          raise ParseError, "unexpected character #{c.inspect} at offset #{@i}"
+        end
+      ensure
+        @depth -= 1
+      end
+
+      def parse_object
+        @i += 1
+        obj = {}
+        skip_ws
+        if @s[@i] == '}'
+          @i += 1
+          return obj
+        end
+        loop do
+          skip_ws
+          raise ParseError, "expected string key at offset #{@i}" unless @s[@i] == '"'
+
+          key = parse_string
+          skip_ws
+          raise ParseError, "expected ':' at offset #{@i}" unless @s[@i] == ':'
+
+          @i += 1
+          obj[key] = parse_value
+          skip_ws
+          case @s[@i]
+          when ','
+            @i += 1
+          when '}'
+            @i += 1
+            return obj
+          else
+            raise ParseError, "expected ',' or '}' at offset #{@i}"
+          end
+        end
+      end
+
+      def parse_array
+        @i += 1
+        arr = []
+        skip_ws
+        if @s[@i] == ']'
+          @i += 1
+          return arr
+        end
+        loop do
+          arr << parse_value
+          skip_ws
+          case @s[@i]
+          when ','
+            @i += 1
+          when ']'
+            @i += 1
+            return arr
+          else
+            raise ParseError, "expected ',' or ']' at offset #{@i}"
+          end
+        end
+      end
+
+      def parse_string
+        @i += 1
+        result = ''.dup
+        while (c = @s[@i])
+          case c
+          when '"'
+            @i += 1
+            return result
+          when '\\'
+            result << parse_escape
+          else
+            result << c
+            @i += 1
+          end
+        end
+        raise ParseError, 'unterminated string'
+      end
+
+      def parse_escape
+        @i += 1
+        esc = @s[@i]
+        @i += 1
+        case esc
+        when '"'  then '"'
+        when '\\' then '\\'
+        when '/'  then '/'
+        when 'b'  then "\b"
+        when 'f'  then "\f"
+        when 'n'  then "\n"
+        when 'r'  then "\r"
+        when 't'  then "\t"
+        when 'u'  then parse_unicode_escape
+        else
+          raise ParseError, "bad escape \\#{esc} at offset #{@i - 1}"
+        end
+      end
+
+      def parse_unicode_escape
+        code = read_hex4
+        # Handle a UTF-16 surrogate pair
+        if code >= 0xD800 && code <= 0xDBFF
+          raise ParseError, "expected low surrogate at offset #{@i}" unless @s[@i, 2] == '\\u'
+
+          @i += 2
+          lo = read_hex4
+          raise ParseError, "invalid low surrogate at offset #{@i}" unless lo >= 0xDC00 && lo <= 0xDFFF
+
+          code = 0x10000 + ((code - 0xD800) * 0x400) + (lo - 0xDC00)
+        elsif code >= 0xDC00 && code <= 0xDFFF
+          # A low surrogate with no preceding high surrogate is not a valid
+          # scalar value; without this guard it would escape as a RangeError.
+          raise ParseError, "unexpected low surrogate at offset #{@i}"
+        end
+        encode_codepoint(code)
+      end
+
+      def read_hex4
+        hex = @s[@i, 4]
+        unless hex && hex.length == 4 && hex_only?(hex)
+          raise ParseError, "bad unicode escape at offset #{@i}"
+        end
+
+        @i += 4
+        hex.to_i(16)
+      end
+
+      def hex_only?(s)
+        s.each_char.all? { |c| (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') }
+      end
+
+      # On CRuby, `Integer#chr(Encoding::UTF_8)` produces a properly tagged
+      # UTF-8 string. mruby (without the encoding mrbgem) lacks `Encoding`, so
+      # we fall back to a hand-rolled UTF-8 byte sequence.
+      def encode_codepoint(code)
+        code.chr(Encoding::UTF_8)
+      rescue NameError, ArgumentError
+        encode_codepoint_bytes(code)
+      end
+
+      def encode_codepoint_bytes(code)
+        if code < 0x80
+          code.chr
+        elsif code < 0x800
+          (0xC0 | (code >> 6)).chr +
+            (0x80 | (code & 0x3F)).chr
+        elsif code < 0x10000
+          (0xE0 | (code >> 12)).chr +
+            (0x80 | ((code >> 6) & 0x3F)).chr +
+            (0x80 | (code & 0x3F)).chr
+        else
+          (0xF0 | (code >> 18)).chr +
+            (0x80 | ((code >> 12) & 0x3F)).chr +
+            (0x80 | ((code >> 6) & 0x3F)).chr +
+            (0x80 | (code & 0x3F)).chr
+        end
+      end
+
+      def parse_number
+        start = @i
+        @i += 1 if @s[@i] == '-'
+        if @s[@i] == '0'
+          @i += 1
+        elsif digit?(@s[@i])
+          @i += 1 while digit?(@s[@i])
+        else
+          raise ParseError, "bad number at offset #{start}"
+        end
+        is_float = false
+        if @s[@i] == '.'
+          is_float = true
+          @i += 1
+          frac_start = @i
+          @i += 1 while digit?(@s[@i])
+          raise ParseError, "expected digits after '.' at offset #{frac_start}" if @i == frac_start
+        end
+        if @s[@i] == 'e' || @s[@i] == 'E'
+          is_float = true
+          @i += 1
+          @i += 1 if @s[@i] == '+' || @s[@i] == '-'
+          exp_start = @i
+          @i += 1 while digit?(@s[@i])
+          raise ParseError, "expected digits after exponent at offset #{exp_start}" if @i == exp_start
+        end
+        token = @s[start...@i]
+        is_float ? token.to_f : token.to_i
+      end
+
+      def digit?(c)
+        c && c >= '0' && c <= '9'
+      end
+
+      def parse_bool
+        if @s[@i, 4] == 'true'
+          @i += 4
+          true
+        elsif @s[@i, 5] == 'false'
+          @i += 5
+          false
+        else
+          raise ParseError, "bad literal at offset #{@i}"
+        end
+      end
+
+      def parse_null
+        raise ParseError, "bad literal at offset #{@i}" unless @s[@i, 4] == 'null'
+
+        @i += 4
+        nil
+      end
+
+      def skip_ws
+        while (c = @s[@i]) && (c == ' ' || c == "\t" || c == "\n" || c == "\r")
+          @i += 1
+        end
+      end
+    end
+  end
+end

data/lib/ruby2d/line.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Ruby2D::Line
 
 module Ruby2D
@@ -7,46 +5,52 @@ module Ruby2D
   class Line
     include Renderable
 
-    attr_accessor :x1, :x2, :y1, :y2, :width
-
-    # Create an Line
-    # @param [Numeric] x1
-    # @param [Numeric] y1
-    # @param [Numeric] x2
-    # @param [Numeric] y2
-    # @param [Numeric] width The +width+ or thickness of the line
-    # @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(x1: 0, y1: 0, x2: 100, y2: 100, z: 0,
-                   width: 2, color: nil, colour: nil, opacity: nil)
+    attr_accessor :x1, :x2, :y1, :y2, :stroke_width, :rotate, :dash, :gap
+
+    # Create a line. Pass `dash:` (and optionally `gap:`) to draw a dashed line.
+    # Specify endpoints via `points:` or via `x1:`/`y1:`/`x2:`/`y2:`. `points:`
+    # takes precedence if both are given.
+    def initialize(x1: 0, y1: 0, x2: 100, y2: 100,
+                   points: nil,
+                   z: 0,
+                   stroke_width: 1, dash: 0, gap: 5,
+                   rotate: 0, rx: nil, ry: nil,
+                   color: nil, colour: nil, opacity: nil,
+                   add: true, visible: true)
+      if points
+        Line.send(:validate_points, points)
+        x1, y1 = points[0]
+        x2, y2 = points[1]
+      end
       @x1 = x1
       @y1 = y1
       @x2 = x2
       @y2 = y2
       @z = z
-      @width = width
+      @stroke_width = stroke_width
+      @dash = dash
+      @gap = gap
+      @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?
+      @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 color of the line. Accepts a single color or a `Color::Set` of 2
+    # (start, end) for a gradient along the length.
     def color=(color)
-      # convert to Color or Color::Set
       color = Color.set(color)
 
-      # require 4 colours if multiple colours provided
-      if color.is_a?(Color::Set) && color.length != 4
+      if color.is_a?(Color::Set) && color.length != 2
         raise ArgumentError,
-              "`#{self.class}` requires 4 colors, one for each vertex. #{color.length} were given."
+              "`#{self.class}` requires 2 colors (start, end) for a gradient. #{color.length} were given."
       end
 
-      @color = color # converted above
-      invalidate_color_components
+      @color = color
+      @_cc = nil
     end
 
     # Return the length of the line
@@ -54,75 +58,180 @@ module Ruby2D
       points_distance(@x1, @y1, @x2, @y2)
     end
 
-    # Line contains a point if the point is closer than the length of line from
-    # both ends and if the distance from point to line is smaller than half of
-    # the width. For reference:
-    #   https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
+    # Bounding-box width and height (extent between the two endpoints)
+    def width
+      (@x1 - @x2).abs
+    end
+
+    def height
+      (@y1 - @y2).abs
+    end
+
+    # Check if the line contains the given point — within half the stroke width
+    # of the drawn segment and between its endpoints, so the hit region matches
+    # the rendered (butt-capped) rectangle rather than overhanging its ends.
+    # Shares the segment test with `Polyline`.
     def contains?(x, y)
-      line_len = length
-      points_distance(@x1, @y1, x, y) <= line_len &&
-        points_distance(@x2, @y2, x, y) <= line_len &&
-        (((@y2 - @y1) * x - (@x2 - @x1) * y + @x2 * @y1 - @y2 * @x1).abs / line_len) <= 0.5 * @width
-    end
-
-    # Draw a line without creating a Line
-    # @param [Numeric] x1
-    # @param [Numeric] y1
-    # @param [Numeric] x2
-    # @param [Numeric] y2
-    # @param [Numeric] width The +width+ or thickness of the line
-    # @param [Array] colors An array or 4 arrays of colour components.
-    def self.draw(x1:, y1:, x2:, y2:, width:, color:)
+      return false if @stroke_width.negative?
+      x, y = _unrotate(x, y) if @rotate != 0
+      half = @stroke_width / 2.0
+      _point_on_segment?(x, y, @x1, @y1, @x2, @y2, half * half)
+    end
+
+    # Get the rotation center x coordinate
+    def rx
+      @_user_rx.nil? ? (@x1 + @x2) / 2.0 : @_user_rx
+    end
+
+    # Get the rotation center y coordinate
+    def ry
+      @_user_ry.nil? ? (@y1 + @y2) / 2.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 line without creating an instance
+    def self.render(x1: 0, y1: 0, x2: 100, y2: 100,
+                    points: nil,
+                    stroke_width: 1, dash: 0, gap: 5,
+                    rotate: 0, rx: nil, ry: nil,
+                    color: nil, colour: nil, opacity: nil)
       Window.render_ready_check
+      if points
+        validate_points(points)
+        x1, y1 = points[0]
+        x2, y2 = points[1]
+      end
 
-      ext_draw([
-                 x1, y1, x2, y2, width,
-                 # splat each colour's components
-                 *color[0], *color[1], *color[2], *color[3]
-               ])
+      input = color || colour
+      c = Color.for_render(input.nil? ? 'white' : input)
+      if c.is_a?(Color::Set) && c.length != 2
+        raise ArgumentError,
+              "`#{self}` requires 2 colors (start, end) for a gradient. #{c.length} were given."
+      end
+
+      # Expand to 4 vertex colors: start -> both start corners, end -> both end corners
+      c0 = c.vertex(0)
+      c1 = c.vertex(1)
+      c0a = opacity || c0.a
+      c1a = opacity || c1.a
+
+      if rotate != 0
+        cx = rx || (x1 + x2) / 2.0
+        cy = ry || (y1 + y2) / 2.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
+      end
+
+      if dash > 0
+        Ext.draw_dashed_line(
+          x1, y1, x2, y2, stroke_width, dash, gap,
+          c0.r, c0.g, c0.b, c0a,
+          c0.r, c0.g, c0.b, c0a,
+          c1.r, c1.g, c1.b, c1a,
+          c1.r, c1.g, c1.b, c1a
+        )
+      else
+        Ext.draw_line(
+          x1, y1, x2, y2, stroke_width,
+          c0.r, c0.g, c0.b, c0a,
+          c0.r, c0.g, c0.b, c0a,
+          c1.r, c1.g, c1.b, c1a,
+          c1.r, c1.g, c1.b, c1a
+        )
+      end
     end
 
     private
 
+    def self.validate_points(points)
+      raise ArgumentError, 'Line requires exactly 2 points' unless points.length == 2
+      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
-      self.class.ext_draw([
-                            @x1, @y1, @x2, @y2, @width,
-                            # splat the colour components from helper
-                            *color_components
-                          ])
+      ensure_cc
+
+      x1 = @x1; y1 = @y1; x2 = @x2; y2 = @y2
+
+      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
+      end
+
+      cc = @_cc
+      if @dash && @dash > 0
+        Ext.draw_dashed_line(
+          x1, y1, x2, y2, @stroke_width, @dash, @gap,
+          cc[0],  cc[1],  cc[2],  cc[3],
+          cc[4],  cc[5],  cc[6],  cc[7],
+          cc[8],  cc[9],  cc[10], cc[11],
+          cc[12], cc[13], cc[14], cc[15]
+        )
+      else
+        Ext.draw_line(
+          x1, y1, x2, y2, @stroke_width,
+          cc[0],  cc[1],  cc[2],  cc[3],
+          cc[4],  cc[5],  cc[6],  cc[7],
+          cc[8],  cc[9],  cc[10], cc[11],
+          cc[12], cc[13], cc[14], cc[15]
+        )
+      end
     end
 
+    # Scene-graph draw hook (see Renderable#_render_scene). Line'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
+
     # Calculate the distance between two points
     def points_distance(x1, y1, x2, y2)
-      Math.sqrt((x1 - x2).abs2 + (y1 - y2).abs2)
-    end
-
-    # Return colours as a memoized flattened array of 4 x colour components
-    def color_components
-      check_if_opacity_changed
-      @color_components ||= if @color.is_a? Color::Set
-                              # Splat the colours from the set; 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[3] != @color.opacity
-    end
-
-    # Invalidate the memoized colour components. Called when Line's colour is changed
-    def invalidate_color_components
-      @color_components = nil
+      dx = x1 - x2
+      dy = y1 - y2
+      Math.sqrt(dx * dx + dy * dy)
+    end
+
+    # Build/rebuild flat color cache for the native extension. Line is a quad
+    # internally, so the 2-color gradient (start, end) expands to 4 vertex
+    # entries: start→both start corners, end→both end corners.
+    def ensure_cc
+      if @_cc.nil? || !cc_matches?
+        c0 = @color.vertex(0)
+        c1 = @color.vertex(1)
+        @_cc = [c0.r, c0.g, c0.b, c0.a,
+                c0.r, c0.g, c0.b, c0.a,
+                c1.r, c1.g, c1.b, c1.a,
+                c1.r, c1.g, c1.b, c1.a]
+      end
+    end
+
+    # Line's 4-vertex expansion is deterministic, so checking the two source
+    # entries (start and end) detects any Color::Set mutation.
+    def cc_matches?
+      c0 = @color.vertex(0)
+      c1 = @color.vertex(1)
+      return false if @_cc[0] != c0.r || @_cc[1] != c0.g || @_cc[2]  != c0.b || @_cc[3]  != c0.a
+      return false if @_cc[8] != c1.r || @_cc[9] != c1.g || @_cc[10] != c1.b || @_cc[11] != c1.a
+      true
     end
   end
 end

data/lib/ruby2d/mruby_compat.rb

@@ -0,0 +1,12 @@
+# CRuby idioms mruby doesn't implement, shimmed as no-ops. Both are visibility
+# hints with no runtime effect, so dropping them on mruby is free — but without
+# these stubs every file that calls one raises `NoMethodError` in the native and
+# web builds while the CRuby specs stay green. CRuby never takes this branch, so
+# the file reads as unused — it isn't.
+
+if RUBY_ENGINE == 'mruby'
+  class Module
+    def private_class_method(*) = self
+    def private_constant(*) = self
+  end
+end