ruby-sfml 3.0.0.0

data/lib/sfml/graphics/transform.rb

@@ -0,0 +1,150 @@
+module SFML
+  # A 2D affine transformation. Wraps the 3×3 matrix that SFML uses to
+  # combine translation, rotation, scaling, and skew. Useful when you
+  # want to:
+  #
+  #   - Apply the same transform across many drawables (push it via
+  #     `RenderStates.new(transform: …)` instead of repeating
+  #     `position=`/`rotation=` on every shape).
+  #   - Build a transform from primitive ops without holding a Drawable.
+  #
+  #   t = SFML::Transform.identity
+  #         .translate([400, 300])
+  #         .rotate(30)
+  #         .scale([2, 2])
+  #
+  #   t.transform_point([10, 0])    #=> Vector2(world coord after t)
+  #   inv = t.inverse                #=> reverse mapping
+  #
+  # Methods are chainable and **mutate in place**, returning self. To
+  # work with a fresh copy use `t.dup`. The CSFML constant for the
+  # identity is exposed via `Transform.identity`.
+  class Transform
+    def initialize
+      @struct = C::Graphics::Transform.new
+      # Start as identity by copying CSFML's sfTransform_Identity.
+      identity_bytes = C::Graphics.sfTransform_Identity.pointer.read_bytes(C::Graphics::Transform.size)
+      @struct.pointer.write_bytes(identity_bytes)
+    end
+
+    def self.identity
+      new
+    end
+
+    # Build from a flat row-major 9-element float array. Lays out as:
+    #   [a, b, c,
+    #    d, e, f,
+    #    g, h, i]   # SFML stores the 3x3 conceptually as a 4x4 padded
+    def self.from_matrix(arr)
+      raise ArgumentError, "expected 9-element matrix, got #{arr.length}" if arr.length != 9
+      t = new
+      9.times { |i| t.struct[:matrix][i] = arr[i].to_f }
+      t
+    end
+
+    def initialize_dup(other)
+      super
+      @struct = C::Graphics::Transform.new
+      @struct.pointer.write_bytes(other.struct.pointer.read_bytes(C::Graphics::Transform.size))
+    end
+
+    # Apply a translation. Mutates self.
+    def translate(offset)
+      vec = _vec2(offset)
+      C::Graphics.sfTransform_translate(@struct.pointer, vec.to_native_f)
+      self
+    end
+
+    # Apply a rotation by `degrees`. Optional `center` to pivot around
+    # a non-origin point.
+    def rotate(degrees, center: nil)
+      if center
+        c = _vec2(center)
+        C::Graphics.sfTransform_rotateWithCenter(@struct.pointer, degrees.to_f, c.to_native_f)
+      else
+        C::Graphics.sfTransform_rotate(@struct.pointer, degrees.to_f)
+      end
+      self
+    end
+
+    # Apply a scale. With `center:`, scales around that pivot.
+    def scale(factors, center: nil)
+      f = _vec2(factors)
+      if center
+        c = _vec2(center)
+        C::Graphics.sfTransform_scaleWithCenter(@struct.pointer, f.to_native_f, c.to_native_f)
+      else
+        C::Graphics.sfTransform_scale(@struct.pointer, f.to_native_f)
+      end
+      self
+    end
+
+    # Multiply this transform by another. `t.combine(t2)` is `t * t2`
+    # in left-to-right order (apply t2's transformation, then t's).
+    def combine(other)
+      raise ArgumentError, "Transform#combine needs another SFML::Transform" unless other.is_a?(Transform)
+      C::Graphics.sfTransform_combine(@struct.pointer, other.struct.pointer)
+      self
+    end
+
+    # Return a new Transform that's the inverse of this one — applying
+    # both in sequence yields the identity.
+    def inverse
+      result = C::Graphics.sfTransform_getInverse(@struct.pointer)
+      t = allocate_new_with(result)
+      t
+    end
+
+    # Map a point through the transform. Returns a Vector2.
+    def transform_point(point)
+      vec = _vec2(point)
+      r   = C::Graphics.sfTransform_transformPoint(@struct.pointer, vec.to_native_f)
+      Vector2.new(r[:x], r[:y])
+    end
+
+    # Map a SFML::Rect through the transform. Returns a new Rect.
+    def transform_rect(rect)
+      raise ArgumentError, "Transform#transform_rect needs a SFML::Rect" unless rect.is_a?(Rect)
+      native = C::Graphics::FloatRect.new
+      native[:position][:x] = rect.x.to_f
+      native[:position][:y] = rect.y.to_f
+      native[:size][:x]     = rect.width.to_f
+      native[:size][:y]     = rect.height.to_f
+
+      r = C::Graphics.sfTransform_transformRect(@struct.pointer, native)
+      Rect.from_native(r)
+    end
+
+    # Read the matrix as a flat 9-element Array of floats (row-major).
+    def matrix
+      (0...9).map { |i| @struct[:matrix][i] }
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Transform)
+      C::Graphics.sfTransform_equal(@struct.pointer, other.struct.pointer)
+    end
+    alias eql? ==
+    def hash = matrix.hash
+
+    def to_s = "Transform(#{matrix.map { |v| v.round(3) }.inspect})"
+    alias inspect to_s
+
+    # @!visibility private
+    attr_reader :struct
+
+    private
+
+    def allocate_new_with(native_struct)
+      t = self.class.allocate
+      new_buf = C::Graphics::Transform.new
+      new_buf.pointer.write_bytes(native_struct.pointer.read_bytes(C::Graphics::Transform.size))
+      t.instance_variable_set(:@struct, new_buf)
+      t
+    end
+
+    def _vec2(value)
+      value.is_a?(Vector2) ? value : Vector2.new(*value)
+    end
+  end
+end

