sfml3-rb 0.2.2 → 0.3.1

data/ext/window/window_base.c

@@ -0,0 +1,251 @@
+#include "window/window_base.h"
+
+#include <ruby.h>
+
+#include "window/video_mode.h"
+#include "window/input_enums.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "core/unicode.h"
+
+static VALUE rb_cWindowBase;
+
+static void Window_mark(void* ptr) {
+    Window* window = ptr;
+
+    rb_gc_mark(window->rb_cursor);
+}
+
+static void Window_free(void* ptr) {
+    Window* window = ptr;
+
+    if (window->handle != NULL) {
+        if (window->kind == SFML_WINDOW_KIND_WINDOW) {
+            sfRenderWindow_destroy(window->handle);
+        } else {
+            sfWindowBase_destroy(window->handle);
+        }
+    }
+
+    free(window);
+}
+
+static const rb_data_type_t Window_data_type = {
+    .wrap_struct_name = "SFML::Window",
+    .function = {.dmark = Window_mark, .dfree = Window_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+VALUE Window_alloc(VALUE klass) {
+    Window* window = malloc(sizeof(Window));
+
+    if (window == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate window");
+    }
+
+    window->handle = NULL;
+    window->kind = SFML_WINDOW_KIND_BASE;
+    window->rb_cursor = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &Window_data_type, window);
+}
+
+VALUE Window_wrap_handle(VALUE klass, void* handle, WindowKind kind) {
+    Window* window = malloc(sizeof(Window));
+
+    if (window == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate window");
+    }
+
+    window->handle = handle;
+    window->kind = kind;
+    window->rb_cursor = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &Window_data_type, window);
+}
+
+static VALUE Window_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
+
+/* call-seq:
+ *   WindowBase.new(video_mode, title, style = :default, state = :windowed) -> WindowBase
+ *
+ * Creates an OS window with no OpenGL context of its own.
+ *
+ * @return [WindowBase]
+ * @raise [RuntimeError] if window creation fails
+ */
+static VALUE WindowBase_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_video_mode, rb_title, rb_style, rb_state, title_buffer;
+    sfWindowState state = sfWindowed;
+    uint32_t style = sfDefaultStyle;
+    sfWindowBase* window;
+
+    rb_scan_args(argc, argv, "22", &rb_video_mode, &rb_title, &rb_style, &rb_state);
+
+    if (!rb_obj_is_kind_of(rb_video_mode, Get_Klass_Mode())) {
+        raise_invalid_argument_class(Get_Klass_Mode());
+    }
+
+    if (!NIL_P(rb_style)) {
+        style = window_style_from_rb(rb_style);
+    }
+
+    if (!NIL_P(rb_state)) {
+        state = window_state_from_rb(rb_state);
+    }
+
+    title_buffer = utf32_from_rb(rb_title);
+    window = sfWindowBase_createUnicode(*Get_Mode_Struct(rb_video_mode), UTF32_PTR(title_buffer),
+                                        style, state);
+    RB_GC_GUARD(title_buffer);
+
+    if (window == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create window");
+    }
+
+    Get_Window_Data(self)->handle = window;
+    Get_Window_Data(self)->kind = SFML_WINDOW_KIND_BASE;
+
+    return self;
+}
+
+/* Adopts an existing OS window by its native handle -- the Integer that
+   WindowBase#native_handle returns, or one obtained from a GUI toolkit. The
+   window is not owned by the toolkit afterwards: destroying it stays the
+   toolkit's job, and closing the Ruby object only tears down this wrapper. */
+/* call-seq:
+ *   WindowBase.from_handle(handle) -> WindowBase
+ *
+ * @return [WindowBase]
+ * @raise [RuntimeError] if window creation fails
+ */
+static VALUE WindowBase_s_from_handle(int argc, VALUE* argv, VALUE klass) {
+    VALUE rb_handle;
+    sfWindowBase* window;
+
+    rb_scan_args(argc, argv, "1", &rb_handle);
+
+    window = sfWindowBase_createFromHandle((sfWindowHandle)(uintptr_t)NUM2ULL(rb_handle));
+
+    if (window == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create window from handle");
+    }
+
+    return Window_wrap_handle(klass, window, SFML_WINDOW_KIND_BASE);
+}
+
+#define WB_FN(name) sfWindowBase_##name
+#define WB_METHOD(name) WindowBase_##name
+#define WB_HANDLE(self) Get_WindowBase_Struct(self)
+#include "window/window_base.inc"
+#undef WB_FN
+#undef WB_METHOD
+#undef WB_HANDLE
+
+/* Document-class: SFML::WindowBase
+ * An OS window and its event queue, without an OpenGL context. It is the base
+ * of SFML::Window and SFML::RenderWindow, and every method below is also
+ * available -- backed by the matching sfRenderWindow entry point -- on both.
+ *
+ * @!method is_open?
+ *   Returns +true+ while the window is open.
+ *   @return [Boolean]
+ * @!method close!
+ *   Closes the window.
+ *   @return [self]
+ * @!method poll_event!(event)
+ *   Pops the next pending event into +event+, if any, without blocking.
+ *   @return [Boolean] whether an event was popped
+ * @!method wait_event!(event)
+ *   Blocks until an event is available and pops it into +event+.
+ *   @return [Boolean] whether an event was popped
+ * @!method position
+ *   Returns the window's position in desktop coordinates.
+ *   @return [Vector2]
+ * @!method position=(value)
+ *   Moves the window to +value+.
+ *   @return [Vector2] +value+
+ * @!method size
+ *   Returns the client area size in pixels.
+ *   @return [Vector2]
+ * @!method size=(value)
+ *   Resizes the window's client area.
+ *   @return [self]
+ * @!method minimum_size=(value)
+ *   Sets the window's minimum allowed client size.
+ *   @return [Vector2] +value+
+ * @!method maximum_size=(value)
+ *   Sets the window's maximum allowed client size.
+ *   @return [Vector2] +value+
+ * @!method title=(value)
+ *   Sets the window title.
+ *   @return [self]
+ * @!method set_icon(size, pixels)
+ *   Sets the window's icon from RGBA32 pixel data.
+ *   @return [String] +pixels+
+ * @!method visible=(value)
+ *   Shows or hides the window.
+ *   @return [self]
+ * @!method cursor_visible=(value)
+ *   Shows or hides the mouse cursor over the window.
+ *   @return [self]
+ * @!method cursor_grabbed=(value)
+ *   Confines or releases the mouse cursor to the window's client area.
+ *   @return [self]
+ * @!method mouse_cursor=(value)
+ *   Sets the window's mouse cursor.
+ *   @return [Cursor] +value+
+ * @!method cursor=(value)
+ *   Sets the window's mouse cursor.
+ *   @return [Cursor] +value+
+ * @!method key_repeat_enabled=(value)
+ *   Enables or disables key-repeat events.
+ *   @return [self]
+ * @!method joystick_threshold=(value)
+ *   Sets the minimum joystick axis change that generates a move event.
+ *   @return [Float] +value+
+ * @!method request_focus
+ *   Requests focus for this window.
+ *   @return [self]
+ * @!method focus?
+ *   Returns +true+ if the window currently has focus.
+ *   @return [Boolean]
+ * @!method native_handle
+ *   Returns the OS-specific window handle.
+ *   @return [Integer]
+ * @!method create_vulkan_surface(instance, allocator = nil)
+ *   Creates a Vulkan surface for this window.
+ *   @return [Integer, nil] the new +VkSurfaceKHR+, or +nil+ if creation failed
+ */
+void Init_WindowBase(VALUE rb_mSFML) {
+    rb_cWindowBase = rb_define_class_under(rb_mSFML, "WindowBase", rb_cObject);
+
+    rb_define_alloc_func(rb_cWindowBase, Window_alloc);
+
+    rb_define_singleton_method(rb_cWindowBase, "from_handle", WindowBase_s_from_handle, -1);
+
+    rb_define_method(rb_cWindowBase, "initialize", WindowBase_initialize, -1);
+    rb_define_private_method(rb_cWindowBase, "initialize_copy", Window_initialize_copy, 1);
+
+    WindowBase_define_methods(rb_cWindowBase);
+}
+
+VALUE Get_Klass_WindowBase(void) {
+    return rb_cWindowBase;
+}
+
+Window* Get_Window_Data(VALUE self) {
+    Window* ptr;
+    TypedData_Get_Struct(self, Window, &Window_data_type, ptr);
+    return ptr;
+}
+
+sfWindowBase* Get_WindowBase_Struct(VALUE self) {
+    return Get_Window_Data(self)->handle;
+}
+
+sfRenderWindow* Get_Window_Struct(VALUE self) {
+    return Get_Window_Data(self)->handle;
+}

