ruby-sfml 3.0.0.3 → 3.0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3261668821d3742648968ea78730bf09a83c72a428e69fe9fc5f2492f13f8557
-  data.tar.gz: 860208fab91bf28c6825948892bca54478defebdc29c596cb30088e394a7f516
+  metadata.gz: 02adbbc1dc50cc42127dc845ad9be68829ee07c100cb915e83f15d2e8deb8df7
+  data.tar.gz: 59e6cadd1e7a325e70b7ad92b162f7ba3d73035fc482317e3ad0f28d8b7afcb6
 SHA512:
-  metadata.gz: 2cae71d47e55c1d1fa1b39c8c18d7362fff927224ae410449ef33444fe07060ef2cf8c8c3c6b0b65beffd7d2f9c99e6cd89c6d2558a5573817150c636493375b
-  data.tar.gz: 5a4e5a8f78ae23ed08d72bc62df15587787e172000abd53b8fe1b9869952f98348d9c775f37c606555f25e5c5b26f2009685e136a26b788ae4ce9123817090be
+  metadata.gz: da0f1e034c77f9a78fb202e4e40e90099aafac7fbe5b2261e94bd693e51f937098c5113491f723eefc45acc731f983b39cc6a27e372c81e6391f8b2777aee99e
+  data.tar.gz: a494f581e0cf1975c5233705838cc9f29f0f99fe88a793cd580478772c5170a0c440330c40f464947a689849d43b8e2c16b4b247c0cf4350eea5e35616d9ec90

data/CHANGELOG.md

@@ -8,6 +8,57 @@ ruby-sfml's own patch level.
 
 ## [Unreleased]
 
+## [3.0.0.4] — 2026-05-09
+
+### Added — graphics
+
+- `Sprite#dup` / `#clone`, `Sprite#texture` (borrowed reference),
+  `Sprite#transform`, `Sprite#inverse_transform`.
+- `View#scissor` / `View#scissor=` — normalised [0..1] clip rect
+  applied at render time (paired with the existing `viewport` API).
+- `Texture.from_memory(bytes, smooth:, repeated:)` — decode +
+  upload a Ruby String of bytes (PNG / JPG / BMP / TGA / …) as a
+  texture. Bypasses the disk for embedded assets / network blobs.
+- `Texture#resize(w, h)` — reallocate GPU memory in place.
+- `Texture#swap(other)` — atomically swap GPU memory between two
+  textures (cheap double-buffer pattern).
+- `Texture#native_handle` — the OpenGL texture-object name for
+  raw GL interop.
+- `Texture#update_from_texture(source, offset:)`,
+  `Texture#update_from_render_window(window, offset:)`,
+  `Texture#update_from_window(window, offset:)` — copy pixels
+  from another GPU texture / from a window's back-buffer / from a
+  bare-Window's framebuffer into this texture at `offset`.
+- `RenderWindow#viewport(view = self.view)` and
+  `RenderWindow#scissor(view = self.view)` — pixel-space
+  `SFML::Rect`s the view actually covers / clips. Same on
+  `RenderTexture`.
+- `Shader#set_int_color(name, color)` — uploads a `SFML::Color`
+  as a `vec4` uniform (CSFML normalises 0–255 → 0.0–1.0 for you).
+
+### Added — audio
+- `Sound#dup` / `#clone`, `Sound#buffer` reader.
+- `Sound#pan` / `#pan=`, `Sound#min_gain`/`#max_gain` (and `=`),
+  `Sound#max_distance` (and `=`), `Sound#spatialization_enabled?` /
+  `#spatialization_enabled=`,
+  `Sound#directional_attenuation_factor` (and `=`) — the full
+  remaining 3D-audio surface from CSFML's SoundSource.
+- Same set on `Music`: `pan`, gain clamps, max-distance,
+  spatialisation, directional-attenuation.
+- `Music#channel_count`, `Music#sample_rate` — stream introspection.
+- `Music#loop_points` / `#loop_points=` — set the looping window
+  inside a track ([offset_time, length_time] pair of `SFML::Time`s).
+- `Music.from_memory(bytes, **opts)` — stream from a Ruby String
+  of bytes (in-memory MP3 / OGG / FLAC). Caller's bytes must
+  outlive the `Music` (we pin the Ruby buffer).
+- `SoundBuffer.from_memory(bytes)` — decode `.wav` / `.ogg` /
+  `.flac` from RAM.
+- `SoundBuffer.from_samples(samples, sample_rate:, channel_count:,
+  channel_map:)` — build a buffer from a Ruby Array of int16
+  samples. Default channel maps for 1- and 2-channel content.
+- `SoundBuffer#dup`, `SoundBuffer#sample_count`,
+  `SoundBuffer#samples` — sample-level introspection.
+
 ## [3.0.0.3] — 2026-05-09
 
 ### Added — typography

