sfml3-rb 0.0.1 → 0.2.2

data/ext/window/input_enums.c

@@ -0,0 +1,261 @@
+#include "window/input_enums.h"
+
+#include <ruby.h>
+#include <string.h>
+
+#include "core/exceptions.h"
+
+static const char *mouse_button_names[] = {"left", "right", "middle", "extra1", "extra2"};
+static const char *mouse_wheel_names[] = {"vertical", "horizontal"};
+static const char *joystick_axis_names[] = {"x", "y", "z", "r", "u", "v", "pov_x", "pov_y"};
+static const char *sensor_type_names[] = {
+    "accelerometer", "gyroscope", "magnetometer", "gravity", "user_acceleration", "orientation"
+};
+
+static const char *cursor_type_names[] = {
+    "arrow", "arrow_wait", "wait", "text", "hand", "size_horizontal", "size_vertical",
+    "size_top_left_bottom_right", "size_bottom_left_top_right", "size_left", "size_right",
+    "size_top", "size_bottom", "size_top_left", "size_bottom_right", "size_bottom_left",
+    "size_top_right", "size_all", "cross", "help", "not_allowed"
+};
+
+/* Returns the matching index, or -1. Integer arguments pass through unchanged
+   by the callers, so this only deals with symbols. */
+static int symbol_index(VALUE rb_symbol, const char *const *names, size_t count) {
+    const char *name;
+    size_t i;
+
+    if (!SYMBOL_P(rb_symbol)) {
+        return -1;
+    }
+
+    name = rb_id2name(SYM2ID(rb_symbol));
+
+    for (i = 0; i < count; i++) {
+        if (strcmp(name, names[i]) == 0) {
+            return (int) i;
+        }
+    }
+
+    return -1;
+}
+
+const char *mouse_button_name(sfMouseButton button) {
+    if (button >= 0 && button <= sfMouseButtonExtra2) {
+        return mouse_button_names[button];
+    }
+
+    return "left";
+}
+
+sfMouseButton mouse_button_from_rb(VALUE rb_button) {
+    int index;
+
+    if (RB_INTEGER_TYPE_P(rb_button)) {
+        return (sfMouseButton) NUM2INT(rb_button);
+    }
+
+    index = symbol_index(rb_button, mouse_button_names, 5);
+
+    if (index < 0) {
+        rb_raise(rb_eArgError, "unknown mouse button");
+    }
+
+    return (sfMouseButton) index;
+}
+
+const char *mouse_wheel_name(sfMouseWheel wheel) {
+    return (wheel == sfMouseHorizontalWheel) ? "horizontal" : "vertical";
+}
+
+sfMouseWheel mouse_wheel_from_rb(VALUE rb_wheel) {
+    int index;
+
+    if (RB_INTEGER_TYPE_P(rb_wheel)) {
+        return (sfMouseWheel) NUM2INT(rb_wheel);
+    }
+
+    index = symbol_index(rb_wheel, mouse_wheel_names, 2);
+
+    if (index < 0) {
+        rb_raise(rb_eArgError, "unknown mouse wheel");
+    }
+
+    return (sfMouseWheel) index;
+}
+
+const char *joystick_axis_name(sfJoystickAxis axis) {
+    if (axis >= 0 && axis <= sfJoystickPovY) {
+        return joystick_axis_names[axis];
+    }
+
+    return "x";
+}
+
+sfJoystickAxis joystick_axis_from_rb(VALUE rb_axis) {
+    int index;
+
+    if (RB_INTEGER_TYPE_P(rb_axis)) {
+        return (sfJoystickAxis) NUM2INT(rb_axis);
+    }
+
+    index = symbol_index(rb_axis, joystick_axis_names, 8);
+
+    if (index < 0) {
+        rb_raise(rb_eArgError, "unknown joystick axis");
+    }
+
+    return (sfJoystickAxis) index;
+}
+
+const char *sensor_type_name(sfSensorType type) {
+    if (type >= 0 && type <= sfSensorOrientation) {
+        return sensor_type_names[type];
+    }
+
+    return "accelerometer";
+}
+
+sfSensorType sensor_type_from_rb(VALUE rb_type) {
+    int index;
+
+    if (RB_INTEGER_TYPE_P(rb_type)) {
+        return (sfSensorType) NUM2INT(rb_type);
+    }
+
+    index = symbol_index(rb_type, sensor_type_names, 6);
+
+    if (index < 0) {
+        rb_raise(rb_eArgError, "unknown sensor type");
+    }
+
+    return (sfSensorType) index;
+}
+
+const char *cursor_type_name(sfCursorType type) {
+    if (type >= 0 && type <= sfCursorNotAllowed) {
+        return cursor_type_names[type];
+    }
+
+    return "arrow";
+}
+
+sfCursorType cursor_type_from_rb(VALUE rb_type) {
+    int index;
+
+    if (RB_INTEGER_TYPE_P(rb_type)) {
+        return (sfCursorType) NUM2INT(rb_type);
+    }
+
+    index = symbol_index(rb_type, cursor_type_names, 21);
+
+    if (index < 0) {
+        rb_raise(rb_eArgError, "unknown cursor type");
+    }
+
+    return (sfCursorType) index;
+}
+
+static uint32_t style_flag_from_symbol(VALUE rb_symbol) {
+    const char *name;
+
+    if (!SYMBOL_P(rb_symbol)) {
+        rb_raise(rb_eArgError, "expected a window style symbol");
+    }
+
+    name = rb_id2name(SYM2ID(rb_symbol));
+
+    if (strcmp(name, "none") == 0) {
+        return sfNone;
+    }
+
+    if (strcmp(name, "titlebar") == 0) {
+        return sfTitlebar;
+    }
+
+    if (strcmp(name, "resize") == 0) {
+        return sfResize;
+    }
+
+    if (strcmp(name, "close") == 0) {
+        return sfClose;
+    }
+
+    if (strcmp(name, "default") == 0) {
+        return sfDefaultStyle;
+    }
+
+    rb_raise(rb_eArgError, "unknown window style: %s", name);
+    return sfNone;
+}
+
+uint32_t window_style_from_rb(VALUE rb_style) {
+    uint32_t style = 0;
+
+    if (RB_INTEGER_TYPE_P(rb_style)) {
+        return (uint32_t) NUM2UINT(rb_style);
+    }
+
+    if (SYMBOL_P(rb_style)) {
+        return style_flag_from_symbol(rb_style);
+    }
+
+    if (RB_TYPE_P(rb_style, T_ARRAY)) {
+        for (long i = 0; i < RARRAY_LEN(rb_style); i++) {
+            style |= style_flag_from_symbol(rb_ary_entry(rb_style, i));
+        }
+
+        return style;
+    }
+
+    rb_raise(rb_eArgError, "expected a window style symbol or array of symbols");
+    return sfNone;
+}
+
+VALUE window_style_to_rb(uint32_t style) {
+    VALUE array = rb_ary_new();
+
+    if (style == sfNone) {
+        rb_ary_push(array, ID2SYM(rb_intern("none")));
+        return array;
+    }
+
+    if ((style & sfTitlebar) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("titlebar")));
+    }
+
+    if ((style & sfResize) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("resize")));
+    }
+
+    if ((style & sfClose) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("close")));
+    }
+
+    return array;
+}
+
+sfWindowState window_state_from_rb(VALUE rb_state) {
+    if (RB_INTEGER_TYPE_P(rb_state)) {
+        return (sfWindowState) NUM2INT(rb_state);
+    }
+
+    if (SYMBOL_P(rb_state)) {
+        const char *name = rb_id2name(SYM2ID(rb_state));
+
+        if (strcmp(name, "fullscreen") == 0) {
+            return sfFullscreen;
+        }
+
+        if (strcmp(name, "windowed") == 0) {
+            return sfWindowed;
+        }
+    }
+
+    rb_raise(rb_eArgError, "expected :windowed or :fullscreen");
+    return sfWindowed;
+}
+
+VALUE window_state_to_rb(sfWindowState state) {
+    return ID2SYM(rb_intern(state == sfFullscreen ? "fullscreen" : "windowed"));
+}

