ruby-sfml 3.0.0.0 → 3.0.0.1

data/lib/sfml/audio/sound_stream.rb

@@ -0,0 +1,206 @@
+module SFML
+  # Procedural audio source. Subclass it and override `#on_get_data`
+  # to fill each chunk on demand — CSFML invokes the callback from
+  # its audio thread whenever the sound queue runs low.
+  #
+  # `#on_get_data` returns either:
+  #   * an Array (or anything responding to `#to_a`) of Int16 PCM
+  #     samples — they're packed into a buffer and handed to CSFML;
+  #   * `nil` to stop the stream.
+  #
+  # Override `#on_seek(time)` to support `playing_offset=`. Default
+  # is a no-op (the next callback continues from wherever the
+  # subclass internal state happens to be).
+  #
+  #   class SineWave < SFML::SoundStream
+  #     def initialize(freq:, sample_rate: 44_100)
+  #       super(channel_count: 1, sample_rate: sample_rate)
+  #       @freq, @sample_rate = freq, sample_rate
+  #       @phase = 0.0
+  #     end
+  #
+  #     def on_get_data
+  #       n = @sample_rate / 10   # ~100ms chunks
+  #       step = 2 * Math::PI * @freq / @sample_rate
+  #       Array.new(n) do
+  #         s = (Math.sin(@phase) * 30_000).to_i
+  #         @phase = (@phase + step) % (2 * Math::PI)
+  #         s
+  #       end
+  #     end
+  #
+  #     def on_seek(time)
+  #       @phase = 0.0
+  #     end
+  #   end
+  #
+  # CAVEATS
+  # * The callback runs on the SFML audio thread; doing heavy work
+  #   there will glitch the audio. Generate samples and return.
+  # * Ruby threads still need the GVL — your callback acquires it
+  #   each invocation. Long Ruby work on the main thread can starve
+  #   the audio thread and produce dropouts.
+  # * Always keep a reference to the SoundStream object (assign to a
+  #   variable, store in an instance var). If the Ruby object is GC'd
+  #   while CSFML is still calling callbacks, the process crashes.
+  class SoundStream
+    DEFAULT_CHUNK_FRAMES = 4096
+
+    def initialize(channel_count:, sample_rate:)
+      raise ArgumentError, "channel_count must be >= 1" if channel_count < 1
+      raise ArgumentError, "sample_rate must be > 0"    if sample_rate < 1
+
+      # Hold strong refs so neither GC nor reload disposes the
+      # callbacks while CSFML is still calling them.
+      @get_data_cb = FFI::Function.new(:bool, [:pointer, :pointer]) do |chunk_ptr, _user|
+        _on_get_data_callback(chunk_ptr)
+      end
+      @seek_cb = FFI::Function.new(:void, [C::System::Time.by_value, :pointer]) do |time, _user|
+        on_seek(Time.from_native(time))
+        nil
+      end
+
+      ptr = C::Audio.sfSoundStream_create(
+        @get_data_cb, @seek_cb,
+        Integer(channel_count), Integer(sample_rate),
+        nil, 0,
+        nil,
+      )
+      raise Error, "sfSoundStream_create returned NULL" if ptr.null?
+
+      @handle = FFI::AutoPointer.new(ptr, C::Audio.method(:sfSoundStream_destroy))
+
+      # We re-use a single MemoryPointer for the sample buffer,
+      # growing it on demand. CSFML reads from the pointer between
+      # callbacks, then asks for the next chunk — by the time we
+      # overwrite, CSFML is done with the previous data.
+      @sample_buffer = nil
+      @sample_buffer_capacity = 0
+    end
+
+    # ---- Subclass hooks ------------------------------------------------
+
+    # Return an Array of Int16 PCM samples (interleaved if multi-channel),
+    # or `nil` to stop the stream. Default raises so subclasses must
+    # implement it.
+    def on_get_data
+      raise NoMethodError, "#{self.class} must override #on_get_data"
+    end
+
+    # Called when the user changes the playing offset. Default is a
+    # no-op — override if your stream tracks position internally
+    # (counters, file offsets, etc.).
+    def on_seek(_time); end
+
+    # ---- Public playback API ------------------------------------------
+
+    def play  = (C::Audio.sfSoundStream_play(@handle); self)
+    def pause = (C::Audio.sfSoundStream_pause(@handle); self)
+    def stop  = (C::Audio.sfSoundStream_stop(@handle); self)
+
+    def status      = C::Audio::STATUSES[C::Audio.sfSoundStream_getStatus(@handle)]
+    def playing?    = status == :playing
+    def paused?     = status == :paused
+    def stopped?    = status == :stopped
+
+    def channel_count = C::Audio.sfSoundStream_getChannelCount(@handle)
+    def sample_rate   = C::Audio.sfSoundStream_getSampleRate(@handle)
+
+    # Cached on the Ruby side; some OpenAL backends (notably the
+    # headless null sink we get on Linux CI) don't reliably read
+    # the loop flag back through CSFML once it's been set.
+    def looping?
+      @looping == true
+    end
+
+    def looping=(value)
+      @looping = !!value
+      C::Audio.sfSoundStream_setLooping(@handle, @looping)
+    end
+
+    def volume = C::Audio.sfSoundStream_getVolume(@handle)
+
+    def volume=(value)
+      C::Audio.sfSoundStream_setVolume(@handle, value.to_f)
+    end
+
+    def pitch = C::Audio.sfSoundStream_getPitch(@handle)
+
+    def pitch=(value)
+      C::Audio.sfSoundStream_setPitch(@handle, value.to_f)
+    end
+
+    def playing_offset
+      Time.from_native(C::Audio.sfSoundStream_getPlayingOffset(@handle))
+    end
+
+    def playing_offset=(value)
+      t = value.is_a?(Time) ? value : Time.seconds(value.to_f)
+      C::Audio.sfSoundStream_setPlayingOffset(@handle, t.to_native)
+    end
+
+    def position
+      v = C::Audio.sfSoundStream_getPosition(@handle)
+      Vector3.new(v[:x], v[:y], v[:z])
+    end
+
+    def position=(value)
+      v = value.is_a?(Vector3) ? value : Vector3.new(*value)
+      packed = C::System::Vector3f.new
+      packed[:x] = v.x.to_f; packed[:y] = v.y.to_f; packed[:z] = v.z.to_f
+      C::Audio.sfSoundStream_setPosition(@handle, packed)
+    end
+
+    def attenuation = C::Audio.sfSoundStream_getAttenuation(@handle)
+
+    def attenuation=(value)
+      C::Audio.sfSoundStream_setAttenuation(@handle, value.to_f)
+    end
+
+    def min_distance = C::Audio.sfSoundStream_getMinDistance(@handle)
+
+    def min_distance=(value)
+      C::Audio.sfSoundStream_setMinDistance(@handle, value.to_f)
+    end
+
+    def relative_to_listener? = C::Audio.sfSoundStream_isRelativeToListener(@handle)
+
+    def relative_to_listener=(value)
+      C::Audio.sfSoundStream_setRelativeToListener(@handle, !!value)
+    end
+
+    attr_reader :handle # :nodoc:
+
+    private
+
+    # Bridge between CSFML's chunk struct and our user-facing
+    # `#on_get_data`. Runs on the audio thread.
+    def _on_get_data_callback(chunk_ptr)
+      samples = on_get_data
+      chunk = C::Audio::SoundStreamChunk.new(chunk_ptr)
+
+      if samples.nil?
+        chunk[:samples]      = FFI::Pointer::NULL
+        chunk[:sample_count] = 0
+        return false
+      end
+
+      arr = samples.respond_to?(:to_a) ? samples.to_a : samples
+      n   = arr.length
+
+      _grow_sample_buffer(n)
+      @sample_buffer.write_array_of_int16(arr) if n > 0
+
+      chunk[:samples]      = @sample_buffer
+      chunk[:sample_count] = n
+      true
+    end
+
+    def _grow_sample_buffer(n)
+      return if @sample_buffer && @sample_buffer_capacity >= n
+
+      @sample_buffer_capacity = [n, DEFAULT_CHUNK_FRAMES].max
+      @sample_buffer          = FFI::MemoryPointer.new(:int16, @sample_buffer_capacity)
+    end
+  end
+end

