sfml3-rb 0.0.1 → 0.2.2

data/ext/audio/listener.c

@@ -0,0 +1,83 @@
+#include "audio/listener.h"
+
+#include <ruby.h>
+
+#include "audio/sound_source_cone.h"
+#include "system/vec3.h"
+
+static VALUE Listener_global_volume(VALUE module) {
+    return DBL2NUM(sfListener_getGlobalVolume());
+}
+
+static VALUE Listener_set_global_volume(VALUE module, VALUE rb_value) {
+    sfListener_setGlobalVolume((float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_position(VALUE module) {
+    return vec3f_to_rb(sfListener_getPosition());
+}
+
+static VALUE Listener_set_position(VALUE module, VALUE rb_value) {
+    sfListener_setPosition(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_direction(VALUE module) {
+    return vec3f_to_rb(sfListener_getDirection());
+}
+
+static VALUE Listener_set_direction(VALUE module, VALUE rb_value) {
+    sfListener_setDirection(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_velocity(VALUE module) {
+    return vec3f_to_rb(sfListener_getVelocity());
+}
+
+static VALUE Listener_set_velocity(VALUE module, VALUE rb_value) {
+    sfListener_setVelocity(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_up_vector(VALUE module) {
+    return vec3f_to_rb(sfListener_getUpVector());
+}
+
+static VALUE Listener_set_up_vector(VALUE module, VALUE rb_value) {
+    sfListener_setUpVector(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_cone(VALUE module) {
+    sfListenerCone cone = sfListener_getCone();
+
+    return sound_source_cone_to_rb((sfSoundSourceCone) {cone.innerAngle, cone.outerAngle,
+                                                        cone.outerGain});
+}
+
+static VALUE Listener_set_cone(VALUE module, VALUE rb_value) {
+    sfSoundSourceCone cone = sound_source_cone_from_rb(rb_value);
+
+    sfListener_setCone((sfListenerCone) {cone.innerAngle, cone.outerAngle, cone.outerGain});
+
+    return rb_value;
+}
+
+void Init_Listener(VALUE rb_module) {
+    VALUE rb_mListener = rb_define_module_under(rb_module, "Listener");
+
+    rb_define_module_function(rb_mListener, "global_volume", Listener_global_volume, 0);
+    rb_define_module_function(rb_mListener, "global_volume=", Listener_set_global_volume, 1);
+    rb_define_module_function(rb_mListener, "position", Listener_position, 0);
+    rb_define_module_function(rb_mListener, "position=", Listener_set_position, 1);
+    rb_define_module_function(rb_mListener, "direction", Listener_direction, 0);
+    rb_define_module_function(rb_mListener, "direction=", Listener_set_direction, 1);
+    rb_define_module_function(rb_mListener, "velocity", Listener_velocity, 0);
+    rb_define_module_function(rb_mListener, "velocity=", Listener_set_velocity, 1);
+    rb_define_module_function(rb_mListener, "up_vector", Listener_up_vector, 0);
+    rb_define_module_function(rb_mListener, "up_vector=", Listener_set_up_vector, 1);
+    rb_define_module_function(rb_mListener, "cone", Listener_cone, 0);
+    rb_define_module_function(rb_mListener, "cone=", Listener_set_cone, 1);
+}

data/ext/audio/listener.h

@@ -0,0 +1,8 @@
+#ifndef SFML_RB_AUDIO_LISTENER_H
+#define SFML_RB_AUDIO_LISTENER_H
+
+#include <ruby.h>
+
+void Init_Listener(VALUE rb_module);
+
+#endif //SFML_RB_AUDIO_LISTENER_H

data/ext/audio/music.c

@@ -0,0 +1,174 @@
+#include "audio/music.h"
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdlib.h>
+
+#include "audio/audio_enums.h"
+#include "audio/effect_processor.h"
+#include "audio/sound_source.h"
+#include "core/exceptions.h"
+#include "system/input_stream.h"
+#include "system/time.h"
+
+typedef struct {
+    SoundSource source;
+    /* Music streams from the InputStream lazily, so unlike Font/Image/Shader
+       the stream has to outlive the create call. The VALUE is both marked and
+       registered as a GC root: the root is what guarantees the InputStream's
+       sfInputStream is still alive when sfMusic_destroy runs in dfree, even if
+       the Music and the stream become unreachable in the same GC cycle. */
+    VALUE rb_stream;
+} Music;
+
+static VALUE rb_cMusic;
+
+static void Music_mark(void* ptr) {
+    Music* music = ptr;
+
+    rb_gc_mark(music->rb_stream);
+}
+
+/* sfMusic_destroy() calls Music::~Music(), which explicitly calls stop() and
+   can block waiting on the audio thread; release the GVL for the same reason
+   as Sound_free/SS_METHOD(stop). */
+static void* Music_destroy_without_gvl(void* handle) {
+    sfMusic_destroy(handle);
+    return NULL;
+}
+
+static void Music_free(void* ptr) {
+    Music* music = ptr;
+
+    effect_processor_release(music->source.effect_slot);
+    rb_thread_call_without_gvl(Music_destroy_without_gvl, music->source.handle, RUBY_UBF_IO, NULL);
+    rb_gc_unregister_address(&music->rb_stream);
+    free(music);
+}
+
+static const rb_data_type_t Music_data_type = {
+    .wrap_struct_name = "SFML::Music",
+    .function = {.dmark = Music_mark, .dfree = Music_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE Music_wrap(VALUE klass, sfMusic* handle, VALUE rb_stream) {
+    Music* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create music");
+    }
+
+    ptr = malloc(sizeof(Music));
+    ptr->source.handle = handle;
+    ptr->source.effect_slot = -1;
+    ptr->rb_stream = rb_stream;
+
+    rb_gc_register_address(&ptr->rb_stream);
+
+    return TypedData_Wrap_Struct(klass, &Music_data_type, ptr);
+}
+
+static VALUE Music_from_file(VALUE klass, VALUE rb_path) {
+    return Music_wrap(klass, sfMusic_createFromFile(StringValueCStr(rb_path)), Qnil);
+}
+
+static VALUE Music_from_memory(VALUE klass, VALUE rb_data) {
+    StringValue(rb_data);
+
+    return Music_wrap(
+        klass, sfMusic_createFromMemory(RSTRING_PTR(rb_data), (size_t)RSTRING_LEN(rb_data)), Qnil);
+}
+
+static VALUE Music_from_stream(VALUE klass, VALUE rb_stream) {
+    VALUE holder = Qnil;
+    sfInputStream* stream = input_stream_from_rb(rb_stream, &holder);
+
+    return Music_wrap(klass, sfMusic_createFromStream(stream), holder);
+}
+
+static VALUE Music_duration(VALUE self) {
+    return time_to_rb(sfMusic_getDuration(Get_Music_Struct(self)));
+}
+
+static VALUE Music_channel_count(VALUE self) {
+    return UINT2NUM(sfMusic_getChannelCount(Get_Music_Struct(self)));
+}
+
+static VALUE Music_sample_rate(VALUE self) {
+    return UINT2NUM(sfMusic_getSampleRate(Get_Music_Struct(self)));
+}
+
+static VALUE Music_channel_map(VALUE self) {
+    size_t count = 0;
+    const sfSoundChannel* map = sfMusic_getChannelMap(Get_Music_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;
+}
+
+/* Loop points are an offset plus a length, matching sfTimeSpan. Returned as a
+   two-element [offset, length] pair of SFML::Time. */
+static VALUE Music_loop_points(VALUE self) {
+    sfTimeSpan span = sfMusic_getLoopPoints(Get_Music_Struct(self));
+
+    return rb_ary_new_from_args(2, time_to_rb(span.offset), time_to_rb(span.length));
+}
+
+static VALUE Music_set_loop_points(VALUE self, VALUE rb_span) {
+    sfTimeSpan span;
+
+    if (!RB_TYPE_P(rb_span, T_ARRAY) || RARRAY_LEN(rb_span) != 2) {
+        rb_raise(rb_eArgError, "loop points must be a two-element [offset, length] array");
+    }
+
+    span.offset = time_from_rb(rb_ary_entry(rb_span, 0));
+    span.length = time_from_rb(rb_ary_entry(rb_span, 1));
+
+    sfMusic_setLoopPoints(Get_Music_Struct(self), span);
+
+    return rb_span;
+}
+
+#define SS_FN(name) sfMusic_##name
+#define SS_METHOD(name) Music_##name
+#include "audio/sound_source.inc"
+#undef SS_FN
+#undef SS_METHOD
+
+void Init_Music(VALUE rb_module) {
+    rb_cMusic = rb_define_class_under(rb_module, "Music", rb_cObject);
+
+    rb_define_singleton_method(rb_cMusic, "from_file", Music_from_file, 1);
+    rb_define_singleton_method(rb_cMusic, "from_memory", Music_from_memory, 1);
+    rb_define_singleton_method(rb_cMusic, "from_stream", Music_from_stream, 1);
+
+    rb_define_method(rb_cMusic, "duration", Music_duration, 0);
+    rb_define_method(rb_cMusic, "channel_count", Music_channel_count, 0);
+    rb_define_method(rb_cMusic, "sample_rate", Music_sample_rate, 0);
+    rb_define_method(rb_cMusic, "channel_map", Music_channel_map, 0);
+    rb_define_method(rb_cMusic, "loop_points", Music_loop_points, 0);
+    rb_define_method(rb_cMusic, "loop_points=", Music_set_loop_points, 1);
+
+    Music_define_sound_source_methods(rb_cMusic);
+}
+
+VALUE Get_Klass_Music(void) {
+    return rb_cMusic;
+}
+
+void* Get_Music_Struct(VALUE self) {
+    Music* ptr;
+    TypedData_Get_Struct(self, Music, &Music_data_type, ptr);
+    return ptr->source.handle;
+}

data/ext/audio/music.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_MUSIC_H
+#define SFML_RB_AUDIO_MUSIC_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Music(VALUE rb_module);
+
+VALUE Get_Klass_Music(void);
+
+void *Get_Music_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_MUSIC_H

data/ext/audio/sound.c

@@ -0,0 +1,139 @@
+#include "audio/sound.h"
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdlib.h>
+
+#include "audio/effect_processor.h"
+#include "audio/sound_buffer.h"
+#include "audio/sound_source.h"
+#include "core/exceptions.h"
+
+typedef struct {
+    SoundSource source;
+    VALUE rb_buffer;
+} Sound;
+
+static VALUE rb_cSound;
+
+static void Sound_mark(void* ptr) {
+    Sound* sound = ptr;
+
+    rb_gc_mark(sound->rb_buffer);
+}
+
+/* sfSound_destroy() calls Sound::stop(), which can block waiting on the audio
+   thread (see the matching comment on SS_METHOD(stop) in sound_source.inc);
+   release the GVL for the same reason. */
+static void* Sound_destroy_without_gvl(void* handle) {
+    sfSound_destroy(handle);
+    return NULL;
+}
+
+static void Sound_free(void* ptr) {
+    Sound* sound = ptr;
+
+    effect_processor_release(sound->source.effect_slot);
+    rb_thread_call_without_gvl(Sound_destroy_without_gvl, sound->source.handle, RUBY_UBF_IO, NULL);
+    free(sound);
+}
+
+static const rb_data_type_t Sound_data_type = {
+    .wrap_struct_name = "SFML::Sound",
+    .function = {.dmark = Sound_mark, .dfree = Sound_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE Sound_wrap(VALUE klass, sfSound* handle, VALUE rb_buffer) {
+    Sound* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sound");
+    }
+
+    ptr = malloc(sizeof(Sound));
+    ptr->source.handle = handle;
+    ptr->source.effect_slot = -1;
+    ptr->rb_buffer = rb_buffer;
+
+    return TypedData_Wrap_Struct(klass, &Sound_data_type, ptr);
+}
+
+static VALUE Sound_new(VALUE klass, VALUE rb_buffer) {
+    if (!rb_obj_is_kind_of(rb_buffer, Get_Klass_SoundBuffer())) {
+        raise_invalid_argument_class(Get_Klass_SoundBuffer());
+    }
+
+    return Sound_wrap(klass, sfSound_create(Get_SoundBuffer_Struct(rb_buffer)), rb_buffer);
+}
+
+static VALUE Sound_copy(VALUE self) {
+    Sound* sound = (Sound*)Get_Sound_Struct(self);
+
+    return Sound_wrap(Get_Klass_Sound(), sfSound_copy((const sfSound*)sound->source.handle),
+                      sound->rb_buffer);
+}
+
+static VALUE Sound_get_buffer(VALUE self) {
+    return ((Sound*)Get_Sound_Struct(self))->rb_buffer;
+}
+
+typedef struct {
+    sfSound* handle;
+    const sfSoundBuffer* buffer;
+} SoundSetBufferArgs;
+
+/* sfSound_setBuffer() calls Sound::stop() when a buffer is already attached,
+   which can block waiting on the audio thread; release the GVL for the same
+   reason as Sound_free/SS_METHOD(stop). */
+static void* Sound_set_buffer_without_gvl(void* raw) {
+    SoundSetBufferArgs* args = raw;
+
+    sfSound_setBuffer(args->handle, args->buffer);
+
+    return NULL;
+}
+
+static VALUE Sound_set_buffer(VALUE self, VALUE rb_buffer) {
+    Sound* sound = (Sound*)Get_Sound_Struct(self);
+    SoundSetBufferArgs args;
+
+    if (!rb_obj_is_kind_of(rb_buffer, Get_Klass_SoundBuffer())) {
+        raise_invalid_argument_class(Get_Klass_SoundBuffer());
+    }
+
+    args.handle = sound->source.handle;
+    args.buffer = Get_SoundBuffer_Struct(rb_buffer);
+
+    rb_thread_call_without_gvl(Sound_set_buffer_without_gvl, &args, RUBY_UBF_IO, NULL);
+    sound->rb_buffer = rb_buffer;
+
+    return rb_buffer;
+}
+
+#define SS_FN(name) sfSound_##name
+#define SS_METHOD(name) Sound_##name
+#include "audio/sound_source.inc"
+#undef SS_FN
+#undef SS_METHOD
+
+void Init_Sound(VALUE rb_module) {
+    rb_cSound = rb_define_class_under(rb_module, "Sound", rb_cObject);
+
+    rb_define_singleton_method(rb_cSound, "new", Sound_new, 1);
+
+    rb_define_method(rb_cSound, "copy", Sound_copy, 0);
+    rb_define_method(rb_cSound, "buffer", Sound_get_buffer, 0);
+    rb_define_method(rb_cSound, "buffer=", Sound_set_buffer, 1);
+
+    Sound_define_sound_source_methods(rb_cSound);
+}
+
+VALUE Get_Klass_Sound(void) {
+    return rb_cSound;
+}
+
+void* Get_Sound_Struct(VALUE self) {
+    Sound* ptr;
+    TypedData_Get_Struct(self, Sound, &Sound_data_type, ptr);
+    return ptr;
+}

data/ext/audio/sound.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_SOUND_H
+#define SFML_RB_AUDIO_SOUND_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Sound(VALUE rb_module);
+
+VALUE Get_Klass_Sound(void);
+
+void *Get_Sound_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_SOUND_H