ruby-sfml 3.0.0.4 → 3.0.0.5

data/lib/sfml/c/graphics.rb

@@ -66,6 +66,12 @@ module SFML
       attach_variable :sfRenderStates_default, RenderStates
       attach_variable :sfTransform_Identity,   Transform
 
+      attach_function :sfColor_fromInteger, [:uint32], Color.by_value
+      attach_function :sfColor_toInteger,   [Color.by_value], :uint32
+      attach_function :sfColor_add,         [Color.by_value, Color.by_value], Color.by_value
+      attach_function :sfColor_subtract,    [Color.by_value, Color.by_value], Color.by_value
+      attach_function :sfColor_modulate,    [Color.by_value, Color.by_value], Color.by_value
+
       attach_function :sfTransform_combine,           [:pointer, :pointer], :void
       attach_function :sfTransform_translate,         [:pointer, System::Vector2f.by_value], :void
       attach_function :sfTransform_rotate,            [:pointer, :float], :void
@@ -153,6 +159,26 @@ module SFML
         layout :x, :int32, :y, :int32, :z, :int32, :w, :int32
       end
 
+      class GlslBvec2 < FFI::Struct
+        layout :x, :bool, :y, :bool
+      end
+
+      class GlslBvec3 < FFI::Struct
+        layout :x, :bool, :y, :bool, :z, :bool
+      end
+
+      class GlslBvec4 < FFI::Struct
+        layout :x, :bool, :y, :bool, :z, :bool, :w, :bool
+      end
+
+      class GlslMat3 < FFI::Struct
+        layout :array, [:float, 9]
+      end
+
+      class GlslMat4 < FFI::Struct
+        layout :array, [:float, 16]
+      end
+
       class Vertex < FFI::Struct
         layout :position,   System::Vector2f,
                :color,      Color,
@@ -222,10 +248,17 @@ module SFML
                       System::Vector2i.by_value
 
       # ---- Texture ----
-      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_create,             [System::Vector2u.by_value], :texture_t
+      attach_function :sfTexture_createSrgb,         [System::Vector2u.by_value], :texture_t
+      attach_function :sfTexture_createFromFile,     [:string, :pointer], :texture_t
+      attach_function :sfTexture_createSrgbFromFile, [:string, :pointer], :texture_t
+      attach_function :sfTexture_createFromImage,    [:image_t, :pointer], :texture_t
+      attach_function :sfTexture_createSrgbFromImage,[:image_t, :pointer], :texture_t
+      attach_function :sfTexture_createFromMemory,   [:pointer, :size_t, :pointer], :texture_t
+      attach_function :sfTexture_createSrgbFromMemory,[:pointer, :size_t, :pointer], :texture_t
+      attach_function :sfTexture_createFromStream,    [:pointer, :pointer], :texture_t
+      attach_function :sfTexture_createSrgbFromStream,[:pointer, :pointer], :texture_t
+      attach_function :sfTexture_resizeSrgb,         [:texture_t, System::Vector2u.by_value], :bool
       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
@@ -259,6 +292,7 @@ module SFML
       attach_function :sfImage_createFromPixels,  [System::Vector2u.by_value, :pointer], :image_t
       attach_function :sfImage_createFromFile,    [:string], :image_t
       attach_function :sfImage_createFromMemory,  [:pointer, :size_t], :image_t
+      attach_function :sfImage_createFromStream,  [:pointer], :image_t
       attach_function :sfImage_copy,              [:image_t], :image_t
       attach_function :sfImage_copyImage,         [:image_t, :image_t, System::Vector2u.by_value, IntRect.by_value, :bool], :bool
       attach_function :sfImage_destroy,           [:image_t], :void
@@ -318,6 +352,17 @@ module SFML
       attach_function :sfCircleShape_move,               [:circle_shape_t, System::Vector2f.by_value], :void
       attach_function :sfCircleShape_rotate,             [:circle_shape_t, :float], :void
       attach_function :sfCircleShape_scale,              [:circle_shape_t, System::Vector2f.by_value], :void