data/ext/window/window_base.h

@@ -0,0 +1,43 @@
+#ifndef SFML_RB_WINDOW_WINDOW_BASE_H
+#define SFML_RB_WINDOW_WINDOW_BASE_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+/* Which CSFML handle a wrapper owns. SFML::Window and SFML::RenderWindow wrap
+   an sfRenderWindow and share every method with sfWindowBase_, but CSFML keys
+   its destroy off the concrete type, so dfree has to know which one to call. */
+typedef enum { SFML_WINDOW_KIND_BASE, SFML_WINDOW_KIND_WINDOW } WindowKind;
+
+/* One C struct backs every window class. SFML::WindowBase owns an
+   sfWindowBase* and SFML::Window/RenderWindow an sfRenderWindow*; the handle is
+   stored as void* and read back through the typed accessors below, one per
+   class, so no cast ever crosses the two. */
+typedef struct {
+    void* handle;
+    WindowKind kind;
+    /* sfWindowBase_setMouseCursor requires the Cursor to stay alive for as long
+       as it's in use by the window (CSFML/SFML docs), so the wrapper retains it
+       -- which is why Window_mark exists, unlike a bare pointer. */
+    VALUE rb_cursor;
+} Window;
+
+void Init_WindowBase(VALUE rb_module);
+
+VALUE Get_Klass_WindowBase(void);
+
+Window* Get_Window_Data(VALUE self);
+
+sfWindowBase* Get_WindowBase_Struct(VALUE self);
+
+sfRenderWindow* Get_Window_Struct(VALUE self);
+
+/* Allocates a wrapper with a NULL handle; registered as the allocator of every
+   window class so the T_DATA default-allocator warning stays quiet. */
+VALUE Window_alloc(VALUE klass);
+
+/* Wraps a freshly created handle, tagging it with the destroy to use. */
+VALUE Window_wrap_handle(VALUE klass, void* handle, WindowKind kind);
+
+#endif // SFML_RB_WINDOW_WINDOW_BASE_H