data/lib/sfml/audio/music.rb

@@ -9,6 +9,29 @@ module SFML
       ptr = C::Audio.sfMusic_createFromFile(path.to_s)
       raise Error, "Could not load music from #{path.inspect}" if ptr.null?
 
+      _wrap(ptr, opts)
+    end
+
+    # Stream music from a Ruby String of bytes (an in-memory MP3,
+    # OGG, FLAC, …). Useful for embedded audio or downloaded
+    # tracks that bypass the disk. The bytes must outlive the
+    # Music object — SFML keeps a pointer into them.
+    def self.from_memory(bytes, **opts)
+      raise ArgumentError, "expected a String, got #{bytes.class}" unless bytes.is_a?(String)
+
+      buf = FFI::MemoryPointer.new(:uint8, bytes.bytesize)
+      buf.write_bytes(bytes)
+      ptr = C::Audio.sfMusic_createFromMemory(buf, bytes.bytesize)
+      raise Error, "sfMusic_createFromMemory returned NULL — unsupported format?" if ptr.null?
+
+      m = _wrap(ptr, opts)
+      m.instance_variable_set(:@_memory_pin, buf)   # keep buffer alive
+      m
+    end
+
+    # Internal — finish initialising a Music from an already-built
+    # CSFML pointer.
+    def self._wrap(ptr, opts)
       m = allocate
       m.send(:_take_ownership, ptr)
       m.instance_variable_set(:@looping, false)
@@ -17,6 +40,7 @@ module SFML
       m.looping = opts[:looping] if opts.key?(:looping)
       m
     end
+    private_class_method :_wrap
 
     def play   = C::Audio.sfMusic_play(@handle)
     def pause  = C::Audio.sfMusic_pause(@handle)
@@ -143,6 +167,69 @@ module SFML
       C::Audio.sfMusic_setRelativeToListener(@handle, value ? true : false)
     end
 
+    # ---- Stream introspection ----
+
+    def channel_count = C::Audio.sfMusic_getChannelCount(@handle)
+    def sample_rate   = C::Audio.sfMusic_getSampleRate(@handle)
+
+    # The portion of the track that loops when `looping = true`.
+    # Returns `[offset, length]` of `SFML::Time`s; defaults to the
+    # whole track. Set with `loop_points = [Time, Time]`.
+    def loop_points
+      span = C::Audio.sfMusic_getLoopPoints(@handle)
+      [Time.from_native(span[:offset]), Time.from_native(span[:length])]
+    end
+
+    def loop_points=(value)
+      offset_t, length_t = value
+      raise ArgumentError, "expected [offset_time, length_time]" unless offset_t && length_t
+
+      span = C::Audio::TimeSpan.new
+      span[:offset][:microseconds] = offset_t.is_a?(Time) ? offset_t.microseconds : Time.seconds(offset_t.to_f).microseconds
+      span[:length][:microseconds] = length_t.is_a?(Time) ? length_t.microseconds : Time.seconds(length_t.to_f).microseconds
+      C::Audio.sfMusic_setLoopPoints(@handle, span)
+    end
+
+    # ---- 3D-audio extras (mirror of Sound's) ----
+
+    def pan = C::Audio.sfMusic_getPan(@handle)
+
+    def pan=(v)
+      C::Audio.sfMusic_setPan(@handle, v.to_f)
+    end
+
+    def min_gain = C::Audio.sfMusic_getMinGain(@handle)
+
+    def min_gain=(v)
+      C::Audio.sfMusic_setMinGain(@handle, v.to_f)
+    end
+
+    def max_gain = C::Audio.sfMusic_getMaxGain(@handle)
+
+    def max_gain=(v)
+      C::Audio.sfMusic_setMaxGain(@handle, v.to_f)
+    end
+
+    def max_distance = C::Audio.sfMusic_getMaxDistance(@handle)
+
+    def max_distance=(v)
+      C::Audio.sfMusic_setMaxDistance(@handle, v.to_f)
+    end
+
+    def spatialization_enabled? = C::Audio.sfMusic_isSpatializationEnabled(@handle)
+
+    def spatialization_enabled=(v)
+      C::Audio.sfMusic_setSpatializationEnabled(@handle, v ? true : false)
+    end
+
+    def directional_attenuation_factor
+      C::Audio.sfMusic_getDirectionalAttenuationFactor(@handle)
+    end
+
+    def directional_attenuation_factor=(v)
+      C::Audio.sfMusic_setDirectionalAttenuationFactor(@handle, v.to_f)
+    end
+
     private
 
     def _take_ownership(ptr)