+      attach_function :sfCircleShape_copy,               [:circle_shape_t], :circle_shape_t
+      attach_function :sfCircleShape_getPoint,           [:circle_shape_t, :size_t], System::Vector2f.by_value
+      attach_function :sfCircleShape_getGeometricCenter, [:circle_shape_t], System::Vector2f.by_value
+      attach_function :sfCircleShape_getLocalBounds,     [:circle_shape_t], FloatRect.by_value
+      attach_function :sfCircleShape_getGlobalBounds,    [:circle_shape_t], FloatRect.by_value
+      attach_function :sfCircleShape_getTransform,       [:circle_shape_t], Transform.by_value
+      attach_function :sfCircleShape_getInverseTransform,[:circle_shape_t], Transform.by_value
+      attach_function :sfCircleShape_setTexture,         [:circle_shape_t, :texture_t, :bool], :void
+      attach_function :sfCircleShape_getTexture,         [:circle_shape_t], :texture_t
+      attach_function :sfCircleShape_setTextureRect,     [:circle_shape_t, IntRect.by_value], :void
+      attach_function :sfCircleShape_getTextureRect,     [:circle_shape_t], IntRect.by_value
 
       # ---- RectangleShape ----
       attach_function :sfRectangleShape_create,             [], :rectangle_shape_t
@@ -341,6 +386,18 @@ module SFML
       attach_function :sfRectangleShape_move,               [:rectangle_shape_t, System::Vector2f.by_value], :void
       attach_function :sfRectangleShape_rotate,             [:rectangle_shape_t, :float], :void
       attach_function :sfRectangleShape_scale,              [:rectangle_shape_t, System::Vector2f.by_value], :void
+      attach_function :sfRectangleShape_copy,               [:rectangle_shape_t], :rectangle_shape_t
+      attach_function :sfRectangleShape_getPointCount,      [:rectangle_shape_t], :size_t
+      attach_function :sfRectangleShape_getPoint,           [:rectangle_shape_t, :size_t], System::Vector2f.by_value
+      attach_function :sfRectangleShape_getGeometricCenter, [:rectangle_shape_t], System::Vector2f.by_value
+      attach_function :sfRectangleShape_getLocalBounds,     [:rectangle_shape_t], FloatRect.by_value
+      attach_function :sfRectangleShape_getGlobalBounds,    [:rectangle_shape_t], FloatRect.by_value
+      attach_function :sfRectangleShape_getTransform,       [:rectangle_shape_t], Transform.by_value
+      attach_function :sfRectangleShape_getInverseTransform,[:rectangle_shape_t], Transform.by_value
+      attach_function :sfRectangleShape_setTexture,         [:rectangle_shape_t, :texture_t, :bool], :void
+      attach_function :sfRectangleShape_getTexture,         [:rectangle_shape_t], :texture_t
+      attach_function :sfRectangleShape_setTextureRect,     [:rectangle_shape_t, IntRect.by_value], :void
+      attach_function :sfRectangleShape_getTextureRect,     [:rectangle_shape_t], IntRect.by_value
 
       # ---- ConvexShape ----
       attach_function :sfConvexShape_create,                [], :convex_shape_t
@@ -366,6 +423,16 @@ module SFML
       attach_function :sfConvexShape_move,                  [:convex_shape_t, System::Vector2f.by_value], :void
       attach_function :sfConvexShape_rotate,                [:convex_shape_t, :float], :void
       attach_function :sfConvexShape_scale,                 [:convex_shape_t, System::Vector2f.by_value], :void
+      attach_function :sfConvexShape_copy,                  [:convex_shape_t], :convex_shape_t
+      attach_function :sfConvexShape_getGeometricCenter,    [:convex_shape_t], System::Vector2f.by_value
+      attach_function :sfConvexShape_getLocalBounds,        [:convex_shape_t], FloatRect.by_value
+      attach_function :sfConvexShape_getGlobalBounds,       [:convex_shape_t], FloatRect.by_value
+      attach_function :sfConvexShape_getTransform,          [:convex_shape_t], Transform.by_value
+      attach_function :sfConvexShape_getInverseTransform,   [:convex_shape_t], Transform.by_value
+      attach_function :sfConvexShape_setTexture,            [:convex_shape_t, :texture_t, :bool], :void
+      attach_function :sfConvexShape_getTexture,            [:convex_shape_t], :texture_t
+      attach_function :sfConvexShape_setTextureRect,        [:convex_shape_t, IntRect.by_value], :void
+      attach_function :sfConvexShape_getTextureRect,        [:convex_shape_t], IntRect.by_value
 
       # ---- VertexArray ----
       attach_function :sfVertexArray_create,            [], :vertex_array_t
@@ -378,6 +445,7 @@ module SFML
       attach_function :sfVertexArray_setPrimitiveType,  [:vertex_array_t, :int], :void
       attach_function :sfVertexArray_getPrimitiveType,  [:vertex_array_t], :int
       attach_function :sfVertexArray_getBounds,         [:vertex_array_t], FloatRect.by_value
