ruby-sfml 3.0.0.0 → 3.0.0.1

data/lib/sfml/network/http.rb

@@ -0,0 +1,117 @@
+module SFML
+  module Network
+    # CSFML's tiny HTTP/1.x client. Useful when an SFML 3 game wants
+    # to talk to a leaderboard / asset server without pulling in
+    # `Net::HTTP`. For anything more involved (TLS, redirects,
+    # streaming, retries, JSON), Ruby's stdlib `Net::HTTP` is the
+    # better tool — this wrapper exists for parity with CSFML, not
+    # because we recommend it.
+    #
+    #   http = SFML::Network::Http.new("http://localhost", port: 8080)
+    #   resp = http.send_request(method: :get, uri: "/")
+    #   resp.status   #=> 200
+    #   resp.body     #=> "Hello world\n"
+    #
+    # `send_request` accepts:
+    #   method:       :get / :post / :head / :put / :delete (default :get)
+    #   uri:          path string (default "/")
+    #   fields:       Hash of header name → value
+    #   body:         String body (POST/PUT)
+    #   http_version: [major, minor] (default [1, 0])
+    #   timeout:      SFML::Time or seconds (default 0 = no timeout)
+    class Http
+      DEFAULT_TIMEOUT = SFML::Time.zero
+      DEFAULT_VERSION = [1, 0].freeze
+
+      def initialize(host, port: 0)
+        ptr = C::Network.sfHttp_create
+        raise Error, "sfHttp_create returned NULL" if ptr.null?
+
+        @handle = FFI::AutoPointer.new(ptr, C::Network.method(:sfHttp_destroy))
+        C::Network.sfHttp_setHost(@handle, host.to_s, Integer(port))
+      end
+
+      def send_request(method: :get, uri: "/", fields: nil, body: nil,
+                       http_version: DEFAULT_VERSION, timeout: DEFAULT_TIMEOUT)
+        request_ptr = C::Network.sfHttpRequest_create
+        raise Error, "sfHttpRequest_create returned NULL" if request_ptr.null?
+
+        begin
+          method_idx = C::Network::HTTP_METHODS.index(method) ||
+            raise(ArgumentError, "Unknown HTTP method: #{method.inspect} " \
+                                 "(expected one of #{C::Network::HTTP_METHODS.inspect})")
+          C::Network.sfHttpRequest_setMethod(request_ptr, method_idx)
+          C::Network.sfHttpRequest_setUri(request_ptr, uri.to_s)
+          C::Network.sfHttpRequest_setHttpVersion(request_ptr, Integer(http_version[0]), Integer(http_version[1]))
+          C::Network.sfHttpRequest_setBody(request_ptr, body.to_s) if body
+          fields&.each_pair do |name, value|
+            C::Network.sfHttpRequest_setField(request_ptr, name.to_s, value.to_s)
+          end
+
+          t = timeout.is_a?(Time) ? timeout : Time.seconds(timeout.to_f)
+          response_ptr = C::Network.sfHttp_sendRequest(@handle, request_ptr, t.to_native)
+          raise Error, "sfHttp_sendRequest returned NULL" if response_ptr.null?
+
+          Response.send(:_take_ownership, response_ptr)
+        ensure
+          C::Network.sfHttpRequest_destroy(request_ptr)
+        end
+      end
+
+      attr_reader :handle # :nodoc:
+
+      # Read-only view onto a CSFML sfHttpResponse. Wraps the C pointer
+      # in a Ruby object that destroys the response when GC'd.
+      class Response
+        # Status mappings — most map onto standard HTTP codes; the four
+        # at the bottom are SFML-side transport errors above the
+        # standard range (≥ 1000).
+        STATUS_NAMES = {
+          200 => :ok, 201 => :created, 202 => :accepted, 204 => :no_content,
+          205 => :reset_content, 206 => :partial_content,
+          301 => :multiple_choices, 302 => :moved_permanently, 303 => :moved_temporarily,
+          304 => :not_modified,
+          400 => :bad_request, 401 => :unauthorized, 403 => :forbidden, 404 => :not_found,
+          405 => :range_not_satisfiable,
+          500 => :internal_server_error, 501 => :not_implemented, 502 => :bad_gateway,
+          503 => :service_not_available, 504 => :gateway_timeout, 505 => :version_not_supported,
+          1000 => :invalid_response, 1001 => :connection_failed,
+        }.freeze
+
+        def initialize
+          raise NoMethodError, "use SFML::Network::Http#send_request to create a Response"
+        end
+
+        def status
+          C::Network.sfHttpResponse_getStatus(@handle)
+        end
+
+        # The status as a symbol when CSFML maps it, otherwise the
+        # raw integer. Useful for `case resp.status_symbol in :ok`.
+        def status_symbol
+          STATUS_NAMES[status] || status
+        end
+
+        def body  = C::Network.sfHttpResponse_getBody(@handle).to_s
+        def field(name) = C::Network.sfHttpResponse_getField(@handle, name.to_s)
+
+        def http_version
+          [
+            C::Network.sfHttpResponse_getMajorVersion(@handle),
+            C::Network.sfHttpResponse_getMinorVersion(@handle),
+          ]
+        end
+
+        attr_reader :handle # :nodoc:
+
+        # @!visibility private
+        def self._take_ownership(ptr)
+          obj = allocate
+          obj.instance_variable_set(:@handle,
+            FFI::AutoPointer.new(ptr, C::Network.method(:sfHttpResponse_destroy)))
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/sfml/network/socket_selector.rb