data/lib/sfml/audio/sound.rb

@@ -180,5 +180,77 @@ module SFML
     def relative_to_listener=(value)
       C::Audio.sfSound_setRelativeToListener(@handle, value ? true : false)
     end
+
+    # The buffer this Sound is currently bound to (the one passed
+    # to `.new`, or whoever last called `buffer=`). Returns nil
+    # if the underlying source has none.
+    def buffer
+      ptr = C::Audio.sfSound_getBuffer(@handle)
+      return nil if ptr.null?
+      @buffer  # keep Ruby reference alive (the C handle is borrowed from it)
+    end
+
+    # Stereo pan in [-1.0, 1.0]: -1 = full left, 0 = centre, 1 = full right.
+    def pan = C::Audio.sfSound_getPan(@handle)
+
+    def pan=(v)
+      C::Audio.sfSound_setPan(@handle, v.to_f)
+    end
+
+    # Output gain clamping. `min_gain` floors the attenuated
+    # gain; `max_gain` caps it. Useful when you want a sound to
+    # always be at least faintly audible (or never louder than
+    # the listener's local SFX volume).
+    def min_gain = C::Audio.sfSound_getMinGain(@handle)
+
+    def min_gain=(v)
+      C::Audio.sfSound_setMinGain(@handle, v.to_f)
+    end
+
+    def max_gain = C::Audio.sfSound_getMaxGain(@handle)
+
+    def max_gain=(v)
+      C::Audio.sfSound_setMaxGain(@handle, v.to_f)
+    end
+
+    # The distance beyond which the source is fully attenuated.
+    def max_distance = C::Audio.sfSound_getMaxDistance(@handle)
+
+    def max_distance=(v)
+      C::Audio.sfSound_setMaxDistance(@handle, v.to_f)
+    end
+
+    # Whether 3D-positional / Doppler / cone math is applied at
+    # mix time. Off → the sound plays as a simple stereo source.
+    def spatialization_enabled? = C::Audio.sfSound_isSpatializationEnabled(@handle)
+
+    def spatialization_enabled=(v)
+      C::Audio.sfSound_setSpatializationEnabled(@handle, v ? true : false)
+    end
+
+    # Multiplier on the Listener's directional attenuation cone.
+    # 0 = source ignores the listener's facing direction (no
+    # cone falloff); 1 = full cone effect.
+    def directional_attenuation_factor
+      C::Audio.sfSound_getDirectionalAttenuationFactor(@handle)
+    end
+
+    def directional_attenuation_factor=(v)
+      C::Audio.sfSound_setDirectionalAttenuationFactor(@handle, v.to_f)
+    end
+
+    # Independent copy — same buffer (buffers are shareable),
+    # independent transport state (volume/pan/spatialisation/etc).
+    def dup
+      ptr = C::Audio.sfSound_copy(@handle)
+      raise Error, "sfSound_copy returned NULL" if ptr.null?
+
+      copy = self.class.allocate
+      copy.instance_variable_set(:@handle,
+        FFI::AutoPointer.new(ptr, C::Audio.method(:sfSound_destroy)))
+      copy.instance_variable_set(:@buffer, @buffer)
+      copy
+    end
+    alias clone dup
   end
 end

data/lib/sfml/audio/sound_buffer.rb

@@ -14,9 +14,83 @@ module SFML
       buf
     end
 
