sfml3-rb 0.0.1 → 0.2.1

data/ext/audio/sound_recorder.c

@@ -0,0 +1,268 @@
+#include "audio/sound_recorder.h"
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "audio/audio_enums.h"
+#include "core/macros.h"
+
+/* A subclassable recorder. The capture callbacks arrive on SFML's audio
+   thread, so each re-enters Ruby through rb_thread_call_with_gvl and treats an
+   exception as "stop capturing" instead of unwinding into the audio engine.
+   A subclass only has to implement #on_process; #on_start and #on_stop are
+   optional and default to continuing. */
+typedef struct {
+    VALUE rb_self;
+    sfSoundRecorder *handle;
+} SoundRecorder;
+
+static VALUE rb_cSoundRecorder;
+
+static void SoundRecorder_mark(void *ptr) {
+    SoundRecorder *recorder = ptr;
+
+    rb_gc_mark(recorder->rb_self);
+}
+
+static void SoundRecorder_free(void *ptr) {
+    SoundRecorder *recorder = ptr;
+
+    if (recorder->handle != NULL) {
+        sfSoundRecorder_destroy(recorder->handle);
+    }
+
+    free(recorder);
+}
+
+static const rb_data_type_t SoundRecorder_data_type = {
+    .wrap_struct_name = "SFML::SoundRecorder",
+    .function = {.dmark = SoundRecorder_mark, .dfree = SoundRecorder_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+typedef struct {
+    VALUE self;
+    ID method;
+} InvokeContext;
+
+static VALUE SoundRecorder_invoke_body(VALUE raw) {
+    InvokeContext *ctx = (InvokeContext *) raw;
+
+    return rb_funcall(ctx->self, ctx->method, 0);
+}
+
+/* Calls a zero-argument Ruby method, swallowing any exception it raises. */
+static void SoundRecorder_invoke(VALUE self, ID method) {
+    InvokeContext ctx = {.self = self, .method = method};
+    int state = 0;
+
+    rb_protect(SoundRecorder_invoke_body, (VALUE) &ctx, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+    }
+}
+
+static bool SoundRecorder_on_start(void *userData) {
+    SoundRecorder *recorder = userData;
+
+    if (rb_respond_to(recorder->rb_self, rb_intern("on_start"))) {
+        SoundRecorder_invoke(recorder->rb_self, rb_intern("on_start"));
+    }
+
+    return true;
+}
+
+typedef struct {
+    SoundRecorder *recorder;
+    const int16_t *samples;
+    size_t sample_count;
+    int ok;
+} ProcessContext;
+
+static VALUE SoundRecorder_process_body(VALUE raw) {
+    ProcessContext *ctx = (ProcessContext *) raw;
+    VALUE rb_samples = rb_ary_new_capa((long) ctx->sample_count);
+    VALUE result;
+    size_t i;
+
+    for (i = 0; i < ctx->sample_count; i++) {
+        rb_ary_push(rb_samples, INT2NUM(ctx->samples[i]));
+    }
+
+    result = rb_funcall(ctx->recorder->rb_self, rb_intern("on_process"), 1, rb_samples);
+    ctx->ok = RTEST(result) ? 1 : 0;
+
+    return Qnil;
+}
+
+static void *SoundRecorder_process_gvl(void *raw) {
+    int state = 0;
+
+    rb_protect(SoundRecorder_process_body, (VALUE) raw, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        ((ProcessContext *) raw)->ok = 0;
+    }
+
+    return NULL;
+}
+
+static bool SoundRecorder_on_process(const int16_t *samples, size_t sample_count, void *userData) {
+    SoundRecorder *recorder = userData;
+    ProcessContext ctx = {
+        .recorder = recorder, .samples = samples, .sample_count = sample_count, .ok = 0
+    };
+
+    rb_thread_call_with_gvl(SoundRecorder_process_gvl, &ctx);
+
+    return ctx.ok ? true : false;
+}
+
+static void SoundRecorder_on_stop(void *userData) {
+    SoundRecorder *recorder = userData;
+
+    if (rb_respond_to(recorder->rb_self, rb_intern("on_stop"))) {
+        SoundRecorder_invoke(recorder->rb_self, rb_intern("on_stop"));
+    }
+}
+
+static VALUE SoundRecorder_new(VALUE klass) {
+    SoundRecorder *ptr;
+    sfSoundRecorder *handle;
+    VALUE self;
+
+    ptr = malloc(sizeof(SoundRecorder));
+    ptr->rb_self = Qnil;
+    ptr->handle = NULL;
+
+    self = TypedData_Wrap_Struct(klass, &SoundRecorder_data_type, ptr);
+    ptr->rb_self = self;
+
+    if (!rb_respond_to(self, rb_intern("on_process"))) {
+        /* Ruby already owns the wrapper; SoundRecorder_free handles the NULL
+           handle, so let GC clean up after the raise. */
+        rb_raise(rb_eNotImpError, "subclass must define #on_process");
+    }
+
+    handle = sfSoundRecorder_create(SoundRecorder_on_start, SoundRecorder_on_process,
+                                    SoundRecorder_on_stop, ptr);
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sound recorder (no capture device?)");
+    }
+
+    ptr->handle = handle;
+
+    return self;
+}
+
+static VALUE SoundRecorder_start(VALUE self, VALUE rb_sample_rate) {
+    return BOOL2RB(sfSoundRecorder_start(Get_SoundRecorder_Struct(self),
+                                         (unsigned int) NUM2INT(rb_sample_rate)));
+}
+
+static VALUE SoundRecorder_stop(VALUE self) {
+    sfSoundRecorder_stop(Get_SoundRecorder_Struct(self));
+    return self;
+}
+
+static VALUE SoundRecorder_sample_rate(VALUE self) {
+    return UINT2NUM(sfSoundRecorder_getSampleRate(Get_SoundRecorder_Struct(self)));
+}
+
+static VALUE SoundRecorder_available(VALUE klass) {
+    return BOOL2RB(sfSoundRecorder_isAvailable());
+}
+
+static VALUE SoundRecorder_available_devices(VALUE klass) {
+    size_t count = 0;
+    const char *const *devices = sfSoundRecorder_getAvailableDevices(&count);
+    VALUE rb_array;
+    size_t i;
+
+    if (devices == NULL) {
+        return rb_ary_new();
+    }
+
+    rb_array = rb_ary_new_capa((long) count);
+
+    for (i = 0; i < count; i++) {
+        rb_ary_push(rb_array, rb_str_new_cstr(devices[i]));
+    }
+
+    return rb_array;
+}
+
+static VALUE SoundRecorder_default_device(VALUE klass) {
+    return rb_str_new_cstr(sfSoundRecorder_getDefaultDevice());
+}
+
+static VALUE SoundRecorder_device(VALUE self) {
+    return rb_str_new_cstr(sfSoundRecorder_getDevice(Get_SoundRecorder_Struct(self)));
+}
+
+static VALUE SoundRecorder_set_device(VALUE self, VALUE rb_name) {
+    return BOOL2RB(
+        sfSoundRecorder_setDevice(Get_SoundRecorder_Struct(self), StringValueCStr(rb_name)));
+}
+
+static VALUE SoundRecorder_channel_count(VALUE self) {
+    return UINT2NUM(sfSoundRecorder_getChannelCount(Get_SoundRecorder_Struct(self)));
+}
+
+static VALUE SoundRecorder_set_channel_count(VALUE self, VALUE rb_count) {
+    sfSoundRecorder_setChannelCount(Get_SoundRecorder_Struct(self), (unsigned int) NUM2INT(rb_count));
+    return rb_count;
+}
+
+static VALUE SoundRecorder_channel_map(VALUE self) {
+    size_t count = 0;
+    sfSoundChannel *map = sfSoundRecorder_getChannelMap(Get_SoundRecorder_Struct(self), &count);
+    VALUE rb_array;
+    size_t i;
+
+    if (map == NULL) {
+        return rb_ary_new();
+    }
+
+    rb_array = rb_ary_new_capa((long) count);
+
+    for (i = 0; i < count; i++) {
+        rb_ary_push(rb_array, ID2SYM(rb_intern(sound_channel_name(map[i]))));
+    }
+
+    return rb_array;
+}
+
+void Init_SoundRecorder(VALUE rb_module) {
+    rb_cSoundRecorder = rb_define_class_under(rb_module, "SoundRecorder", rb_cObject);
+
+    rb_define_singleton_method(rb_cSoundRecorder, "new", SoundRecorder_new, 0);
+    rb_define_singleton_method(rb_cSoundRecorder, "available?", SoundRecorder_available, 0);
+    rb_define_singleton_method(rb_cSoundRecorder, "available_devices",
+                               SoundRecorder_available_devices, 0);
+    rb_define_singleton_method(rb_cSoundRecorder, "default_device", SoundRecorder_default_device, 0);
+
+    rb_define_method(rb_cSoundRecorder, "start", SoundRecorder_start, 1);
+    rb_define_method(rb_cSoundRecorder, "stop", SoundRecorder_stop, 0);
+    rb_define_method(rb_cSoundRecorder, "sample_rate", SoundRecorder_sample_rate, 0);
+    rb_define_method(rb_cSoundRecorder, "device", SoundRecorder_device, 0);
+    rb_define_method(rb_cSoundRecorder, "device=", SoundRecorder_set_device, 1);
+    rb_define_method(rb_cSoundRecorder, "channel_count", SoundRecorder_channel_count, 0);
+    rb_define_method(rb_cSoundRecorder, "channel_count=", SoundRecorder_set_channel_count, 1);
+    rb_define_method(rb_cSoundRecorder, "channel_map", SoundRecorder_channel_map, 0);
+}
+
+VALUE Get_Klass_SoundRecorder(void) {
+    return rb_cSoundRecorder;
+}
+
+void *Get_SoundRecorder_Struct(VALUE self) {
+    SoundRecorder *ptr;
+    TypedData_Get_Struct(self, SoundRecorder, &SoundRecorder_data_type, ptr);
+    return ptr->handle;
+}

data/ext/audio/sound_recorder.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_SOUND_RECORDER_H
+#define SFML_RB_AUDIO_SOUND_RECORDER_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_SoundRecorder(VALUE rb_module);
+
+VALUE Get_Klass_SoundRecorder(void);
+
+void *Get_SoundRecorder_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_SOUND_RECORDER_H

data/ext/audio/sound_source.h

@@ -0,0 +1,13 @@
+#ifndef SFML_RB_AUDIO_SOUND_SOURCE_H
+#define SFML_RB_AUDIO_SOUND_SOURCE_H
+
+/* Every wrapper that mixes in the SoundSource methods (Sound, Music,
+   SoundStream) starts with this prefix, so the shared method bodies in
+   sound_source.inc can reach the underlying handle and the effect-processor
+   slot through RTYPEDDATA_DATA without knowing the concrete struct. */
+typedef struct {
+    void *handle;
+    int effect_slot;
+} SoundSource;
+
+#endif //SFML_RB_AUDIO_SOUND_SOURCE_H

data/ext/audio/sound_source.inc

@@ -0,0 +1,271 @@
+/* Shared method bodies for every sound source (Sound, Music, SoundStream).
+   Included from three translation units; each defines SS_FN and SS_METHOD
+   before including this file, then undefines them after. Generating concrete
+   methods per class keeps the compiler's function-pointer type checks happy,
+   which a runtime vtable of cast function pointers would not.
+
+   The wrapper structs all begin with a SoundSource prefix, so the handle and
+   the effect-processor slot are reachable without knowing the concrete type. */
+
+#include <ruby/thread.h>
+
+#include "audio/sound_source.h"
+#include "audio/audio_enums.h"
+#include "audio/effect_processor.h"
+#include "audio/sound_source_cone.h"
+#include "core/macros.h"
+#include "system/time.h"
+#include "system/vec3.h"
+
+#define SS_HANDLE(self) (((SoundSource *) RTYPEDDATA_DATA(self))->handle)
+#define SS_SLOT(self) (((SoundSource *) RTYPEDDATA_DATA(self))->effect_slot)
+
+static VALUE SS_METHOD(play)(VALUE self) {
+    SS_FN(play)(SS_HANDLE(self));
+    return self;
+}
+
+static VALUE SS_METHOD(pause)(VALUE self) {
+    SS_FN(pause)(SS_HANDLE(self));
+    return self;
+}
+
+/* stop() blocks until any in-flight audio-thread callback for this source
+   finishes (SFML's AudioDevice::waitForReadingComplete()). If that callback
+   is itself waiting on the foreign-thread worker (e.g. an effect processor
+   or SoundStream#on_get_data), holding the GVL here for the whole wait would
+   deadlock: worker needs the GVL, we are blocked holding it waiting for the
+   very callback the worker is servicing. Releasing the GVL around the call
+   breaks the cycle. */
+static void *SS_METHOD(stop_without_gvl)(void *handle) {
+    SS_FN(stop)(handle);
+    return NULL;
+}
+
+static VALUE SS_METHOD(stop)(VALUE self) {
+    rb_thread_call_without_gvl(SS_METHOD(stop_without_gvl), SS_HANDLE(self), RUBY_UBF_IO, NULL);
+    return self;
+}
+
+static VALUE SS_METHOD(status)(VALUE self) {
+    return ID2SYM(rb_intern(sound_status_name(SS_FN(getStatus)(SS_HANDLE(self)))));
+}
+
+static VALUE SS_METHOD(looping)(VALUE self) {
+    return BOOL2RB(SS_FN(isLooping)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_looping)(VALUE self, VALUE rb_value) {
+    SS_FN(setLooping)(SS_HANDLE(self), RTEST(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(pitch)(VALUE self) {
+    return DBL2NUM(SS_FN(getPitch)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_pitch)(VALUE self, VALUE rb_value) {
+    SS_FN(setPitch)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(pan)(VALUE self) {
+    return DBL2NUM(SS_FN(getPan)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_pan)(VALUE self, VALUE rb_value) {
+    SS_FN(setPan)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(volume)(VALUE self) {
+    return DBL2NUM(SS_FN(getVolume)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_volume)(VALUE self, VALUE rb_value) {
+    SS_FN(setVolume)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(spatialization_enabled)(VALUE self) {
+    return BOOL2RB(SS_FN(isSpatializationEnabled)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_spatialization_enabled)(VALUE self, VALUE rb_value) {
+    SS_FN(setSpatializationEnabled)(SS_HANDLE(self), RTEST(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(position)(VALUE self) {
+    return vec3f_to_rb(SS_FN(getPosition)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_position)(VALUE self, VALUE rb_value) {
+    SS_FN(setPosition)(SS_HANDLE(self), vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(direction)(VALUE self) {
+    return vec3f_to_rb(SS_FN(getDirection)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_direction)(VALUE self, VALUE rb_value) {
+    SS_FN(setDirection)(SS_HANDLE(self), vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(velocity)(VALUE self) {
+    return vec3f_to_rb(SS_FN(getVelocity)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_velocity)(VALUE self, VALUE rb_value) {
+    SS_FN(setVelocity)(SS_HANDLE(self), vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(cone)(VALUE self) {
+    return sound_source_cone_to_rb(SS_FN(getCone)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_cone)(VALUE self, VALUE rb_value) {
+    SS_FN(setCone)(SS_HANDLE(self), sound_source_cone_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(doppler_factor)(VALUE self) {
+    return DBL2NUM(SS_FN(getDopplerFactor)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_doppler_factor)(VALUE self, VALUE rb_value) {
+    SS_FN(setDopplerFactor)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(directional_attenuation_factor)(VALUE self) {
+    return DBL2NUM(SS_FN(getDirectionalAttenuationFactor)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_directional_attenuation_factor)(VALUE self, VALUE rb_value) {
+    SS_FN(setDirectionalAttenuationFactor)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(relative_to_listener)(VALUE self) {
+    return BOOL2RB(SS_FN(isRelativeToListener)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_relative_to_listener)(VALUE self, VALUE rb_value) {
+    SS_FN(setRelativeToListener)(SS_HANDLE(self), RTEST(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(min_distance)(VALUE self) {
+    return DBL2NUM(SS_FN(getMinDistance)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_min_distance)(VALUE self, VALUE rb_value) {
+    SS_FN(setMinDistance)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(max_distance)(VALUE self) {
+    return DBL2NUM(SS_FN(getMaxDistance)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_max_distance)(VALUE self, VALUE rb_value) {
+    SS_FN(setMaxDistance)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(min_gain)(VALUE self) {
+    return DBL2NUM(SS_FN(getMinGain)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_min_gain)(VALUE self, VALUE rb_value) {
+    SS_FN(setMinGain)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(max_gain)(VALUE self) {
+    return DBL2NUM(SS_FN(getMaxGain)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_max_gain)(VALUE self, VALUE rb_value) {
+    SS_FN(setMaxGain)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(attenuation)(VALUE self) {
+    return DBL2NUM(SS_FN(getAttenuation)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_attenuation)(VALUE self, VALUE rb_value) {
+    SS_FN(setAttenuation)(SS_HANDLE(self), (float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(playing_offset)(VALUE self) {
+    return time_to_rb(SS_FN(getPlayingOffset)(SS_HANDLE(self)));
+}
+
+static VALUE SS_METHOD(set_playing_offset)(VALUE self, VALUE rb_value) {
+    SS_FN(setPlayingOffset)(SS_HANDLE(self), time_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE SS_METHOD(set_effect_processor)(VALUE self, VALUE rb_proc) {
+    sfEffectProcessor processor = effect_processor_acquire(rb_proc, &SS_SLOT(self));
+
+    SS_FN(setEffectProcessor)(SS_HANDLE(self), processor);
+
+    return rb_proc;
+}
+
+static void SS_METHOD(define_sound_source_methods)(VALUE klass) {
+    rb_define_method(klass, "play", SS_METHOD(play), 0);
+    rb_define_method(klass, "pause", SS_METHOD(pause), 0);
+    rb_define_method(klass, "stop", SS_METHOD(stop), 0);
+    rb_define_method(klass, "status", SS_METHOD(status), 0);
+    rb_define_method(klass, "looping?", SS_METHOD(looping), 0);
+    rb_define_method(klass, "looping=", SS_METHOD(set_looping), 1);
+    rb_define_method(klass, "pitch", SS_METHOD(pitch), 0);
+    rb_define_method(klass, "pitch=", SS_METHOD(set_pitch), 1);
+    rb_define_method(klass, "pan", SS_METHOD(pan), 0);
+    rb_define_method(klass, "pan=", SS_METHOD(set_pan), 1);
+    rb_define_method(klass, "volume", SS_METHOD(volume), 0);
+    rb_define_method(klass, "volume=", SS_METHOD(set_volume), 1);
+    rb_define_method(klass, "spatialization_enabled?", SS_METHOD(spatialization_enabled), 0);
+    rb_define_method(klass, "spatialization_enabled=", SS_METHOD(set_spatialization_enabled), 1);
+    rb_define_method(klass, "position", SS_METHOD(position), 0);
+    rb_define_method(klass, "position=", SS_METHOD(set_position), 1);
+    rb_define_method(klass, "direction", SS_METHOD(direction), 0);
+    rb_define_method(klass, "direction=", SS_METHOD(set_direction), 1);
+    rb_define_method(klass, "velocity", SS_METHOD(velocity), 0);
+    rb_define_method(klass, "velocity=", SS_METHOD(set_velocity), 1);
+    rb_define_method(klass, "cone", SS_METHOD(cone), 0);
+    rb_define_method(klass, "cone=", SS_METHOD(set_cone), 1);
+    rb_define_method(klass, "doppler_factor", SS_METHOD(doppler_factor), 0);
+    rb_define_method(klass, "doppler_factor=", SS_METHOD(set_doppler_factor), 1);
+    rb_define_method(klass, "directional_attenuation_factor",
+                     SS_METHOD(directional_attenuation_factor), 0);
+    rb_define_method(klass, "directional_attenuation_factor=",
+                     SS_METHOD(set_directional_attenuation_factor), 1);
+    rb_define_method(klass, "relative_to_listener?", SS_METHOD(relative_to_listener), 0);
+    rb_define_method(klass, "relative_to_listener=", SS_METHOD(set_relative_to_listener), 1);
+    rb_define_method(klass, "min_distance", SS_METHOD(min_distance), 0);
+    rb_define_method(klass, "min_distance=", SS_METHOD(set_min_distance), 1);
+    rb_define_method(klass, "max_distance", SS_METHOD(max_distance), 0);
+    rb_define_method(klass, "max_distance=", SS_METHOD(set_max_distance), 1);
+    rb_define_method(klass, "min_gain", SS_METHOD(min_gain), 0);
+    rb_define_method(klass, "min_gain=", SS_METHOD(set_min_gain), 1);
+    rb_define_method(klass, "max_gain", SS_METHOD(max_gain), 0);
+    rb_define_method(klass, "max_gain=", SS_METHOD(set_max_gain), 1);
+    rb_define_method(klass, "attenuation", SS_METHOD(attenuation), 0);
+    rb_define_method(klass, "attenuation=", SS_METHOD(set_attenuation), 1);
+    rb_define_method(klass, "playing_offset", SS_METHOD(playing_offset), 0);
+    rb_define_method(klass, "playing_offset=", SS_METHOD(set_playing_offset), 1);
+    rb_define_method(klass, "effect_processor=", SS_METHOD(set_effect_processor), 1);
+}
+
+#undef SS_HANDLE
+#undef SS_SLOT

data/ext/audio/sound_source_cone.c

@@ -0,0 +1,138 @@
+#include "audio/sound_source_cone.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfSoundSourceCone cone;
+} SoundSourceCone;
+
+static VALUE rb_cSoundSourceCone;
+
+static void SoundSourceCone_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t SoundSourceCone_data_type = {
+    .wrap_struct_name = "SFML::SoundSourceCone",
+    .function = {.dmark = NULL, .dfree = SoundSourceCone_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE SoundSourceCone_wrap(sfSoundSourceCone cone) {
+    SoundSourceCone *ptr = malloc(sizeof(SoundSourceCone));
+
+    ptr->cone = cone;
+
+    return TypedData_Wrap_Struct(rb_cSoundSourceCone, &SoundSourceCone_data_type, ptr);
+}
+
+static VALUE SoundSourceCone_new(VALUE klass, VALUE rb_inner, VALUE rb_outer, VALUE rb_gain) {
+    sfSoundSourceCone cone = {
+        .innerAngle = (float) NUM2DBL(rb_inner),
+        .outerAngle = (float) NUM2DBL(rb_outer),
+        .outerGain = (float) NUM2DBL(rb_gain)
+    };
+
+    return SoundSourceCone_wrap(cone);
+}
+
+static VALUE SoundSourceCone_get_inner_angle(VALUE self) {
+    return DBL2NUM(((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone.innerAngle);
+}
+
+static VALUE SoundSourceCone_get_outer_angle(VALUE self) {
+    return DBL2NUM(((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone.outerAngle);
+}
+
+static VALUE SoundSourceCone_get_outer_gain(VALUE self) {
+    return DBL2NUM(((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone.outerGain);
+}
+
+static VALUE SoundSourceCone_set_inner_angle(VALUE self, VALUE rb_value) {
+    ((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone.innerAngle = (float) NUM2DBL(rb_value);
+    return rb_value;
+}
+
+static VALUE SoundSourceCone_set_outer_angle(VALUE self, VALUE rb_value) {
+    ((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone.outerAngle = (float) NUM2DBL(rb_value);
+    return rb_value;
+}
+
+static VALUE SoundSourceCone_set_outer_gain(VALUE self, VALUE rb_value) {
+    ((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone.outerGain = (float) NUM2DBL(rb_value);
+    return rb_value;
+}
+
+static VALUE SoundSourceCone_to_a(VALUE self) {
+    sfSoundSourceCone cone = ((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone;
+
+    return rb_ary_new_from_args(3, DBL2NUM(cone.innerAngle), DBL2NUM(cone.outerAngle),
+                                DBL2NUM(cone.outerGain));
+}
+
+static VALUE SoundSourceCone_eql(VALUE self, VALUE rb_other) {
+    sfSoundSourceCone a = ((SoundSourceCone *) Get_SoundSourceCone_Struct(self))->cone;
+    sfSoundSourceCone b;
+
+    if (!rb_obj_is_kind_of(rb_other, rb_cSoundSourceCone)) {
+        return Qfalse;
+    }
+
+    b = ((SoundSourceCone *) Get_SoundSourceCone_Struct(rb_other))->cone;
+
+    return BOOL2RB(a.innerAngle == b.innerAngle && a.outerAngle == b.outerAngle &&
+                   a.outerGain == b.outerGain);
+}
+
+void Init_SoundSourceCone(VALUE rb_module) {
+    rb_cSoundSourceCone = rb_define_class_under(rb_module, "SoundSourceCone", rb_cObject);
+
+    rb_define_singleton_method(rb_cSoundSourceCone, "new", SoundSourceCone_new, 3);
+
+    rb_define_method(rb_cSoundSourceCone, "inner_angle", SoundSourceCone_get_inner_angle, 0);
+    rb_define_method(rb_cSoundSourceCone, "outer_angle", SoundSourceCone_get_outer_angle, 0);
+    rb_define_method(rb_cSoundSourceCone, "outer_gain", SoundSourceCone_get_outer_gain, 0);
+    rb_define_method(rb_cSoundSourceCone, "inner_angle=", SoundSourceCone_set_inner_angle, 1);
+    rb_define_method(rb_cSoundSourceCone, "outer_angle=", SoundSourceCone_set_outer_angle, 1);
+    rb_define_method(rb_cSoundSourceCone, "outer_gain=", SoundSourceCone_set_outer_gain, 1);
+    rb_define_method(rb_cSoundSourceCone, "to_a", SoundSourceCone_to_a, 0);
+    rb_define_method(rb_cSoundSourceCone, "==", SoundSourceCone_eql, 1);
+}
+
+VALUE Get_Klass_SoundSourceCone(void) {
+    return rb_cSoundSourceCone;
+}
+
+void *Get_SoundSourceCone_Struct(VALUE self) {
+    SoundSourceCone *ptr;
+    TypedData_Get_Struct(self, SoundSourceCone, &SoundSourceCone_data_type, ptr);
+    return ptr;
+}
+
+sfSoundSourceCone sound_source_cone_from_rb(VALUE rb_cone) {
+    if (rb_obj_is_kind_of(rb_cone, rb_cSoundSourceCone)) {
+        return ((SoundSourceCone *) Get_SoundSourceCone_Struct(rb_cone))->cone;
+    }
+
+    if (RB_TYPE_P(rb_cone, T_ARRAY) && RARRAY_LEN(rb_cone) == 3) {
+        sfSoundSourceCone cone = {
+            .innerAngle = (float) NUM2DBL(rb_ary_entry(rb_cone, 0)),
+            .outerAngle = (float) NUM2DBL(rb_ary_entry(rb_cone, 1)),
+            .outerGain = (float) NUM2DBL(rb_ary_entry(rb_cone, 2))
+        };
+
+        return cone;
+    }
+
+    raise_invalid_argument_class(rb_cSoundSourceCone);
+
+    return (sfSoundSourceCone) {0.0f, 0.0f, 0.0f};
+}
+
+VALUE sound_source_cone_to_rb(sfSoundSourceCone cone) {
+    return SoundSourceCone_wrap(cone);
+}