sfml3-rb 0.0.1 → 0.2.2

data/ext/system/input_stream.c

@@ -0,0 +1,229 @@
+#include "system/input_stream.h"
+
+#include <ruby.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "core/exceptions.h"
+
+/* Wrap a Ruby IO-like object (read/seek/tell, optionally size). The struct is
+   owned by the Ruby object; userData points at it, and dmark keeps the IO
+   alive for as long as any load call might touch it. */
+typedef struct {
+    sfInputStream stream;
+    VALUE rb_io;
+} InputStream;
+
+static VALUE rb_cInputStream;
+
+static void InputStream_mark(void *ptr) {
+    InputStream *stream = ptr;
+
+    rb_gc_mark(stream->rb_io);
+}
+
+static void InputStream_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t InputStream_data_type = {
+    .wrap_struct_name = "SFML::InputStream",
+    .function = {.dmark = InputStream_mark, .dfree = InputStream_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+/* Callbacks run from C++ (SFML), so a Ruby exception must never unwind through
+   those frames. Each body runs under rb_protect and reports failure as a
+   negative result instead. */
+typedef struct {
+    VALUE io;
+    size_t size;
+    void *data;
+    int64_t result;
+} ReadContext;
+
+static VALUE InputStream_read_body(VALUE v) {
+    ReadContext *ctx = (ReadContext *) v;
+    VALUE str = rb_funcall(ctx->io, rb_intern("read"), 1, SIZET2NUM(ctx->size));
+
+    if (NIL_P(str)) {
+        ctx->result = 0;
+        return Qnil;
+    }
+
+    StringValue(str);
+
+    long length = RSTRING_LEN(str);
+
+    if ((size_t) length > ctx->size) {
+        length = (long) ctx->size;
+    }
+
+    if (length > 0) {
+        memcpy(ctx->data, RSTRING_PTR(str), (size_t) length);
+    }
+
+    ctx->result = (int64_t) length;
+
+    return Qnil;
+}
+
+static int64_t InputStream_read(void *data, size_t size, void *userData) {
+    InputStream *stream = userData;
+    ReadContext ctx = {.io = stream->rb_io, .size = size, .data = data, .result = -1};
+    int state = 0;
+
+    rb_protect(InputStream_read_body, (VALUE) &ctx, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        return -1;
+    }
+
+    return ctx.result;
+}
+
+typedef struct {
+    VALUE io;
+    size_t position;
+    int64_t result;
+} SeekContext;
+
+static VALUE InputStream_seek_body(VALUE v) {
+    SeekContext *ctx = (SeekContext *) v;
+
+    rb_funcall(ctx->io, rb_intern("seek"), 2, SIZET2NUM(ctx->position), INT2NUM(SEEK_SET));
+    ctx->result = (int64_t) ctx->position;
+
+    return Qnil;
+}
+
+static int64_t InputStream_seek(size_t position, void *userData) {
+    InputStream *stream = userData;
+    SeekContext ctx = {.io = stream->rb_io, .position = position, .result = -1};
+    int state = 0;
+
+    rb_protect(InputStream_seek_body, (VALUE) &ctx, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        return -1;
+    }
+
+    return ctx.result;
+}
+
+static VALUE InputStream_tell_body(VALUE v) {
+    VALUE io = (VALUE) v;
+
+    if (rb_respond_to(io, rb_intern("tell"))) {
+        return rb_funcall(io, rb_intern("tell"), 0);
+    }
+
+    return rb_funcall(io, rb_intern("pos"), 0);
+}
+
+static int64_t InputStream_tell(void *userData) {
+    InputStream *stream = userData;
+    int state = 0;
+    VALUE result = rb_protect(InputStream_tell_body, stream->rb_io, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        return -1;
+    }
+
+    return NUM2LL(result);
+}
+
+static VALUE InputStream_get_size_body(VALUE v) {
+    VALUE io = (VALUE) v;
+
+    if (rb_respond_to(io, rb_intern("size"))) {
+        return rb_funcall(io, rb_intern("size"), 0);
+    }
+
+    return rb_funcall(io, rb_intern("length"), 0);
+}
+
+static int64_t InputStream_get_size(void *userData) {
+    InputStream *stream = userData;
+    int state = 0;
+    VALUE result = rb_protect(InputStream_get_size_body, stream->rb_io, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        return -1;
+    }
+
+    return NUM2LL(result);
+}
+
+static VALUE InputStream_new(VALUE klass, VALUE rb_io) {
+    VALUE self;
+    InputStream *stream;
+
+    if (!rb_respond_to(rb_io, rb_intern("read"))) {
+        rb_raise(rb_eArgError, "stream object must respond to #read");
+    }
+
+    stream = malloc(sizeof(InputStream));
+
+    stream->rb_io = rb_io;
+    stream->stream.read = InputStream_read;
+    stream->stream.seek = InputStream_seek;
+    stream->stream.tell = InputStream_tell;
+    stream->stream.getSize = InputStream_get_size;
+    stream->stream.userData = stream;
+
+    self = TypedData_Wrap_Struct(klass, &InputStream_data_type, stream);
+
+    return self;
+}
+
+static VALUE InputStream_get_io(VALUE self) {
+    return ((InputStream *) Get_InputStream_Struct(self))->rb_io;
+}
+
+void Init_InputStream(VALUE rb_module) {
+    rb_cInputStream = rb_define_class_under(rb_module, "InputStream", rb_cObject);
+
+    rb_define_singleton_method(rb_cInputStream, "new", InputStream_new, 1);
+
+    rb_define_method(rb_cInputStream, "io", InputStream_get_io, 0);
+}
+
+VALUE Get_Klass_InputStream(void) {
+    return rb_cInputStream;
+}
+
+sfInputStream *Get_InputStream_Struct(VALUE self) {
+    InputStream *ptr;
+    TypedData_Get_Struct(self, InputStream, &InputStream_data_type, ptr);
+    return &ptr->stream;
+}
+
+int InputStream_is_stream(VALUE rb_stream) {
+    return rb_obj_is_kind_of(rb_stream, rb_cInputStream) ? 1 : 0;
+}
+
+sfInputStream *input_stream_from_rb(VALUE rb_stream, VALUE *holder) {
+    if (InputStream_is_stream(rb_stream)) {
+        return Get_InputStream_Struct(rb_stream);
+    }
+
+    if (rb_respond_to(rb_stream, rb_intern("read"))) {
+        VALUE wrapper = rb_funcall(rb_cInputStream, rb_intern("new"), 1, rb_stream);
+
+        /* Callers keep this on their own stack so a GC triggered by the load
+           call cannot collect the wrapper mid-flight. */
+        if (holder != NULL) {
+            *holder = wrapper;
+        }
+
+        return Get_InputStream_Struct(wrapper);
+    }
+
+    rb_raise(rb_eArgError, "expected an SFML::InputStream or an object responding to #read");
+    return NULL;
+}

data/ext/system/input_stream.h

@@ -0,0 +1,23 @@
+#ifndef SFML_RB_SYSTEM_INPUT_STREAM_H
+#define SFML_RB_SYSTEM_INPUT_STREAM_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_InputStream(VALUE rb_module);
+
+VALUE Get_Klass_InputStream(void);
+
+sfInputStream *Get_InputStream_Struct(VALUE self);
+
+/* True when the object is an SFML::InputStream. */
+int InputStream_is_stream(VALUE rb_stream);
+
+/* Returns the underlying sfInputStream, wrapping any #read-able object in an
+   SFML::InputStream first. When wrapping happens the wrapper is stored in
+   *holder (a caller-local VALUE), so a GC during the subsequent load cannot
+   collect it. */
+sfInputStream *input_stream_from_rb(VALUE rb_stream, VALUE *holder);
+
+#endif //SFML_RB_SYSTEM_INPUT_STREAM_H

data/ext/system/sleep.c

@@ -0,0 +1,16 @@
+#include "system/sleep.h"
+
+#include <ruby.h>
+
+#include "system/time.h"
+#include "core/sfml.h"
+
+static VALUE Sleep_sleep(VALUE module, VALUE rb_duration) {
+    sfSleep(time_from_rb(rb_duration));
+
+    return rb_duration;
+}
+
+void Init_Sleep(VALUE rb_module) {
+    rb_define_module_function(rb_module, "sleep", Sleep_sleep, 1);
+}

data/ext/system/sleep.h

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

data/ext/system/time.c

@@ -0,0 +1,218 @@
+#include "system/time.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfTime time;
+} Time;
+
+static VALUE rb_cSFTime;
+
+static void Time_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Time_data_type = {
+    .wrap_struct_name = "SFML::Time",
+    .function = {.dmark = NULL, .dfree = Time_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Time_wrap(sfTime time) {
+    Time *ptr = malloc(sizeof(Time));
+
+    ptr->time = time;
+
+    return TypedData_Wrap_Struct(rb_cSFTime, &Time_data_type, ptr);
+}
+
+static VALUE Time_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE self;
+    Time *ptr;
+    sfTime time = sfTime_Zero;
+
+    if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cSFTime)) {
+        time = ((Time *) Get_Time_Struct(argv[0]))->time;
+    } else if (argc == 1 && RB_INTEGER_TYPE_P(argv[0])) {
+        time = sfMicroseconds((int64_t) NUM2LL(argv[0]));
+    } else if (argc == 1) {
+        time = sfSeconds((float) NUM2DBL(argv[0]));
+    } else if (argc != 0) {
+        raise_invalid_arguments_excepted(1, argc);
+    }
+
+    ptr = malloc(sizeof(Time));
+    ptr->time = time;
+
+    self = TypedData_Wrap_Struct(klass, &Time_data_type, ptr);
+
+    return self;
+}
+
+static VALUE Time_seconds(VALUE klass, VALUE rb_seconds) {
+    return Time_wrap(sfSeconds((float) NUM2DBL(rb_seconds)));
+}
+
+static VALUE Time_milliseconds(VALUE klass, VALUE rb_milliseconds) {
+    return Time_wrap(sfMilliseconds((int32_t) NUM2INT(rb_milliseconds)));
+}
+
+static VALUE Time_microseconds(VALUE klass, VALUE rb_microseconds) {
+    return Time_wrap(sfMicroseconds((int64_t) NUM2LL(rb_microseconds)));
+}
+
+static VALUE Time_zero(VALUE klass) {
+    return Time_wrap(sfTime_Zero);
+}
+
+static VALUE Time_as_seconds(VALUE self) {
+    return DBL2NUM(sfTime_asSeconds(((Time *) Get_Time_Struct(self))->time));
+}
+
+static VALUE Time_as_milliseconds(VALUE self) {
+    return INT2NUM(sfTime_asMilliseconds(((Time *) Get_Time_Struct(self))->time));
+}
+
+static VALUE Time_as_microseconds(VALUE self) {
+    return LL2NUM(sfTime_asMicroseconds(((Time *) Get_Time_Struct(self))->time));
+}
+
+static VALUE Time_to_f(VALUE self) {
+    return Time_as_seconds(self);
+}
+
+static VALUE Time_to_i(VALUE self) {
+    return Time_as_microseconds(self);
+}
+
+static VALUE Time_add(VALUE self, VALUE rb_other) {
+    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime b = time_from_rb(rb_other);
+
+    return Time_wrap(sfMicroseconds(sfTime_asMicroseconds(a) + sfTime_asMicroseconds(b)));
+}
+
+static VALUE Time_sub(VALUE self, VALUE rb_other) {
+    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime b = time_from_rb(rb_other);
+
+    return Time_wrap(sfMicroseconds(sfTime_asMicroseconds(a) - sfTime_asMicroseconds(b)));
+}
+
+static VALUE Time_mul(VALUE self, VALUE rb_scalar) {
+    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+
+    return Time_wrap(sfMicroseconds((int64_t) (sfTime_asMicroseconds(a) * NUM2DBL(rb_scalar))));
+}
+
+static VALUE Time_div(VALUE self, VALUE rb_other) {
+    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+
+    if (rb_obj_is_kind_of(rb_other, rb_cSFTime)) {
+        int64_t b = sfTime_asMicroseconds(((Time *) Get_Time_Struct(rb_other))->time);
+
+        if (b == 0) {
+            rb_raise(rb_eZeroDivError, "divided by 0");
+        }
+
+        return DBL2NUM((double) sfTime_asMicroseconds(a) / (double) b);
+    }
+
+    return Time_wrap(sfMicroseconds((int64_t) (sfTime_asMicroseconds(a) / NUM2DBL(rb_other))));
+}
+
+static VALUE Time_cmp(VALUE self, VALUE rb_other) {
+    sfTime a = ((Time *) Get_Time_Struct(self))->time;
+    sfTime b = time_from_rb(rb_other);
+    int64_t micro_a = sfTime_asMicroseconds(a);
+    int64_t micro_b = sfTime_asMicroseconds(b);
+
+    if (micro_a < micro_b) {
+        return INT2NUM(-1);
+    }
+
+    if (micro_a > micro_b) {
+        return INT2NUM(1);
+    }
+
+    return INT2NUM(0);
+}
+
+static VALUE Time_eql(VALUE self, VALUE rb_other) {
+    if (!rb_obj_is_kind_of(rb_other, rb_cSFTime)) {
+        return Qfalse;
+    }
+
+    return BOOL2RB(sfTime_asMicroseconds(((Time *) Get_Time_Struct(self))->time) ==
+                   sfTime_asMicroseconds(((Time *) Get_Time_Struct(rb_other))->time));
+}
+
+static VALUE Time_to_s(VALUE self) {
+    char buffer[64];
+
+    snprintf(buffer, sizeof(buffer), "%g s", sfTime_asSeconds(((Time *) Get_Time_Struct(self))->time));
+
+    return rb_str_new2(buffer);
+}
+
+void Init_Time(VALUE rb_module) {
+    rb_cSFTime = rb_define_class_under(rb_module, "Time", rb_cObject);
+
+    rb_include_module(rb_cSFTime, rb_mComparable);
+
+    rb_define_singleton_method(rb_cSFTime, "new", Time_new, -1);
+    rb_define_singleton_method(rb_cSFTime, "seconds", Time_seconds, 1);
+    rb_define_singleton_method(rb_cSFTime, "milliseconds", Time_milliseconds, 1);
+    rb_define_singleton_method(rb_cSFTime, "microseconds", Time_microseconds, 1);
+    rb_define_singleton_method(rb_cSFTime, "zero", Time_zero, 0);
+
+    rb_define_method(rb_cSFTime, "as_seconds", Time_as_seconds, 0);
+    rb_define_method(rb_cSFTime, "as_milliseconds", Time_as_milliseconds, 0);
+    rb_define_method(rb_cSFTime, "as_microseconds", Time_as_microseconds, 0);
+    rb_define_method(rb_cSFTime, "to_f", Time_to_f, 0);
+    rb_define_method(rb_cSFTime, "to_i", Time_to_i, 0);
+
+    rb_define_method(rb_cSFTime, "+", Time_add, 1);
+    rb_define_method(rb_cSFTime, "-", Time_sub, 1);
+    rb_define_method(rb_cSFTime, "*", Time_mul, 1);
+    rb_define_method(rb_cSFTime, "/", Time_div, 1);
+    rb_define_method(rb_cSFTime, "<=>", Time_cmp, 1);
+    rb_define_method(rb_cSFTime, "==", Time_eql, 1);
+    rb_define_method(rb_cSFTime, "to_s", Time_to_s, 0);
+}
+
+VALUE Get_Klass_Time(void) {
+    return rb_cSFTime;
+}
+
+void *Get_Time_Struct(VALUE self) {
+    Time *ptr;
+    TypedData_Get_Struct(self, Time, &Time_data_type, ptr);
+    return ptr;
+}
+
+sfTime time_from_rb(VALUE rb_time) {
+    if (rb_obj_is_kind_of(rb_time, rb_cSFTime)) {
+        return ((Time *) Get_Time_Struct(rb_time))->time;
+    }
+
+    if (RB_INTEGER_TYPE_P(rb_time)) {
+        return sfMicroseconds((int64_t) NUM2LL(rb_time));
+    }
+
+    if (RB_FLOAT_TYPE_P(rb_time) || RB_TYPE_P(rb_time, T_RATIONAL)) {
+        return sfSeconds((float) NUM2DBL(rb_time));
+    }
+
+    raise_invalid_argument_class(rb_cSFTime);
+
+    return sfTime_Zero;
+}
+
+VALUE time_to_rb(sfTime c_time) {
+    return Time_wrap(c_time);
+}

data/ext/system/time.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_SYSTEM_TIME_H
+#define SFML_RB_SYSTEM_TIME_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Time(VALUE rb_module);
+
+VALUE Get_Klass_Time(void);
+
+void *Get_Time_Struct(VALUE self);
+
+sfTime time_from_rb(VALUE rb_time);
+
+VALUE time_to_rb(sfTime c_time);
+
+#endif //SFML_RB_SYSTEM_TIME_H