+    # Decode a Ruby String of bytes (.wav, .ogg, .flac, …)
+    # straight into a buffer — bypass the disk.
+    def self.from_memory(bytes)
+      raise ArgumentError, "expected a String, got #{bytes.class}" unless bytes.is_a?(String)
+
+      buf_p = FFI::MemoryPointer.new(:uint8, bytes.bytesize)
+      buf_p.write_bytes(bytes)
+      ptr = C::Audio.sfSoundBuffer_createFromMemory(buf_p, bytes.bytesize)
+      raise Error, "sfSoundBuffer_createFromMemory returned NULL — unsupported format?" if ptr.null?
+
+      buf = allocate
+      buf.send(:_take_ownership, ptr)
+      buf
+    end
+
+    # Default channel-layout map for the common 1- and 2-channel
+    # cases — saves callers from spelling out the SoundChannel
+    # enum just to build a mono blip or stereo waveform.
+    DEFAULT_CHANNEL_MAPS = {
+      1 => [1],          # sfSoundChannelMono
+      2 => [2, 3],       # sfSoundChannelFrontLeft, FrontRight
+    }.freeze
+
+    # Build a buffer from raw 16-bit signed samples. `samples` is
+    # an Array of Integers in [-32768, 32767]. The caller specifies
+    # `sample_rate` (Hz) and `channel_count` (1 = mono, 2 = stereo).
+    # `channel_map` is an Array of `sfSoundChannel` enum values; for
+    # 1- and 2-channel content the default mono / front-L+R layout
+    # is filled in automatically.
+    def self.from_samples(samples, sample_rate:, channel_count:, channel_map: nil)
+      arr = samples.to_a.map { |s| Integer(s) }
+      buf = FFI::MemoryPointer.new(:int16, arr.length)
+      buf.write_array_of_int16(arr)
+
+      map = channel_map || DEFAULT_CHANNEL_MAPS.fetch(channel_count) do
+        raise ArgumentError,
+              "no default channel_map for #{channel_count} channels — pass `channel_map: [...]` explicitly"
+      end
+      map_buf = FFI::MemoryPointer.new(:int, map.length)
+      map_buf.write_array_of_int(map.map { |v| Integer(v) })
+
+      ptr = C::Audio.sfSoundBuffer_createFromSamples(buf, arr.length,
+                                                     Integer(channel_count),
+                                                     Integer(sample_rate),
+                                                     map_buf, map.length)
+      raise Error, "sfSoundBuffer_createFromSamples returned NULL" if ptr.null?
+
+      sb = allocate
+      sb.send(:_take_ownership, ptr)
+      sb
+    end
+
     def duration      = Time.from_native(C::Audio.sfSoundBuffer_getDuration(@handle))
     def sample_rate   = C::Audio.sfSoundBuffer_getSampleRate(@handle)
     def channel_count = C::Audio.sfSoundBuffer_getChannelCount(@handle)
+    def sample_count  = C::Audio.sfSoundBuffer_getSampleCount(@handle)
+
+    # The decoded 16-bit signed samples as a Ruby Array of
+    # Integers. Heavy — copies every sample. For analysis or
+    # custom DSP that needs the raw waveform.
+    def samples
+      ptr = C::Audio.sfSoundBuffer_getSamples(@handle)
+      return [] if ptr.null?
+      ptr.read_array_of_int16(sample_count)
+    end
+
+    # Independent copy — same decoded waveform, different
+    # underlying memory block.
+    def dup
+      ptr = C::Audio.sfSoundBuffer_copy(@handle)
+      raise Error, "sfSoundBuffer_copy returned NULL" if ptr.null?
+
+      copy = self.class.allocate
+      copy.send(:_take_ownership, ptr)
+      copy
+    end
+    alias clone dup
 
     # Write the buffer out to disk. Format is inferred from the file
     # extension (.wav / .ogg / .flac, depends on what CSFML was built

data/lib/sfml/c/audio.rb

@@ -26,10 +26,31 @@ module SFML
       attach_function :sfSoundBuffer_getDuration,    [:sound_buffer_t], System::Time.by_value
       attach_function :sfSoundBuffer_getSampleRate,  [:sound_buffer_t], :uint32
       attach_function :sfSoundBuffer_getChannelCount,[:sound_buffer_t], :uint32
+      attach_function :sfSoundBuffer_copy,           [:sound_buffer_t], :sound_buffer_t
+      attach_function :sfSoundBuffer_createFromMemory, [:pointer, :size_t], :sound_buffer_t
+      attach_function :sfSoundBuffer_createFromSamples,
+                      [:pointer, :uint64, :uint32, :uint32, :pointer, :size_t], :sound_buffer_t
+      attach_function :sfSoundBuffer_getSampleCount, [:sound_buffer_t], :uint64
+      attach_function :sfSoundBuffer_getSamples,     [:sound_buffer_t], :pointer
+      attach_function :sfSoundBuffer_getChannelMap,  [:sound_buffer_t, :pointer], :pointer
 
       # ---- Sound ----
       attach_function :sfSound_create,        [:sound_buffer_t], :sound_t
+      attach_function :sfSound_copy,          [:sound_t], :sound_t
       attach_function :sfSound_destroy,       [:sound_t], :void