data/lib/sfml/c/audio.rb

@@ -12,6 +12,13 @@ module SFML
       # sfSoundStatus = { sfStopped, sfPaused, sfPlaying } in that order.
       STATUSES = %i[stopped paused playing].freeze
 
+      # Plain-old-data struct that mirrors sfSoundSourceCone.
+      class SoundSourceCone < FFI::Struct
+        layout :inner_angle, :float,
+               :outer_angle, :float,
+               :outer_gain,  :float
+      end
+
       # ---- SoundBuffer ----
       attach_function :sfSoundBuffer_createFromFile, [:string], :sound_buffer_t
       attach_function :sfSoundBuffer_destroy,        [:sound_buffer_t], :void
@@ -44,6 +51,19 @@ module SFML
       attach_function :sfSound_getAttenuation,        [:sound_t], :float
       attach_function :sfSound_setRelativeToListener, [:sound_t, :bool], :void
       attach_function :sfSound_isRelativeToListener,  [:sound_t], :bool
+      attach_function :sfSound_setPlayingOffset,      [:sound_t, System::Time.by_value], :void
+      attach_function :sfSound_getPlayingOffset,      [:sound_t], System::Time.by_value
+      attach_function :sfSound_setVelocity,           [:sound_t, System::Vector3f.by_value], :void
+      attach_function :sfSound_getVelocity,           [:sound_t], System::Vector3f.by_value
+      attach_function :sfSound_setDopplerFactor,      [:sound_t, :float], :void
+      attach_function :sfSound_getDopplerFactor,      [:sound_t], :float
+      attach_function :sfSound_setDirection,          [:sound_t, System::Vector3f.by_value], :void
+      attach_function :sfSound_getDirection,          [:sound_t], System::Vector3f.by_value
+      attach_function :sfSound_setCone,               [:sound_t, SoundSourceCone.by_value], :void
+      attach_function :sfSound_getCone,               [:sound_t], SoundSourceCone.by_value
+      # void(*)(const float* in, unsigned int* in_count, float* out, unsigned int* out_count, unsigned int channels, void* userData)
+      callback :sf_effect_processor, [:pointer, :pointer, :pointer, :pointer, :uint32, :pointer], :void
+      attach_function :sfSound_setEffectProcessor,    [:sound_t, :sf_effect_processor, :pointer], :void
 
       # ---- Music ----
       attach_function :sfMusic_createFromFile, [:string], :music_t