data/lib/sfml/graphics/transformable.rb

@@ -0,0 +1,74 @@
+module SFML
+  module Graphics
+    # Shared transform interface for Sprite, CircleShape, RectangleShape
+    # (and Text once added). Including class must:
+    #   1. Define a constant CSFML_PREFIX (Symbol), e.g. :sfCircleShape
+    #   2. Hold the FFI handle in @handle
+    #
+    # All wrappers go through C::Graphics.public_send so the same Ruby code
+    # picks up sfSprite_*, sfCircleShape_*, sfRectangleShape_* etc. without
+    # repetition. The cost (~1µs of method dispatch on a typical call) is
+    # negligible against any GPU work, but the wins on maintainability are
+    # large — adding a new shape becomes ~5 lines.
+    module Transformable
+      def position
+        Vector2.from_native(_csfml(:getPosition, @handle))
+      end
+
+      def position=(value)
+        _csfml(:setPosition, @handle, _coerce_vec2(value).to_native_f)
+      end
+
+      def rotation
+        _csfml(:getRotation, @handle)
+      end
+
+      def rotation=(degrees)
+        _csfml(:setRotation, @handle, degrees.to_f)
+      end
+
+      def scale
+        Vector2.from_native(_csfml(:getScale, @handle))
+      end
+
+      def scale=(value)
+        _csfml(:setScale, @handle, _coerce_vec2(value).to_native_f)
+      end
+
+      def origin
+        Vector2.from_native(_csfml(:getOrigin, @handle))
+      end
+
+      def origin=(value)
+        _csfml(:setOrigin, @handle, _coerce_vec2(value).to_native_f)
+      end
+
+      def move(offset)
+        _csfml(:move, @handle, _coerce_vec2(offset).to_native_f)
+        self
+      end
+
+      def rotate(degrees)
+        _csfml(:rotate, @handle, degrees.to_f)
+        self
+      end
+
+      def scale_by(factors)
+        _csfml(:scale, @handle, _coerce_vec2(factors).to_native_f)
+        self
+      end
+
+      private
+
+      def _csfml(suffix, *args)
+        C::Graphics.public_send(:"#{self.class::CSFML_PREFIX}_#{suffix}", *args)
+      end
+
+      # Accept a Vector2 or any [x, y] pair so users can pass a literal:
+      #   shape.position = [400, 300]
+      def _coerce_vec2(value)
+        value.is_a?(Vector2) ? value : Vector2.new(*value)
+      end
+    end
+  end
+end