+      attach_function :sfSound_getBuffer,     [:sound_t], :sound_buffer_t
+      attach_function :sfSound_setPan,                 [:sound_t, :float], :void
+      attach_function :sfSound_getPan,                 [:sound_t], :float
+      attach_function :sfSound_setMinGain,             [:sound_t, :float], :void
+      attach_function :sfSound_getMinGain,             [:sound_t], :float
+      attach_function :sfSound_setMaxGain,             [:sound_t, :float], :void
+      attach_function :sfSound_getMaxGain,             [:sound_t], :float
+      attach_function :sfSound_setMaxDistance,         [:sound_t, :float], :void
+      attach_function :sfSound_getMaxDistance,         [:sound_t], :float
+      attach_function :sfSound_setSpatializationEnabled, [:sound_t, :bool], :void
+      attach_function :sfSound_isSpatializationEnabled,  [:sound_t], :bool
+      attach_function :sfSound_setDirectionalAttenuationFactor, [:sound_t, :float], :void
+      attach_function :sfSound_getDirectionalAttenuationFactor, [:sound_t], :float
       attach_function :sfSound_play,          [:sound_t], :void
       attach_function :sfSound_pause,         [:sound_t], :void
       attach_function :sfSound_stop,          [:sound_t], :void
@@ -66,8 +87,31 @@ module SFML
       attach_function :sfSound_setEffectProcessor,    [:sound_t, :sf_effect_processor, :pointer], :void
 
       # ---- Music ----
+      class TimeSpan < FFI::Struct
+        layout :offset, System::Time,
+               :length, System::Time
+      end
+
       attach_function :sfMusic_createFromFile, [:string], :music_t
+      attach_function :sfMusic_createFromMemory, [:pointer, :size_t], :music_t
       attach_function :sfMusic_destroy,        [:music_t], :void
+      attach_function :sfMusic_getChannelCount, [:music_t], :uint32
+      attach_function :sfMusic_getSampleRate,   [:music_t], :uint32
+      attach_function :sfMusic_getChannelMap,   [:music_t, :pointer], :pointer
+      attach_function :sfMusic_getLoopPoints,   [:music_t], TimeSpan.by_value
+      attach_function :sfMusic_setLoopPoints,   [:music_t, TimeSpan.by_value], :void
+      attach_function :sfMusic_setPan,                 [:music_t, :float], :void
+      attach_function :sfMusic_getPan,                 [:music_t], :float
+      attach_function :sfMusic_setMinGain,             [:music_t, :float], :void
+      attach_function :sfMusic_getMinGain,             [:music_t], :float
+      attach_function :sfMusic_setMaxGain,             [:music_t, :float], :void
+      attach_function :sfMusic_getMaxGain,             [:music_t], :float
+      attach_function :sfMusic_setMaxDistance,         [:music_t, :float], :void
+      attach_function :sfMusic_getMaxDistance,         [:music_t], :float
+      attach_function :sfMusic_setSpatializationEnabled, [:music_t, :bool], :void
+      attach_function :sfMusic_isSpatializationEnabled,  [:music_t], :bool
+      attach_function :sfMusic_setDirectionalAttenuationFactor, [:music_t, :float], :void
+      attach_function :sfMusic_getDirectionalAttenuationFactor, [:music_t], :float
       attach_function :sfMusic_play,           [:music_t], :void
       attach_function :sfMusic_pause,          [:music_t], :void
       attach_function :sfMusic_stop,           [:music_t], :void

data/lib/sfml/c/graphics.rb

@@ -121,6 +121,8 @@ module SFML
       attach_function :sfRenderWindow_resetGLStates,          [:render_window_t], :void
       attach_function :sfRenderWindow_isSrgb,                 [:render_window_t], :bool
       attach_function :sfRenderWindow_waitEvent,              [:render_window_t, System::Time.by_value, :pointer], :bool
+      attach_function :sfRenderWindow_getScissor,             [:render_window_t, :pointer], IntRect.by_value
+      attach_function :sfRenderWindow_getViewport,            [:render_window_t, :pointer], IntRect.by_value
 
       typedef :pointer, :texture_t
       typedef :pointer, :render_texture_t
@@ -197,6 +199,8 @@ module SFML
       attach_function :sfView_getRotation,    [:view_t], :float
       attach_function :sfView_setViewport,    [:view_t, FloatRect.by_value], :void
       attach_function :sfView_getViewport,    [:view_t], FloatRect.by_value
