ruby2d 0.12.0 → 1.0.0

data/lib/ruby2d/ellipse.rb

@@ -0,0 +1,228 @@
+# Ruby2D::Ellipse
+
+module Ruby2D
+  # An ellipse
+  class Ellipse
+    include Renderable
+
+    attr_accessor :xradius, :yradius, :sectors, :rotate, :fill, :stroke_width
+    attr_reader :x, :y, :stroke_color
+    alias_method :stroke_colour, :stroke_color
+
+    # Set the x position (the center). Pass a symbol (`:left`, `:center`,
+    # `:right`) to set alignment intent — resolved at draw time against the
+    # window, with the ellipse's bounding box hugging the chosen edge.
+    def x=(value)
+      return self.x_align = value if value.is_a?(Symbol)
+      @x_align = nil unless @_resolving_alignment
+      @x = value
+    end
+
+    # Set the y position (the center). Pass a symbol (`:top`, `:center`,
+    # `:bottom`) to set alignment intent.
+    def y=(value)
+      return self.y_align = value if value.is_a?(Symbol)
+      @y_align = nil unless @_resolving_alignment
+      @y = value
+    end
+
+    # Create an ellipse
+    def initialize(x: 0, y: 0, z: 0, xradius: 50, yradius: 30, sectors: 30,
+                   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(xradius: xradius, yradius: yradius)
+      @x = x
+      @y = y
+      @z = z
+      @xradius = xradius
+      @yradius = yradius
+      @sectors = sectors
+      @rotate = rotate
+      @_user_rx = rx
+      @_user_ry = ry
+      self.color = color || colour || 'white'
+      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
+
+    # Get the rotation center x coordinate
+    def rx
+      @_user_rx.nil? ? @x : @_user_rx
+    end
+
+    # Get the rotation center y coordinate
+    def ry
+      @_user_ry.nil? ? @y : @_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
+
+    # Bounding-box width and height (the axis diameters)
+    def width
+      @xradius * 2
+    end
+
+    def height
+      @yradius * 2
+    end
+
+    # Set the fill color. Single-color only — a per-vertex color array is
+    # rejected with a clear message rather than a generic "not a valid color".
+    def color=(color)
+      c = Color.set(color)
+      if c.is_a?(Color::Set)
+        raise ArgumentError, "`#{self.class}` does not support per-vertex colors; pass a single color"
+      end
+
+      @color = c
+      @_cc = nil
+    end
+
+    # Set the stroke color. Single-color only — a per-vertex array is rejected.
+    def stroke_color=(c)
+      resolved = c.nil? ? nil : Color.set(c)
+      if resolved.is_a?(Color::Set)
+        raise ArgumentError, "`#{self.class}` does not support per-vertex stroke colors; pass a single color"
+      end
+
+      @stroke_color = resolved || Color.new('white')
+      @_stroke_cc = nil
+    end
+    alias_method :stroke_colour=, :stroke_color=
+
+    # Check if the ellipse contains the given point
+    def contains?(x, y)
+      x, y = _unrotate(x, y)
+      dx = x - @x
+      dy = y - @y
+      rx = @xradius.to_f
+      ry = @yradius.to_f
+      # A zero radius collapses the ellipse on that axis, so the point must lie
+      # exactly on it — mirrors Circle, which is "inside" only at the center
+      # when radius is 0. (The plain formula would divide by zero here.)
+      return false if rx == 0 && dx != 0
+      return false if ry == 0 && dy != 0
+      tx = rx == 0 ? 0.0 : (dx * dx) / (rx * rx)
+      ty = ry == 0 ? 0.0 : (dy * dy) / (ry * ry)
+      tx + ty <= 1.0
+    end
+
+    # Render an ellipse without creating an instance
+    def self.render(x: 0, y: 0, xradius: 50, yradius: 30, sectors: 30, rotate: 0,
+                    rx: nil, ry: nil, color: nil, colour: nil, opacity: nil,
+                    fill: true, stroke_width: 0, stroke_color: nil, stroke_colour: nil)
+      fill_input = color || colour
+      explicit_stroke = stroke_color || stroke_colour
+      stroke_input = explicit_stroke || fill_input
+      # Reject a per-vertex stroke color, matching the instance setter — ellipses
+      # have a single stroke color. Only check when the stroke is drawn or an
+      # explicit stroke color was given, so an invalid one still raises.
+      if (stroke_width > 0 || !explicit_stroke.nil?) && !stroke_input.nil? &&
+         Color.set(stroke_input).is_a?(Color::Set)
+        raise ArgumentError, "`#{self}` does not support per-vertex stroke colors; pass a single color"
+      end
+
+      Window.render_ready_check
+      c = Renderable.flatten_color(fill_input, 1, opacity)
+
+      # `rotate` (degrees) tilts the ellipse and, given a pivot other than the
+      # center, orbits its center around that pivot — matching Quad/Triangle.
+      # `rad` is passed to the draw so the rim itself tilts.
+      rad = rotate * Math::PI / 180.0
+      if rotate != 0
+        cx = rx || x
+        cy = ry || y
+        sa = Math.sin(rad); ca = Math.cos(rad)
+        dx = x - cx; dy = y - cy
+        x = dx * ca - dy * sa + cx
+        y = dx * sa + dy * ca + cy
+      end
+
+      Ext.draw_ellipse(x, y, xradius, yradius, rad, sectors, c[0], c[1], c[2], c[3]) if fill
+      # Resolve the stroke color only when actually stroking.
+      if stroke_width > 0
+        sc = Renderable.resolve_single_color(stroke_input) || Color.new('white')
+        sc = Color.new(sc)
+        sc.opacity = opacity if opacity
+        Ext.stroke_ellipse(x, y, xradius, yradius, rad, sectors, stroke_width, sc.r, sc.g, sc.b, sc.a)
+      end
+    end
+
+    private
+
+    # Ellipse is center-anchored, so shift the alignment resolver's bounding-box
+    # top-left result by each radius to land on the center.
+    def _alignment_anchor_dx
+      @xradius
+    end
+
+    def _alignment_anchor_dy
+      @yradius
+    end
+
+    def render
+      _resolve_alignment
+      ensure_cc
+      ensure_scc if @stroke_width && @stroke_width > 0
+
+      x = @x; y = @y
+
+      rad = @rotate * Math::PI / 180.0
+      if @rotate != 0
+        cx = rx; cy = ry
+        sa = Math.sin(rad); ca = Math.cos(rad)
+        dx = x - cx; dy = y - cy
+        x = dx * ca - dy * sa + cx
+        y = dx * sa + dy * ca + cy
+      end
+
+      if @fill
+        cc = @_cc
+        Ext.draw_ellipse(x, y, @xradius, @yradius, rad, @sectors, cc[0], cc[1], cc[2], cc[3])
+      end
+
+      if @stroke_width && @stroke_width > 0
+        scc = @_stroke_cc
+        Ext.stroke_ellipse(x, y, @xradius, @yradius, rad, @sectors, @stroke_width,
+                           scc[0], scc[1], scc[2], scc[3])
+      end
+    end
+
+    # Scene-graph draw hook (see Renderable#_render_scene). Ellipse'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
+
+    def ensure_cc
+      if @_cc.nil? || @_cc[0] != @color.r || @_cc[1] != @color.g || @_cc[2] != @color.b || @_cc[3] != @color.a
+        @_cc = [@color.r, @color.g, @color.b, @color.a]
+      end
+    end
+
+    def ensure_scc
+      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
+    end
+  end
+end

data/lib/ruby2d/exceptions.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Ruby2D
   # Ruby2D::Error
   class Error < StandardError

data/lib/ruby2d/font.rb

@@ -1,60 +1,35 @@
-# frozen_string_literal: true
-
 # Ruby2D::Font
 
 module Ruby2D
-  #
-  # Font represents a single typeface in a specific size and style.
-  # Use +Font.load+ to load/retrieve a +Font+ instance by path, size and style.
+  # System-font discovery: list the available fonts, resolve a name to a file
+  # path, and locate the bundled default. Font *files* are opened and cached
+  # natively (see `R2D_FontCacheGet` in the C extension), keyed by path, size,
+  # and style — there are no Ruby-side `Font` instances.
   class Font
-    FONT_CACHE_LIMIT = 100
-
-    attr_reader :ttf_font
-
-    # Cache loaded fonts in a class variable
-    @loaded_fonts = {}
-
     class << self
-      # Return a font by +path+, +size+ and +style+, loading the font if not already in the cache.
-      #
-      # @param path [#to_s] Full path to the font file
-      # @param size [Numeric] Size of font to setup
-      # @param style [String] Font style
-      #
-      # @return [Font]
-      def load(path, size, style = nil)
-        path = path.to_s
-        raise Error, "Cannot find font file `#{path}`" unless File.exist? path
-
-        (@loaded_fonts[[path, size, style]] ||= Font.send(:new, path, size, style)).tap do |_font|
-          @loaded_fonts.shift if @loaded_fonts.size > FONT_CACHE_LIMIT
-        end
-      end
-
       # List all fonts, names only
       def all
         all_paths.map { |path| path.split('/').last.chomp('.ttf').downcase }.uniq.sort
       end
 
-      # Find a font file path from its name, if it exists in the platforms list of fonts
-      # @return [String] full path if +font_name+ is known
-      # @return [nil] if +font_name+ is unknown
+      # Find a font file path from its name (case-insensitive, matching `all`)
       def path(font_name)
-        all_paths.find { |path| path.downcase.include?(font_name) }
+        font_name = font_name.to_s.downcase
+        # Match against the file's basename (as `all` computes names), not the
+        # whole path — otherwise a directory component like 'fonts' matches.
+        all_paths.find { |path| path.split('/').last.chomp('.ttf').downcase.include?(font_name) }
       end
 
       # Get full path to the default font
       def default
-        if all.include? 'arial'
-          path 'arial'
+        if RUBY_ENGINE == 'mruby'
+          # Native and WASM builds bundle fonts at ruby2d/fonts/ relative to the binary
+          'ruby2d/fonts/outfit/outfit.ttf'
         else
-          all_paths.first
+          File.expand_path('../../assets/resources/fonts/outfit/outfit.ttf', __dir__)
         end
       end
 
-      # Font cannot be instantiated directly; use +Font.load+ instead.
-      private :new
-
       private
 
       # Get all fonts with full file paths
@@ -77,11 +52,13 @@ module Ruby2D
 
       # Return all font files in the platform's font location
       def find_os_font_files
+        return [] unless directory
+
         if RUBY_ENGINE == 'mruby'
           # MRuby does not have `Dir` defined
           `find #{directory} -name *.ttf`.split("\n")
         else
-          # If MRI and/or non-Bash shell (like cmd.exe)
+          # If CRuby and/or non-Bash shell (like cmd.exe)
           Dir["#{directory}/**/*.ttf"]
         end
       end
@@ -96,45 +73,28 @@ module Ruby2D
 
       # Get the fonts directory for the current platform
       def directory
-        # If MRI and/or non-Bash shell (like cmd.exe)
-        # memoize so we only calculate once
-        @directory ||= OS_FONT_PATHS[ruby_platform_osname || sys_uname_osname]
+        @directory ||= OS_FONT_PATHS[host_os]
       end
 
-      # Uses RUBY_PLATFORM to identify OS
-      def ruby_platform_osname
-        return unless Object.const_defined? :RUBY_PLATFORM
-
-        case RUBY_PLATFORM
-        when /darwin/ # macOS
-          :macos
-        when /linux/
-          :linux
-        when /mingw/
-          :windows
-        when /openbsd/
-          :openbsd
-        end
-      end
-
-      # Uses uname command to identify OS
-      def sys_uname_osname
-        uname = `uname`
-        if uname.include? 'Darwin' # macOS
-          :macos
-        elsif uname.include? 'Linux'
-          :linux
-        elsif uname.include? 'MINGW'
-          :windows
-        elsif uname.include? 'OpenBSD'
-          :openbsd
+      # Identify the host OS, mirroring AssetsTarget.host_os but returning a symbol.
+      # Uses RbConfig when available (CRuby), falls back to uname (mruby).
+      def host_os
+        if Object.const_defined?(:RbConfig)
+          host = RbConfig::CONFIG['host_os'].downcase
+          return :windows if host.match?(/mswin|mingw|cygwin/)
+          return :macos   if host.include?('darwin')
+          return :linux   if host.include?('linux')
+          return :openbsd if host.include?('openbsd')
+        else
+          uname = `uname`.strip
+          return :macos   if uname.include?('Darwin')
+          return :linux   if uname.include?('Linux')
+          return :windows if uname.include?('MINGW')
+          return :openbsd if uname.include?('OpenBSD')
         end
+      rescue IOError
+        nil
       end
     end
-
-    # Private constructor, called internally using +Font.send(:new,...)+
-    def initialize(path, size, style = nil)
-      @ttf_font = Font.ext_load(path.to_s, size, style.to_s)
-    end
   end
 end