+      attach_function :sfVertexArray_copy,              [:vertex_array_t], :vertex_array_t
 
       # ---- RenderTexture ----
       attach_function :sfRenderTexture_create,          [System::Vector2u.by_value, :pointer], :render_texture_t
@@ -433,6 +501,7 @@ module SFML
       # ---- Shader ----
       attach_function :sfShader_createFromFile,   [:string, :string, :string], :shader_t
       attach_function :sfShader_createFromMemory, [:string, :string, :string], :shader_t
+      attach_function :sfShader_createFromStream, [:pointer, :pointer, :pointer], :shader_t
       attach_function :sfShader_destroy,          [:shader_t], :void
       attach_function :sfShader_isAvailable,      [], :bool
       attach_function :sfShader_bind,             [:shader_t], :void
@@ -471,6 +540,7 @@ module SFML
       attach_function :sfVertexBuffer_setUsage,       [:vertex_buffer_t, :int], :void
       attach_function :sfVertexBuffer_getUsage,       [:vertex_buffer_t], :int
       attach_function :sfVertexBuffer_isAvailable,    [], :bool
+      attach_function :sfVertexBuffer_bind,           [:vertex_buffer_t], :void
 
       # Bulk array uniform setters. The array argument is a packed
       # buffer of N elements (N×{1,2,3,4} floats); the length argument
@@ -480,6 +550,14 @@ module SFML
       attach_function :sfShader_setVec3UniformArray,  [:shader_t, :string, :pointer, :size_t], :void
       attach_function :sfShader_setVec4UniformArray,  [:shader_t, :string, :pointer, :size_t], :void
 
+      attach_function :sfShader_setBvec2Uniform,      [:shader_t, :string, GlslBvec2.by_value], :void
+      attach_function :sfShader_setBvec3Uniform,      [:shader_t, :string, GlslBvec3.by_value], :void
+      attach_function :sfShader_setBvec4Uniform,      [:shader_t, :string, GlslBvec4.by_value], :void
+      attach_function :sfShader_setMat3Uniform,       [:shader_t, :string, :pointer], :void
+      attach_function :sfShader_setMat4Uniform,       [:shader_t, :string, :pointer], :void
+      attach_function :sfShader_setMat3UniformArray,  [:shader_t, :string, :pointer, :size_t], :void
+      attach_function :sfShader_setMat4UniformArray,  [:shader_t, :string, :pointer, :size_t], :void
+
       # ---- Font ----
       # `sfFontInfo` carries one field — the human-readable font
       # family. CSFML 3 expanded this struct's surface area only
@@ -491,6 +569,7 @@ module SFML
 
       attach_function :sfFont_createFromFile,        [:string], :font_t
       attach_function :sfFont_createFromMemory,      [:pointer, :size_t], :font_t
+      attach_function :sfFont_createFromStream,      [:pointer], :font_t
       attach_function :sfFont_copy,                  [:font_t], :font_t
       attach_function :sfFont_destroy,               [:font_t], :void
       attach_function :sfFont_setSmooth,             [:font_t, :bool], :void
@@ -552,6 +631,69 @@ module SFML
       attach_function :sfSprite_getTextureRect,   [:sprite_t], IntRect.by_value
       attach_function :sfSprite_getLocalBounds,   [:sprite_t], FloatRect.by_value
       attach_function :sfSprite_getGlobalBounds,  [:sprite_t], FloatRect.by_value