+      attach_function :sfView_setScissor,     [:view_t, FloatRect.by_value], :void
+      attach_function :sfView_getScissor,     [:view_t], FloatRect.by_value
       attach_function :sfView_move,           [:view_t, System::Vector2f.by_value], :void
       attach_function :sfView_rotate,         [:view_t, :float], :void
       attach_function :sfView_zoom,           [:view_t, :float], :void
@@ -221,7 +225,17 @@ module SFML
       attach_function :sfTexture_create,         [System::Vector2u.by_value], :texture_t
       attach_function :sfTexture_createFromFile, [:string, :pointer], :texture_t
       attach_function :sfTexture_createFromImage,[:image_t, :pointer], :texture_t
+      attach_function :sfTexture_createFromMemory,[:pointer, :size_t, :pointer], :texture_t
       attach_function :sfTexture_copy,           [:texture_t], :texture_t
+      attach_function :sfTexture_resize,         [:texture_t, System::Vector2u.by_value], :bool
+      attach_function :sfTexture_swap,           [:texture_t, :texture_t], :void
+      attach_function :sfTexture_getNativeHandle,[:texture_t], :uint
+      attach_function :sfTexture_updateFromTexture,
+                      [:texture_t, :texture_t, System::Vector2u.by_value], :void
+      attach_function :sfTexture_updateFromRenderWindow,
+                      [:texture_t, :render_window_t, System::Vector2u.by_value], :void
+      attach_function :sfTexture_updateFromWindow,
+                      [:texture_t, :pointer, System::Vector2u.by_value], :void
       attach_function :sfTexture_isSrgb,         [:texture_t], :bool
       attach_function :sfTexture_generateMipmap, [:texture_t], :bool
       attach_function :sfTexture_getMaximumSize, [], :uint
@@ -275,6 +289,10 @@ module SFML
       attach_function :sfSprite_setColor,      [:sprite_t, Color.by_value], :void
       attach_function :sfSprite_getColor,      [:sprite_t], Color.by_value
       attach_function :sfSprite_setTexture,    [:sprite_t, :texture_t, :bool], :void
+      attach_function :sfSprite_getTexture,    [:sprite_t], :texture_t
+      attach_function :sfSprite_copy,          [:sprite_t], :sprite_t
+      attach_function :sfSprite_getTransform,  [:sprite_t], Transform.by_value
+      attach_function :sfSprite_getInverseTransform, [:sprite_t], Transform.by_value
 
       # ---- CircleShape ----
       attach_function :sfCircleShape_create,             [], :circle_shape_t
@@ -385,6 +403,8 @@ module SFML
       attach_function :sfRenderTexture_pushGLStates,    [:render_texture_t], :void
       attach_function :sfRenderTexture_popGLStates,     [:render_texture_t], :void
       attach_function :sfRenderTexture_resetGLStates,   [:render_texture_t], :void
+      attach_function :sfRenderTexture_getScissor,      [:render_texture_t, :view_t], IntRect.by_value
+      attach_function :sfRenderTexture_getViewport,     [:render_texture_t, :view_t], IntRect.by_value
 
       attach_function :sfRenderTexture_mapPixelToCoords,
                       [:render_texture_t, System::Vector2i.by_value, :view_t],
@@ -417,6 +437,7 @@ module SFML
       attach_function :sfShader_isAvailable,      [], :bool
       attach_function :sfShader_bind,             [:shader_t], :void
       attach_function :sfShader_getNativeHandle,  [:shader_t], :uint
+      attach_function :sfShader_setIntColorUniform, [:shader_t, :string, Color.by_value], :void
       attach_function :sfShader_isGeometryAvailable, [], :bool
 
       attach_function :sfShader_setFloatUniform,  [:shader_t, :string, :float], :void

data/lib/sfml/graphics/render_texture.rb

@@ -78,6 +78,18 @@ module SFML
     def pop_gl_states   = C::Graphics.sfRenderTexture_popGLStates(@handle)
     def reset_gl_states = C::Graphics.sfRenderTexture_resetGLStates(@handle)
 
+    # Pixel-space viewport / scissor for the given view (defaults
+    # to the active view). Same shape as RenderWindow's.
+    def viewport(view = self.view)
+      raise ArgumentError, "expected a SFML::View" unless view.is_a?(View)
+      Rect.from_native(C::Graphics.sfRenderTexture_getViewport(@handle, view.handle))
+    end
+
+    def scissor(view = self.view)
+      raise ArgumentError, "expected a SFML::View" unless view.is_a?(View)
+      Rect.from_native(C::Graphics.sfRenderTexture_getScissor(@handle, view.handle))
+    end
+
     # The Texture this RenderTexture is rendering into. Borrowed — its
     # lifetime is bounded by `self`. Memoised so repeated calls return
     # the same Ruby wrapper.