@@ -68,6 +88,60 @@ module SFML
       attach_function :sfMusic_getAttenuation,        [:music_t], :float
       attach_function :sfMusic_setRelativeToListener, [:music_t, :bool], :void
       attach_function :sfMusic_isRelativeToListener,  [:music_t], :bool
+      attach_function :sfMusic_setPlayingOffset,      [:music_t, System::Time.by_value], :void
+      attach_function :sfMusic_getPlayingOffset,      [:music_t], System::Time.by_value
+      attach_function :sfMusic_setVelocity,           [:music_t, System::Vector3f.by_value], :void
+      attach_function :sfMusic_getVelocity,           [:music_t], System::Vector3f.by_value
+      attach_function :sfMusic_setDopplerFactor,      [:music_t, :float], :void
+      attach_function :sfMusic_getDopplerFactor,      [:music_t], :float
+      attach_function :sfMusic_setDirection,          [:music_t, System::Vector3f.by_value], :void
+      attach_function :sfMusic_getDirection,          [:music_t], System::Vector3f.by_value
+      attach_function :sfMusic_setCone,               [:music_t, SoundSourceCone.by_value], :void
+      attach_function :sfMusic_getCone,               [:music_t], SoundSourceCone.by_value
+      attach_function :sfMusic_setEffectProcessor,    [:music_t, :sf_effect_processor, :pointer], :void
+
+      # ---- SoundStream ----
+      # Custom audio source — fills a chunk via a Ruby callback that
+      # CSFML invokes from the audio thread. Beware: that callback
+      # has to acquire the GVL to run any Ruby code, so don't do
+      # heavy work there. Generate samples and return.
+      typedef :pointer, :sound_stream_t
+
+      class SoundStreamChunk < FFI::Struct
+        layout :samples,      :pointer,
+               :sample_count, :uint32
+      end
+
+      callback :sound_stream_get_data, [:pointer, :pointer], :bool
+      callback :sound_stream_seek,     [System::Time.by_value, :pointer], :void
+
+      attach_function :sfSoundStream_create,
+                      [:sound_stream_get_data, :sound_stream_seek,
+                       :uint32, :uint32, :pointer, :size_t, :pointer],
+                      :sound_stream_t
+      attach_function :sfSoundStream_destroy,           [:sound_stream_t], :void
+      attach_function :sfSoundStream_play,              [:sound_stream_t], :void
+      attach_function :sfSoundStream_pause,             [:sound_stream_t], :void
+      attach_function :sfSoundStream_stop,              [:sound_stream_t], :void
+      attach_function :sfSoundStream_getChannelCount,   [:sound_stream_t], :uint32
+      attach_function :sfSoundStream_getSampleRate,     [:sound_stream_t], :uint32
+      attach_function :sfSoundStream_getStatus,         [:sound_stream_t], :int
+      attach_function :sfSoundStream_setPlayingOffset,  [:sound_stream_t, System::Time.by_value], :void
+      attach_function :sfSoundStream_getPlayingOffset,  [:sound_stream_t], System::Time.by_value
+      attach_function :sfSoundStream_setLooping,        [:sound_stream_t, :bool], :void
+      attach_function :sfSoundStream_isLooping,         [:sound_stream_t], :bool
+      attach_function :sfSoundStream_setVolume,         [:sound_stream_t, :float], :void
+      attach_function :sfSoundStream_getVolume,         [:sound_stream_t], :float
+      attach_function :sfSoundStream_setPitch,          [:sound_stream_t, :float], :void
+      attach_function :sfSoundStream_getPitch,          [:sound_stream_t], :float
+      attach_function :sfSoundStream_setPosition,       [:sound_stream_t, System::Vector3f.by_value], :void
+      attach_function :sfSoundStream_getPosition,       [:sound_stream_t], System::Vector3f.by_value
+      attach_function :sfSoundStream_setMinDistance,    [:sound_stream_t, :float], :void
+      attach_function :sfSoundStream_getMinDistance,    [:sound_stream_t], :float
+      attach_function :sfSoundStream_setAttenuation,    [:sound_stream_t, :float], :void
+      attach_function :sfSoundStream_getAttenuation,    [:sound_stream_t], :float
+      attach_function :sfSoundStream_setRelativeToListener, [:sound_stream_t, :bool], :void
+      attach_function :sfSoundStream_isRelativeToListener,  [:sound_stream_t], :bool
 
       # ---- SoundBufferRecorder ----
       # The simple "record into a SoundBuffer" path. Raw sfSoundRecorder