+
+      # ---- Abstract Shape (callback-based custom polygon) ----
+      typedef :pointer, :shape_t
+      callback :shape_get_point_count, [:pointer], :size_t
+      callback :shape_get_point,       [:size_t, :pointer], System::Vector2f.by_value
+
+      attach_function :sfShape_create,                [:shape_get_point_count, :shape_get_point, :pointer], :shape_t
+      attach_function :sfShape_destroy,               [:shape_t], :void
+      attach_function :sfShape_setPosition,           [:shape_t, System::Vector2f.by_value], :void
+      attach_function :sfShape_getPosition,           [:shape_t], System::Vector2f.by_value
+      attach_function :sfShape_setRotation,           [:shape_t, :float], :void
+      attach_function :sfShape_getRotation,           [:shape_t], :float
+      attach_function :sfShape_setScale,              [:shape_t, System::Vector2f.by_value], :void
+      attach_function :sfShape_getScale,              [:shape_t], System::Vector2f.by_value
+      attach_function :sfShape_setOrigin,             [:shape_t, System::Vector2f.by_value], :void
+      attach_function :sfShape_getOrigin,             [:shape_t], System::Vector2f.by_value
+      attach_function :sfShape_move,                  [:shape_t, System::Vector2f.by_value], :void
+      attach_function :sfShape_rotate,                [:shape_t, :float], :void
+      attach_function :sfShape_scale,                 [:shape_t, System::Vector2f.by_value], :void
+      attach_function :sfShape_getTransform,          [:shape_t], Transform.by_value
+      attach_function :sfShape_getInverseTransform,   [:shape_t], Transform.by_value
+      attach_function :sfShape_setTexture,            [:shape_t, :texture_t, :bool], :void
+      attach_function :sfShape_getTexture,            [:shape_t], :texture_t
+      attach_function :sfShape_setTextureRect,        [:shape_t, IntRect.by_value], :void
+      attach_function :sfShape_getTextureRect,        [:shape_t], IntRect.by_value
+      attach_function :sfShape_setFillColor,          [:shape_t, Color.by_value], :void
+      attach_function :sfShape_getFillColor,          [:shape_t], Color.by_value
+      attach_function :sfShape_setOutlineColor,       [:shape_t, Color.by_value], :void
+      attach_function :sfShape_getOutlineColor,       [:shape_t], Color.by_value
+      attach_function :sfShape_setOutlineThickness,   [:shape_t, :float], :void
+      attach_function :sfShape_getOutlineThickness,   [:shape_t], :float
+      attach_function :sfShape_getPointCount,         [:shape_t], :size_t
+      attach_function :sfShape_getPoint,              [:shape_t, :size_t], System::Vector2f.by_value
+      attach_function :sfShape_getGeometricCenter,    [:shape_t], System::Vector2f.by_value
+      attach_function :sfShape_getLocalBounds,        [:shape_t], FloatRect.by_value
+      attach_function :sfShape_getGlobalBounds,       [:shape_t], FloatRect.by_value
+      attach_function :sfShape_update,                [:shape_t], :void
+
+      # CSFML draw entry-point for the abstract shape (same shape as
+      # the concrete CircleShape/RectangleShape/ConvexShape variants).
+      attach_function :sfRenderWindow_drawShape,
+                      [:render_window_t, :shape_t, :render_states_t], :void
+      attach_function :sfRenderTexture_drawShape,
+                      [:render_texture_t, :shape_t, :render_states_t], :void
+
+      # ---- Standalone Transformable ----
+      typedef :pointer, :transformable_t
+      attach_function :sfTransformable_create,                [], :transformable_t
+      attach_function :sfTransformable_copy,                  [:transformable_t], :transformable_t
+      attach_function :sfTransformable_destroy,               [:transformable_t], :void
+      attach_function :sfTransformable_setPosition,           [:transformable_t, System::Vector2f.by_value], :void
+      attach_function :sfTransformable_getPosition,           [:transformable_t], System::Vector2f.by_value
+      attach_function :sfTransformable_setRotation,           [:transformable_t, :float], :void
+      attach_function :sfTransformable_getRotation,           [:transformable_t], :float
+      attach_function :sfTransformable_setScale,              [:transformable_t, System::Vector2f.by_value], :void
+      attach_function :sfTransformable_getScale,              [:transformable_t], System::Vector2f.by_value
+      attach_function :sfTransformable_setOrigin,             [:transformable_t, System::Vector2f.by_value], :void
+      attach_function :sfTransformable_getOrigin,             [:transformable_t], System::Vector2f.by_value
+      attach_function :sfTransformable_move,                  [:transformable_t, System::Vector2f.by_value], :void
+      attach_function :sfTransformable_rotate,                [:transformable_t, :float], :void
+      attach_function :sfTransformable_scale,                 [:transformable_t, System::Vector2f.by_value], :void
+      attach_function :sfTransformable_getTransform,          [:transformable_t], Transform.by_value
+      attach_function :sfTransformable_getInverseTransform,   [:transformable_t], Transform.by_value
     end
   end
 end

data/lib/sfml/c/network.rb

@@ -69,11 +69,51 @@ module SFML
       attach_function :sfUdpSocket_maxDatagramSize,  [], :uint32
 
       # ---- Packet (typed serializer) ----
