sfml3-rb 0.0.1 → 0.2.2

data/ext/window/context.h

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

data/ext/window/context_settings.c

@@ -0,0 +1,220 @@
+#include "window/context_settings.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfContextSettings settings;
+} ContextSettings;
+
+static VALUE rb_cContextSettings;
+
+static void ContextSettings_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t ContextSettings_data_type = {
+    .wrap_struct_name = "SFML::ContextSettings",
+    .function = {.dmark = NULL, .dfree = ContextSettings_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE ContextSettings_wrap(sfContextSettings settings) {
+    ContextSettings *ptr = malloc(sizeof(ContextSettings));
+
+    ptr->settings = settings;
+
+    return TypedData_Wrap_Struct(rb_cContextSettings, &ContextSettings_data_type, ptr);
+}
+
+static const char *context_flag_name(VALUE value) {
+    if (SYMBOL_P(value)) {
+        return rb_id2name(SYM2ID(value));
+    }
+
+    return StringValueCStr(value);
+}
+
+static VALUE ContextSettings_new(int argc, VALUE *argv, VALUE klass) {    sfContextSettings settings = {0, 0, 0, 1, 1, sfContextDefault, false};
+    VALUE rb_depth, rb_stencil, rb_antialiasing, rb_major, rb_minor, rb_flags, rb_srgb;
+    VALUE self;
+
+    rb_scan_args(argc, argv, "07", &rb_depth, &rb_stencil, &rb_antialiasing, &rb_major, &rb_minor, &rb_flags,
+                 &rb_srgb);
+
+    if (!NIL_P(rb_depth)) {
+        settings.depthBits = (unsigned int) NUM2UINT(rb_depth);
+    }
+
+    if (!NIL_P(rb_stencil)) {
+        settings.stencilBits = (unsigned int) NUM2UINT(rb_stencil);
+    }
+
+    if (!NIL_P(rb_antialiasing)) {
+        settings.antiAliasingLevel = (unsigned int) NUM2UINT(rb_antialiasing);
+    }
+
+    if (!NIL_P(rb_major)) {
+        settings.majorVersion = (unsigned int) NUM2UINT(rb_major);
+    }
+
+    if (!NIL_P(rb_minor)) {
+        settings.minorVersion = (unsigned int) NUM2UINT(rb_minor);
+    }
+
+    if (!NIL_P(rb_flags)) {
+        uint32_t flags = 0;
+
+        if (RB_INTEGER_TYPE_P(rb_flags)) {
+            flags = (uint32_t) NUM2UINT(rb_flags);
+        } else if (SYMBOL_P(rb_flags) || RB_TYPE_P(rb_flags, T_STRING)) {
+            rb_flags = rb_ary_new_from_args(1, rb_flags);
+        }
+
+        if (RB_TYPE_P(rb_flags, T_ARRAY)) {
+            for (long i = 0; i < RARRAY_LEN(rb_flags); i++) {
+                VALUE entry = rb_ary_entry(rb_flags, i);
+                const char *name = context_flag_name(entry);
+
+                if (strcmp(name, "core") == 0) {
+                    flags |= sfContextCore;
+                } else if (strcmp(name, "debug") == 0) {
+                    flags |= sfContextDebug;
+                } else if (strcmp(name, "default") != 0) {
+                    rb_raise(rb_eArgError, "unknown context attribute: %s", name);
+                }
+            }
+        }
+
+        settings.attributeFlags = flags;
+    }
+
+    if (!NIL_P(rb_srgb)) {
+        settings.sRgbCapable = RTEST(rb_srgb);
+    }
+
+    self = ContextSettings_wrap(settings);
+
+    return self;
+}
+
+#define CONTEXT_SETTINGS_UINT_ACCESSOR(name, field)                          \
+    static VALUE ContextSettings_get_##name(VALUE self) {                    \
+        return UINT2NUM(((ContextSettings *) Get_ContextSettings_Struct(self))->settings.field); \
+    }                                                                        \
+    static VALUE ContextSettings_set_##name(VALUE self, VALUE rb_value) {     \
+        ((ContextSettings *) Get_ContextSettings_Struct(self))->settings.field = (unsigned int) NUM2UINT(rb_value); \
+        return rb_value;                                                     \
+    }
+
+CONTEXT_SETTINGS_UINT_ACCESSOR(depth_bits, depthBits)
+CONTEXT_SETTINGS_UINT_ACCESSOR(stencil_bits, stencilBits)
+CONTEXT_SETTINGS_UINT_ACCESSOR(antialiasing_level, antiAliasingLevel)
+CONTEXT_SETTINGS_UINT_ACCESSOR(major_version, majorVersion)
+CONTEXT_SETTINGS_UINT_ACCESSOR(minor_version, minorVersion)
+
+static VALUE ContextSettings_get_attribute_flags(VALUE self) {
+    uint32_t flags = ((ContextSettings *) Get_ContextSettings_Struct(self))->settings.attributeFlags;
+    VALUE array = rb_ary_new();
+
+    if ((flags & sfContextCore) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("core")));
+    }
+
+    if ((flags & sfContextDebug) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("debug")));
+    }
+
+    if (RARRAY_LEN(array) == 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("default")));
+    }
+
+    return array;
+}
+
+static VALUE ContextSettings_set_attribute_flags(VALUE self, VALUE rb_value) {
+    ContextSettings *settings = Get_ContextSettings_Struct(self);
+    uint32_t flags = 0;
+
+    if (RB_INTEGER_TYPE_P(rb_value)) {
+        flags = (uint32_t) NUM2UINT(rb_value);
+    } else {
+        VALUE array = RB_TYPE_P(rb_value, T_ARRAY) ? rb_value : rb_ary_new_from_args(1, rb_value);
+
+        for (long i = 0; i < RARRAY_LEN(array); i++) {
+            VALUE entry = rb_ary_entry(array, i);
+            const char *name = context_flag_name(entry);
+
+            if (strcmp(name, "core") == 0) {
+                flags |= sfContextCore;
+            } else if (strcmp(name, "debug") == 0) {
+                flags |= sfContextDebug;
+            }
+        }
+    }
+
+    settings->settings.attributeFlags = flags;
+
+    return rb_value;
+}
+
+static VALUE ContextSettings_get_srgb(VALUE self) {
+    return BOOL2RB(((ContextSettings *) Get_ContextSettings_Struct(self))->settings.sRgbCapable);
+}
+
+static VALUE ContextSettings_set_srgb(VALUE self, VALUE rb_value) {
+    ((ContextSettings *) Get_ContextSettings_Struct(self))->settings.sRgbCapable = RTEST(rb_value);
+    return rb_value;
+}
+
+void Init_ContextSettings(VALUE rb_module) {
+    rb_cContextSettings = rb_define_class_under(rb_module, "ContextSettings", rb_cObject);
+
+    rb_define_singleton_method(rb_cContextSettings, "new", ContextSettings_new, -1);
+
+    rb_define_method(rb_cContextSettings, "depth_bits", ContextSettings_get_depth_bits, 0);
+    rb_define_method(rb_cContextSettings, "stencil_bits", ContextSettings_get_stencil_bits, 0);
+    rb_define_method(rb_cContextSettings, "antialiasing_level", ContextSettings_get_antialiasing_level, 0);
+    rb_define_method(rb_cContextSettings, "major_version", ContextSettings_get_major_version, 0);
+    rb_define_method(rb_cContextSettings, "minor_version", ContextSettings_get_minor_version, 0);
+    rb_define_method(rb_cContextSettings, "attribute_flags", ContextSettings_get_attribute_flags, 0);
+    rb_define_method(rb_cContextSettings, "srgb_capable?", ContextSettings_get_srgb, 0);
+
+    rb_define_method(rb_cContextSettings, "depth_bits=", ContextSettings_set_depth_bits, 1);
+    rb_define_method(rb_cContextSettings, "stencil_bits=", ContextSettings_set_stencil_bits, 1);
+    rb_define_method(rb_cContextSettings, "antialiasing_level=", ContextSettings_set_antialiasing_level, 1);
+    rb_define_method(rb_cContextSettings, "major_version=", ContextSettings_set_major_version, 1);
+    rb_define_method(rb_cContextSettings, "minor_version=", ContextSettings_set_minor_version, 1);
+    rb_define_method(rb_cContextSettings, "attribute_flags=", ContextSettings_set_attribute_flags, 1);
+    rb_define_method(rb_cContextSettings, "srgb_capable=", ContextSettings_set_srgb, 1);
+}
+
+VALUE Get_Klass_ContextSettings(void) {
+    return rb_cContextSettings;
+}
+
+void *Get_ContextSettings_Struct(VALUE self) {
+    ContextSettings *ptr;
+    TypedData_Get_Struct(self, ContextSettings, &ContextSettings_data_type, ptr);
+    return ptr;
+}
+
+sfContextSettings context_settings_from_rb(VALUE rb_settings) {
+    if (NIL_P(rb_settings)) {
+        return (sfContextSettings) {0, 0, 0, 1, 1, sfContextDefault, false};
+    }
+
+    if (!rb_obj_is_kind_of(rb_settings, rb_cContextSettings)) {
+        raise_invalid_argument_class(rb_cContextSettings);
+    }
+
+    return ((ContextSettings *) Get_ContextSettings_Struct(rb_settings))->settings;
+}
+
+VALUE context_settings_to_rb(sfContextSettings settings) {
+    return ContextSettings_wrap(settings);
+}