data/ext/window/input_enums.h

@@ -0,0 +1,36 @@
+#ifndef SFML_RB_WINDOW_INPUT_ENUMS_H
+#define SFML_RB_WINDOW_INPUT_ENUMS_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+const char *mouse_button_name(sfMouseButton button);
+
+sfMouseButton mouse_button_from_rb(VALUE rb_button);
+
+const char *mouse_wheel_name(sfMouseWheel wheel);
+
+sfMouseWheel mouse_wheel_from_rb(VALUE rb_wheel);
+
+const char *joystick_axis_name(sfJoystickAxis axis);
+
+sfJoystickAxis joystick_axis_from_rb(VALUE rb_axis);
+
+const char *sensor_type_name(sfSensorType type);
+
+sfSensorType sensor_type_from_rb(VALUE rb_type);
+
+const char *cursor_type_name(sfCursorType type);
+
+sfCursorType cursor_type_from_rb(VALUE rb_type);
+
+uint32_t window_style_from_rb(VALUE rb_style);
+
+VALUE window_style_to_rb(uint32_t style);
+
+sfWindowState window_state_from_rb(VALUE rb_state);
+
+VALUE window_state_to_rb(sfWindowState state);
+
+#endif //SFML_RB_WINDOW_INPUT_ENUMS_H