data/ext/window/window_base.inc

@@ -0,0 +1,236 @@
+/* Shared method bodies for every window class (WindowBase, Window,
+   RenderWindow). Included from several translation units; each defines WB_FN,
+   WB_METHOD and WB_HANDLE before including this file, then undefines them
+   after. Generating concrete methods per class keeps the compiler's type
+   checks on the handle and on every sf* call, which a runtime dispatch through
+   void* would not.
+
+   CSFML gives sfWindowBase_* and sfRenderWindow_* the same window surface under
+   two name prefixes, so WB_FN is the only thing that differs. Anything that is
+   not on sfWindowBase (settings, display, setActive, vsync, framerate) lives in
+   individual classes, not here. */
+
+#include "window/window_base.h"
+#include "window/event.h"
+#include "window/cursor.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "core/unicode.h"
+
+/* call-seq: is_open? -> true or false */
+static VALUE WB_METHOD(is_open)(VALUE self) {
+    return BOOL2RB(WB_FN(isOpen)(WB_HANDLE(self)));
+}
+
+/* call-seq: close! -> self */
+static VALUE WB_METHOD(close)(VALUE self) {
+    WB_FN(close)(WB_HANDLE(self));
+    return self;
+}
+
+/* call-seq: poll_event!(event) -> true or false */
+static VALUE WB_METHOD(poll_event)(VALUE self, VALUE rb_event) {
+    if (!rb_obj_is_kind_of(rb_event, Get_Klass_Event())) {
+        raise_invalid_argument_class(Get_Klass_Event());
+    }
+
+    return BOOL2RB(WB_FN(pollEvent)(WB_HANDLE(self), Get_Event_Struct(rb_event)));
+}
+
+/* call-seq: wait_event!(event) -> true or false */
+static VALUE WB_METHOD(wait_event)(VALUE self, VALUE rb_event) {
+    if (!rb_obj_is_kind_of(rb_event, Get_Klass_Event())) {
+        raise_invalid_argument_class(Get_Klass_Event());
+    }
+
+    return BOOL2RB(WB_FN(waitEvent)(WB_HANDLE(self), sfTime_Zero, Get_Event_Struct(rb_event)));
+}
+
+/* call-seq: position -> Vector2 */
+static VALUE WB_METHOD(get_position)(VALUE self) {
+    return VEC2_C2RB(WB_FN(getPosition)(WB_HANDLE(self)));
+}
+
+/* call-seq: position=(value) -> value */
+static VALUE WB_METHOD(set_position)(VALUE self, VALUE rb_arr) {
+    WB_FN(setPosition)(WB_HANDLE(self), vec2i_new_from_ruby(rb_arr));
+    return self;
+}
+
+/* call-seq: size -> Vector2 */
+static VALUE WB_METHOD(get_size)(VALUE self) {
+    return VEC2_C2RB(WB_FN(getSize)(WB_HANDLE(self)));
+}
+
+/* call-seq: size=(value) -> self */
+static VALUE WB_METHOD(set_size)(VALUE self, VALUE rb_size) {
+    WB_FN(setSize)(WB_HANDLE(self), vec2u_from_rb(rb_size));
+    return self;
+}
+
+/* call-seq: minimum_size=(value) -> value */
+static VALUE WB_METHOD(set_minimum_size)(VALUE self, VALUE rb_size) {
+    sfVector2u size = vec2u_from_rb(rb_size);
+
+    WB_FN(setMinimumSize)(WB_HANDLE(self), &size);
+
+    return rb_size;
+}
+
+/* call-seq: maximum_size=(value) -> value */
+static VALUE WB_METHOD(set_maximum_size)(VALUE self, VALUE rb_size) {
+    sfVector2u size = vec2u_from_rb(rb_size);
+
+    WB_FN(setMaximumSize)(WB_HANDLE(self), &size);
+
+    return rb_size;
+}
+
+/* Through the UTF-32 entry point: the narrow setTitle decodes the bytes with
+   the C locale and mangles anything outside ASCII. */
+/* call-seq: title=(value) -> self */
+static VALUE WB_METHOD(set_title)(VALUE self, VALUE rb_title) {
+    VALUE buffer = utf32_from_rb(rb_title);
+
+    WB_FN(setUnicodeTitle)(WB_HANDLE(self), UTF32_PTR(buffer));
+
+    RB_GC_GUARD(buffer);
+
+    return self;
+}
+
+/* call-seq: set_icon(size, pixels) -> pixels */
+static VALUE WB_METHOD(set_icon)(VALUE self, VALUE rb_size, VALUE rb_pixels) {
+    sfVector2u size = vec2u_from_rb(rb_size);
+    size_t expected = (size_t)size.x * size.y * 4;
+
+    StringValue(rb_pixels);
+
+    if ((size_t)RSTRING_LEN(rb_pixels) < expected) {
+        rb_raise(rb_eArgError, "pixel data too short: expected %zu bytes", expected);
+    }
+
+    WB_FN(setIcon)(WB_HANDLE(self), size, (const uint8_t*)RSTRING_PTR(rb_pixels));
+
+    return rb_pixels;
+}
+
+/* call-seq: visible=(value) -> self */
+static VALUE WB_METHOD(set_visible)(VALUE self, VALUE rb_visible) {
+    WB_FN(setVisible)(WB_HANDLE(self), RTEST(rb_visible));
+    return self;
+}
+
+/* call-seq: cursor_visible=(value) -> self */
+static VALUE WB_METHOD(set_mouse_cursor_visible)(VALUE self, VALUE rb_visible) {
+    WB_FN(setMouseCursorVisible)(WB_HANDLE(self), RTEST(rb_visible));
+    return self;
+}
+
+/* call-seq: cursor_grabbed=(value) -> self */
+static VALUE WB_METHOD(set_mouse_cursor_grabbed)(VALUE self, VALUE rb_grabbed) {
+    WB_FN(setMouseCursorGrabbed)(WB_HANDLE(self), RTEST(rb_grabbed));
+    return self;
+}
+
+/* CSFML has no way to clear the cursor back to a system default once set (its C
+   API unconditionally dereferences the pointer, so NULL crashes rather than
+   clearing), so unlike most assignment-style methods here, nil is not
+   accepted. */
+/* call-seq: cursor=(value) -> value */
+static VALUE WB_METHOD(set_mouse_cursor)(VALUE self, VALUE rb_cursor) {
+    Window* window = Get_Window_Data(self);
+
+    if (!rb_obj_is_kind_of(rb_cursor, Get_Klass_Cursor())) {
+        raise_invalid_argument_class(Get_Klass_Cursor());
+    }
+
+    WB_FN(setMouseCursor)(WB_HANDLE(self), Get_Cursor_Struct(rb_cursor));
+    /* Keep the Cursor alive for as long as the window may use it. */
+    window->rb_cursor = rb_cursor;
+
+    return rb_cursor;
+}
+
+/* call-seq: key_repeat_enabled=(value) -> self */
+static VALUE WB_METHOD(set_key_repeat_enabled)(VALUE self, VALUE rb_enabled) {
+    WB_FN(setKeyRepeatEnabled)(WB_HANDLE(self), RTEST(rb_enabled));
+    return self;
+}
+
+/* call-seq: joystick_threshold=(value) -> value */
+static VALUE WB_METHOD(set_joystick_threshold)(VALUE self, VALUE rb_threshold) {
+    WB_FN(setJoystickThreshold)(WB_HANDLE(self), NUM2DBL(rb_threshold));
+    return rb_threshold;
+}
+
+/* call-seq: request_focus -> self */
+static VALUE WB_METHOD(request_focus)(VALUE self) {
+    WB_FN(requestFocus)(WB_HANDLE(self));
+    return self;
+}
+
+/* call-seq: focus? -> true or false */
+static VALUE WB_METHOD(has_focus)(VALUE self) {
+    return BOOL2RB(WB_FN(hasFocus)(WB_HANDLE(self)));
+}
+
+/* call-seq: native_handle -> Integer */
+static VALUE WB_METHOD(get_native_handle)(VALUE self) {
+    return ULL2NUM((unsigned long long)(uintptr_t)WB_FN(getNativeHandle)(WB_HANDLE(self)));
+}
+
+/* Vulkan handles cross this binding as Integers, the same way
+   SFML::Vulkan.function already returns one -- there is no Vulkan object model
+   here to wrap them in. Returns the new VkSurfaceKHR, or nil on failure. */
+/* call-seq: create_vulkan_surface(instance, allocator = nil) -> Integer or nil */
+static VALUE WB_METHOD(create_vulkan_surface)(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_instance, rb_allocator;
+    VkInstance instance;
+    VkSurfaceKHR surface;
+    const VkAllocationCallbacks* allocator = NULL;
+
+    rb_scan_args(argc, argv, "11", &rb_instance, &rb_allocator);
+
+    instance = (VkInstance)(uintptr_t)NUM2ULL(rb_instance);
+
+    if (!NIL_P(rb_allocator)) {
+        allocator = (const VkAllocationCallbacks*)(uintptr_t)NUM2ULL(rb_allocator);
+    }
+
+    if (!WB_FN(createVulkanSurface)(WB_HANDLE(self), &instance, &surface, allocator)) {
+        return Qnil;
+    }
+
+    return ULL2NUM((unsigned long long)(uintptr_t)surface);
+}
+
+static void WB_METHOD(define_methods)(VALUE klass) {
+    rb_define_method(klass, "is_open?", WB_METHOD(is_open), 0);
+    rb_define_method(klass, "close!", WB_METHOD(close), 0);
+    rb_define_method(klass, "poll_event!", WB_METHOD(poll_event), 1);
+    rb_define_method(klass, "wait_event!", WB_METHOD(wait_event), 1);
+
+    rb_define_method(klass, "position", WB_METHOD(get_position), 0);
+    rb_define_method(klass, "size", WB_METHOD(get_size), 0);
+    rb_define_method(klass, "focus?", WB_METHOD(has_focus), 0);
+    rb_define_method(klass, "native_handle", WB_METHOD(get_native_handle), 0);
+
+    rb_define_method(klass, "position=", WB_METHOD(set_position), 1);
+    rb_define_method(klass, "size=", WB_METHOD(set_size), 1);
+    rb_define_method(klass, "minimum_size=", WB_METHOD(set_minimum_size), 1);
+    rb_define_method(klass, "maximum_size=", WB_METHOD(set_maximum_size), 1);
+    rb_define_method(klass, "title=", WB_METHOD(set_title), 1);
+    rb_define_method(klass, "set_icon", WB_METHOD(set_icon), 2);
+    rb_define_method(klass, "visible=", WB_METHOD(set_visible), 1);
+    rb_define_method(klass, "cursor_visible=", WB_METHOD(set_mouse_cursor_visible), 1);
+    rb_define_method(klass, "cursor_grabbed=", WB_METHOD(set_mouse_cursor_grabbed), 1);
+    rb_define_method(klass, "mouse_cursor=", WB_METHOD(set_mouse_cursor), 1);
+    rb_define_method(klass, "cursor=", WB_METHOD(set_mouse_cursor), 1);
+    rb_define_method(klass, "key_repeat_enabled=", WB_METHOD(set_key_repeat_enabled), 1);
+    rb_define_method(klass, "joystick_threshold=", WB_METHOD(set_joystick_threshold), 1);
+
+    rb_define_method(klass, "request_focus", WB_METHOD(request_focus), 0);
+    rb_define_method(klass, "create_vulkan_surface", WB_METHOD(create_vulkan_surface), -1);
+}

data/lib/sfml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SFML
-  VERSION = '0.2.2'
+  VERSION = '0.3.1'
 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 initialize: (SoundBuffer buffer) -> void
+
+    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