data/lib/sfml/graphics/render_window.rb

@@ -224,6 +224,22 @@ module SFML
       Event.from_native(@event_buffer)
     end
 
+    # The pixel-space rect a `view` projects onto inside this
+    # window. Combines the view's normalised viewport with the
+    # window's pixel size.
+    def viewport(view = self.view)
+      raise ArgumentError, "expected a SFML::View" unless view.is_a?(View)
+      Rect.from_native(C::Graphics.sfRenderWindow_getViewport(@handle, view.handle))
+    end
+
+    # The pixel-space scissor rect — same idea as `viewport` but
+    # for the view's `scissor` property. Pixels outside this rect
+    # are clipped before rendering.
+    def scissor(view = self.view)
+      raise ArgumentError, "expected a SFML::View" unless view.is_a?(View)
+      Rect.from_native(C::Graphics.sfRenderWindow_getScissor(@handle, view.handle))
+    end
+
     # Wrap an existing OS-level window. `handle` is a platform native
     # handle (Integer address or FFI::Pointer). Useful for embedding
     # the renderer inside another framework's window (Qt, Gtk, raw

data/lib/sfml/graphics/shader.rb

@@ -152,6 +152,15 @@ module SFML
     # with raw GL libraries.
     def native_handle = C::Graphics.sfShader_getNativeHandle(@handle)
 
+    # Set a `vec4` uniform from an integer-channel `SFML::Color`
+    # (RGBA 0–255). Equivalent to writing `[c.r/255, ..., c.a/255]`
+    # by hand into a vec4 — the CSFML helper does the divide for
+    # you.
+    def set_int_color(name, color)
+      raise ArgumentError, "expected SFML::Color" unless color.is_a?(Color)
+      C::Graphics.sfShader_setIntColorUniform(@handle, name.to_s, color.to_native)
+    end
+
     attr_reader :handle # :nodoc:
 
     private

data/lib/sfml/graphics/sprite.rb

@@ -70,6 +70,38 @@ module SFML
       target._draw_native(:Sprite, @handle, states_ptr)
     end
 
+    # The Texture this sprite was last bound to. Borrowed — caller
+    # is responsible for keeping the source texture alive.
+    def texture
+      ptr = C::Graphics.sfSprite_getTexture(@handle)
+      return nil if ptr.null?
+      Texture.send(:_borrow, ptr)
+    end
+
+    # Combined transform (translation + rotation + scale + origin)
+    # the renderer applies when drawing this sprite.
+    def transform
+      C::Graphics.sfSprite_getTransform(@handle)
+    end
+
+    def inverse_transform
+      C::Graphics.sfSprite_getInverseTransform(@handle)
+    end
+
+    # Deep copy — same texture binding (textures are shared GPU
+    # objects), independent transform / colour state.
+    def dup
+      ptr = C::Graphics.sfSprite_copy(@handle)
+      raise Error, "sfSprite_copy returned NULL" if ptr.null?
+
+      copy = self.class.allocate
+      copy.instance_variable_set(:@handle,
+        FFI::AutoPointer.new(ptr, C::Graphics.method(:sfSprite_destroy)))
+      copy.instance_variable_set(:@texture, @texture)   # keep source alive
+      copy
+    end
+    alias clone dup
+
     attr_reader :handle # :nodoc:
   end
 end

data/lib/sfml/graphics/texture.rb

@@ -31,6 +31,24 @@ module SFML
       tex
     end
 
+    # Decode + upload a Ruby String of bytes (PNG, JPG, BMP, …) as
+    # a texture. Useful for embedded assets / network responses
+    # that bypass the disk.
+    def self.from_memory(bytes, smooth: false, repeated: false)
+      raise ArgumentError, "expected a String, got #{bytes.class}" unless bytes.is_a?(String)
+
+      buf = FFI::MemoryPointer.new(:uint8, bytes.bytesize)
+      buf.write_bytes(bytes)
+      ptr = C::Graphics.sfTexture_createFromMemory(buf, bytes.bytesize, nil)
+      raise Error, "sfTexture_createFromMemory returned NULL — unsupported format?" if ptr.null?
+
+      tex = allocate
+      tex.send(:_take_ownership, ptr)
+      tex.smooth   = smooth
+      tex.repeated = repeated
+      tex
+    end
+
     # Upload a CPU-side SFML::Image to the GPU as a new Texture. Keeps
     # the RGBA byte order and dimensions of the source image.
     def self.from_image(image, smooth: false, repeated: false)