data/lib/sfml/graphics/vertex.rb

@@ -0,0 +1,53 @@
+module SFML
+  # A single point of geometry: position, colour, and texture coordinate.
+  # Plain Ruby value object — VertexArray copies it into / out of CSFML
+  # storage, so mutating a Vertex after appending doesn't propagate.
+  #
+  #   SFML::Vertex.new([10, 20])
+  #   SFML::Vertex.new([10, 20], color: SFML::Color.red)
+  #   SFML::Vertex.new([10, 20], color: SFML::Color.red, tex_coords: [0, 0])
+  class Vertex
+    attr_accessor :position, :color, :tex_coords
+
+    def initialize(position = Vector2.zero, color: Color::WHITE, tex_coords: Vector2.zero)
+      @position   = _coerce_vec2(position)
+      @color      = color
+      @tex_coords = _coerce_vec2(tex_coords)
+    end
+
+    def to_s
+      "Vertex(#{@position.x}, #{@position.y})"
+    end
+    alias inspect to_s
+
+    # @!visibility private
+    def to_native
+      v = C::Graphics::Vertex.new
+      v[:position][:x]   = @position.x.to_f
+      v[:position][:y]   = @position.y.to_f
+      v[:color][:r]      = @color.r
+      v[:color][:g]      = @color.g
+      v[:color][:b]      = @color.b
+      v[:color][:a]      = @color.a
+      v[:tex_coords][:x] = @tex_coords.x.to_f
+      v[:tex_coords][:y] = @tex_coords.y.to_f
+      v
+    end
+
+    # @!visibility private
+    def self.from_native(struct)
+      new(
+        Vector2.new(struct[:position][:x], struct[:position][:y]),
+        color:      Color.new(struct[:color][:r], struct[:color][:g],
+                              struct[:color][:b], struct[:color][:a]),
+        tex_coords: Vector2.new(struct[:tex_coords][:x], struct[:tex_coords][:y]),
+      )
+    end
+
+    private
+
+    def _coerce_vec2(value)
+      value.is_a?(Vector2) ? value : Vector2.new(*value)
+    end
+  end
+end

data/lib/sfml/graphics/vertex_array.rb

