sfml3-rb 0.3.0 → 0.3.1

data/ext/system/clock.c

@@ -36,6 +36,16 @@ static VALUE Clock_new_from(VALUE klass, sfClock* clock) {
     return self;
 }
 
+static VALUE Clock_alloc(VALUE klass) {
+    sfClock* clock = Clock_create();
+
+    if (clock == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate clock");
+    }
+
+    return TypedData_Wrap_Struct(klass, &Clock_data_type, clock);
+}
+
 /* call-seq:
  *   Clock.new -> Clock
  *
@@ -43,10 +53,6 @@ static VALUE Clock_new_from(VALUE klass, sfClock* clock) {
  *
  * @return [Clock]
  */
-static VALUE Clock_new(VALUE klass) {
-    return Clock_new_from(klass, Clock_create());
-}
-
 static VALUE Clock_init(VALUE self) {
     return self;
 }
@@ -133,7 +139,7 @@ static VALUE Clock_copy(VALUE self) {
 void Init_Clock(VALUE rb_mSFML) {
     rb_cClock = rb_define_class_under(rb_mSFML, "Clock", rb_cObject);
 
-    rb_define_singleton_method(rb_cClock, "new", Clock_new, 0);
+    rb_define_alloc_func(rb_cClock, Clock_alloc);
 
     // methods
     rb_define_method(rb_cClock, "initialize", Clock_init, 0);

data/ext/system/input_stream.c

@@ -190,6 +190,23 @@ static int64_t InputStream_get_size(void* userData) {
     return ctx.result;
 }
 
+static VALUE InputStream_alloc(VALUE klass) {
+    InputStream* stream = malloc(sizeof(InputStream));
+
+    if (stream == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate input stream");
+    }
+
+    stream->rb_io = Qnil;
+    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;
+
+    return TypedData_Wrap_Struct(klass, &InputStream_data_type, stream);
+}
+
 /* call-seq:
  *   InputStream.new(io) -> InputStream
  *
@@ -200,24 +217,16 @@ static int64_t InputStream_get_size(void* userData) {
  * @return [InputStream]
  * @raise [ArgumentError] if +io+ does not respond to +#read+
  */
-static VALUE InputStream_new(VALUE klass, VALUE rb_io) {
-    VALUE self;
+static VALUE InputStream_initialize(VALUE self, VALUE rb_io) {
     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));
+    TypedData_Get_Struct(self, InputStream, &InputStream_data_type, stream);
 
     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;
 }
@@ -240,7 +249,8 @@ static VALUE InputStream_get_io(VALUE self) {
 void Init_InputStream(VALUE rb_mSFML) {
     rb_cInputStream = rb_define_class_under(rb_mSFML, "InputStream", rb_cObject);
 
-    rb_define_singleton_method(rb_cInputStream, "new", InputStream_new, 1);
+    rb_define_alloc_func(rb_cInputStream, InputStream_alloc);
+    rb_define_method(rb_cInputStream, "initialize", InputStream_initialize, 1);
 
     rb_define_method(rb_cInputStream, "io", InputStream_get_io, 0);
 }

data/ext/system/time.c

@@ -33,6 +33,18 @@ static VALUE Time_wrap(sfTime time) {
     return TypedData_Wrap_Struct(rb_cSFTime, &Time_data_type, ptr);
 }
 
+static VALUE Time_alloc(VALUE klass) {
+    Time* ptr = malloc(sizeof(Time));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate time");
+    }
+
+    ptr->time = sfTime_Zero;
+
+    return TypedData_Wrap_Struct(klass, &Time_data_type, ptr);
+}
+
 /* call-seq:
  *   Time.new             -> Time(0)
  *   Time.new(seconds)    -> Time
@@ -46,9 +58,7 @@ static VALUE Time_wrap(sfTime time) {
  * @return [Time]
  * @raise [ArgumentError] if given more than one argument
  */
-static VALUE Time_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE self;
-    Time* ptr;
+static VALUE Time_initialize(int argc, VALUE* argv, VALUE self) {
     sfTime time = sfTime_Zero;
 
     if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cSFTime)) {
@@ -61,15 +71,7 @@ static VALUE Time_new(int argc, VALUE* argv, VALUE klass) {
         raise_invalid_arguments_excepted(1, argc);
     }
 
-    ptr = malloc(sizeof(Time));
-
-    if (ptr == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate time");
-    }
-
-    ptr->time = time;
-
-    self = TypedData_Wrap_Struct(klass, &Time_data_type, ptr);
+    ((Time*)Get_Time_Struct(self))->time = time;
 
     return self;
 }
