sfml3-rb 0.3.0-arm-linux-gnu

data/TODO.md

@@ -0,0 +1,199 @@
+# Roadmap: SFML 3 API port to Ruby
+
+Tracks porting coverage of the SFML 3 API into this gem, module by module and class by class.
+
+This binding wraps **CSFML 3** (the C API), not SFML's C++ API directly, so the scope below is
+CSFML 3.0.0's actual header set — not every C++-only construct in the
+[reference docs](https://www.sfml-dev.org/documentation/3.1.0/annotated.html). Out of scope for that
+reason: `String`/`Utf`/`Literals` (SFML C++ uses `std::string`; CSFML takes plain C strings),
+`Exception` (CSFML reports errors via return codes, not C++ exceptions), and C++-utility-only types
+(`SuspendAwareClock`, `TimeoutWithPredicate`, `U8StringCharTraits`). `Glsl` is handled as plain
+`set_*_uniform` calls (its types are CSFML structs, not a templated class), and `InputStream`'s C
+struct form *is* bound (`SFML::InputStream`). `Sftp` is also out of scope: it was added to SFML in
+3.1, and the CSFML 3.0.0 this gem vendors predates it.
+
+Status legend: `[x]` bound and tested · `[~]` compiled but not exposed to Ruby, or exposed as an
+internal helper only · `[ ]` not started.
+
+**Coverage is tracked per function, not per class.** Every `sf*` entry point in
+`ports/<target>/include/CSFML` is accounted for: bound, or listed in "Deliberately unbound" at the
+bottom. Re-derive the list with:
+
+```sh
+grep -rhoE '\bsf[A-Za-z0-9_]+\s*\(' ports/<target>/include/CSFML --include='*.h' \
+  | tr -d ' (' | sort -u > /tmp/api.txt
+grep -rhoE '\bsf[A-Za-z0-9_]+' ext --include='*.c' --include='*.h' --include='*.inc' \
+  | sort -u > /tmp/used.txt
+comm -23 /tmp/api.txt /tmp/used.txt
+```
+
+Mind the false positives: functions reached through token paste (`sfSound_*`, `sfMusic_*`,
+`sfSoundStream_*` from `ext/audio/sound_source.inc`; `sfPacket_read*`/`write*` from the macro in
+`ext/network/packet.c`; the shared `sfRenderWindow_*`/`sfRenderTexture_*` render-target methods
+from `ext/graphics/render_target.inc`) never appear literally in the sources and so show up as
+"missing" every time.
+
+## System
+
+Base module: time, vectors, clocks, streams.
+
+- [x] **Clock** — `SFML::Clock` (`ext/system/clock.c`); `elapsed_time`, `restart!`, `reset!`,
+      `start!`, `stop!`, `running?`, `copy`
+- [x] **Vector2** — `SFML::Vector2` (`ext/system/vec2.c`); setters still accept `[x, y]`
+- [x] **Vector3** — `SFML::Vector3` (`ext/system/vec3.c`)
+- [x] **Time** — `SFML::Time` (`ext/system/time.c`); arithmetic, comparison, unit conversions
+- [x] **Sleep** — `SFML.sleep` (`ext/system/sleep.c`)
+- [x] **InputStream** — `SFML::InputStream` (`ext/system/input_stream.c`); wraps any `#read`-able
+      object and is accepted by every `from_stream` constructor
+- [x] **Buffer** — `SFML::Buffer` (`ext/system/buffer.c`); returned by `Image#save_to_memory`
+
+## Window
+
+OpenGL-based windows, events, input handling.
+
+- [x] **Window** — `SFML::Window` (`ext/window/window.c`); wraps `sfRenderWindow`, so this single
+      class covers what SFML splits into `WindowBase` + `Window` + `RenderWindow`. Accepts style,
+      state and `ContextSettings`; exposes min/max size, icon, cursor, native handle, settings.
+- [x] **VideoMode** — `SFML::VideoMode` (`ext/window/video_mode.c`); includes `desktop_mode` and
+      `fullscreen_modes`
+- [x] **Event** — `SFML::Event` (`ext/window/event.c`, `ext/window/event_name.c`); every payload is
+      exposed — text, key, mouse move/raw/button/wheel, joystick move/button/connect, touch, sensor
+- [x] **Keyboard** — `SFML::Keyboard` (`ext/window/keyboard.c`); real-time `pressed?`,
+      `scancode_pressed?`, `localize`, `delocalize`, `description`, virtual-keyboard toggle
+- [x] **Mouse** — `SFML::Mouse` (`ext/window/mouse.c`)
+- [x] **Joystick** — `SFML::Joystick` (`ext/window/joystick.c`)
+- [x] **Touch** — `SFML::Touch` (`ext/window/touch.c`)
+- [x] **Sensor** — `SFML::Sensor` (`ext/window/sensor.c`)
+- [x] **Clipboard** — `SFML::Clipboard` (`ext/window/clipboard.c`)
+- [x] **Cursor** — `SFML::Cursor` (`ext/window/cursor.c`)
+- [x] **Context** / **ContextSettings** — `SFML::Context`, `SFML::ContextSettings`
+      (`ext/window/context.c`, `ext/window/context_settings.c`)
+- [x] **Vulkan** — `SFML::Vulkan` (`ext/window/vulkan.c`)
+
+## Graphics
+
+2D rendering: shapes, sprites, text, render targets.
+
+- [x] **Transform** — `SFML::Transform` (`ext/graphics/transform.c`); a class wrapping
+      `sfTransform` by value. `identity`/`IDENTITY` (frozen), `from_a`, `to_a`/`matrix` (3x3),
+      `gl_matrix` (the 16-float 4x4 for `glLoadMatrixf`), `==`, `translate!`, `rotate!`, `scale!`
+      (both taking an optional centre), non-mutating `translate`/`rotate`/`scale`,
+      `transform_point`, `transform_rect`, `combine!`, `*`, `inverse`, `copy`. The old module
+      functions `Transform.combine`/`Transform.inverse` remain, Array-in/Array-out. Every class
+      that exposes `#transform` still returns a plain 9-element Array, and anything that *takes*
+      a transform accepts either form
+- [x] **Transformable** — `SFML::Transformable` (`ext/graphics/transformable.c`); including
+      `inverse_transform` and `copy`
+- [x] **Drawable** — `SFML::Drawable` mixin (`ext/graphics/drawable.c`)
+- [x] **RenderStates** — `SFML::RenderState` (`ext/graphics/render_state.c`); blend mode, stencil
+      mode, coordinate type, texture, shader and transform are all settable
+- [x] **RenderTarget** — `SFML::Target` (`ext/graphics/target.c`) dispatches to `sfRenderWindow_*`
+      or `sfRenderTexture_*` at runtime for `Drawable#draw`. The methods each concrete target owns
+      directly — `map_pixel_to_coords`, `map_coords_to_pixel`, `push_gl_states`, `pop_gl_states`,
+      `reset_gl_states`, `draw_primitives`, `draw_vertex_buffer_range`, `clear_stencil`,
+      `clear_color_and_stencil`, `viewport`, `scissor`, `srgb?` — are generated once for both
+      `Window` and `RenderTexture` from `ext/graphics/render_target.inc`
+- [x] **RenderWindow** — folded into `SFML::Window` (see Window module above)
+- [x] **RenderTexture** — `SFML::RenderTexture` (`ext/graphics/render_texture.c`)
+- [x] **View** — `SFML::View` (`ext/graphics/view.c`); including `View.from_rect` and
+      `scissor`/`scissor=`
+- [x] **CircleShape** — `SFML::Circle` (`ext/graphics/circle.c`)
+- [x] **RectangleShape** — `SFML::RectangleShape` (`ext/graphics/rectangle.c`)
+- [x] **ConvexShape** — `SFML::ConvexShape` (`ext/graphics/polygon.c`)
+- [x] **Shape** — `SFML::Shape` (`ext/graphics/shape.c`); subclass and define `point_count`/`point`
+- [x] **Sprite** — `SFML::Sprite` (`ext/graphics/sprite.c`)
+- [x] **Texture** — `SFML::Texture` (`ext/graphics/texture.c`); every constructor in both linear
+      and sRGB form, plus `resize`/`resize_srgb` and `swap`
+- [x] **Image** — `SFML::Image` (`ext/graphics/image.c`)
+- [x] **Font** — `SFML::Font` (`ext/graphics/font.c`)
+- [x] **Text** — `SFML::Text` (`ext/graphics/text.c`); `#string` goes through the UTF-32 entry
+      points, so non-ASCII round-trips exactly
+- [x] **Glyph** — `SFML::Glyph` (`ext/graphics/glyph.c`)
+- [x] **Shader** — `SFML::Shader` (`ext/graphics/shader.c`); scalar/vector/color/int/bool/matrix
+      uniforms, all six array uniforms (float, vec2-4, mat3, mat4), plus a generic `uniform=`
+- [x] **Color** — `SFML::Color` (`ext/graphics/color.c`)
+- [x] **Rect** — `SFML::Rect` (`ext/graphics/rect.c`); `sfFloatRect` and `sfIntRect`
+- [x] **BlendMode** — `SFML::BlendMode` (`ext/graphics/blend_mode.c`)
+- [x] **StencilMode** — `SFML::StencilMode` (`ext/graphics/stencil_mode.c`)
+- [x] **Vertex** / **VertexArray** / **VertexBuffer** — `ext/graphics/vertex*.c`
+
+## Audio
+
+Sounds, streaming, recording, spatialization.
+
+- [x] **Listener** — `SFML::Listener` (`ext/audio/listener.c`); global volume plus
+      position/direction/velocity/up-vector/cone
+- [x] **ListenerCone** / **SoundSourceCone** — `SFML::SoundSourceCone` (`ext/audio/sound_source_cone.c`)
+- [x] **SoundSource** — the shared play/pause/stop/status, pitch, pan, volume, spatialization,
+      position/direction/velocity, cone, doppler/directional-attenuation, min/max distance/gain,
+      attenuation, playing-offset and effect-processor surface, generated per class from
+      `ext/audio/sound_source.inc`
+- [x] **SoundStatus** / **SoundChannel** — `SFML::SoundStatus`, `SFML::SoundChannel`
+      (`ext/audio/audio_enums.c`)
+- [x] **SoundBuffer** — `SFML::SoundBuffer` (`ext/audio/sound_buffer.c`); loading from file, memory,
+      stream and raw samples, saving, sample access and channel map
+- [x] **Sound** — `SFML::Sound` (`ext/audio/sound.c`)
+- [x] **SoundStream** — `SFML::SoundStream` (`ext/audio/sound_stream.c`); subclass and implement
+      `#on_get_data` (and optionally `#on_seek`)
+- [x] **SoundBufferRecorder** — `SFML::SoundBufferRecorder` (`ext/audio/sound_buffer_recorder.c`)
+- [x] **SoundRecorder** — `SFML::SoundRecorder` (`ext/audio/sound_recorder.c`); subclass and
+      implement `#on_process` (and optionally `#on_start`/`#on_stop`)
+- [x] **Music** — `SFML::Music` (`ext/audio/music.c`); file, memory and stream sources, loop points
+- [x] **EffectProcessor** — `SFML::SoundSource#effect_processor=`; a Ruby proc is dispatched through
+      a bounded pool of C thunks (`ext/audio/effect_processor.c`), because `sfEffectProcessor` has
+      no `userData` to identify the source
+- [x] **Build support** — `ext/ports.rb` builds Ogg 1.3.5, Vorbis 1.3.7 and FLAC 1.4.3 as pinned,
+      static, position-independent ports (SFML 3's audio backend is miniaudio, so no OpenAL), and
+      enables `SFML_BUILD_AUDIO` / `CSFML_BUILD_AUDIO`
+
+## Network
+
+Socket-based communication and higher-level protocols.
+
+- [x] **IpAddress** — `SFML::IpAddress` (`ext/network/ip_address.c`); string/bytes/integer
+      constructors, `NONE`/`ANY`/`LOCAL_HOST`/`BROADCAST`, local and public address lookup
+- [x] **Packet** — `SFML::Packet` (`ext/network/packet.c`); raw data plus every typed reader/writer
+      (booleans, all integer widths, floats, string)
+- [x] **SocketSelector** — `SFML::SocketSelector` (`ext/network/socket_selector.c`); add/remove for
+      each socket type, wait and readiness checks
+- [x] **TcpSocket** / **TcpListener** — `SFML::TcpSocket`, `SFML::TcpListener`
+      (`ext/network/tcp_socket.c`, `ext/network/tcp_listener.c`); connect/accept, blocking control,
+      raw and packet sends/receives
+- [x] **UdpSocket** — `SFML::UdpSocket` (`ext/network/udp_socket.c`); bind/send/receive and packet
+      variants, datagram size and any-port helpers
+- [x] **Http** — `SFML::Http`, `SFML::HttpRequest`, `SFML::HttpResponse` (`ext/network/http.c`)
+- [x] **Ftp** — `SFML::Ftp`, `SFML::FtpResponse`, `SFML::FtpDirectoryResponse`,
+      `SFML::FtpListingResponse` (`ext/network/ftp.c`)
+- [x] **SocketStatus** / **HttpMethod** / **HttpStatus** / **FtpStatus** / **FtpTransferMode** —
+      enum modules (`ext/network/network_enums.c`)
+- [x] **Build support** — `ext/ports.rb` enables `SFML_BUILD_NETWORK` / `CSFML_BUILD_NETWORK`; the
+      module needs no external dependency (just `ws2_32` on Windows)
+
+Note that CSFML exposes no `sfSocket` base class, so there is nothing to bind for "Socket base" —
+only the concrete TCP/UDP sockets and the selector.
+
+## Deliberately unbound
+
+These CSFML entry points have no Ruby surface on purpose. Listed so a coverage diff can be read
+without re-deriving the reasoning each time.
+
+| Symbols | Why |
+| --- | --- |
+| `sfWindow_*`, `sfWindowBase_*` (~55 functions) | `SFML::Window` wraps `sfRenderWindow`, which subsumes both a plain window and a base window. |
+| `sfMouse_*WindowBase`, `sfTouch_getPositionWindowBase` | Superseded by the `*RenderWindow` forms, which need no downcast. |
+| `sfRenderWindow_create`, `sfText_getString`/`setString`, `sfRenderWindow_setTitle`, `sfFtpDirectoryResponse_getDirectory` | Superseded by their `*Unicode` counterparts; the narrow forms decode through the C locale and mangle non-ASCII. |
+| `sfColor_add`/`subtract`/`modulate`/`fromRGB`/`fromRGBA`/`fromInteger`/`toInteger`, `sfIntRect_contains`/`intersects` | Reimplemented directly in C in `color.c` / `rect.c`; the Ruby methods exist. |
+| `sfSprite_getTexture`, `sfText_getFont`, `sf*Shape_getTexture` | The Ruby getters return the cached wrapper object. CSFML returns a non-owning pointer, so re-wrapping it would hand Ruby an object it must not free. |
+| `sfShape_getPoint`, `sfShape_getPointCount` | `SFML::Shape` reads these from the Ruby subclass, which is where they are defined. |
+| `sfTexture_updateFromWindow` | `Texture#update_from_window` uses `sfTexture_updateFromRenderWindow`, since `SFML::Window` is a render window. |
+| `sfFree` | CSFML's allocator hook; nothing in a Ruby binding should call it. |
+| `sfGlslVec4_fromsfColor`, `sfGlslIvec4_fromsfColor` | Documentation-only helpers; `Shader#set_color` does the conversion. |
+
+## References
+
+- [SFML 3.1.0 module topics](https://www.sfml-dev.org/documentation/3.1.0/topics.html)
+- [SFML 3.1.0 class index](https://www.sfml-dev.org/documentation/3.1.0/annotated.html)
+- [SFML 3.1.0 namespace index](https://www.sfml-dev.org/documentation/3.1.0/namespaces.html)
+- [CSFML 3.0.0 headers](https://github.com/SFML/CSFML/tree/3.0.0/include/CSFML) — the actual C API
+  surface this gem binds against, vendored locally under `ports/<target>/include/CSFML/`
+  once `rake ports` has run

data/lib/sfml/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SFML
+  VERSION = '0.3.0'
+end

data/lib/sfml.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'sfml/version'
+
+begin
+  # Binary gems ship one extension per Ruby ABI under lib/sfml/<major.minor>/.
+  # A gem built from source installs a single lib/sfml/sfml_ext.so instead.
+  require "sfml/#{RUBY_VERSION[/\d+\.\d+/]}/sfml_ext"
+rescue LoadError
+  require 'sfml/sfml_ext'
+end

data/sig/audio/audio_enums.rbs

@@ -0,0 +1,30 @@
+module SFML
+  module SoundStatus
+    STOPPED: Integer
+    PAUSED: Integer
+    PLAYING: Integer
+  end
+
+  module SoundChannel
+    UNSPECIFIED: Integer
+    MONO: Integer
+    FRONT_LEFT: Integer
+    FRONT_RIGHT: Integer
+    FRONT_CENTER: Integer
+    FRONT_LEFT_OF_CENTER: Integer
+    FRONT_RIGHT_OF_CENTER: Integer
+    LOW_FREQUENCY_EFFECTS: Integer
+    BACK_LEFT: Integer
+    BACK_RIGHT: Integer
+    BACK_CENTER: Integer
+    SIDE_LEFT: Integer
+    SIDE_RIGHT: Integer
+    TOP_CENTER: Integer
+    TOP_FRONT_LEFT: Integer
+    TOP_FRONT_RIGHT: Integer
+    TOP_FRONT_CENTER: Integer
+    TOP_BACK_LEFT: Integer
+    TOP_BACK_RIGHT: Integer
+    TOP_BACK_CENTER: Integer
+  end
+end

data/sig/audio/listener.rbs

@@ -0,0 +1,16 @@
+module SFML
+  module Listener
+    def self.global_volume: () -> Float
+    def self.global_volume=: (Float value) -> Float
+    def self.position: () -> Vector3
+    def self.position=: (Vector3 value) -> Vector3
+    def self.direction: () -> Vector3
+    def self.direction=: (Vector3 value) -> Vector3
+    def self.velocity: () -> Vector3
+    def self.velocity=: (Vector3 value) -> Vector3
+    def self.up_vector: () -> Vector3
+    def self.up_vector=: (Vector3 value) -> Vector3
+    def self.cone: () -> SoundSourceCone
+    def self.cone=: (SoundSourceCone value) -> SoundSourceCone
+  end
+end

data/sig/audio/music.rbs

@@ -0,0 +1,56 @@
+module SFML
+  class Music
+    def self.from_file: (String path) -> Music
+    def self.from_memory: (String data) -> Music
+    def self.from_stream: (untyped stream) -> Music
+
+    def duration: () -> Time
+    def channel_count: () -> Integer
+    def sample_rate: () -> Integer
+    def channel_map: () -> Array[Symbol]
+    def loop_points: () -> [Time, Time]
+    def loop_points=: ([Time, Time] value) -> [Time, Time]
+
+    def play: () -> self
+    def pause: () -> self
+    def stop: () -> self
+    def status: () -> (:stopped | :paused | :playing)
+    def looping?: () -> bool
+    def looping=: (bool value) -> bool
+    def pitch: () -> Float
+    def pitch=: (Float value) -> Float
+    def pan: () -> Float
+    def pan=: (Float value) -> Float
+    def volume: () -> Float
+    def volume=: (Float value) -> Float
+    def spatialization_enabled?: () -> bool
+    def spatialization_enabled=: (bool value) -> bool
+    def position: () -> Vector3
+    def position=: (Vector3 value) -> Vector3
+    def direction: () -> Vector3
+    def direction=: (Vector3 value) -> Vector3
+    def velocity: () -> Vector3
+    def velocity=: (Vector3 value) -> Vector3
+    def cone: () -> SoundSourceCone
+    def cone=: (SoundSourceCone value) -> SoundSourceCone
+    def doppler_factor: () -> Float
+    def doppler_factor=: (Float value) -> Float
+    def directional_attenuation_factor: () -> Float
+    def directional_attenuation_factor=: (Float value) -> Float
+    def relative_to_listener?: () -> bool
+    def relative_to_listener=: (bool value) -> bool
+    def min_distance: () -> Float
+    def min_distance=: (Float value) -> Float
+    def max_distance: () -> Float
+    def max_distance=: (Float value) -> Float
+    def min_gain: () -> Float
+    def min_gain=: (Float value) -> Float
+    def max_gain: () -> Float
+    def max_gain=: (Float value) -> Float
+    def attenuation: () -> Float
+    def attenuation=: (Float value) -> Float
+    def playing_offset: () -> Time
+    def playing_offset=: (Time value) -> Time
+    def effect_processor=: (Proc proc) -> Proc
+  end
+end

data/sig/audio/sound.rbs

@@ -0,0 +1,51 @@
+module SFML
+  class Sound
+    def self.new: (SoundBuffer buffer) -> Sound
+
+    def copy: () -> Sound
+    def buffer: () -> SoundBuffer
+    def buffer=: (SoundBuffer value) -> SoundBuffer
+
+    def play: () -> self
+    def pause: () -> self
+    def stop: () -> self
+    def status: () -> (:stopped | :paused | :playing)
+    def looping?: () -> bool
+    def looping=: (bool value) -> bool
+    def pitch: () -> Float
+    def pitch=: (Float value) -> Float
+    def pan: () -> Float
+    def pan=: (Float value) -> Float
+    def volume: () -> Float
+    def volume=: (Float value) -> Float
+    def spatialization_enabled?: () -> bool
+    def spatialization_enabled=: (bool value) -> bool
+    def position: () -> Vector3
+    def position=: (Vector3 value) -> Vector3
+    def direction: () -> Vector3
+    def direction=: (Vector3 value) -> Vector3
+    def velocity: () -> Vector3
+    def velocity=: (Vector3 value) -> Vector3
+    def cone: () -> SoundSourceCone
+    def cone=: (SoundSourceCone value) -> SoundSourceCone
+    def doppler_factor: () -> Float
+    def doppler_factor=: (Float value) -> Float
+    def directional_attenuation_factor: () -> Float
+    def directional_attenuation_factor=: (Float value) -> Float
+    def relative_to_listener?: () -> bool
+    def relative_to_listener=: (bool value) -> bool
+    def min_distance: () -> Float
+    def min_distance=: (Float value) -> Float
+    def max_distance: () -> Float
+    def max_distance=: (Float value) -> Float
+    def min_gain: () -> Float
+    def min_gain=: (Float value) -> Float
+    def max_gain: () -> Float
+    def max_gain=: (Float value) -> Float
+    def attenuation: () -> Float
+    def attenuation=: (Float value) -> Float
+    def playing_offset: () -> Time
+    def playing_offset=: (Time value) -> Time
+    def effect_processor=: (Proc proc) -> Proc
+  end
+end

data/sig/audio/sound_buffer.rbs

@@ -0,0 +1,17 @@
+module SFML
+  class SoundBuffer
+    def self.from_file: (String path) -> SoundBuffer
+    def self.from_memory: (String data) -> SoundBuffer
+    def self.from_stream: (untyped stream) -> SoundBuffer
+    def self.from_samples: (Array[Integer] | String samples, Integer channel_count, Integer sample_rate, ?Array[Symbol] channel_map) -> SoundBuffer
+
+    def copy: () -> SoundBuffer
+    def save_to_file: (String path) -> bool
+    def samples: () -> Array[Integer]
+    def sample_count: () -> Integer
+    def sample_rate: () -> Integer
+    def channel_count: () -> Integer
+    def channel_map: () -> Array[Symbol]
+    def duration: () -> Time
+  end
+end

data/sig/audio/sound_buffer_recorder.rbs

@@ -0,0 +1,14 @@
+module SFML
+  class SoundBufferRecorder
+    def self.new: () -> SoundBufferRecorder
+
+    def start: (Integer sample_rate) -> bool
+    def stop: () -> self
+    def sample_rate: () -> Integer
+    def buffer: () -> SoundBuffer
+    def device: () -> String
+    def device=: (String value) -> bool
+    def channel_count: () -> Integer
+    def channel_count=: (Integer value) -> Integer
+  end
+end

data/sig/audio/sound_recorder.rbs

@@ -0,0 +1,17 @@
+module SFML
+  class SoundRecorder
+    def self.new: () -> SoundRecorder
+    def self.available?: () -> bool
+    def self.available_devices: () -> Array[String]
+    def self.default_device: () -> String?
+
+    def start: (Integer sample_rate) -> bool
+    def stop: () -> self
+    def sample_rate: () -> Integer
+    def device: () -> String?
+    def device=: (String value) -> bool
+    def channel_count: () -> Integer
+    def channel_count=: (Integer value) -> Integer
+    def channel_map: () -> Array[Symbol]
+  end
+end

data/sig/audio/sound_source_cone.rbs

@@ -0,0 +1,14 @@
+module SFML
+  class SoundSourceCone
+    def self.new: (Float inner_angle, Float outer_angle, Float outer_gain) -> SoundSourceCone
+
+    def inner_angle: () -> Float
+    def inner_angle=: (Float value) -> Float
+    def outer_angle: () -> Float
+    def outer_angle=: (Float value) -> Float
+    def outer_gain: () -> Float
+    def outer_gain=: (Float value) -> Float
+    def to_a: () -> [Float, Float, Float]
+    def ==: (untyped other) -> bool
+  end
+end

data/sig/audio/sound_stream.rbs

@@ -0,0 +1,51 @@
+module SFML
+  class SoundStream
+    def self.new: (Integer channel_count, Integer sample_rate, ?Array[Symbol] channel_map) -> SoundStream
+
+    def channel_count: () -> Integer
+    def sample_rate: () -> Integer
+    def channel_map: () -> Array[Symbol]
+
+    def play: () -> self
+    def pause: () -> self
+    def stop: () -> self
+    def status: () -> (:stopped | :paused | :playing)
+    def looping?: () -> bool
+    def looping=: (bool value) -> bool
+    def pitch: () -> Float
+    def pitch=: (Float value) -> Float
+    def pan: () -> Float
+    def pan=: (Float value) -> Float
+    def volume: () -> Float
+    def volume=: (Float value) -> Float
+    def spatialization_enabled?: () -> bool
+    def spatialization_enabled=: (bool value) -> bool
+    def position: () -> Vector3
+    def position=: (Vector3 value) -> Vector3
+    def direction: () -> Vector3
+    def direction=: (Vector3 value) -> Vector3
+    def velocity: () -> Vector3
+    def velocity=: (Vector3 value) -> Vector3
+    def cone: () -> SoundSourceCone
+    def cone=: (SoundSourceCone value) -> SoundSourceCone
+    def doppler_factor: () -> Float
+    def doppler_factor=: (Float value) -> Float
+    def directional_attenuation_factor: () -> Float
+    def directional_attenuation_factor=: (Float value) -> Float
+    def relative_to_listener?: () -> bool
+    def relative_to_listener=: (bool value) -> bool
+    def min_distance: () -> Float
+    def min_distance=: (Float value) -> Float
+    def max_distance: () -> Float
+    def max_distance=: (Float value) -> Float
+    def min_gain: () -> Float
+    def min_gain=: (Float value) -> Float
+    def max_gain: () -> Float
+    def max_gain=: (Float value) -> Float
+    def attenuation: () -> Float
+    def attenuation=: (Float value) -> Float
+    def playing_offset: () -> Time
+    def playing_offset=: (Time value) -> Time
+    def effect_processor=: (Proc proc) -> Proc
+  end
+end

data/sig/graphics/blend_mode.rbs

@@ -0,0 +1,29 @@
+module SFML
+  class BlendMode
+    def self.new: () -> BlendMode
+                 | (Symbol | Integer color_src_factor, Symbol | Integer color_dst_factor,
+                    Symbol | Integer color_equation, Symbol | Integer alpha_src_factor,
+                    Symbol | Integer alpha_dst_factor, Symbol | Integer alpha_equation) -> BlendMode
+
+    def color_src_factor: () -> Symbol
+    def color_src_factor=: (Symbol | Integer value) -> Symbol
+    def color_dst_factor: () -> Symbol
+    def color_dst_factor=: (Symbol | Integer value) -> Symbol
+    def color_equation: () -> Symbol
+    def color_equation=: (Symbol | Integer value) -> Symbol
+    def alpha_src_factor: () -> Symbol
+    def alpha_src_factor=: (Symbol | Integer value) -> Symbol
+    def alpha_dst_factor: () -> Symbol
+    def alpha_dst_factor=: (Symbol | Integer value) -> Symbol
+    def alpha_equation: () -> Symbol
+    def alpha_equation=: (Symbol | Integer value) -> Symbol
+    def ==: (untyped other) -> bool
+
+    NONE: BlendMode
+    ALPHA: BlendMode
+    ADD: BlendMode
+    MULTIPLY: BlendMode
+    MIN: BlendMode
+    MAX: BlendMode
+  end
+end

data/sig/graphics/circle.rbs

@@ -0,0 +1,44 @@
+module SFML
+  class Circle
+    include Drawable
+
+    def self.new: (?Float radius) -> Circle
+
+    def copy: () -> Circle
+    def move: (Vector2 | Array[Float] offset) -> self
+    def rotate: (Float angle) -> self
+    def scale!: (Vector2 | Array[Float] factors) -> self
+    def draw: (untyped target, RenderState state) -> nil
+
+    def radius=: (Float value) -> Float
+    def position=: (Vector2 | Array[Float] value) -> Vector2
+    def rotation=: (Float value) -> Float
+    def scale=: (Vector2 | Array[Float] value) -> Vector2
+    def origin=: (Vector2 | Array[Float] value) -> Vector2
+    def fill_color=: (Color value) -> Color
+    def outline_color=: (Color value) -> Color
+    def outline_thickness=: (Float value) -> Float
+    def texture=: (Texture? value) -> Texture?
+    def texture_rect=: (Rect value) -> Rect
+    def point_count=: (Integer value) -> self
+
+    def radius: () -> Float
+    def position: () -> Vector2
+    def rotation: () -> Float
+    def scale: () -> Vector2
+    def origin: () -> Vector2
+    def fill_color: () -> Color
+    def outline_color: () -> Color
+    def outline_thickness: () -> Float
+    def texture: () -> (Texture | nil)
+    def texture_rect: () -> Rect
+    def point_count: () -> Integer
+    def point: (Integer index) -> Vector2
+    def geometric_center: () -> Vector2
+    def local_bounds: () -> Rect
+    def global_bounds: () -> Rect
+    def transform: () -> Array[untyped]
+    def inverse_transform: () -> Array[untyped]
+    def matrix: () -> Array[untyped]
+  end
+end

data/sig/graphics/color.rbs

@@ -0,0 +1,39 @@
+module SFML
+  class Color
+    def self.new: () -> Color
+                 | (Integer r, Integer g, Integer b, ?Integer a) -> Color
+                 | (Array[Integer] rgb_or_rgba) -> Color
+                 | (Integer packed) -> Color
+                 | (Color other) -> Color
+    def self.from_rgb: (Integer rgb) -> Color
+    def self.from_rgba: (Integer rgba) -> Color
+    def self.from_integer: (Integer rgba) -> Color
+
+    def r: () -> Integer
+    def r=: (Integer value) -> Integer
+    def g: () -> Integer
+    def g=: (Integer value) -> Integer
+    def b: () -> Integer
+    def b=: (Integer value) -> Integer
+    def a: () -> Integer
+    def a=: (Integer value) -> Integer
+    def to_i: () -> Integer
+    def to_a: () -> [Integer, Integer, Integer, Integer]
+    def to_ary: () -> [Integer, Integer, Integer, Integer]
+    def ==: (untyped other) -> bool
+    def +: (Color | Array[Integer] | Integer other) -> Color
+    def -: (Color | Array[Integer] | Integer other) -> Color
+    def *: (Color | Array[Integer] | Integer other) -> Color
+    def to_s: () -> String
+
+    BLACK: Color
+    WHITE: Color
+    RED: Color
+    GREEN: Color
+    BLUE: Color
+    YELLOW: Color
+    MAGENTA: Color
+    CYAN: Color
+    TRANSPARENT: Color
+  end
+end

data/sig/graphics/drawable.rbs

@@ -0,0 +1,5 @@
+module SFML
+  module Drawable
+    def draw: (untyped target, RenderState state) -> nil
+  end
+end

data/sig/graphics/font.rbs

@@ -0,0 +1,20 @@
+module SFML
+  class Font
+    def self.from_file: (String path) -> Font
+    def self.from_memory: (String data) -> Font
+    def self.from_stream: (untyped stream) -> Font
+
+    def copy: () -> Font
+    def glyph: (Integer codepoint, Integer size, ?bool bold, ?Float outline_thickness) -> Glyph
+    def has_glyph?: (Integer codepoint) -> bool
+    def kerning: (Integer first, Integer second, Integer size) -> Float
+    def bold_kerning: (Integer first, Integer second, Integer size) -> Float
+    def line_spacing: (Integer size) -> Float
+    def underline_position: (Integer size) -> Float
+    def underline_thickness: (Integer size) -> Float
+    def texture: (Integer size) -> Texture
+    def smooth=: (bool value) -> bool
+    def smooth?: () -> bool
+    def info: () -> String
+  end
+end

data/sig/graphics/glyph.rbs

@@ -0,0 +1,7 @@
+module SFML
+  class Glyph
+    def advance: () -> Float
+    def bounds: () -> Rect
+    def texture_rect: () -> Rect
+  end
+end