@@ -101,6 +175,10 @@ module SFML
       attach_function :sfListener_getDirection,    [], System::Vector3f.by_value
       attach_function :sfListener_setUpVector,     [System::Vector3f.by_value], :void
       attach_function :sfListener_getUpVector,     [], System::Vector3f.by_value
+      attach_function :sfListener_setVelocity,     [System::Vector3f.by_value], :void
+      attach_function :sfListener_getVelocity,     [], System::Vector3f.by_value
+      attach_function :sfListener_setCone,         [SoundSourceCone.by_value], :void
+      attach_function :sfListener_getCone,         [], SoundSourceCone.by_value
     end
   end
 end

data/lib/sfml/c/graphics.rb

@@ -94,8 +94,17 @@ module SFML
       attach_function :sfRenderWindow_setFramerateLimit,      [:render_window_t, :uint32], :void
       attach_function :sfRenderWindow_display,                [:render_window_t], :void
       attach_function :sfRenderWindow_clear,                  [:render_window_t, Color.by_value], :void
+      attach_function :sfRenderWindow_clearStencil,           [:render_window_t, StencilValue.by_value], :void
+      attach_function :sfRenderWindow_clearColorAndStencil,   [:render_window_t, Color.by_value, StencilValue.by_value], :void
       attach_function :sfRenderWindow_getSize,                [:render_window_t], System::Vector2u.by_value
       attach_function :sfRenderWindow_setSize,                [:render_window_t, System::Vector2u.by_value], :void
+      attach_function :sfRenderWindow_setIcon,                [:render_window_t, System::Vector2u.by_value, :pointer], :void
+
+      typedef :pointer, :vertex_buffer_t
+      attach_function :sfRenderWindow_setMinimumSize,         [:render_window_t, :pointer], :void
+      attach_function :sfRenderWindow_setMaximumSize,         [:render_window_t, :pointer], :void
+      attach_function :sfRenderWindow_createFromHandle,       [:pointer, :pointer], :render_window_t
+      attach_function :sfRenderWindow_getNativeHandle,        [:render_window_t], :pointer
 
       typedef :pointer, :texture_t
       typedef :pointer, :render_texture_t
@@ -144,6 +153,10 @@ module SFML
                       [:render_window_t, :text_t, :render_states_t], :void
       attach_function :sfRenderWindow_drawVertexArray,
                       [:render_window_t, :vertex_array_t, :render_states_t], :void
+      attach_function :sfRenderWindow_drawVertexBuffer,
+                      [:render_window_t, :vertex_buffer_t, :render_states_t], :void
+      attach_function :sfRenderWindow_drawVertexBufferRange,
+                      [:render_window_t, :vertex_buffer_t, :uint32, :uint32, :render_states_t], :void
 
       # Mouse position queries relative to a render-window.
       attach_function :sfMouse_getPositionRenderWindow,
@@ -151,6 +164,10 @@ module SFML
       attach_function :sfMouse_setPositionRenderWindow,
                       [System::Vector2i.by_value, :render_window_t], :void
 
+      # Touch position relative to a render-window.
+      attach_function :sfTouch_getPositionRenderWindow,
+                      [:uint32, :render_window_t], System::Vector2i.by_value
+
       # ---- View ----
       attach_function :sfView_create,         [], :view_t
       attach_function :sfView_createFromRect, [FloatRect.by_value], :view_t
@@ -206,6 +223,7 @@ module SFML
       attach_function :sfImage_copy,              [:image_t], :image_t
       attach_function :sfImage_destroy,           [:image_t], :void
       attach_function :sfImage_saveToFile,        [:image_t, :string], :bool
+      attach_function :sfImage_saveToMemory,      [:image_t, :pointer, :string], :bool
       attach_function :sfImage_getSize,           [:image_t], System::Vector2u.by_value
       attach_function :sfImage_setPixel,          [:image_t, System::Vector2u.by_value, Color.by_value], :void
       attach_function :sfImage_getPixel,          [:image_t, System::Vector2u.by_value], Color.by_value