@@ -0,0 +1,114 @@
+module SFML
+  # Batched geometry: a single CSFML draw call shipping many vertices to
+  # the GPU at once. This is how you draw thousands of particles, custom
+  # meshes, or tile maps without the per-shape overhead.
+  #
+  #   va = SFML::VertexArray.new(:triangles)
+  #   va << SFML::Vertex.new([100, 100], color: SFML::Color.red)
+  #   va << SFML::Vertex.new([200, 100], color: SFML::Color.green)
+  #   va << SFML::Vertex.new([150, 200], color: SFML::Color.blue)
+  #   window.draw(va)
+  #
+  # Primitive types control how vertices form geometry:
+  #   :points          one isolated point per vertex
+  #   :lines           pairs of vertices form line segments
+  #   :line_strip      consecutive vertices form a chain of segments
+  #   :triangles       triples form independent triangles
+  #   :triangle_strip  each new vertex extends the strip
+  #   :triangle_fan    every vertex shares a fan-out with vertex 0
+  class VertexArray
+    include Enumerable
+
+    # Order matches sfPrimitiveType in CSFML/Graphics/PrimitiveType.h.
+    PRIMITIVE_TYPES = %i[points lines line_strip triangles triangle_strip triangle_fan].freeze
+    PRIMITIVE_INDEX = PRIMITIVE_TYPES.each_with_index.to_h.freeze
+
+    def initialize(primitive_type = :points, vertices = nil)
+      ptr = C::Graphics.sfVertexArray_create
+      raise Error, "sfVertexArray_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfVertexArray_destroy))
+
+      self.primitive_type = primitive_type
+      vertices&.each { |v| append(v) }
+    end
+
+    def primitive_type
+      PRIMITIVE_TYPES[C::Graphics.sfVertexArray_getPrimitiveType(@handle)] || :unknown
+    end
+
+    def primitive_type=(type)
+      code = PRIMITIVE_INDEX.fetch(type) do
+        raise ArgumentError,
+              "Unknown primitive type: #{type.inspect}. Expected one of: #{PRIMITIVE_TYPES.inspect}"
+      end
+      C::Graphics.sfVertexArray_setPrimitiveType(@handle, code)
+    end
+
+    def size = C::Graphics.sfVertexArray_getVertexCount(@handle)
+    alias length size
+    alias count  size
+
+    def empty? = size.zero?
+
+    def clear
+      C::Graphics.sfVertexArray_clear(@handle)
+      self
+    end
+
+    def resize(n)
+      C::Graphics.sfVertexArray_resize(@handle, Integer(n))
+      self
+    end
+
+    def append(vertex)
+      C::Graphics.sfVertexArray_append(@handle, vertex.to_native)
+      self
+    end
+    alias << append
+
+    # Read a vertex by index, or nil if out of range. Returns a fresh
+    # SFML::Vertex copy — mutate via `va[i] = new_vertex` to write back,
+    # not through the returned object.
+    def [](index)
+      i = Integer(index)
+      return nil if i < 0 || i >= size
+      ptr = C::Graphics.sfVertexArray_getVertex(@handle, i)
+      Vertex.from_native(C::Graphics::Vertex.new(ptr))
+    end
+
+    def []=(index, vertex)
+      i = Integer(index)
+      # CSFML's sfVertexArray_getVertex aborts the process on out-of-range
+      # access (it asserts), so we have to bounds-check on the Ruby side.
+      raise IndexError, "vertex index #{i} out of range (size: #{size})" if i < 0 || i >= size
+
+      ptr = C::Graphics.sfVertexArray_getVertex(@handle, i)
+      cv = C::Graphics::Vertex.new(ptr)
+      cv[:position][:x]   = vertex.position.x.to_f
+      cv[:position][:y]   = vertex.position.y.to_f
+      cv[:color][:r]      = vertex.color.r
+      cv[:color][:g]      = vertex.color.g
+      cv[:color][:b]      = vertex.color.b
+      cv[:color][:a]      = vertex.color.a
+      cv[:tex_coords][:x] = vertex.tex_coords.x.to_f
+      cv[:tex_coords][:y] = vertex.tex_coords.y.to_f
+      vertex
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      size.times { |i| yield self[i] }
+      self
+    end
+
+    def bounds
+      Rect.from_native(C::Graphics.sfVertexArray_getBounds(@handle))
+    end
+
+    def draw_on(target, states_ptr = nil) # :nodoc:
+      target._draw_native(:VertexArray, @handle, states_ptr)
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/graphics/view.rb