-      attach_function :sfPacket_create,         [], :packet_t
-      attach_function :sfPacket_destroy,        [:packet_t], :void
-      attach_function :sfPacket_append,         [:packet_t, :pointer, :size_t], :void
-      attach_function :sfPacket_clear,          [:packet_t], :void
-      attach_function :sfPacket_getData,        [:packet_t], :pointer
+      attach_function :sfPacket_create,           [], :packet_t
+      attach_function :sfPacket_copy,             [:packet_t], :packet_t
+      attach_function :sfPacket_destroy,          [:packet_t], :void
+      attach_function :sfPacket_append,           [:packet_t, :pointer, :size_t], :void
+      attach_function :sfPacket_clear,            [:packet_t], :void
+      attach_function :sfPacket_getData,          [:packet_t], :pointer
+      attach_function :sfPacket_getDataSize,      [:packet_t], :size_t
+      attach_function :sfPacket_getReadPosition,  [:packet_t], :size_t
+      attach_function :sfPacket_endOfPacket,      [:packet_t], :bool
+      attach_function :sfPacket_canRead,          [:packet_t], :bool
+
+      attach_function :sfPacket_readBool,    [:packet_t], :bool
+      attach_function :sfPacket_readInt8,    [:packet_t], :int8
+      attach_function :sfPacket_readUint8,   [:packet_t], :uint8
+      attach_function :sfPacket_readInt16,   [:packet_t], :int16
+      attach_function :sfPacket_readUint16,  [:packet_t], :uint16
+      attach_function :sfPacket_readInt32,   [:packet_t], :int32
+      attach_function :sfPacket_readUint32,  [:packet_t], :uint32
+      attach_function :sfPacket_readInt64,   [:packet_t], :int64
+      attach_function :sfPacket_readUint64,  [:packet_t], :uint64
+      attach_function :sfPacket_readFloat,   [:packet_t], :float
+      attach_function :sfPacket_readDouble,  [:packet_t], :double
+      # CSFML's `readString` writes a NUL-terminated C string into a
+      # caller-allocated buffer. We size the buffer from the packet's
+      # remaining bytes — the encoded length precedes the chars, so
+      # `getDataSize - getReadPosition` is a safe upper bound.
+      attach_function :sfPacket_readString,  [:packet_t, :pointer], :void
+
+      attach_function :sfPacket_writeBool,    [:packet_t, :bool], :void
+      attach_function :sfPacket_writeInt8,    [:packet_t, :int8], :void
+      attach_function :sfPacket_writeUint8,   [:packet_t, :uint8], :void
+      attach_function :sfPacket_writeInt16,   [:packet_t, :int16], :void
+      attach_function :sfPacket_writeUint16,  [:packet_t, :uint16], :void
+      attach_function :sfPacket_writeInt32,   [:packet_t, :int32], :void
+      attach_function :sfPacket_writeUint32,  [:packet_t, :uint32], :void
+      attach_function :sfPacket_writeInt64,   [:packet_t, :int64], :void
+      attach_function :sfPacket_writeUint64,  [:packet_t, :uint64], :void
+      attach_function :sfPacket_writeFloat,   [:packet_t, :float], :void
+      attach_function :sfPacket_writeDouble,  [:packet_t, :double], :void
+      attach_function :sfPacket_writeString,  [:packet_t, :string], :void
+
+      attach_function :sfTcpSocket_sendPacket,    [:tcp_socket_t, :packet_t], :int
+      attach_function :sfTcpSocket_receivePacket, [:tcp_socket_t, :packet_t], :int, blocking: true
+      attach_function :sfUdpSocket_sendPacket,    [:udp_socket_t, :packet_t, IpAddress.by_value, :uint16], :int
+      attach_function :sfUdpSocket_receivePacket, [:udp_socket_t, :packet_t, :pointer, :pointer], :int, blocking: true
 
       # ---- HTTP ----
       typedef :pointer, :http_t

data/lib/sfml/c/system.rb

@@ -48,6 +48,18 @@ module SFML
       attach_function :sfBuffer_destroy, [:buffer_t],               :void
       attach_function :sfBuffer_getSize, [:buffer_t],               :size_t
       attach_function :sfBuffer_getData, [:buffer_t],               :pointer
+
+      # sfInputStream — a struct of 4 function pointers Ruby fills in
+      # to expose a Ruby IO-like object to CSFML's loader functions.
+      # User-data is ignored; we close over the Ruby object in each
+      # callback closure directly.
+      class InputStream < FFI::Struct
+        layout :read,      :pointer,
+               :seek,      :pointer,
+               :tell,      :pointer,
+               :get_size,  :pointer,
+               :user_data, :pointer
+      end
     end
   end
 end

data/lib/sfml/c/window.rb

@@ -159,9 +159,16 @@ module SFML
         end
       end
 
-      attach_function :sfVideoMode_getDesktopMode, [], VideoMode.by_value
+      attach_function :sfVideoMode_getDesktopMode,     [], VideoMode.by_value
+      attach_function :sfVideoMode_getFullscreenModes, [:pointer], :pointer
+      attach_function :sfVideoMode_isValid,            [VideoMode.by_value], :bool
 