data/ext/window/joystick.c

@@ -0,0 +1,60 @@
+#include "window/joystick.h"
+
+#include <ruby.h>
+
+#include "window/input_enums.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE Joystick_is_connected(VALUE module, VALUE rb_joystick) {
+    return BOOL2RB(sfJoystick_isConnected(NUM2UINT(rb_joystick)));
+}
+
+static VALUE Joystick_get_button_count(VALUE module, VALUE rb_joystick) {
+    return UINT2NUM(sfJoystick_getButtonCount(NUM2UINT(rb_joystick)));
+}
+
+static VALUE Joystick_has_axis(VALUE module, VALUE rb_joystick, VALUE rb_axis) {
+    return BOOL2RB(sfJoystick_hasAxis(NUM2UINT(rb_joystick), joystick_axis_from_rb(rb_axis)));
+}
+
+static VALUE Joystick_is_button_pressed(VALUE module, VALUE rb_joystick, VALUE rb_button) {
+    return BOOL2RB(sfJoystick_isButtonPressed(NUM2UINT(rb_joystick), NUM2UINT(rb_button)));
+}
+
+static VALUE Joystick_get_axis_position(VALUE module, VALUE rb_joystick, VALUE rb_axis) {
+    return DBL2NUM(sfJoystick_getAxisPosition(NUM2UINT(rb_joystick), joystick_axis_from_rb(rb_axis)));
+}
+
+static VALUE Joystick_get_identification(VALUE module, VALUE rb_joystick) {
+    sfJoystickIdentification identification = sfJoystick_getIdentification(NUM2UINT(rb_joystick));
+    VALUE hash = rb_hash_new();
+
+    rb_hash_aset(hash, ID2SYM(rb_intern("name")),
+                 rb_str_new_cstr(identification.name != NULL ? identification.name : ""));
+    rb_hash_aset(hash, ID2SYM(rb_intern("vendor_id")), UINT2NUM(identification.vendorId));
+    rb_hash_aset(hash, ID2SYM(rb_intern("product_id")), UINT2NUM(identification.productId));
+
+    return hash;
+}
+
+static VALUE Joystick_update(VALUE module) {
+    sfJoystick_update();
+    return Qnil;
+}
+
+void Init_Joystick(VALUE rb_module) {
+    VALUE rb_mJoystick = rb_define_module_under(rb_module, "Joystick");
+
+    rb_define_const(rb_mJoystick, "COUNT", INT2NUM(sfJoystickCount));
+    rb_define_const(rb_mJoystick, "BUTTON_COUNT", INT2NUM(sfJoystickButtonCount));
+    rb_define_const(rb_mJoystick, "AXIS_COUNT", INT2NUM(sfJoystickAxisCount));
+
+    rb_define_module_function(rb_mJoystick, "connected?", Joystick_is_connected, 1);
+    rb_define_module_function(rb_mJoystick, "button_count", Joystick_get_button_count, 1);
+    rb_define_module_function(rb_mJoystick, "has_axis?", Joystick_has_axis, 2);
+    rb_define_module_function(rb_mJoystick, "button_pressed?", Joystick_is_button_pressed, 2);
+    rb_define_module_function(rb_mJoystick, "axis_position", Joystick_get_axis_position, 2);
+    rb_define_module_function(rb_mJoystick, "identification", Joystick_get_identification, 1);
+    rb_define_module_function(rb_mJoystick, "update!", Joystick_update, 0);
+}

data/ext/window/joystick.h

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

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

@@ -1,9 +1,12 @@
-#include "ext/klass/keyboard.h"
+#include "window/keyboard.h"
 
 #include <stddef.h>
+#include <ruby.h>
 #include <string.h>
 