@@ -0,0 +1,126 @@
+module SFML
+  # A 2D camera. A View defines what part of the world is visible in the
+  # window: a centre point, a size in world units, an optional rotation,
+  # and a viewport rectangle (in normalised window coords [0,1]) that
+  # places the view inside the window — useful for split-screen or for
+  # rendering a mini-map alongside the main camera.
+  #
+  # Two flows you'll typically use:
+  #
+  #   # 1. Define from a centre + size:
+  #   camera = SFML::View.new(center: [400, 300], size: [800, 600])
+  #
+  #   # 2. Define from a world rectangle (top-left + size):
+  #   camera = SFML::View.from_rect(SFML::Rect.new([0, 0], [1600, 1200]))
+  #
+  #   window.view = camera         # apply
+  #   window.draw(stuff)           # everything draws through the camera
+  #   window.view = window.default_view   # restore the 1:1 default
+  #
+  # All coordinate inputs accept either a SFML::Vector2 or a [x, y] array.
+  class View
+    def initialize(center: nil, size: nil, rotation: nil, viewport: nil, _handle: nil)
+      ptr = _handle || C::Graphics.sfView_create
+      raise Error, "sfView_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfView_destroy))
+
+      self.center   = center   if center
+      self.size     = size     if size
+      self.rotation = rotation if rotation
+      self.viewport = viewport if viewport
+    end
+
+    # Build a View whose rectangle covers the given world Rect.
+    def self.from_rect(rect)
+      raise ArgumentError, "View.from_rect needs a SFML::Rect" unless rect.is_a?(Rect)
+
+      native = C::Graphics::FloatRect.new
+      native[:position][:x] = rect.x.to_f
+      native[:position][:y] = rect.y.to_f
+      native[:size][:x]     = rect.width.to_f
+      native[:size][:y]     = rect.height.to_f
+
+      ptr = C::Graphics.sfView_createFromRect(native)
+      raise Error, "sfView_createFromRect returned NULL" if ptr.null?
+      new(_handle: ptr)
+    end
+
+    # @!visibility private
+    # Wrap a CSFML view pointer that we don't own (e.g. the value returned
+    # by sfRenderWindow_getView). We deep-copy via sfView_copy so the Ruby
+    # object owns its own lifetime.
+    def self.from_borrowed(ptr)
+      raise Error, "borrowed view pointer is NULL" if ptr.null?
+      copy = C::Graphics.sfView_copy(ptr)
+      new(_handle: copy)
+    end
+
+    def center
+      Vector2.from_native(C::Graphics.sfView_getCenter(@handle))
+    end
+
+    def center=(value)
+      C::Graphics.sfView_setCenter(@handle, _vec2(value).to_native_f)
+    end
+
+    def size
+      Vector2.from_native(C::Graphics.sfView_getSize(@handle))
+    end
+
+    def size=(value)
+      C::Graphics.sfView_setSize(@handle, _vec2(value).to_native_f)
+    end
+
+    def rotation
+      C::Graphics.sfView_getRotation(@handle)
+    end
+
+    def rotation=(degrees)
+      C::Graphics.sfView_setRotation(@handle, degrees.to_f)
+    end
+
+    # Viewport in normalised [0,1] window coordinates. Default is the full
+    # window (Rect.new([0,0], [1,1])). Use [0, 0, 0.5, 1] for left half,
+    # [0.75, 0, 0.25, 0.25] for a top-right mini-map, etc.
+    def viewport
+      Rect.from_native(C::Graphics.sfView_getViewport(@handle))
+    end
+
+    def viewport=(rect)
+      raise ArgumentError, "View#viewport= needs a SFML::Rect" unless rect.is_a?(Rect)
+      native = C::Graphics::FloatRect.new
+      native[:position][:x] = rect.x.to_f
+      native[:position][:y] = rect.y.to_f
+      native[:size][:x]     = rect.width.to_f
+      native[:size][:y]     = rect.height.to_f
+      C::Graphics.sfView_setViewport(@handle, native)
+    end
+
+    # Pan the camera by an offset in world units.
+    def move(offset)
+      C::Graphics.sfView_move(@handle, _vec2(offset).to_native_f)
+      self
+    end
+
+    # Rotate the camera by `degrees`, relative to current rotation.
+    def rotate(degrees)
+      C::Graphics.sfView_rotate(@handle, degrees.to_f)
+      self
+    end
+
+    # Multiply the visible area by `factor`. Factor < 1.0 zooms in;
+    # factor > 1.0 zooms out.
+    def zoom(factor)
+      C::Graphics.sfView_zoom(@handle, factor.to_f)
+      self
+    end
+
+    attr_reader :handle # :nodoc:
+
+    private
+
+    def _vec2(value)
+      value.is_a?(Vector2) ? value : Vector2.new(*value)
+    end
+  end
+end

data/lib/sfml/network/ip_address.rb