-      attach_function :sfKeyboard_isKeyPressed, [:int], :bool
+      attach_function :sfKeyboard_isKeyPressed,            [:int], :bool
+      attach_function :sfKeyboard_isScancodePressed,       [:int], :bool
+      attach_function :sfKeyboard_localize,                [:int], :int
+      attach_function :sfKeyboard_delocalize,              [:int], :int
+      attach_function :sfKeyboard_getDescription,          [:int], :string
+      attach_function :sfKeyboard_setVirtualKeyboardVisible, [:bool], :void
 
       # Mouse: position queries here use a sfWindow*. Pass NULL to get
       # desktop-relative coordinates. The render-window variants live in
@@ -260,6 +267,17 @@ module SFML
       # to use defaults.
       attach_function :sfWindow_createFromHandle, [:pointer, :pointer], :raw_window_t
       attach_function :sfWindow_getNativeHandle,  [:raw_window_t], :pointer
+
+      # ---- Context (headless GL context — for off-screen shader
+      #               compilation or raw GL work without a window) ----
+      typedef :pointer, :context_t
+      attach_function :sfContext_create,                [], :context_t
+      attach_function :sfContext_destroy,               [:context_t], :void
+      attach_function :sfContext_isExtensionAvailable,  [:string], :bool
+      attach_function :sfContext_setActive,             [:context_t, :bool], :bool
+      attach_function :sfContext_getFunction,           [:string], :pointer
+      attach_function :sfContext_getSettings,           [:context_t], ContextSettings.by_value
+      attach_function :sfContext_getActiveContextId,    [], :uint64
     end
   end
 end

data/lib/sfml/graphics/circle_shape.rb

@@ -10,6 +10,7 @@ module SFML
   #   window.draw(ball)
   class CircleShape
     include Graphics::Transformable
+    include Graphics::ShapeInspectable
     CSFML_PREFIX = :sfCircleShape
 
     def initialize(radius: 10.0, **opts)
@@ -22,6 +23,8 @@ module SFML
       self.fill_color         = opts[:fill_color]         if opts.key?(:fill_color)
       self.outline_color      = opts[:outline_color]      if opts.key?(:outline_color)
       self.outline_thickness  = opts[:outline_thickness]  if opts.key?(:outline_thickness)
+      self.texture            = opts[:texture]            if opts.key?(:texture)
+      self.texture_rect       = opts[:texture_rect]       if opts.key?(:texture_rect)
       self.position           = opts[:position]           if opts.key?(:position)
       self.origin             = opts[:origin]             if opts.key?(:origin)
       self.rotation           = opts[:rotation]           if opts.key?(:rotation)

data/lib/sfml/graphics/color.rb

@@ -59,6 +59,36 @@ module SFML
       new(struct[:r], struct[:g], struct[:b], struct[:a])
     end
 
+    # Build from a packed 0xRRGGBBAA integer.
+    def self.from_integer(value)
+      from_native(C::Graphics.sfColor_fromInteger(Integer(value)))
+    end
+
+    # Pack this color into a single 0xRRGGBBAA integer.
+    def to_integer = C::Graphics.sfColor_toInteger(to_native)
+
+    # Component-wise channel arithmetic (saturating in CSFML — values
+    # clamp to [0, 255]).
+
+    def +(other)
+      raise ArgumentError, "Color +: expected SFML::Color" unless other.is_a?(Color)
+      self.class.from_native(C::Graphics.sfColor_add(to_native, other.to_native))
+    end
+
+    def -(other)
+      raise ArgumentError, "Color -: expected SFML::Color" unless other.is_a?(Color)
+      self.class.from_native(C::Graphics.sfColor_subtract(to_native, other.to_native))
+    end
+
+    # Channel-wise multiply, e.g. for tinting (white modulates to
+    # input; black modulates to black). Uses CSFML's normalised
+    # formula `(a * b) / 255`.
+    def *(other)
+      raise ArgumentError, "Color *: expected SFML::Color" unless other.is_a?(Color)
+      self.class.from_native(C::Graphics.sfColor_modulate(to_native, other.to_native))
+    end
+    alias modulate *
+
     # Standard SFML colors.
     BLACK       = new(0,   0,   0)
     WHITE       = new(255, 255, 255)

data/lib/sfml/graphics/convex_shape.rb

@@ -13,6 +13,7 @@ module SFML
   #   window.draw(star)
   class ConvexShape
     include Graphics::Transformable