@@ -0,0 +1,93 @@
+module SFML
+  module Network
+    # Multiplex many sockets onto a single blocking #wait. Useful for
+    # one-thread network servers — register every socket / listener
+    # you care about, call #wait, then ask each one whether it's
+    # `ready?`. Ready means there's data to read or, for a listener,
+    # an incoming connection waiting.
+    #
+    #   selector = SFML::Network::SocketSelector.new
+    #   selector.add(listener)
+    #   clients.each { |c| selector.add(c) }
+    #
+    #   if selector.wait(timeout: 1.0)
+    #     if selector.ready?(listener)
+    #       # accept() will not block
+    #     end
+    #     clients.each do |c|
+    #       next unless selector.ready?(c)
+    #       # receive() will return data
+    #     end
+    #   end
+    #
+    # Ruby's `IO.select` covers a similar use case for plain Ruby IO
+    # objects; this binding exists for game code that's already using
+    # `SFML::Network::Tcp{Socket,Listener}` / `UdpSocket`.
+    class SocketSelector
+      def initialize
+        ptr = C::Network.sfSocketSelector_create
+        raise Error, "sfSocketSelector_create returned NULL" if ptr.null?
+
+        @handle = FFI::AutoPointer.new(ptr, C::Network.method(:sfSocketSelector_destroy))
+      end
+
+      def add(socket)
+        case socket
+        when TcpListener then C::Network.sfSocketSelector_addTcpListener(@handle, socket.handle)
+        when TcpSocket   then C::Network.sfSocketSelector_addTcpSocket(@handle,  socket.handle)
+        when UdpSocket   then C::Network.sfSocketSelector_addUdpSocket(@handle,  socket.handle)
+        else
+          raise ArgumentError,
+                "SocketSelector#add expects TcpListener, TcpSocket, or UdpSocket (got #{socket.class})"
+        end
+        self
+      end
+
+      def remove(socket)
+        case socket
+        when TcpListener then C::Network.sfSocketSelector_removeTcpListener(@handle, socket.handle)
+        when TcpSocket   then C::Network.sfSocketSelector_removeTcpSocket(@handle,  socket.handle)
+        when UdpSocket   then C::Network.sfSocketSelector_removeUdpSocket(@handle,  socket.handle)
+        else
+          raise ArgumentError,
+                "SocketSelector#remove expects TcpListener, TcpSocket, or UdpSocket (got #{socket.class})"
+        end
+        self
+      end
+
+      def clear
+        C::Network.sfSocketSelector_clear(@handle)
+        self
+      end
+
+      # Block until at least one registered socket has activity, or
+      # `timeout` elapses. `timeout` may be a SFML::Time, a Numeric
+      # (seconds), or nil / SFML::Time.zero (no timeout — block
+      # forever). Returns true if a socket is ready, false on timeout.
+      def wait(timeout: nil)
+        t =
+          case timeout
+          when nil     then SFML::Time.zero
+          when Time    then timeout
+          when Numeric then SFML::Time.seconds(timeout.to_f)
+          else
+            raise ArgumentError, "timeout must be SFML::Time, Numeric, or nil"
+          end
+        C::Network.sfSocketSelector_wait(@handle, t.to_native)
+      end
+
+      def ready?(socket)
+        case socket
+        when TcpListener then C::Network.sfSocketSelector_isTcpListenerReady(@handle, socket.handle)
+        when TcpSocket   then C::Network.sfSocketSelector_isTcpSocketReady(@handle,  socket.handle)
+        when UdpSocket   then C::Network.sfSocketSelector_isUdpSocketReady(@handle,  socket.handle)
+        else
+          raise ArgumentError,
+                "SocketSelector#ready? expects TcpListener, TcpSocket, or UdpSocket (got #{socket.class})"
+        end
+      end
+
+      attr_reader :handle # :nodoc:
+    end
+  end
+end