@@ -324,6 +342,9 @@ module SFML
       attach_function :sfRenderTexture_setActive,       [:render_texture_t, :bool], :bool
       attach_function :sfRenderTexture_display,         [:render_texture_t], :void
       attach_function :sfRenderTexture_clear,           [:render_texture_t, Color.by_value], :void
+      attach_function :sfRenderTexture_clearStencil,    [:render_texture_t, StencilValue.by_value], :void
+      attach_function :sfRenderTexture_clearColorAndStencil,
+                                                        [:render_texture_t, Color.by_value, StencilValue.by_value], :void
       attach_function :sfRenderTexture_setView,         [:render_texture_t, :view_t], :void
       attach_function :sfRenderTexture_getView,         [:render_texture_t], :view_t
       attach_function :sfRenderTexture_getDefaultView,  [:render_texture_t], :view_t
@@ -347,6 +368,9 @@ module SFML
       attach_function :sfRenderTexture_drawConvexShape,     [:render_texture_t, :convex_shape_t,     :render_states_t], :void
       attach_function :sfRenderTexture_drawText,            [:render_texture_t, :text_t,             :render_states_t], :void
       attach_function :sfRenderTexture_drawVertexArray,     [:render_texture_t, :vertex_array_t,     :render_states_t], :void
+      attach_function :sfRenderTexture_drawVertexBuffer,    [:render_texture_t, :vertex_buffer_t,    :render_states_t], :void
+      attach_function :sfRenderTexture_drawVertexBufferRange,
+                      [:render_texture_t, :vertex_buffer_t, :uint32, :uint32, :render_states_t], :void
 
       # ---- Raw primitive drawing (without a VertexArray object) ----
       attach_function :sfRenderWindow_drawPrimitives,
@@ -374,6 +398,33 @@ module SFML
       attach_function :sfShader_setTextureUniform,[:shader_t, :string, :texture_t], :void
       attach_function :sfShader_setCurrentTextureUniform, [:shader_t, :string], :void
 
+      # ---- VertexBuffer (static GPU vertex buffer) ----
+      # USAGE order matches sfVertexBufferUsage in CSFML.
+      VERTEX_BUFFER_USAGES = %i[stream dynamic static].freeze
+
+      attach_function :sfVertexBuffer_create,         [:uint32, :int, :int], :vertex_buffer_t
+      attach_function :sfVertexBuffer_copy,           [:vertex_buffer_t], :vertex_buffer_t
+      attach_function :sfVertexBuffer_destroy,        [:vertex_buffer_t], :void
+      attach_function :sfVertexBuffer_getVertexCount, [:vertex_buffer_t], :uint32
+      attach_function :sfVertexBuffer_update,         [:vertex_buffer_t, :pointer, :uint32, :uint32], :bool
+      attach_function :sfVertexBuffer_updateFromVertexBuffer,
+                      [:vertex_buffer_t, :vertex_buffer_t], :bool
+      attach_function :sfVertexBuffer_swap,           [:vertex_buffer_t, :vertex_buffer_t], :void
+      attach_function :sfVertexBuffer_getNativeHandle,[:vertex_buffer_t], :uint32
+      attach_function :sfVertexBuffer_setPrimitiveType,[:vertex_buffer_t, :int], :void
+      attach_function :sfVertexBuffer_getPrimitiveType,[:vertex_buffer_t], :int
+      attach_function :sfVertexBuffer_setUsage,       [:vertex_buffer_t, :int], :void
+      attach_function :sfVertexBuffer_getUsage,       [:vertex_buffer_t], :int
+      attach_function :sfVertexBuffer_isAvailable,    [], :bool
+
+      # Bulk array uniform setters. The array argument is a packed
+      # buffer of N elements (N×{1,2,3,4} floats); the length argument
+      # is the *element* count, not the float count.
+      attach_function :sfShader_setFloatUniformArray, [:shader_t, :string, :pointer, :size_t], :void
+      attach_function :sfShader_setVec2UniformArray,  [:shader_t, :string, :pointer, :size_t], :void
+      attach_function :sfShader_setVec3UniformArray,  [:shader_t, :string, :pointer, :size_t], :void
+      attach_function :sfShader_setVec4UniformArray,  [:shader_t, :string, :pointer, :size_t], :void
+
       # ---- Font ----
       attach_function :sfFont_createFromFile, [:string], :font_t
       attach_function :sfFont_destroy,        [:font_t], :void

data/lib/sfml/c/network.rb

@@ -74,6 +74,110 @@ module SFML
       attach_function :sfPacket_append,         [:packet_t, :pointer, :size_t], :void
       attach_function :sfPacket_clear,          [:packet_t], :void
       attach_function :sfPacket_getData,        [:packet_t], :pointer