+    include Graphics::ShapeInspectable
     CSFML_PREFIX = :sfConvexShape
 
     def initialize(points: nil, **opts)
@@ -24,6 +25,8 @@ module SFML
       self.fill_color        = opts[:fill_color]        if opts.key?(:fill_color)
       self.outline_color     = opts[:outline_color]     if opts.key?(:outline_color)
       self.outline_thickness = opts[:outline_thickness] if opts.key?(:outline_thickness)
+      self.texture           = opts[:texture]           if opts.key?(:texture)
+      self.texture_rect      = opts[:texture_rect]      if opts.key?(:texture_rect)
       self.position          = opts[:position]          if opts.key?(:position)
       self.origin            = opts[:origin]            if opts.key?(:origin)
       self.rotation          = opts[:rotation]          if opts.key?(:rotation)

data/lib/sfml/graphics/font.rb

@@ -41,6 +41,25 @@ module SFML
 
       font = allocate
       font.send(:_take_ownership, ptr)
+      # CSFML doesn't copy the font bytes — keep them pinned so the
+      # GC doesn't free them while CSFML still references the buffer.
+      font.instance_variable_set(:@_memory_pin, buf)
+      font
+    end
+
+    # Load a TTF/OTF from any Ruby IO-like object — file, in-memory,
+    # network-backed reader. Keep the IO open until the Font is no
+    # longer in use; CSFML reads glyphs lazily.
+    def self.from_stream(io)
+      stream = SFML::InputStream.new(io)
+      ptr = C::Graphics.sfFont_createFromStream(stream.to_ptr)
+      raise Error, "sfFont_createFromStream returned NULL" if ptr.null?
+
+      font = allocate
+      font.send(:_take_ownership, ptr)
+      # CSFML reads the font lazily from this stream — keep it pinned.
+      font.instance_variable_set(:@_stream_pin, stream)
+      font.instance_variable_set(:@_io_pin, io)
       font
     end
 

data/lib/sfml/graphics/image.rb

@@ -58,6 +58,18 @@ module SFML
       img
     end
 
+    # Decode an image from any Ruby IO-like object (File, StringIO,
+    # network-backed reader). The stream must support read/seek/pos/size.
+    def self.from_stream(io)
+      stream = SFML::InputStream.new(io)
+      ptr = C::Graphics.sfImage_createFromStream(stream.to_ptr)
+      raise Error, "sfImage_createFromStream returned NULL — unsupported format?" if ptr.null?
+
+      img = allocate
+      img.send(:_take_ownership, ptr)
+      img
+    end
+
     # Build an image from a raw RGBA byte string. `pixels` must be
     # exactly width*height*4 bytes, row-major from the top-left.
     def self.from_pixels(width, height, pixels)

data/lib/sfml/graphics/rectangle_shape.rb

@@ -9,6 +9,7 @@ module SFML
   #   window.draw(wall)
   class RectangleShape
     include Graphics::Transformable
+    include Graphics::ShapeInspectable
     CSFML_PREFIX = :sfRectangleShape
 
     def initialize(size:, **opts)
@@ -20,12 +21,16 @@ module SFML
       self.fill_color         = opts[:fill_color]         if opts.key?(:fill_color)
       self.outline_color      = opts[:outline_color]      if opts.key?(:outline_color)
       self.outline_thickness  = opts[:outline_thickness]  if opts.key?(:outline_thickness)
+      self.texture            = opts[:texture]            if opts.key?(:texture)
+      self.texture_rect       = opts[:texture_rect]       if opts.key?(:texture_rect)
       self.position           = opts[:position]           if opts.key?(:position)
       self.origin             = opts[:origin]             if opts.key?(:origin)
       self.rotation           = opts[:rotation]           if opts.key?(:rotation)
       self.scale              = opts[:scale]              if opts.key?(:scale)
     end
 
+    def point_count = C::Graphics.sfRectangleShape_getPointCount(@handle)
+
     def size
       Vector2.from_native(C::Graphics.sfRectangleShape_getSize(@handle))
     end

data/lib/sfml/graphics/shader.rb

@@ -68,6 +68,18 @@ module SFML
       _wrap(ptr)
     end
 
+    # Build a shader from one or more IO-like streams (any object
+    # answering read/seek/pos/size). Useful when shader source lives
+    # inside an archive or a network resource.
+    def self.from_stream(vertex: nil, geometry: nil, fragment: nil)
+      _check_at_least_one(vertex, geometry, fragment)
+      streams = [vertex, geometry, fragment].map { |io| io && SFML::InputStream.new(io) }
+      ptrs    = streams.map { |s| s ? s.to_ptr : nil }
+      ptr = C::Graphics.sfShader_createFromStream(*ptrs)
+      raise Error, "sfShader_createFromStream failed (GLSL compile error?)" if ptr.null?
+      _wrap(ptr)
+    end
+
     # Set a uniform by name. Dispatches to the right CSFML setter based
     # on the Ruby value's type — see the class-level docs for the table.
     def []=(name, value)