data/lib/sfml/version.rb

@@ -15,5 +15,5 @@ module SFML
   #   "3.0.1.0"  — CSFML 3.0.1 ships, we re-cut from upstream
   #   "3.0.1.1"  — our patch on top of CSFML 3.0.1
   #   "3.1.0.0"  — CSFML 3.1.0 ships, we add new bindings
-  VERSION = "3.0.0.0"
+  VERSION = "3.0.0.1"
 end

data/lib/sfml/window/event.rb

@@ -122,6 +122,20 @@ module SFML
         c = C::Window::JoystickConnectEvent.new(ptr)
         { joystick_id: c[:joystick_id] }
 
+      when :touch_began, :touch_moved, :touch_ended
+        t = C::Window::TouchEvent.new(ptr)
+        {
+          finger:   t[:finger],
+          position: Vector2.new(t[:position][:x], t[:position][:y]),
+        }
+
+      when :sensor_changed
+        s = C::Window::SensorEvent.new(ptr)
+        {
+          sensor: Sensor::TYPES[s[:sensor]] || :unknown,
+          value:  Vector3.new(s[:value][:x], s[:value][:y], s[:value][:z]),
+        }
+
       else
         EMPTY
       end

data/lib/sfml/window/sensor.rb

@@ -0,0 +1,50 @@
+module SFML
+  # Mobile-platform inertial / environment sensors. SFML treats every
+  # device the same way: identify the sensor by symbol, ask if it's
+  # available, enable it before reading, then poll a Vector3 value
+  # whose components depend on the sensor type (e.g. acceleration in
+  # m/s² for `:accelerometer`, angular velocity in deg/s for
+  # `:gyroscope`, magnetic field in µT for `:magnetometer`).
+  #
+  #   if SFML::Sensor.available?(:accelerometer)
+  #     SFML::Sensor.enable(:accelerometer)
+  #     gravity = SFML::Sensor.value(:accelerometer)
+  #   end
+  #
+  # On desktop platforms without sensor hardware, `available?` returns
+  # `false` and `value` returns the zero vector — calls don't raise.
+  #
+  # Sensor data also surfaces through the event loop as
+  # `{type: :sensor_changed, sensor: :accelerometer, value: Vector3}`.
+  module Sensor
+    TYPES       = C::Window::SENSOR_TYPES
+    TYPE_INDEX  = TYPES.each_with_index.to_h.freeze
+
+    module_function
+
+    def available?(type)
+      C::Window.sfSensor_isAvailable(_index(type))
+    end
+
+    def enable(type)
+      C::Window.sfSensor_setEnabled(_index(type), true)
+    end
+
+    def disable(type)
+      C::Window.sfSensor_setEnabled(_index(type), false)
+    end
+
+    def value(type)
+      v = C::Window.sfSensor_getValue(_index(type))
+      Vector3.new(v[:x], v[:y], v[:z])
+    end
+
+    # @!visibility private
+    def _index(type)
+      TYPE_INDEX.fetch(type) do
+        raise ArgumentError, "Unknown sensor type: #{type.inspect} " \
+                             "(expected one of #{TYPES.inspect})"
+      end
+    end
+  end
+end

data/lib/sfml/window/touch.rb

@@ -0,0 +1,39 @@
+module SFML
+  # Polling API for touchscreen input. Each finger is identified by an
+  # integer (0 = first contact, 1 = second, etc.). The same fingers
+  # also surface through the event loop as `:touch_began`,
+  # `:touch_moved`, `:touch_ended` events with `finger:` and
+  # `position:` fields.
+  #
+  #   if SFML::Touch.down?(0)
+  #     pos = SFML::Touch.position(0, relative_to: window)
+  #     ...
+  #   end
+  #
+  # On desktop platforms without touchscreen hardware these always
+  # return `false` / `[0, 0]`.
+  module Touch
+    module_function
+
+    # True while finger `n` is currently in contact with the screen.
+    def down?(finger = 0)
+      C::Window.sfTouch_isDown(Integer(finger))
+    end
+
+    # Position of finger `n`. Without `relative_to:`, returns
+    # desktop-relative coordinates; pass a Window or RenderWindow to
+    # get window-local coordinates.
+    def position(finger = 0, relative_to: nil)
+      f = Integer(finger)
+      vec =
+        case relative_to
+        when nil          then C::Window.sfTouch_getPosition(f, nil)
+        when RenderWindow then C::Graphics.sfTouch_getPositionRenderWindow(f, relative_to.handle)
+        when Window       then C::Window.sfTouch_getPosition(f, relative_to.handle)
+        else
+          raise ArgumentError, "relative_to: must be SFML::Window, SFML::RenderWindow, or nil"
+        end
+      Vector2.new(vec[:x], vec[:y])
+    end
+  end
+end