-#include "ext/sfml.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "core/sfml.h"
 
 /* Indexed by sfKeyCode rather than by position: if upstream reorders or
    removes a key, this fails to compile instead of silently renaming every
@@ -133,3 +136,72 @@ const char *get_key_event(unsigned int key) {
 
     return "";
 }
+
+static int Keyboard_key_code(VALUE rb_key) {
+    int code;
+
+    if (SYMBOL_P(rb_key)) {
+        const char *name = rb_id2name(SYM2ID(rb_key));
+
+        code = find_key(name);
+
+        if (code < 0) {
+            rb_raise(rb_eArgError, "unknown key: %s", name);
+        }
+
+        return code;
+    }
+
+    if (RB_TYPE_P(rb_key, T_STRING)) {
+        const char *name = StringValueCStr(rb_key);
+
+        code = find_key(name);
+
+        if (code < 0) {
+            rb_raise(rb_eArgError, "unknown key: %s", name);
+        }
+
+        return code;
+    }
+
+    return NUM2INT(rb_key);
+}
+
+static VALUE Keyboard_pressed_p(VALUE module, VALUE rb_key) {
+    return BOOL2RB(sfKeyboard_isKeyPressed((sfKeyCode) Keyboard_key_code(rb_key)));
+}
+
+static VALUE Keyboard_scancode_pressed_p(VALUE module, VALUE rb_scancode) {
+    return BOOL2RB(sfKeyboard_isScancodePressed((sfScancode) NUM2INT(rb_scancode)));
+}
+
+static VALUE Keyboard_localize(VALUE module, VALUE rb_scancode) {
+    return ID2SYM(rb_intern(get_key_event((unsigned int) sfKeyboard_localize((sfScancode) NUM2INT(rb_scancode)))));
+}
+
+static VALUE Keyboard_delocalize(VALUE module, VALUE rb_key) {
+    return INT2NUM(sfKeyboard_delocalize((sfKeyCode) Keyboard_key_code(rb_key)));
+}
+
+static VALUE Keyboard_description(VALUE module, VALUE rb_scancode) {
+    const char *description = sfKeyboard_getDescription((sfScancode) NUM2INT(rb_scancode));
+
+    return rb_str_new_cstr(description != NULL ? description : "");
+}
+
+static VALUE Keyboard_set_virtual_keyboard_visible(VALUE module, VALUE rb_visible) {
+    sfKeyboard_setVirtualKeyboardVisible(RTEST(rb_visible));
+    return rb_visible;
+}
+
+void Init_Keyboard(VALUE rb_module) {
+    VALUE rb_mKeyboard = rb_define_module_under(rb_module, "Keyboard");
+
+    rb_define_module_function(rb_mKeyboard, "pressed?", Keyboard_pressed_p, 1);
+    rb_define_module_function(rb_mKeyboard, "scancode_pressed?", Keyboard_scancode_pressed_p, 1);
+    rb_define_module_function(rb_mKeyboard, "localize", Keyboard_localize, 1);
+    rb_define_module_function(rb_mKeyboard, "delocalize", Keyboard_delocalize, 1);
+    rb_define_module_function(rb_mKeyboard, "description", Keyboard_description, 1);
+    rb_define_module_function(rb_mKeyboard, "virtual_keyboard_visible=",
+                              Keyboard_set_virtual_keyboard_visible, 1);
+}

data/ext/window/keyboard.h

@@ -0,0 +1,12 @@
+#ifndef SFML_RB_WINDOW_KEYBOARD_H
+#define SFML_RB_WINDOW_KEYBOARD_H
+
+#include <ruby.h>
+
+void Init_Keyboard(VALUE rb_module);
+
+int find_key(const char *name);
+
+const char *get_key_event(unsigned int key);
+
+#endif //SFML_RB_WINDOW_KEYBOARD_H

data/ext/window/mouse.c

@@ -0,0 +1,70 @@
+#include "window/mouse.h"
+
+#include <ruby.h>
+
+#include "window/input_enums.h"
+#include "window/window.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+/* nil means desktop-relative. CSFML gives sfRenderWindow its own entry points,
+   so a window argument never has to be cast down to sfWindowBase. */
+static const sfRenderWindow* Mouse_relative_window(VALUE rb_window) {
+    if (NIL_P(rb_window)) {
+        return NULL;
+    }
+
+    if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        raise_invalid_argument_class(Get_Klass_Window());
+    }
+
+    return Get_Window_Struct(rb_window);
+}
+
+static VALUE Mouse_is_button_pressed(VALUE module, VALUE rb_button) {
+    return BOOL2RB(sfMouse_isButtonPressed(mouse_button_from_rb(rb_button)));
+}
+
+static VALUE Mouse_get_position(int argc, VALUE* argv, VALUE module) {
+    VALUE rb_window;
+    sfVector2i position;
+
+    rb_scan_args(argc, argv, "01", &rb_window);
+    if (NIL_P(rb_window)) {
+        position = sfMouse_getPosition(NULL);
+    } else {
+        position = sfMouse_getPositionRenderWindow(Mouse_relative_window(rb_window));
+    }
+
+    return vec2f_to_rb((sfVector2f){(float)position.x, (float)position.y});
+}
+
+static VALUE Mouse_set_position(int argc, VALUE* argv, VALUE module) {
+    VALUE rb_position, rb_window;
+
+    rb_scan_args(argc, argv, "11", &rb_position, &rb_window);
+    if (NIL_P(rb_window)) {
+        sfMouse_setPosition(vec2i_from_rb(rb_position), NULL);
+    } else {
+        sfMouse_setPositionRenderWindow(vec2i_from_rb(rb_position),
+                                        Mouse_relative_window(rb_window));
+    }
+
+    return rb_position;
+}
+
+static VALUE Mouse_position_eq(VALUE module, VALUE rb_position) {
+    return Mouse_set_position(1, &rb_position, module);
+}
+
+void Init_Mouse(VALUE rb_module) {
+    VALUE rb_mMouse = rb_define_module_under(rb_module, "Mouse");
+
+    rb_define_module_function(rb_mMouse, "button_pressed?", Mouse_is_button_pressed, 1);
+    rb_define_module_function(rb_mMouse, "pressed?", Mouse_is_button_pressed, 1);
+    rb_define_module_function(rb_mMouse, "position", Mouse_get_position, -1);
+    rb_define_module_function(rb_mMouse, "set_position", Mouse_set_position, -1);
+    rb_define_module_function(rb_mMouse, "position=", Mouse_position_eq, 1);
+}