@@ -139,6 +151,56 @@ module SFML
       C::Graphics.sfShader_setFloatUniformArray(@handle, name.to_s, buf, values.length)
     end
 
+    # Set a `uniform bvec2/3/4` from a Ruby Array of booleans. Length
+    # picks the dimensionality.
+    def set_bvec(name, *components)
+      flat = components.flatten
+      case flat.length
+      when 2
+        s = C::Graphics::GlslBvec2.new
+        s[:x] = !!flat[0]; s[:y] = !!flat[1]
+        C::Graphics.sfShader_setBvec2Uniform(@handle, name.to_s, s)
+      when 3
+        s = C::Graphics::GlslBvec3.new
+        s[:x] = !!flat[0]; s[:y] = !!flat[1]; s[:z] = !!flat[2]
+        C::Graphics.sfShader_setBvec3Uniform(@handle, name.to_s, s)
+      when 4
+        s = C::Graphics::GlslBvec4.new
+        s[:x] = !!flat[0]; s[:y] = !!flat[1]; s[:z] = !!flat[2]; s[:w] = !!flat[3]
+        C::Graphics.sfShader_setBvec4Uniform(@handle, name.to_s, s)
+      else
+        raise ArgumentError, "bvec uniform must have 2, 3, or 4 components (got #{flat.length})"
+      end
+    end
+
+    # Set a `uniform mat3` from a 9-element row-major float array (or
+    # an SFML::Transform — its 3×3 matrix is read directly).
+    def set_mat3(name, matrix)
+      values = _coerce_matrix(matrix, 9, "mat3")
+      mat = C::Graphics::GlslMat3.new
+      values.each_with_index { |v, i| mat[:array][i] = v }
+      C::Graphics.sfShader_setMat3Uniform(@handle, name.to_s, mat.pointer)
+    end
+
+    # Set a `uniform mat4` from a 16-element row-major float array.
+    def set_mat4(name, matrix)
+      values = _coerce_matrix(matrix, 16, "mat4")
+      mat = C::Graphics::GlslMat4.new
+      values.each_with_index { |v, i| mat[:array][i] = v }
+      C::Graphics.sfShader_setMat4Uniform(@handle, name.to_s, mat.pointer)
+    end
+
+    # Set a `uniform mat3 arr[N];` / `uniform mat4 arr[N];` from a
+    # list of matrices (each a 9- or 16-element flat array, or an
+    # SFML::Transform for mat3).
+    def set_mat3_array(name, matrices)
+      _set_mat_array(name, matrices, 9, :sfShader_setMat3UniformArray)
+    end
+
+    def set_mat4_array(name, matrices)
+      _set_mat_array(name, matrices, 16, :sfShader_setMat4UniformArray)
+    end
+
     # Bind this shader as the active GL program. Useful when you
     # want to issue raw GL draw calls under SFML's context. Pair
     # with `Shader.unbind` to restore SFML's default. Most users
@@ -165,6 +227,30 @@ module SFML
 
     private
 
+    def _coerce_matrix(matrix, expected_length, label)
+      values =
+        case matrix
+        when Transform then matrix.matrix
+        when Array     then matrix.flatten
+        else
+          raise ArgumentError, "#{label} uniform requires an Array or SFML::Transform (got #{matrix.class})"
+        end
+      unless values.length == expected_length
+        raise ArgumentError, "#{label} uniform needs #{expected_length} elements (got #{values.length})"
+      end
+      values.map(&:to_f)
+    end
+
+    def _set_mat_array(name, matrices, stride, setter)
+      raise ArgumentError, "matrix array must not be empty" if matrices.empty?
+
+      label = stride == 9 ? "mat3" : "mat4"
+      flat = matrices.flat_map { |m| _coerce_matrix(m, stride, label) }
+      buf  = FFI::MemoryPointer.new(:float, flat.length)
+      buf.write_array_of_float(flat)
+      C::Graphics.public_send(setter, @handle, name.to_s, buf, matrices.length)
+    end
+
     # Detect the inner length (2/3/4), pack a contiguous float buffer,
     # and dispatch to the matching CSFML setVec*UniformArray.
     def _set_vec_array_uniform(name, elements)