data/lib/sfml/window/window.rb

@@ -129,10 +129,67 @@ module SFML
       C::Window.sfWindow_setActive(@handle, value ? true : false)
     end
 
+    # Replace the window's title-bar / taskbar icon with the pixels from
+    # the given SFML::Image. The OS scales it as needed; 32×32 RGBA
+    # is the typical sweet spot.
+    def icon=(image)
+      raise ArgumentError, "Window#icon= requires a SFML::Image" unless image.is_a?(SFML::Image)
+
+      size = C::System::Vector2u.new
+      size[:x] = image.width
+      size[:y] = image.height
+      C::Window.sfWindow_setIcon(@handle, size, C::Graphics.sfImage_getPixelsPtr(image.handle))
+    end
+
+    # Constrain user-driven resizes. Accepts a [w, h] Array, a Vector2,
+    # or nil to clear the limit. When set, the OS won't let the user
+    # drag the window smaller (or larger) than this — programmatic
+    # `size=` is not affected.
+    def minimum_size=(value)
+      C::Window.sfWindow_setMinimumSize(@handle, _vec2u_or_nil(value))
+    end
+
+    def maximum_size=(value)
+      C::Window.sfWindow_setMaximumSize(@handle, _vec2u_or_nil(value))
+    end
+
+    # OS-specific native handle for the underlying window — `HWND` on
+    # Windows, `NSView*` on macOS, X11 `Window` xid on Linux.
+    # Returns an FFI::Pointer; cast or read as the platform expects.
+    def native_handle
+      C::Window.sfWindow_getNativeHandle(@handle)
+    end
+
+    # Wrap an existing OS-level window. `handle` is a platform native
+    # handle (Integer address or FFI::Pointer). Useful when SFML is
+    # being embedded inside another framework (Qt, Gtk, raw Win32,
+    # Cocoa NSView). The framework owns the window's lifecycle; SFML
+    # only renders into it.
+    def self.from_handle(handle)
+      ptr = handle.is_a?(FFI::Pointer) ? handle : FFI::Pointer.new(:void, Integer(handle))
+      raw = C::Window.sfWindow_createFromHandle(ptr, nil)
+      raise Error, "sfWindow_createFromHandle returned NULL" if raw.null?
+
+      win = allocate
+      win.instance_variable_set(:@handle,
+        FFI::AutoPointer.new(raw, C::Window.method(:sfWindow_destroy)))
+      win.instance_variable_set(:@event_buffer, C::Window::Event.new)
+      win
+    end
+
     attr_reader :handle # :nodoc:
 
     private
 
+    def _vec2u_or_nil(value)
+      return nil if value.nil?
+
+      vec = value.is_a?(Vector2) ? value : Vector2.new(*value)
+      v = C::System::Vector2u.new
+      v[:x] = Integer(vec.x); v[:y] = Integer(vec.y)
+      v
+    end
+
     def parse_args(args)
       case args.length
       when 2

data/lib/sfml.rb

@@ -32,13 +32,28 @@ at_exit do
     else                            1
     end
 
-  # 2. Quiet the audio thread before anything else — OpenAL holds onto
+  # 2. If we're exiting because of an unhandled exception, print it
+  #    ourselves — `exit!` below skips Ruby's terminal exception
+  #    reporter, so without this the user sees a silent exit instead
+  #    of the stack trace they'd normally get.
+  if $! && !$!.is_a?(SystemExit)
+    err = $!
+    warn "#{err.backtrace.first}: #{err.message} (#{err.class})"
+    err.backtrace.drop(1).each { |line| warn "\tfrom #{line}" }
+  end
+
+  # 3. Quiet the audio thread before anything else — OpenAL holds onto
   #    sample buffers and crashes if Ruby starts freeing them while
   #    a Sound/Music is mid-loop.
   ObjectSpace.each_object(SFML::Sound) { |s| s.stop rescue nil } if defined?(SFML::Sound)
   ObjectSpace.each_object(SFML::Music) { |m| m.stop rescue nil } if defined?(SFML::Music)
+  # SoundStream isn't stopped from this hook on purpose — by the time
+  # at_exit runs, finalizer ordering can have already destroyed
+  # the underlying CSFML stream, and CSFML asserts on a stale handle.
+  # Either explicitly #stop your SoundStream before exit, or rely on
+  # exit!() below to skip the audio thread's natural teardown.
 