+
+      # ---- HTTP ----
+      typedef :pointer, :http_t
+      typedef :pointer, :http_request_t
+      typedef :pointer, :http_response_t
+
+      # Order matches sfHttpMethod in CSFML 3.
+      HTTP_METHODS = %i[get post head put delete].freeze
+
+      # CSFML returns sfHttpStatus as an int. Most are HTTP status
+      # codes; the four sfInvalid*/sfConnectionFailed are SFML-side
+      # transport errors above the HTTP status range.
+      attach_function :sfHttpRequest_create,      [], :http_request_t
+      attach_function :sfHttpRequest_destroy,     [:http_request_t], :void
+      attach_function :sfHttpRequest_setField,    [:http_request_t, :string, :string], :void
+      attach_function :sfHttpRequest_setMethod,   [:http_request_t, :int], :void
+      attach_function :sfHttpRequest_setUri,      [:http_request_t, :string], :void
+      attach_function :sfHttpRequest_setHttpVersion, [:http_request_t, :uint32, :uint32], :void
+      attach_function :sfHttpRequest_setBody,     [:http_request_t, :string], :void
+
+      attach_function :sfHttpResponse_destroy,         [:http_response_t], :void
+      attach_function :sfHttpResponse_getField,        [:http_response_t, :string], :string
+      attach_function :sfHttpResponse_getStatus,       [:http_response_t], :int
+      attach_function :sfHttpResponse_getMajorVersion, [:http_response_t], :uint32
+      attach_function :sfHttpResponse_getMinorVersion, [:http_response_t], :uint32
+      attach_function :sfHttpResponse_getBody,         [:http_response_t], :string
+
+      attach_function :sfHttp_create,        [], :http_t
+      attach_function :sfHttp_destroy,       [:http_t], :void
+      attach_function :sfHttp_setHost,       [:http_t, :string, :uint16], :void
+      # The actual network round-trip — release the GVL so other Ruby
+      # threads (timers, audio, even an in-process test server) can run
+      # while CSFML is blocked on the socket.
+      attach_function :sfHttp_sendRequest,
+                      [:http_t, :http_request_t, System::Time.by_value],
+                      :http_response_t,
+                      blocking: true
+
+      # ---- SocketSelector ----
+      typedef :pointer, :socket_selector_t
+
+      attach_function :sfSocketSelector_create,             [], :socket_selector_t
+      attach_function :sfSocketSelector_copy,               [:socket_selector_t], :socket_selector_t
+      attach_function :sfSocketSelector_destroy,            [:socket_selector_t], :void
+      attach_function :sfSocketSelector_addTcpListener,     [:socket_selector_t, :tcp_listener_t], :void
+      attach_function :sfSocketSelector_addTcpSocket,       [:socket_selector_t, :tcp_socket_t], :void
+      attach_function :sfSocketSelector_addUdpSocket,       [:socket_selector_t, :udp_socket_t], :void
+      attach_function :sfSocketSelector_removeTcpListener,  [:socket_selector_t, :tcp_listener_t], :void
+      attach_function :sfSocketSelector_removeTcpSocket,    [:socket_selector_t, :tcp_socket_t], :void
+      attach_function :sfSocketSelector_removeUdpSocket,    [:socket_selector_t, :udp_socket_t], :void
+      attach_function :sfSocketSelector_clear,              [:socket_selector_t], :void
+      attach_function :sfSocketSelector_wait,
+                      [:socket_selector_t, System::Time.by_value], :bool, blocking: true
+      attach_function :sfSocketSelector_isTcpListenerReady, [:socket_selector_t, :tcp_listener_t], :bool
+      attach_function :sfSocketSelector_isTcpSocketReady,   [:socket_selector_t, :tcp_socket_t], :bool
+      attach_function :sfSocketSelector_isUdpSocketReady,   [:socket_selector_t, :udp_socket_t], :bool
+
+      # ---- FTP ----
+      typedef :pointer, :ftp_t
+      typedef :pointer, :ftp_response_t
+      typedef :pointer, :ftp_dir_response_t
+      typedef :pointer, :ftp_listing_response_t
+
+      # Order matches sfFtpTransferMode.
+      FTP_TRANSFER_MODES = %i[binary ascii ebcdic].freeze
+
+      attach_function :sfFtpResponse_destroy,    [:ftp_response_t], :void
+      attach_function :sfFtpResponse_isOk,       [:ftp_response_t], :bool
+      attach_function :sfFtpResponse_getStatus,  [:ftp_response_t], :int
+      attach_function :sfFtpResponse_getMessage, [:ftp_response_t], :string
+
+      attach_function :sfFtpDirectoryResponse_destroy,      [:ftp_dir_response_t], :void
+      attach_function :sfFtpDirectoryResponse_isOk,         [:ftp_dir_response_t], :bool
+      attach_function :sfFtpDirectoryResponse_getStatus,    [:ftp_dir_response_t], :int
+      attach_function :sfFtpDirectoryResponse_getMessage,   [:ftp_dir_response_t], :string
+      attach_function :sfFtpDirectoryResponse_getDirectory, [:ftp_dir_response_t], :string
+
+      attach_function :sfFtpListingResponse_destroy,    [:ftp_listing_response_t], :void
+      attach_function :sfFtpListingResponse_isOk,       [:ftp_listing_response_t], :bool
+      attach_function :sfFtpListingResponse_getStatus,  [:ftp_listing_response_t], :int
+      attach_function :sfFtpListingResponse_getMessage, [:ftp_listing_response_t], :string
+      attach_function :sfFtpListingResponse_getCount,   [:ftp_listing_response_t], :size_t
+      attach_function :sfFtpListingResponse_getName,    [:ftp_listing_response_t, :size_t], :string
+
+      attach_function :sfFtp_create,                [], :ftp_t
+      attach_function :sfFtp_destroy,               [:ftp_t], :void
+      attach_function :sfFtp_connect,
+                      [:ftp_t, IpAddress.by_value, :uint16, System::Time.by_value],
+                      :ftp_response_t, blocking: true
+      attach_function :sfFtp_loginAnonymous,        [:ftp_t], :ftp_response_t,    blocking: true
+      attach_function :sfFtp_login,                 [:ftp_t, :string, :string], :ftp_response_t, blocking: true
+      attach_function :sfFtp_disconnect,            [:ftp_t], :ftp_response_t,    blocking: true
+      attach_function :sfFtp_keepAlive,             [:ftp_t], :ftp_response_t,    blocking: true
+      attach_function :sfFtp_getWorkingDirectory,   [:ftp_t], :ftp_dir_response_t, blocking: true
+      attach_function :sfFtp_getDirectoryListing,   [:ftp_t, :string], :ftp_listing_response_t, blocking: true
+      attach_function :sfFtp_changeDirectory,       [:ftp_t, :string], :ftp_response_t, blocking: true
+      attach_function :sfFtp_parentDirectory,       [:ftp_t], :ftp_response_t,    blocking: true
+      attach_function :sfFtp_createDirectory,       [:ftp_t, :string], :ftp_dir_response_t, blocking: true
+      attach_function :sfFtp_deleteDirectory,       [:ftp_t, :string], :ftp_response_t, blocking: true
+      attach_function :sfFtp_renameFile,            [:ftp_t, :string, :string], :ftp_response_t, blocking: true
+      attach_function :sfFtp_deleteFile,            [:ftp_t, :string], :ftp_response_t, blocking: true
+      attach_function :sfFtp_download,              [:ftp_t, :string, :string, :int], :ftp_response_t, blocking: true
+      attach_function :sfFtp_upload,                [:ftp_t, :string, :string, :int, :bool], :ftp_response_t, blocking: true
+      attach_function :sfFtp_sendCommand,           [:ftp_t, :string, :string], :ftp_response_t, blocking: true
     end
   end
 end