data/ext/window/context_settings.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_WINDOW_CONTEXT_SETTINGS_H
+#define SFML_RB_WINDOW_CONTEXT_SETTINGS_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_ContextSettings(VALUE rb_module);
+
+VALUE Get_Klass_ContextSettings(void);
+
+void *Get_ContextSettings_Struct(VALUE self);
+
+sfContextSettings context_settings_from_rb(VALUE rb_settings);
+
+VALUE context_settings_to_rb(sfContextSettings settings);
+
+#endif //SFML_RB_WINDOW_CONTEXT_SETTINGS_H

data/ext/window/cursor.c

@@ -0,0 +1,56 @@
+#include "window/cursor.h"
+
+#include <ruby.h>
+
+#include "window/input_enums.h"
+#include "system/vec2.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE rb_cCursor;
+
+static void Cursor_free(void *ptr) {
+    sfCursor_destroy(ptr);
+}
+
+static const rb_data_type_t Cursor_data_type = {
+    .wrap_struct_name = "SFML::Cursor",
+    .function = {.dmark = NULL, .dfree = Cursor_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Cursor_wrap(sfCursor *cursor) {
+    if (cursor == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create cursor");
+    }
+
+    return TypedData_Wrap_Struct(rb_cCursor, &Cursor_data_type, cursor);
+}
+
+static VALUE Cursor_from_pixels(VALUE klass, VALUE rb_pixels, VALUE rb_size, VALUE rb_hotspot) {
+    StringValue(rb_pixels);
+
+    return Cursor_wrap(sfCursor_createFromPixels((const uint8_t *) RSTRING_PTR(rb_pixels), vec2u_from_rb(rb_size),
+                                                 vec2u_from_rb(rb_hotspot)));
+}
+
+static VALUE Cursor_from_system(VALUE klass, VALUE rb_type) {
+    return Cursor_wrap(sfCursor_createFromSystem(cursor_type_from_rb(rb_type)));
+}
+
+void Init_Cursor(VALUE rb_module) {
+    rb_cCursor = rb_define_class_under(rb_module, "Cursor", rb_cObject);
+
+    rb_define_singleton_method(rb_cCursor, "from_pixels", Cursor_from_pixels, 3);
+    rb_define_singleton_method(rb_cCursor, "from_system", Cursor_from_system, 1);
+}
+
+VALUE Get_Klass_Cursor(void) {
+    return rb_cCursor;
+}
+
+const sfCursor *Get_Cursor_Struct(VALUE self) {
+    sfCursor *ptr;
+    TypedData_Get_Struct(self, sfCursor, &Cursor_data_type, ptr);
+    return ptr;
+}

data/ext/window/cursor.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_WINDOW_CURSOR_H
+#define SFML_RB_WINDOW_CURSOR_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Cursor(VALUE rb_module);
+
+VALUE Get_Klass_Cursor(void);
+
+const sfCursor *Get_Cursor_Struct(VALUE self);
+
+#endif //SFML_RB_WINDOW_CURSOR_H

data/ext/window/event.c

@@ -0,0 +1,216 @@
+#include "window/event.h"
+
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "window/event_name.h"
+#include "window/keyboard.h"
+#include "window/input_enums.h"
+#include "system/vec2.h"
+#include "system/vec3.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE rb_cEvent;
+
+static sfEvent *Event_create() {
+    return malloc(sizeof(sfEvent));
+}
+
+static void Event_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Event_data_type = {
+    .wrap_struct_name = "SFML::Event",
+    .function = {.dmark = NULL, .dfree = Event_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Event_new(VALUE klass) {
+    VALUE self;
+    sfEvent *event;
+
+    event = Event_create();
+    self = TypedData_Wrap_Struct(klass, &Event_data_type, event);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE Event_init(VALUE self) {
+    return self;
+}
+
+static VALUE Event_type(VALUE self) {
+    return rb_str_new2(get_event_name(Get_Event_Struct(self)->type));
+}
+
+static VALUE Event_get_size(VALUE self) {
+    sfVector2u size = Get_Event_Struct(self)->size.size;
+
+    return vec2f_to_rb((sfVector2f) {(float) size.x, (float) size.y});
+}
+
+static VALUE Event_get_key(VALUE self) {
+    sfKeyEvent *event = &Get_Event_Struct(self)->key;
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("code")), ID2SYM(rb_intern(get_key_event(event->code))));
+    rb_hash_aset(hash, ID2SYM(rb_intern("scancode")), rb_str_new2(sfKeyboard_getDescription(event->scancode)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("alt")), BOOL2RB(event->alt));
+    rb_hash_aset(hash, ID2SYM(rb_intern("control")), BOOL2RB(event->control));
+    rb_hash_aset(hash, ID2SYM(rb_intern("shift")), BOOL2RB(event->shift));
+    rb_hash_aset(hash, ID2SYM(rb_intern("system")), BOOL2RB(event->system));
+
+    return hash;
+}
+
+static VALUE unicode_to_utf8(uint32_t code) {
+    char buffer[5];
+    int length = 0;
+
+    if (code < 0x80) {
+        buffer[length++] = (char) code;
+    } else if (code < 0x800) {
+        buffer[length++] = (char) (0xC0 | (code >> 6));
+        buffer[length++] = (char) (0x80 | (code & 0x3F));
+    } else if (code < 0x10000) {
+        buffer[length++] = (char) (0xE0 | (code >> 12));
+        buffer[length++] = (char) (0x80 | ((code >> 6) & 0x3F));
+        buffer[length++] = (char) (0x80 | (code & 0x3F));
+    } else {
+        buffer[length++] = (char) (0xF0 | (code >> 18));
+        buffer[length++] = (char) (0x80 | ((code >> 12) & 0x3F));
+        buffer[length++] = (char) (0x80 | ((code >> 6) & 0x3F));
+        buffer[length++] = (char) (0x80 | (code & 0x3F));
+    }
+
+    return rb_utf8_str_new(buffer, length);
+}
+
+static VALUE Event_get_text(VALUE self) {
+    return unicode_to_utf8(Get_Event_Struct(self)->text.unicode);
+}
+
+static VALUE Event_get_mouse_move(VALUE self) {
+    sfVector2i position = Get_Event_Struct(self)->mouseMove.position;
+
+    return vec2f_to_rb((sfVector2f) {(float) position.x, (float) position.y});
+}
+
+static VALUE Event_get_mouse_move_raw(VALUE self) {
+    sfVector2i delta = Get_Event_Struct(self)->mouseMoveRaw.delta;
+
+    return vec2f_to_rb((sfVector2f) {(float) delta.x, (float) delta.y});
+}
+
+static VALUE Event_get_mouse_button(VALUE self) {
+    sfMouseButtonEvent *event = &Get_Event_Struct(self)->mouseButton;
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("button")), ID2SYM(rb_intern(mouse_button_name(event->button))));
+    rb_hash_aset(hash, ID2SYM(rb_intern("position")),
+                 vec2f_to_rb((sfVector2f) {(float) event->position.x, (float) event->position.y}));
+
+    return hash;
+}
+
+static VALUE Event_get_mouse_wheel_scroll(VALUE self) {
+    sfMouseWheelScrollEvent *event = &Get_Event_Struct(self)->mouseWheelScroll;
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("wheel")), ID2SYM(rb_intern(mouse_wheel_name(event->wheel))));
+    rb_hash_aset(hash, ID2SYM(rb_intern("delta")), DBL2NUM(event->delta));
+    rb_hash_aset(hash, ID2SYM(rb_intern("position")),
+                 vec2f_to_rb((sfVector2f) {(float) event->position.x, (float) event->position.y}));
+
+    return hash;
+}
+
+static VALUE Event_get_joystick_move(VALUE self) {
+    sfJoystickMoveEvent *event = &Get_Event_Struct(self)->joystickMove;
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("joystick_id")), UINT2NUM(event->joystickId));
+    rb_hash_aset(hash, ID2SYM(rb_intern("axis")), ID2SYM(rb_intern(joystick_axis_name(event->axis))));
+    rb_hash_aset(hash, ID2SYM(rb_intern("position")), DBL2NUM(event->position));
+
+    return hash;
+}
+
+static VALUE Event_get_joystick_button(VALUE self) {
+    sfJoystickButtonEvent *event = &Get_Event_Struct(self)->joystickButton;
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("joystick_id")), UINT2NUM(event->joystickId));
+    rb_hash_aset(hash, ID2SYM(rb_intern("button")), UINT2NUM(event->button));
+
+    return hash;
+}
+
+static VALUE Event_get_joystick_connect(VALUE self) {
+    sfEvent *event = Get_Event_Struct(self);
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("joystick_id")), UINT2NUM(event->joystickConnect.joystickId));
+    rb_hash_aset(hash, ID2SYM(rb_intern("connected")), BOOL2RB(event->type == sfEvtJoystickConnected));
+
+    return hash;
+}
+
+static VALUE Event_get_touch(VALUE self) {
+    sfTouchEvent *event = &Get_Event_Struct(self)->touch;
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("finger")), UINT2NUM(event->finger));
+    rb_hash_aset(hash, ID2SYM(rb_intern("position")),
+                 vec2f_to_rb((sfVector2f) {(float) event->position.x, (float) event->position.y}));
+
+    return hash;
+}
+
+static VALUE Event_get_sensor(VALUE self) {
+    sfSensorEvent *event = &Get_Event_Struct(self)->sensor;
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("type")), ID2SYM(rb_intern(sensor_type_name(event->sensorType))));
+    rb_hash_aset(hash, ID2SYM(rb_intern("value")), vec3f_to_rb(event->value));
+
+    return hash;
+}
+
+void Init_Event(VALUE rb_module) {
+    rb_cEvent = rb_define_class_under(rb_module, "Event", rb_cObject);
+
+    rb_define_singleton_method(rb_cEvent, "new", Event_new, 0);
+
+    rb_define_method(rb_cEvent, "initialize", Event_init, 0);
+
+    rb_define_method(rb_cEvent, "type", Event_type, 0);
+    rb_define_method(rb_cEvent, "size", Event_get_size, 0);
+    rb_define_method(rb_cEvent, "key", Event_get_key, 0);
+    rb_define_method(rb_cEvent, "text", Event_get_text, 0);
+    rb_define_method(rb_cEvent, "mouse_move", Event_get_mouse_move, 0);
+    rb_define_method(rb_cEvent, "mouse_move_raw", Event_get_mouse_move_raw, 0);
+    rb_define_method(rb_cEvent, "mouse_button", Event_get_mouse_button, 0);
+    rb_define_method(rb_cEvent, "mouse_wheel_scroll", Event_get_mouse_wheel_scroll, 0);
+    rb_define_method(rb_cEvent, "mouse_wheel", Event_get_mouse_wheel_scroll, 0);
+    rb_define_method(rb_cEvent, "joystick_move", Event_get_joystick_move, 0);
+    rb_define_method(rb_cEvent, "joystick_button", Event_get_joystick_button, 0);
+    rb_define_method(rb_cEvent, "joystick_connect", Event_get_joystick_connect, 0);
+    rb_define_method(rb_cEvent, "touch", Event_get_touch, 0);
+    rb_define_method(rb_cEvent, "sensor", Event_get_sensor, 0);
+}
+
+sfEvent *Get_Event_Struct(VALUE self) {
+    sfEvent *ptr;
+    TypedData_Get_Struct(self, sfEvent, &Event_data_type, ptr);
+    return ptr;
+}
+
+VALUE Get_Klass_Event() {
+    return rb_cEvent;
+}

data/ext/window/event.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_WINDOW_EVENT_H
+#define SFML_RB_WINDOW_EVENT_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Event(VALUE rb_module);
+
+sfEvent *Get_Event_Struct(VALUE self);
+
+VALUE Get_Klass_Event();
+
+#endif //SFML_RB_WINDOW_EVENT_H

data/ext/{event_name.c → window/event_name.c}

@@ -1,8 +1,8 @@
-#include "ext/klass/event/event_name.h"
+#include "window/event_name.h"
 
 #include <stddef.h>
 
-#include "ext/sfml.h"
+#include "core/sfml.h"
 
 /* Indexed by sfEventType rather than by position. The CSFML 2.x table was
    positional, which broke silently under CSFML 3: the enum still has 24

data/ext/window/event_name.h

@@ -0,0 +1,8 @@
+#ifndef SFML_RB_WINDOW_EVENT_NAME_H
+#define SFML_RB_WINDOW_EVENT_NAME_H
+
+#include <stddef.h>
+
+const char *get_event_name(size_t name);
+
+#endif //SFML_RB_WINDOW_EVENT_NAME_H