@@ -0,0 +1,67 @@
+module SFML
+  module Network
+    # An IPv4 address. The CSFML side stores it as a fixed-size 16-byte
+    # NUL-terminated dotted-decimal string ("192.168.1.42").
+    #
+    #   SFML::Network::IpAddress.from_string("192.168.1.42")
+    #   SFML::Network::IpAddress.from_bytes(192, 168, 1, 42)
+    #   SFML::Network::IpAddress::LOCALHOST   # 127.0.0.1
+    #   SFML::Network::IpAddress::ANY         # 0.0.0.0
+    #   SFML::Network::IpAddress::BROADCAST   # 255.255.255.255
+    #   SFML::Network::IpAddress.local        # local network IP
+    class IpAddress
+      def self.from_string(s)
+        wrap(C::Network.sfIpAddress_fromString(s.to_s))
+      end
+
+      def self.from_bytes(a, b, c, d)
+        wrap(C::Network.sfIpAddress_fromBytes(Integer(a), Integer(b), Integer(c), Integer(d)))
+      end
+
+      def self.from_integer(n)
+        wrap(C::Network.sfIpAddress_fromInteger(Integer(n)))
+      end
+
+      # The IP this machine sees on its local network.
+      def self.local
+        wrap(C::Network.sfIpAddress_getLocalAddress)
+      end
+
+      # Public-facing IP. Performs an outbound query, so optionally
+      # cap with a timeout. Slow — minutes if the network is down.
+      def self.public(timeout: SFML::Time.zero)
+        wrap(C::Network.sfIpAddress_getPublicAddress(timeout.to_native))
+      end
+
+      # @!visibility private
+      def self.wrap(struct)
+        ip = allocate
+        ip.instance_variable_set(:@struct, struct)
+        ip.freeze
+      end
+
+      def to_s
+        @struct[:address].to_ptr.read_string_to_null
+      end
+      alias inspect to_s
+
+      def to_i
+        C::Network.sfIpAddress_toInteger(@struct)
+      end
+
+      def ==(other)
+        other.is_a?(IpAddress) && to_s == other.to_s
+      end
+      alias eql? ==
+      def hash = to_s.hash
+
+      # @!visibility private
+      attr_reader :struct
+
+      NONE      = wrap(C::Network.sfIpAddress_None)
+      ANY       = wrap(C::Network.sfIpAddress_Any)
+      LOCALHOST = wrap(C::Network.sfIpAddress_LocalHost)
+      BROADCAST = wrap(C::Network.sfIpAddress_Broadcast)
+    end
+  end
+end

data/lib/sfml/network/tcp_listener.rb

@@ -0,0 +1,61 @@
+module SFML
+  module Network
+    # The server side of TCP. Listens on a port; #accept blocks until a
+    # client connects, then returns a fresh TcpSocket for that peer.
+    #
+    #   listener = SFML::Network::TcpListener.new
+    #   listener.listen(port: 8080)
+    #   loop do
+    #     status, peer = listener.accept
+    #     break unless status == :done
+    #     handle_client(peer)
+    #   end
+    class TcpListener
+      def initialize
+        ptr = C::Network.sfTcpListener_create
+        raise Error, "sfTcpListener_create returned NULL" if ptr.null?
+        @handle = FFI::AutoPointer.new(ptr, C::Network.method(:sfTcpListener_destroy))
+      end
+
+      # Bind the listener to a port and start listening.
+      # `address` (default: any local interface) restricts which interface
+      # to listen on — pass IpAddress::LOCALHOST for loopback-only.
+      def listen(port:, address: IpAddress::ANY)
+        addr = address.is_a?(IpAddress) ? address : IpAddress.from_string(address)
+        code = C::Network.sfTcpListener_listen(@handle, Integer(port), addr.struct)
+        C::Network::STATUSES[code]
+      end
+
+      def close
+        C::Network.sfTcpListener_close(@handle)
+        self
+      end
+
+      # Returns [status, TcpSocket] — the socket is non-nil only when
+      # status == :done.
+      def accept
+        out_ptr = FFI::MemoryPointer.new(:pointer)
+        code = C::Network.sfTcpListener_accept(@handle, out_ptr)
+        status = C::Network::STATUSES[code]
+
+        return [status, nil] unless status == :done
+        sock_ptr = out_ptr.read_pointer
+        return [status, nil] if sock_ptr.null?
+
+        sock = TcpSocket.allocate
+        sock.instance_variable_set(:@handle, FFI::AutoPointer.new(sock_ptr, C::Network.method(:sfTcpSocket_destroy)))
+        [status, sock]
+      end
+
+      def blocking? = C::Network.sfTcpListener_isBlocking(@handle)
+
+      def blocking=(value)
+        C::Network.sfTcpListener_setBlocking(@handle, value ? true : false)
+      end
+
+      def local_port = C::Network.sfTcpListener_getLocalPort(@handle)
+
+      attr_reader :handle # :nodoc:
+    end
+  end
+end