data/lib/sfml/c/system.rb

@@ -38,6 +38,16 @@ module SFML
       attach_function :sfClock_reset,          [:clock_t],    Time.by_value
 
       attach_function :sfSleep,                [Time.by_value], :void
+
+      # sfBuffer — opaque growable byte buffer used by APIs like
+      # sfImage_saveToMemory to return variable-length binary data
+      # without forcing the caller to pre-size an output buffer.
+      typedef :pointer, :buffer_t
+
+      attach_function :sfBuffer_create,  [],                       :buffer_t
+      attach_function :sfBuffer_destroy, [:buffer_t],               :void
+      attach_function :sfBuffer_getSize, [:buffer_t],               :size_t
+      attach_function :sfBuffer_getData, [:buffer_t],               :pointer
     end
   end
 end

data/lib/sfml/c/window.rb

@@ -104,6 +104,18 @@ module SFML
                :joystick_id, :uint32
       end
 
+      class TouchEvent < FFI::Struct
+        layout :type,     :int,
+               :finger,   :uint32,
+               :position, System::Vector2i
+      end
+
+      class SensorEvent < FFI::Struct
+        layout :type,   :int,
+               :sensor, :int,
+               :value,  System::Vector3f
+      end
+
       # sfEvent is a C union. The largest variant (KeyEvent on x86_64: 4+4+4+4
       # = 20 bytes) defines the union size; we allocate a buffer that big and
       # reinterpret per-type. We use a Struct (not Union) here because Ruby
@@ -156,6 +168,25 @@ module SFML
       attach_function :sfJoystick_getIdentification, [:uint32], JoystickIdentification.by_value
       attach_function :sfJoystick_update,          [], :void
 