data/ext/window/mouse.h

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

data/ext/window/sensor.c

@@ -0,0 +1,30 @@
+#include "window/sensor.h"
+
+#include <ruby.h>
+
+#include "window/input_enums.h"
+#include "system/vec3.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE Sensor_is_available(VALUE module, VALUE rb_type) {
+    return BOOL2RB(sfSensor_isAvailable(sensor_type_from_rb(rb_type)));
+}
+
+static VALUE Sensor_set_enabled(VALUE module, VALUE rb_type, VALUE rb_enabled) {
+    sfSensor_setEnabled(sensor_type_from_rb(rb_type), RTEST(rb_enabled));
+    return rb_enabled;
+}
+
+static VALUE Sensor_get_value(VALUE module, VALUE rb_type) {
+    return vec3f_to_rb(sfSensor_getValue(sensor_type_from_rb(rb_type)));
+}
+
+void Init_Sensor(VALUE rb_module) {
+    VALUE rb_mSensor = rb_define_module_under(rb_module, "Sensor");
+
+    rb_define_module_function(rb_mSensor, "available?", Sensor_is_available, 1);
+    rb_define_module_function(rb_mSensor, "set_enabled", Sensor_set_enabled, 2);
+    rb_define_module_function(rb_mSensor, "enabled=", Sensor_set_enabled, 2);
+    rb_define_module_function(rb_mSensor, "value", Sensor_get_value, 1);
+}

data/ext/window/sensor.h

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

data/ext/window/touch.c

@@ -0,0 +1,49 @@
+#include "window/touch.h"
+
+#include <ruby.h>
+
+#include "window/window.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+/* nil means desktop-relative. CSFML gives sfRenderWindow its own entry point,
+   so a window argument never has to be cast down to sfWindowBase. */
+static const sfRenderWindow* Touch_relative_window(VALUE rb_window) {
+    if (NIL_P(rb_window)) {
+        return NULL;
+    }
+
+    if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        raise_invalid_argument_class(Get_Klass_Window());
+    }
+
+    return Get_Window_Struct(rb_window);
+}
+
+static VALUE Touch_is_down(VALUE module, VALUE rb_finger) {
+    return BOOL2RB(sfTouch_isDown(NUM2UINT(rb_finger)));
+}
+
+static VALUE Touch_get_position(int argc, VALUE* argv, VALUE module) {
+    VALUE rb_finger, rb_window;
+    sfVector2i position;
+
+    rb_scan_args(argc, argv, "11", &rb_finger, &rb_window);
+    if (NIL_P(rb_window)) {
+        position = sfTouch_getPosition(NUM2UINT(rb_finger), NULL);
+    } else {
+        position =
+            sfTouch_getPositionRenderWindow(NUM2UINT(rb_finger), Touch_relative_window(rb_window));
+    }
+
+    return vec2f_to_rb((sfVector2f){(float)position.x, (float)position.y});
+}
+
+void Init_Touch(VALUE rb_module) {
+    VALUE rb_mTouch = rb_define_module_under(rb_module, "Touch");
+
+    rb_define_module_function(rb_mTouch, "down?", Touch_is_down, 1);
+    rb_define_module_function(rb_mTouch, "position", Touch_get_position, -1);
+}

data/ext/window/touch.h

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