@@ -302,7 +304,9 @@ void Init_Time(VALUE rb_mSFML) {
 
     rb_include_module(rb_cSFTime, rb_mComparable);
 
-    rb_define_singleton_method(rb_cSFTime, "new", Time_new, -1);
+    rb_define_alloc_func(rb_cSFTime, Time_alloc);
+    rb_define_method(rb_cSFTime, "initialize", Time_initialize, -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);

data/ext/system/vec2.c

@@ -22,6 +22,19 @@ static const rb_data_type_t Vector2_data_type = {
     .function = {.dmark = NULL, .dfree = Vector2_free, .dsize = NULL},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
+static VALUE Vector2_alloc(VALUE klass) {
+    Vector2* ptr = malloc(sizeof(Vector2));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vector");
+    }
+
+    ptr->vec.x = 0;
+    ptr->vec.y = 0;
+
+    return TypedData_Wrap_Struct(klass, &Vector2_data_type, ptr);
+}
+
 /* call-seq:
  *   Vector2.new                -> Vector2(0, 0)
  *   Vector2.new(x, y)          -> Vector2(x, y)
@@ -35,8 +48,7 @@ static const rb_data_type_t Vector2_data_type = {
  * @raise [ArgumentError] if given an Array shorter than 2 elements, or an
  *   argument count other than 0, 1 or 2
  */
-static VALUE Vector2_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE self;
+static VALUE Vector2_initialize(int argc, VALUE* argv, VALUE self) {
     Vector2* ptr;
     float x = 0;
     float y = 0;
@@ -59,17 +71,10 @@ static VALUE Vector2_new(int argc, VALUE* argv, VALUE klass) {
         raise_invalid_arguments_excepted(2, argc);
     }
 
-    ptr = malloc(sizeof(Vector2));
-
-    if (ptr == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate vector");
-    }
-
+    ptr = Get_Vector2_Struct(self);
     ptr->vec.x = x;
     ptr->vec.y = y;
 
-    self = TypedData_Wrap_Struct(klass, &Vector2_data_type, ptr);
-
     return self;
 }
 
@@ -266,7 +271,8 @@ void Init_Vector2(VALUE rb_mSFML) {
 
     rb_include_module(rb_cVector2, rb_mEnumerable);
 
-    rb_define_singleton_method(rb_cVector2, "new", Vector2_new, -1);
+    rb_define_alloc_func(rb_cVector2, Vector2_alloc);
+    rb_define_method(rb_cVector2, "initialize", Vector2_initialize, -1);
 
     rb_define_method(rb_cVector2, "x", Vector2_get_x, 0);
     rb_define_method(rb_cVector2, "y", Vector2_get_y, 0);

data/ext/system/vec3.c

@@ -21,6 +21,20 @@ static const rb_data_type_t Vector3_data_type = {
     .function = {.dmark = NULL, .dfree = Vector3_free, .dsize = NULL},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
+static VALUE Vector3_alloc(VALUE klass) {
+    Vector3* ptr = malloc(sizeof(Vector3));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vector");
+    }
+
+    ptr->vec.x = 0;
+    ptr->vec.y = 0;
+    ptr->vec.z = 0;
+
+    return TypedData_Wrap_Struct(klass, &Vector3_data_type, ptr);
+}
+
 /* call-seq:
  *   Vector3.new                -> Vector3(0, 0, 0)
  *   Vector3.new(x, y, z)       -> Vector3(x, y, z)
@@ -34,8 +48,7 @@ static const rb_data_type_t Vector3_data_type = {
  * @raise [ArgumentError] if given an Array shorter than 3 elements, or an
  *   argument count other than 0, 1 or 3
  */
-static VALUE Vector3_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE self;
+static VALUE Vector3_initialize(int argc, VALUE* argv, VALUE self) {
     Vector3* ptr;
     float x = 0;
     float y = 0;
@@ -62,18 +75,11 @@ static VALUE Vector3_new(int argc, VALUE* argv, VALUE klass) {
         raise_invalid_arguments_excepted(3, argc);
     }
 
-    ptr = malloc(sizeof(Vector3));
-
-    if (ptr == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate vector");
-    }
-
+    ptr = Get_Vector3_Struct(self);
     ptr->vec.x = x;
     ptr->vec.y = y;
     ptr->vec.z = z;
 
-    self = TypedData_Wrap_Struct(klass, &Vector3_data_type, ptr);
-
     return self;
 }
 
@@ -286,7 +292,8 @@ void Init_Vector3(VALUE rb_mSFML) {
 
     rb_include_module(rb_cVector3, rb_mEnumerable);
 
-    rb_define_singleton_method(rb_cVector3, "new", Vector3_new, -1);
+    rb_define_alloc_func(rb_cVector3, Vector3_alloc);
+    rb_define_method(rb_cVector3, "initialize", Vector3_initialize, -1);
 
     rb_define_method(rb_cVector3, "x", Vector3_get_x, 0);
     rb_define_method(rb_cVector3, "y", Vector3_get_y, 0);

data/ext/window/context.c

@@ -23,6 +23,16 @@ static sfContext* Get_Context_Struct(VALUE self) {
     return ptr;
 }
 
+static VALUE Context_alloc(VALUE klass) {
+    sfContext* context = sfContext_create();
+
+    if (context == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create context");
+    }
+
+    return TypedData_Wrap_Struct(klass, &Context_data_type, context);
+}
+
 /* call-seq:
  *   Context.new -> Context
  *
@@ -31,16 +41,7 @@ static sfContext* Get_Context_Struct(VALUE self) {
  * @return [Context]
  * @raise [RuntimeError] if context creation fails
  */
-static VALUE Context_new(VALUE klass) {
-    sfContext* context = sfContext_create();
-    VALUE self;
-
-    if (context == NULL) {
-        rb_raise(rb_eRuntimeError, "failed to create context");
-    }
-
-    self = TypedData_Wrap_Struct(klass, &Context_data_type, context);
-
+static VALUE Context_initialize(VALUE self) {
     return self;
 }
 
@@ -110,7 +111,9 @@ static VALUE Context_active_context_id(VALUE klass) {
 void Init_Context(VALUE rb_mSFML) {
     rb_cContext = rb_define_class_under(rb_mSFML, "Context", rb_cObject);
 
-    rb_define_singleton_method(rb_cContext, "new", Context_new, 0);
+    rb_define_alloc_func(rb_cContext, Context_alloc);
+    rb_define_method(rb_cContext, "initialize", Context_initialize, 0);
+
     rb_define_singleton_method(rb_cContext, "extension_available?", Context_extension_available, 1);
     rb_define_singleton_method(rb_cContext, "function", Context_get_function, 1);
     rb_define_singleton_method(rb_cContext, "active_context_id", Context_active_context_id, 0);

data/ext/window/context_settings.c

@@ -42,6 +42,18 @@ static const char* context_flag_name(VALUE value) {
     return StringValueCStr(value);
 }
 
+static VALUE ContextSettings_alloc(VALUE klass) {
+    ContextSettings* ptr = malloc(sizeof(ContextSettings));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate context settings");
+    }
+
+    ptr->settings = (sfContextSettings){0, 0, 0, 1, 1, sfContextDefault, false};
+
+    return TypedData_Wrap_Struct(klass, &ContextSettings_data_type, ptr);
+}
+
 /* call-seq:
  *   ContextSettings.new(depth_bits = 0, stencil_bits = 0, antialiasing_level = 0, major_version =
  * 1, minor_version = 1, flags = :default, srgb_capable = false) -> ContextSettings
@@ -49,10 +61,9 @@ static const char* context_flag_name(VALUE value) {
  * @return [ContextSettings]
  * @raise [ArgumentError] if +flags+ contains an unknown attribute name
  */
-static VALUE ContextSettings_new(int argc, VALUE* argv, VALUE klass) {
+static VALUE ContextSettings_initialize(int argc, VALUE* argv, VALUE self) {
     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);
@@ -108,7 +119,7 @@ static VALUE ContextSettings_new(int argc, VALUE* argv, VALUE klass) {
         settings.sRgbCapable = RTEST(rb_srgb);
     }
 
-    self = ContextSettings_wrap(settings);
+    ((ContextSettings*)Get_ContextSettings_Struct(self))->settings = settings;
 
     return self;
 }
@@ -248,7 +259,8 @@ static VALUE ContextSettings_set_srgb(VALUE self, VALUE rb_value) {
 void Init_ContextSettings(VALUE rb_mSFML) {
     rb_cContextSettings = rb_define_class_under(rb_mSFML, "ContextSettings", rb_cObject);
 
-    rb_define_singleton_method(rb_cContextSettings, "new", ContextSettings_new, -1);
+    rb_define_alloc_func(rb_cContextSettings, ContextSettings_alloc);
+    rb_define_method(rb_cContextSettings, "initialize", ContextSettings_initialize, -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);

data/ext/window/cursor.c

@@ -64,12 +64,18 @@ static VALUE Cursor_from_system(VALUE klass, VALUE rb_type) {
     return Cursor_wrap(sfCursor_createFromSystem(cursor_type_from_rb(rb_type)));
 }
 
+static VALUE Cursor_alloc(VALUE klass) {
+    (void)klass;
+    rb_raise(rb_eNotImpError, "use Cursor.from_system or Cursor.from_pixels");
+}
+
 /* Document-class: SFML::Cursor
  * A native mouse cursor, either built from raw pixel data or one of the
  * platform's built-in system cursors. Assign to Window#cursor= to apply.
  */
 void Init_Cursor(VALUE rb_mSFML) {
     rb_cCursor = rb_define_class_under(rb_mSFML, "Cursor", rb_cObject);
+    rb_define_alloc_func(rb_cCursor, Cursor_alloc);
 
     rb_define_singleton_method(rb_cCursor, "from_pixels", Cursor_from_pixels, 3);
     rb_define_singleton_method(rb_cCursor, "from_system", Cursor_from_system, 1);

data/ext/window/event.c

@@ -14,16 +14,6 @@
 
 static VALUE rb_cEvent;
 
-static sfEvent* Event_create() {
-    sfEvent* event = malloc(sizeof(sfEvent));
-
-    if (event == NULL) {
-        rb_raise(rb_eNoMemError, "failed to allocate event");
-    }
-
-    return event;
-}
-
 static void Event_free(void* ptr) {
     free(ptr);
 }
@@ -33,6 +23,18 @@ static const rb_data_type_t Event_data_type = {
     .function = {.dmark = NULL, .dfree = Event_free, .dsize = NULL},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
+static VALUE Event_alloc(VALUE klass) {
+    sfEvent* event = malloc(sizeof(sfEvent));
+
+    if (event == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate event");
+    }
+
+    *event = (sfEvent){0};
+
+    return TypedData_Wrap_Struct(klass, &Event_data_type, event);
+}
+
 /* call-seq:
  *   Event.new -> Event
  *
@@ -40,17 +42,6 @@ static const rb_data_type_t Event_data_type = {
  *
  * @return [Event]
  */
-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;
-}
 
 /* call-seq: initialize -> self
  *
@@ -60,7 +51,7 @@ static VALUE Event_new(VALUE klass) {
  *   internally (e.g. by #poll_event!).
  * @return [self]
  */
-static VALUE Event_init(VALUE self) {
+static VALUE Event_initialize(VALUE self) {
     return self;
 }
 
@@ -306,9 +297,8 @@ static VALUE Event_get_sensor(VALUE self) {
 void Init_Event(VALUE rb_mSFML) {
     rb_cEvent = rb_define_class_under(rb_mSFML, "Event", rb_cObject);
 
-    rb_define_singleton_method(rb_cEvent, "new", Event_new, 0);
-
-    rb_define_method(rb_cEvent, "initialize", Event_init, 0);
+    rb_define_alloc_func(rb_cEvent, Event_alloc);
+    rb_define_method(rb_cEvent, "initialize", Event_initialize, 0);
 
     rb_define_method(rb_cEvent, "type", Event_type, 0);
     rb_define_method(rb_cEvent, "size", Event_get_size, 0);

data/ext/window/mouse.c

@@ -4,23 +4,41 @@
 
 #include "window/input_enums.h"
 #include "window/window.h"
+#include "window/window_base.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;
+/* A RenderWindow and a Window both wrap an sfRenderWindow; a WindowBase wraps
+   an sfWindowBase. CSFML ships a separate entry point for each, so pick the one
+   matching the handle -- casting an sfRenderWindow* down to sfWindowBase* would
+   rely on the base being at offset 0, which CSFML does not guarantee. */
+static sfVector2i Mouse_get_relative_position(VALUE rb_window) {
+    if (rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        return sfMouse_getPositionRenderWindow(Get_Window_Struct(rb_window));
+    }
+
+    if (rb_obj_is_kind_of(rb_window, Get_Klass_WindowBase())) {
+        return sfMouse_getPositionWindowBase(Get_WindowBase_Struct(rb_window));
+    }
+
+    raise_invalid_argument_class(Get_Klass_WindowBase());
+    return (sfVector2i){0, 0};
+}
+
+static void Mouse_set_relative_position(VALUE rb_window, sfVector2i position) {
+    if (rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        sfMouse_setPositionRenderWindow(position, Get_Window_Struct(rb_window));
+        return;
     }
 
-    if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
-        raise_invalid_argument_class(Get_Klass_Window());
+    if (rb_obj_is_kind_of(rb_window, Get_Klass_WindowBase())) {
+        sfMouse_setPositionWindowBase(position, Get_WindowBase_Struct(rb_window));
+        return;
     }
 
-    return Get_Window_Struct(rb_window);
+    raise_invalid_argument_class(Get_Klass_WindowBase());
 }
 
 /* call-seq:
@@ -51,7 +69,7 @@ static VALUE Mouse_get_position(int argc, VALUE* argv, VALUE module) {
     if (NIL_P(rb_window)) {
         position = sfMouse_getPosition(NULL);
     } else {
-        position = sfMouse_getPositionRenderWindow(Mouse_relative_window(rb_window));
+        position = Mouse_get_relative_position(rb_window);
     }
 
     return vec2f_to_rb((sfVector2f){(float)position.x, (float)position.y});
@@ -72,8 +90,7 @@ static VALUE Mouse_set_position(int argc, VALUE* argv, VALUE module) {
     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));
+        Mouse_set_relative_position(rb_window, vec2i_from_rb(rb_position));
     }
 
     return rb_position;

data/ext/window/touch.c

@@ -3,23 +3,26 @@
 #include <ruby.h>
 
 #include "window/window.h"
+#include "window/window_base.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;
+/* A RenderWindow and a Window both wrap an sfRenderWindow; a WindowBase wraps
+   an sfWindowBase. CSFML ships a separate entry point for each, so pick the one
+   matching the handle rather than casting between them. */
+static sfVector2i Touch_relative_position(unsigned int finger, VALUE rb_window) {
+    if (rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        return sfTouch_getPositionRenderWindow(finger, Get_Window_Struct(rb_window));
     }
 
-    if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
-        raise_invalid_argument_class(Get_Klass_Window());
+    if (rb_obj_is_kind_of(rb_window, Get_Klass_WindowBase())) {
+        return sfTouch_getPositionWindowBase(finger, Get_WindowBase_Struct(rb_window));
     }
 
-    return Get_Window_Struct(rb_window);
+    raise_invalid_argument_class(Get_Klass_WindowBase());
+    return (sfVector2i){0, 0};
 }
 
 /* call-seq:
@@ -49,8 +52,7 @@ static VALUE Touch_get_position(int argc, VALUE* argv, VALUE module) {
     if (NIL_P(rb_window)) {
         position = sfTouch_getPosition(NUM2UINT(rb_finger), NULL);
     } else {
-        position =
-            sfTouch_getPositionRenderWindow(NUM2UINT(rb_finger), Touch_relative_window(rb_window));
+        position = Touch_relative_position(NUM2UINT(rb_finger), rb_window);
     }
 
     return vec2f_to_rb((sfVector2f){(float)position.x, (float)position.y});

data/ext/window/video_mode.c

@@ -9,7 +9,7 @@
 
 static VALUE rb_cMode;
 
-static sfVideoMode* VideoMode_alloc(unsigned width, unsigned height, unsigned bits, int* created) {
+static sfVideoMode* VideoMode_create(unsigned width, unsigned height, unsigned bits, int* created) {
     sfVideoMode* mode = malloc(sizeof(sfVideoMode));
 
     if (mode == NULL) {
@@ -36,8 +36,14 @@ static const rb_data_type_t VideoMode_data_type = {
     .function = {.dmark = NULL, .dfree = VideoMode_free, .dsize = NULL},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
+static VALUE VideoMode_alloc(VALUE klass) {
+    sfVideoMode* ptr = VideoMode_create(0, 0, 0, NULL);
+
+    return TypedData_Wrap_Struct(klass, &VideoMode_data_type, ptr);
+}
+
 static VALUE VideoMode_from_c(sfVideoMode mode) {
-    sfVideoMode* ptr = VideoMode_alloc(mode.size.x, mode.size.y, mode.bitsPerPixel, NULL);
+    sfVideoMode* ptr = VideoMode_create(mode.size.x, mode.size.y, mode.bitsPerPixel, NULL);
     VALUE self = TypedData_Wrap_Struct(rb_cMode, &VideoMode_data_type, ptr);
 
     rb_iv_set(self, "@width", UINT2NUM(mode.size.x));
@@ -54,28 +60,13 @@ static VALUE VideoMode_from_c(sfVideoMode mode) {
  *
  * @return [VideoMode]
  */
-static VALUE VideoMode_new(VALUE klass, VALUE rb_width, VALUE rb_height, VALUE rb_bits) {
-    VALUE self;
-    VALUE argv[] = {rb_width, rb_height, rb_bits};
-
-    self = VideoMode_from_c(
-        (sfVideoMode){{(unsigned)NUM2UINT(rb_width), (unsigned)NUM2UINT(rb_height)},
-                      (unsigned)NUM2UINT(rb_bits)});
+static VALUE VideoMode_initialize(VALUE self, VALUE rb_width, VALUE rb_height, VALUE rb_bits) {
+    sfVideoMode* mode = Get_Mode_Struct(self);
 
-    rb_obj_call_init(self, 3, argv);
+    mode->size.x = (unsigned)NUM2UINT(rb_width);
+    mode->size.y = (unsigned)NUM2UINT(rb_height);
+    mode->bitsPerPixel = (unsigned)NUM2UINT(rb_bits);
 
-    return self;
-}
-
-/* call-seq: initialize(width, height, bits) -> self
- *
- * Stores the mode's dimensions; called internally by .new.
- *
- * @private Sets the ivars backing the #width/#height/#bits readers; called
- *   internally by .new.
- * @return [self]
- */
-static VALUE VideoMode_init(VALUE self, VALUE rb_width, VALUE rb_height, VALUE rb_bits) {
     rb_iv_set(self, "@width", rb_width);
     rb_iv_set(self, "@height", rb_height);
     rb_iv_set(self, "@bits", rb_bits);
@@ -179,11 +170,11 @@ static VALUE VideoMode_eql(VALUE self, VALUE rb_other) {
 void Init_VideoMode(VALUE rb_mSFML) {
     rb_cMode = rb_define_class_under(rb_mSFML, "VideoMode", rb_cObject);
 
-    rb_define_singleton_method(rb_cMode, "new", VideoMode_new, 3);
+    rb_define_alloc_func(rb_cMode, VideoMode_alloc);
+    rb_define_method(rb_cMode, "initialize", VideoMode_initialize, 3);
+
     rb_define_singleton_method(rb_cMode, "desktop_mode", VideoMode_desktop_mode, 0);
     rb_define_singleton_method(rb_cMode, "fullscreen_modes", VideoMode_fullscreen_modes, 0);
-
-    rb_define_method(rb_cMode, "initialize", VideoMode_init, 3);
     rb_define_method(rb_cMode, "available?", VideoMode_is_available, 0);
     rb_define_method(rb_cMode, "valid?", VideoMode_is_available, 0);
     rb_define_method(rb_cMode, "size", VideoMode_get_size, 0);