+      # ---- Touch ----
+      attach_function :sfTouch_isDown,        [:uint32], :bool
+      attach_function :sfTouch_getPosition,   [:uint32, :pointer], System::Vector2i.by_value
+
+      # ---- Sensor ----
+      # Order matches sfSensorType in CSFML 3.
+      SENSOR_TYPES = %i[
+        accelerometer
+        gyroscope
+        magnetometer
+        gravity
+        user_acceleration
+        orientation
+      ].freeze
+
+      attach_function :sfSensor_isAvailable,  [:int], :bool
+      attach_function :sfSensor_setEnabled,   [:int, :bool], :void
+      attach_function :sfSensor_getValue,     [:int], System::Vector3f.by_value
+
       # ---- Bare Window (no rendering) ----
       # SFML 3 splits sf::Window (pure window + GL context) from
       # sf::RenderWindow (window + 2D batcher). The bare variant is
@@ -181,6 +212,17 @@ module SFML
       attach_function :sfWindow_requestFocus,  [:raw_window_t], :void
       attach_function :sfWindow_hasFocus,      [:raw_window_t], :bool
       attach_function :sfWindow_setActive,     [:raw_window_t, :bool], :bool
+      attach_function :sfWindow_setIcon,       [:raw_window_t, System::Vector2u.by_value, :pointer], :void
+      # NULL pointer clears the limit. Pass a Vector2u* to set it.
+      attach_function :sfWindow_setMinimumSize, [:raw_window_t, :pointer], :void
+      attach_function :sfWindow_setMaximumSize, [:raw_window_t, :pointer], :void
+
+      # Embed into an existing platform window. The first argument is
+      # an OS-specific native handle (HWND on Windows, NSView* on
+      # macOS, Window XID on X11). Pass NULL for the ContextSettings
+      # to use defaults.
+      attach_function :sfWindow_createFromHandle, [:pointer, :pointer], :raw_window_t
+      attach_function :sfWindow_getNativeHandle,  [:raw_window_t], :pointer
     end
   end
 end

data/lib/sfml/graphics/image.rb

@@ -96,6 +96,29 @@ module SFML
       path
     end
 
+    # Encode the image as `format` ("png", "jpg", "bmp", or "tga") and
+    # return the encoded bytes as a Ruby String. Useful for sending
+    # screenshots over the network, generating data: URLs, piping into
+    # an image-processing library, etc., without touching the disk.
+    #
+    #   png_bytes = img.save_to_memory("png")
+    #   File.binwrite("out.png", png_bytes)
+    def save_to_memory(format)
+      buffer = C::System.sfBuffer_create
+      raise Error, "sfBuffer_create returned NULL" if buffer.null?
+
+      begin
+        ok = C::Graphics.sfImage_saveToMemory(@handle, buffer, format.to_s)
+        raise Error, "Could not encode image as #{format.inspect}" unless ok
+
+        size = C::System.sfBuffer_getSize(buffer)
+        data = C::System.sfBuffer_getData(buffer)
+        data.read_bytes(size)
+      ensure
+        C::System.sfBuffer_destroy(buffer)
+      end
+    end
+
     # Replace any pixel matching `color` with that colour at `alpha`
     # opacity — typical use is to turn a fixed background colour
     # transparent: img.mask_color!(SFML::Color.magenta, alpha: 0).

data/lib/sfml/graphics/render_states.rb

@@ -17,12 +17,13 @@ module SFML
     COORDINATE_TYPES = %i[normalized pixels].freeze
     COORDINATE_INDEX = COORDINATE_TYPES.each_with_index.to_h.freeze
 
-    attr_reader :blend_mode, :texture, :shader, :coordinate_type
+    attr_reader :blend_mode, :stencil_mode, :texture, :shader, :coordinate_type
 
-    def initialize(blend_mode: nil, texture: nil, shader: nil, coordinate_type: :normalized)
+    def initialize(blend_mode: nil, stencil_mode: nil, texture: nil, shader: nil, coordinate_type: :normalized)
       @blend_mode      = blend_mode
+      @stencil_mode    = stencil_mode
       @texture         = texture
-      @shader          = shader   # placeholder until SFML::Shader lands in the next P1 step
+      @shader          = shader
       @coordinate_type = coordinate_type
       raise ArgumentError, "unknown coordinate_type: #{coordinate_type.inspect}" unless COORDINATE_INDEX.key?(coordinate_type)
       freeze
@@ -39,6 +40,7 @@ module SFML
         .then { |bytes| buffer.pointer.write_bytes(bytes) }
 
       @blend_mode&.populate(buffer[:blend_mode])
+      @stencil_mode&.populate(buffer[:stencil_mode])
       buffer[:coordinate_type] = COORDINATE_INDEX[@coordinate_type]
       buffer[:texture] = @texture ? @texture.handle : nil
       buffer[:shader]  = @shader  ? @shader.handle  : nil