-  # 3. Bypass Ruby's natural finalizer pass entirely. Process memory is
+  # 4. Bypass Ruby's natural finalizer pass entirely. Process memory is
   #    about to be reclaimed by the kernel anyway, and Ruby's
   #    non-deterministic destruction order races with CSFML's GL/audio
   #    internals — segfaulting inside libopenal/libGL is the typical
@@ -59,6 +74,8 @@ require "sfml/system/rect"
 require "sfml/window/keyboard"
 require "sfml/window/mouse"
 require "sfml/window/joystick"
+require "sfml/window/touch"
+require "sfml/window/sensor"
 require "sfml/window/cursor"
 require "sfml/window/clipboard"
 require "sfml/window/video_mode"
@@ -74,25 +91,33 @@ require "sfml/graphics/rectangle_shape"
 require "sfml/graphics/convex_shape"
 require "sfml/graphics/vertex"
 require "sfml/graphics/vertex_array"
+require "sfml/graphics/vertex_buffer"
 require "sfml/graphics/font"
 require "sfml/graphics/text"
 require "sfml/graphics/view"
 require "sfml/graphics/blend_mode"
+require "sfml/graphics/stencil_mode"
 require "sfml/graphics/shader"
 require "sfml/graphics/transform"
 require "sfml/graphics/render_states"
 require "sfml/graphics/render_target"
 require "sfml/graphics/render_window"
 require "sfml/graphics/render_texture"
+require "sfml/audio/internal"
 require "sfml/audio/sound_buffer"
+require "sfml/audio/sound_cone"
 require "sfml/audio/sound"
 require "sfml/audio/music"
 require "sfml/audio/listener"
 require "sfml/audio/sound_recorder"
 require "sfml/audio/sound_buffer_recorder"
+require "sfml/audio/sound_stream"
 require "sfml/network/ip_address"
 require "sfml/network/tcp_socket"
 require "sfml/network/tcp_listener"
 require "sfml/network/udp_socket"
+require "sfml/network/socket_selector"
+require "sfml/network/http"
+require "sfml/network/ftp"
 require "sfml/assets"
 require "sfml/game"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-sfml
 version: !ruby/object:Gem::Version
-  version: 3.0.0.0
+  version: 3.0.0.1
 platform: ruby
 authors:
 - Mykhailo Melnyk
@@ -82,12 +82,15 @@ files:
 - lib/sfml/assets.rb
 - lib/sfml/assets/fonts/DejaVuSans.LICENSE.txt
 - lib/sfml/assets/fonts/DejaVuSans.ttf
+- lib/sfml/audio/internal.rb
 - lib/sfml/audio/listener.rb
 - lib/sfml/audio/music.rb
 - lib/sfml/audio/sound.rb
 - lib/sfml/audio/sound_buffer.rb
 - lib/sfml/audio/sound_buffer_recorder.rb
+- lib/sfml/audio/sound_cone.rb
 - lib/sfml/audio/sound_recorder.rb
+- lib/sfml/audio/sound_stream.rb
 - lib/sfml/c.rb
 - lib/sfml/c/audio.rb
 - lib/sfml/c/graphics.rb
@@ -108,14 +111,19 @@ files:
 - lib/sfml/graphics/render_window.rb
 - lib/sfml/graphics/shader.rb
 - lib/sfml/graphics/sprite.rb
+- lib/sfml/graphics/stencil_mode.rb
 - lib/sfml/graphics/text.rb
 - lib/sfml/graphics/texture.rb
 - lib/sfml/graphics/transform.rb
 - lib/sfml/graphics/transformable.rb
 - lib/sfml/graphics/vertex.rb
 - lib/sfml/graphics/vertex_array.rb
+- lib/sfml/graphics/vertex_buffer.rb
 - lib/sfml/graphics/view.rb
+- lib/sfml/network/ftp.rb
+- lib/sfml/network/http.rb
 - lib/sfml/network/ip_address.rb
+- lib/sfml/network/socket_selector.rb
 - lib/sfml/network/tcp_listener.rb
 - lib/sfml/network/tcp_socket.rb
 - lib/sfml/network/udp_socket.rb
@@ -131,6 +139,8 @@ files:
 - lib/sfml/window/joystick.rb
 - lib/sfml/window/keyboard.rb
 - lib/sfml/window/mouse.rb
+- lib/sfml/window/sensor.rb
+- lib/sfml/window/touch.rb
 - lib/sfml/window/video_mode.rb
 - lib/sfml/window/window.rb
 - ruby-sfml.gemspec