@@ -123,6 +141,54 @@ module SFML
     end
     alias clone dup
 
+    # Reallocate this texture's GPU memory at a new size. Returns
+    # `false` if the GPU rejects the size (driver limit / OOM);
+    # the texture's contents become undefined on success.
+    def resize(width, height)
+      size = C::System::Vector2u.new
+      size[:x] = Integer(width); size[:y] = Integer(height)
+      C::Graphics.sfTexture_resize(@handle, size)
+    end
+
+    # Atomically swap the GPU memory between two textures —
+    # cheaper than `dup` + reassign for double-buffer-style
+    # patterns (paint-buffer ⇄ visible-buffer).
+    def swap(other)
+      raise ArgumentError, "Texture#swap needs a Texture" unless other.is_a?(Texture)
+      C::Graphics.sfTexture_swap(@handle, other.handle)
+      self
+    end
+
+    # The OpenGL texture-object name (a `glGenTextures` ID).
+    # Useful when feeding this texture into raw GL calls.
+    def native_handle = C::Graphics.sfTexture_getNativeHandle(@handle)
+
+    # Upload the contents of another texture into this one at
+    # `offset` (`[x, y]`). Both textures must remain alive for the
+    # duration of the call.
+    def update_from_texture(source, offset: [0, 0])
+      raise ArgumentError, "expected a Texture" unless source.is_a?(Texture)
+      C::Graphics.sfTexture_updateFromTexture(@handle, source.handle, _vec2u(offset))
+      self
+    end
+
+    # Read the back-buffer of a `RenderWindow` into this texture
+    # at `offset`. Useful for capturing the rendered scene
+    # without re-drawing into a separate `RenderTexture`.
+    def update_from_render_window(window, offset: [0, 0])
+      raise ArgumentError, "expected a RenderWindow" unless window.is_a?(RenderWindow)
+      C::Graphics.sfTexture_updateFromRenderWindow(@handle, window.handle, _vec2u(offset))
+      self
+    end
+
+    # Same as `update_from_render_window` for the bare `Window`
+    # (when you're managing GL yourself).
+    def update_from_window(window, offset: [0, 0])
+      raise ArgumentError, "expected a Window" unless window.is_a?(SFML::Window)
+      C::Graphics.sfTexture_updateFromWindow(@handle, window.handle, _vec2u(offset))
+      self
+    end
+
     attr_reader :handle # :nodoc:
 
     # Internal — borrow a CSFML-owned `sfTexture*` (e.g. one
@@ -140,5 +206,12 @@ module SFML
     def _take_ownership(ptr)
       @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfTexture_destroy))
     end
+
+    def _vec2u(value)
+      v = C::System::Vector2u.new
+      x, y = value.is_a?(Vector2) ? [value.x, value.y] : value
+      v[:x] = Integer(x); v[:y] = Integer(y)
+      v
+    end
   end
 end

data/lib/sfml/graphics/view.rb

@@ -88,12 +88,20 @@ module SFML
 
     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)
+      C::Graphics.sfView_setViewport(@handle, _to_floatrect(rect))
+    end
+
+    # Scissor rect in normalised [0,1] window coords — pixels
+    # *outside* this rect are clipped before rendering. Default
+    # `[0, 0, 1, 1]` (no clipping). Use it to render UI inside a
+    # sub-region of the window without re-projecting.
+    def scissor
+      Rect.from_native(C::Graphics.sfView_getScissor(@handle))
+    end
+
+    def scissor=(rect)
+      raise ArgumentError, "View#scissor= needs a SFML::Rect" unless rect.is_a?(Rect)
+      C::Graphics.sfView_setScissor(@handle, _to_floatrect(rect))
     end
 
     # Pan the camera by an offset in world units.
@@ -119,6 +127,15 @@ module SFML
 
     private
 
+    def _to_floatrect(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
+      native
+    end
+
     def _vec2(value)
       value.is_a?(Vector2) ? value : Vector2.new(*value)
     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.3"
+  VERSION = "3.0.0.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-sfml
 version: !ruby/object:Gem::Version
-  version: 3.0.0.3
+  version: 3.0.0.4
 platform: ruby
 authors:
 - Mykhailo Melnyk