sfml3-rb 0.3.0 → 0.3.1

data/ext/graphics/shape.c

@@ -96,20 +96,14 @@ static sfVector2f CustomShape_get_point(size_t index, void* userData) {
     return vec2f_from_rb(point);
 }
 
-/* call-seq:
- *   Shape.new -> Shape
- *
- * A base class meant to be subclassed: override #point_count and #point(i)
- * in Ruby to define the shape's geometry, then call #update! whenever it
- * changes.
- *
- * @return [Shape]
- * @raise [RuntimeError] if the underlying shape cannot be created
- */
-static VALUE CustomShape_new(VALUE klass) {
+static VALUE CustomShape_alloc(VALUE klass) {
     CustomShape* ptr = malloc(sizeof(CustomShape));
     VALUE self;
 
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate shape");
+    }
+
     ptr->rb_self = Qnil;
     ptr->rb_texture = Qnil;
     ptr->shape = sfShape_create(CustomShape_get_point_count, CustomShape_get_point, ptr);
@@ -125,6 +119,19 @@ static VALUE CustomShape_new(VALUE klass) {
     return self;
 }
 
+/* call-seq:
+ *   Shape.new -> Shape
+ *
+ * A base class meant to be subclassed: override #point_count and #point(i)
+ * in Ruby to define the shape's geometry, then call #update! whenever it
+ * changes.
+ *
+ * @return [Shape]
+ */
+static VALUE CustomShape_initialize(VALUE self) {
+    return self;
+}
+
 /* call-seq: update! -> self
  *
  * Recomputes the shape's geometry by calling back into the subclass's
@@ -443,15 +450,13 @@ static VALUE CustomShape_get_global_bounds(VALUE self) {
  * @return [nil]
  */
 static VALUE CustomShape_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
-    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
-        raise_invalid_argument_class(Get_Klass_Target());
-    }
+    TargetView view = Get_RenderTarget_View(rb_target);
 
     if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
         raise_invalid_argument_class(Get_Klass_RenderState());
     }
 
-    TARGET_DRAW(Get_Target_Struct(rb_target), sfRenderWindow_drawShape, sfRenderTexture_drawShape,
+    TARGET_DRAW(view, sfRenderWindow_drawShape, sfRenderTexture_drawShape,
                 Get_CustomShape_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
@@ -495,9 +500,11 @@ static VALUE CustomShape_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_Shape(VALUE rb_mSFML) {
     rb_cCustomShape = rb_define_class_under(rb_mSFML, "Shape", rb_cObject);
 
+    rb_define_alloc_func(rb_cCustomShape, CustomShape_alloc);
+
     rb_include_module(rb_cCustomShape, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cCustomShape, "new", CustomShape_new, 0);
+    rb_define_method(rb_cCustomShape, "initialize", CustomShape_initialize, 0);
 
     rb_define_method(rb_cCustomShape, "update!", CustomShape_update, 0);
     rb_define_method(rb_cCustomShape, "position", CustomShape_get_position, 0);

data/ext/graphics/sprite.c

@@ -26,7 +26,10 @@ static void Sprite_mark(void* ptr) {
 }
 
 static void Sprite_free(void* ptr) {
-    sfSprite_destroy(((Sprite*)ptr)->sprite);
+    if (((Sprite*)ptr)->sprite != NULL) {
+        sfSprite_destroy(((Sprite*)ptr)->sprite);
+    }
+
     free(ptr);
 }
 
@@ -59,6 +62,24 @@ static VALUE Sprite_wrap(VALUE klass, sfSprite* sprite) {
     return TypedData_Wrap_Struct(klass, &Sprite_data_type, ptr);
 }
 
+static VALUE Sprite_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
+
+static VALUE Sprite_alloc(VALUE klass) {
+    Sprite* ptr = malloc(sizeof(Sprite));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate sprite");
+    }
+
+    ptr->sprite = NULL;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &Sprite_data_type, ptr);
+}
+
 /* call-seq:
  *   Sprite.new(texture) -> Sprite
  *
@@ -69,19 +90,21 @@ static VALUE Sprite_wrap(VALUE klass, sfSprite* sprite) {
  * @return [Sprite]
  * @raise [ArgumentError] if +texture+ is not a Texture
  */
-static VALUE Sprite_new(VALUE klass, VALUE rb_texture) {
-    VALUE self;
+static VALUE Sprite_initialize(VALUE self, VALUE rb_texture) {
     Sprite* ptr;
 
     if (!rb_obj_is_kind_of(rb_texture, Get_Klass_Texture())) {
         raise_invalid_argument_class(Get_Klass_Texture());
     }
 
-    ptr = malloc(sizeof(Sprite));
+    TypedData_Get_Struct(self, Sprite, &Sprite_data_type, ptr);
+
     ptr->sprite = sfSprite_create(Get_Texture_Struct(rb_texture));
     ptr->rb_texture = rb_texture;
 
-    self = TypedData_Wrap_Struct(klass, &Sprite_data_type, ptr);
+    if (ptr->sprite == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sprite");
+    }
 
     return self;
 }
@@ -356,15 +379,13 @@ static VALUE Sprite_get_global_bounds(VALUE self) {
  *   RenderState
  */
 static VALUE Sprite_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
-    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
-        raise_invalid_argument_class(Get_Klass_Target());
-    }
+    TargetView view = Get_RenderTarget_View(rb_target);
 
     if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
         raise_invalid_argument_class(Get_Klass_RenderState());
     }
 
-    TARGET_DRAW(Get_Target_Struct(rb_target), sfRenderWindow_drawSprite, sfRenderTexture_drawSprite,
+    TARGET_DRAW(view, sfRenderWindow_drawSprite, sfRenderTexture_drawSprite,
                 Get_Sprite_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
@@ -402,9 +423,12 @@ static VALUE Sprite_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_Sprite(VALUE rb_mSFML) {
     rb_cSprite = rb_define_class_under(rb_mSFML, "Sprite", rb_cObject);
 
+    rb_define_alloc_func(rb_cSprite, Sprite_alloc);
+
     rb_include_module(rb_cSprite, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cSprite, "new", Sprite_new, 1);
+    rb_define_method(rb_cSprite, "initialize", Sprite_initialize, 1);
+    rb_define_private_method(rb_cSprite, "initialize_copy", Sprite_initialize_copy, 1);
 
     rb_define_method(rb_cSprite, "copy", Sprite_copy, 0);
 

data/ext/graphics/stencil_mode.c

@@ -78,6 +78,18 @@ static sfStencilUpdateOperation operation_from_rb(VALUE rb_value) {
     return sfStencilUpdateOperationKeep;
 }
 
+static VALUE StencilMode_alloc(VALUE klass) {
+    StencilMode* ptr = malloc(sizeof(StencilMode));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate stencil mode");
+    }
+
+    ptr->mode = sfStencilMode_default;
+
+    return TypedData_Wrap_Struct(klass, &StencilMode_data_type, ptr);
+}
+
 /* call-seq:
  *   StencilMode.new -> StencilMode
  *   StencilMode.new(comparison, update_operation, reference, mask, stencil_only) -> StencilMode
@@ -90,9 +102,7 @@ static sfStencilUpdateOperation operation_from_rb(VALUE rb_value) {
  * @return [StencilMode]
  * @raise [ArgumentError] if given an argument count other than 0 or 5
  */
-static VALUE StencilMode_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE self;
-    StencilMode* ptr;
+static VALUE StencilMode_initialize(int argc, VALUE* argv, VALUE self) {
     sfStencilMode mode = sfStencilMode_default;
 
     if (argc == 5) {
@@ -105,10 +115,7 @@ static VALUE StencilMode_new(int argc, VALUE* argv, VALUE klass) {
         raise_invalid_arguments_excepted(5, argc);
     }
 
-    ptr = malloc(sizeof(StencilMode));
-    ptr->mode = mode;
-
-    self = TypedData_Wrap_Struct(klass, &StencilMode_data_type, ptr);
+    ((StencilMode*)Get_StencilMode_Struct(self))->mode = mode;
 
     return self;
 }
@@ -280,7 +287,8 @@ static VALUE StencilMode_eql(VALUE self, VALUE rb_other) {
 void Init_StencilMode(VALUE rb_mSFML) {
     rb_cStencilMode = rb_define_class_under(rb_mSFML, "StencilMode", rb_cObject);
 
-    rb_define_singleton_method(rb_cStencilMode, "new", StencilMode_new, -1);
+    rb_define_alloc_func(rb_cStencilMode, StencilMode_alloc);
+    rb_define_method(rb_cStencilMode, "initialize", StencilMode_initialize, -1);
 
     rb_define_method(rb_cStencilMode, "comparison", StencilMode_get_comparison, 0);
     rb_define_method(rb_cStencilMode, "update_operation", StencilMode_get_operation, 0);

data/ext/graphics/target.c

@@ -5,16 +5,22 @@
 
 #include "graphics/render_state.h"
 #include "graphics/render_texture.h"
+#include "graphics/render_window.h"
 #include "graphics/view.h"
 #include "window/window.h"
 #include "core/exceptions.h"
 #include "core/macros.h"
 
 static VALUE rb_cTarget;
+static VALUE rb_mRenderTarget;
 
 static Target* Target_create(TargetType type, void* handle, VALUE rb_source) {
     Target* target = malloc(sizeof(Target));
 
+    if (target == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate render target");
+    }
+
     target->type = type;
     target->handle = handle;
     target->rb_source = rb_source;
@@ -35,6 +41,15 @@ static const rb_data_type_t RenderTarget_data_type = {
     .function = {.dmark = RenderTarget_mark, .dfree = RenderTarget_free, .dsize = NULL},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
+static VALUE RenderTarget_wrap(VALUE klass, TargetType type, void* handle, VALUE rb_source) {
+    return TypedData_Wrap_Struct(klass, &RenderTarget_data_type,
+                                 Target_create(type, handle, rb_source));
+}
+
+static VALUE RenderTarget_alloc(VALUE klass) {
+    return RenderTarget_wrap(klass, SFML_TARGET_WINDOW, NULL, Qnil);
+}
+
 /* call-seq:
  *   Target.new(window) -> Target
  *
@@ -43,26 +58,21 @@ static const rb_data_type_t RenderTarget_data_type = {
  * @return [Target]
  * @raise [TypeError] if +window+ is not a Window
  */
-static VALUE RenderTarget_new(VALUE klass, VALUE rb_window) {
-    VALUE self;
+static VALUE RenderTarget_initialize(VALUE self, VALUE rb_window) {
     Target* target;
 
     if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
         raise_invalid_argument_class(Get_Klass_Window());
     }
 
-    target = Target_create(SFML_TARGET_WINDOW, Get_Window_Struct(rb_window), rb_window);
-    self = TypedData_Wrap_Struct(klass, &RenderTarget_data_type, target);
-
-    rb_obj_call_init(self, 0, NULL);
+    target = Get_Target_Struct(self);
+    target->type = SFML_TARGET_WINDOW;
+    target->handle = Get_Window_Struct(rb_window);
+    target->rb_source = rb_window;
 
     return self;
 }
 
-static VALUE RenderTarget_init(VALUE self) {
-    return self;
-}
-
 /* call-seq:
  *   draw(drawable, state) -> void
  *
@@ -123,22 +133,51 @@ static VALUE RenderTarget_get_view(VALUE self) {
     return Get_Casting_View(view);
 }
 
+TargetView Get_RenderTarget_View(VALUE self) {
+    TargetView view;
+
+    if (rb_obj_is_kind_of(self, Get_Klass_Target())) {
+        Target* target = Get_Target_Struct(self);
+
+        view.type = target->type;
+        view.handle = target->handle;
+        return view;
+    }
+
+    if (rb_obj_is_kind_of(self, rb_mRenderTarget)) {
+        if (rb_obj_is_kind_of(self, Get_Klass_RenderWindow())) {
+            view.type = SFML_TARGET_WINDOW;
+            view.handle = Get_Window_Struct(self);
+        } else {
+            view.type = SFML_TARGET_TEXTURE;
+            view.handle = Get_RenderTexture_Struct(self);
+        }
+        return view;
+    }
+
+    rb_raise(rb_eArgError, "expected a RenderTarget (RenderWindow or RenderTexture)");
+}
+
 /* Document-class: SFML::Target
- * A generic handle onto whatever can be drawn to -- a Window or a
+ * A legacy generic handle onto whatever can be drawn to -- a Window or a
  * RenderTexture -- used by Drawable#draw so drawable objects don't need to
  * know which concrete kind of target they're being drawn onto.
  *
+ * New code should pass a SFML::RenderWindow or SFML::RenderTexture (both
+ * include SFML::RenderTarget) straight to a drawable's #draw.
+ *
  * @!attribute view
  *   The target's current view.
  *   @return [View]
  */
 void Init_Target(VALUE rb_mSFML) {
     rb_cTarget = rb_define_class_under(rb_mSFML, "Target", rb_cObject);
+    rb_mRenderTarget = rb_define_module_under(rb_mSFML, "RenderTarget");
 
-    rb_define_singleton_method(rb_cTarget, "new", RenderTarget_new, 1);
+    rb_define_alloc_func(rb_cTarget, RenderTarget_alloc);
 
     // methods
-    rb_define_method(rb_cTarget, "initialize", RenderTarget_init, 0);
+    rb_define_method(rb_cTarget, "initialize", RenderTarget_initialize, 1);
     rb_define_method(rb_cTarget, "draw", RenderTarget_draw, 2);
 
     // setters
@@ -152,6 +191,10 @@ VALUE Get_Klass_Target(void) {
     return rb_cTarget;
 }
 
+VALUE Get_Module_RenderTarget(void) {
+    return rb_mRenderTarget;
+}
+
 Target* Get_Target_Struct(VALUE self) {
     Target* ptr;
     TypedData_Get_Struct(self, Target, &RenderTarget_data_type, ptr);
@@ -159,20 +202,10 @@ Target* Get_Target_Struct(VALUE self) {
 }
 
 VALUE Get_New_Target(VALUE rb_window) {
-    return RenderTarget_new(Get_Klass_Target(), rb_window);
-}
-
-VALUE Get_New_Target_From_RenderTexture(VALUE rb_render_texture) {
-    VALUE self;
-    Target* target;
-
-    if (!rb_obj_is_kind_of(rb_render_texture, Get_Klass_RenderTexture())) {
-        raise_invalid_argument_class(Get_Klass_RenderTexture());
+    if (!rb_obj_is_kind_of(rb_window, Get_Klass_Window())) {
+        raise_invalid_argument_class(Get_Klass_Window());
     }
 
-    target = Target_create(SFML_TARGET_TEXTURE, Get_RenderTexture_Struct(rb_render_texture),
-                           rb_render_texture);
-    self = TypedData_Wrap_Struct(rb_cTarget, &RenderTarget_data_type, target);
-
-    return self;
+    return RenderTarget_wrap(Get_Klass_Target(), SFML_TARGET_WINDOW, Get_Window_Struct(rb_window),
+                             rb_window);
 }

data/ext/graphics/target.h

@@ -7,23 +7,32 @@
 
 typedef enum { SFML_TARGET_WINDOW, SFML_TARGET_TEXTURE } TargetType;
 
+/* A borrowed view onto whatever a draw call is headed for: the kind plus the
+   opaque handle. Built on the stack by Get_RenderTarget_View, never owned. */
 typedef struct {
     TargetType type;
     void* handle;
-    /* The Window/RenderTexture `handle` is borrowed from, kept alive for as
-       long as this Target references it -- see Target_mark in target.c. */
+} TargetView;
+
+/* The legacy generic wrapper behind SFML::Target. It owns only the borrow, so
+   it keeps its source alive for as long as it references it. */
+typedef struct {
+    TargetType type;
+    void* handle;
+    /* The Window/RenderWindow/RenderTexture `handle` is borrowed from, kept
+       alive for as long as this Target references it -- see Target_mark. */
     VALUE rb_source;
 } Target;
 
-/* Dispatch a draw call to whichever underlying render surface this target
+/* Dispatch a draw call to whichever underlying render surface this view
    wraps. Pass NULL states to use the defaults; never hand CSFML a NULL. */
-#define TARGET_DRAW(target, window_fn, texture_fn, object, states)                                 \
+#define TARGET_DRAW(view, window_fn, texture_fn, object, states)                                   \
     do {                                                                                           \
         const sfRenderStates* sfml_states = (states) ? (states) : &sfRenderStates_default;         \
-        if ((target)->type == SFML_TARGET_WINDOW) {                                                \
-            window_fn((sfRenderWindow*)(target)->handle, (object), sfml_states);                   \
+        if ((view).type == SFML_TARGET_WINDOW) {                                                   \
+            window_fn((sfRenderWindow*)(view).handle, (object), sfml_states);                      \
         } else {                                                                                   \
-            texture_fn((sfRenderTexture*)(target)->handle, (object), sfml_states);                 \
+            texture_fn((sfRenderTexture*)(view).handle, (object), sfml_states);                    \
         }                                                                                          \
     } while (0)
 
@@ -35,6 +44,11 @@ Target* Get_Target_Struct(VALUE self);
 
 VALUE Get_New_Target(VALUE rb_window);
 
-VALUE Get_New_Target_From_RenderTexture(VALUE rb_render_texture);
+/* The SFML::RenderTarget module, included by RenderWindow and RenderTexture. */
+VALUE Get_Module_RenderTarget(void);
+
+/* Resolves any accepted draw target -- a legacy Target, a RenderWindow or a
+   RenderTexture -- to its kind and handle, raising TypeError otherwise. */
+TargetView Get_RenderTarget_View(VALUE self);
 
 #endif // SFML_RB_GRAPHICS_TARGET_H

data/ext/graphics/text.c

@@ -28,7 +28,10 @@ static void Text_mark(void* ptr) {
 }
 
 static void Text_free(void* ptr) {
-    sfText_destroy(((Text*)ptr)->text);
+    if (((Text*)ptr)->text != NULL) {
+        sfText_destroy(((Text*)ptr)->text);
+    }
+
     free(ptr);
 }
 
@@ -61,6 +64,24 @@ static VALUE Text_wrap(VALUE klass, sfText* text) {
     return TypedData_Wrap_Struct(klass, &Text_data_type, ptr);
 }
 
+static VALUE Text_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
+
+static VALUE Text_alloc(VALUE klass) {
+    Text* ptr = malloc(sizeof(Text));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate text");
+    }
+
+    ptr->text = NULL;
+    ptr->rb_font = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &Text_data_type, ptr);
+}
+
 /* call-seq:
  *   Text.new(font)                        -> Text
  *   Text.new(font, string)                -> Text
@@ -73,8 +94,8 @@ static VALUE Text_wrap(VALUE klass, sfText* text) {
  * @return [Text]
  * @raise [ArgumentError] if +font+ is not a Font
  */
-static VALUE Text_new(int argc, VALUE* argv, VALUE klass) {
-    VALUE rb_font, rb_string, rb_size, self;
+static VALUE Text_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE rb_font, rb_string, rb_size;
     Text* ptr;
 
     rb_scan_args(argc, argv, "12", &rb_font, &rb_string, &rb_size);
@@ -83,17 +104,15 @@ static VALUE Text_new(int argc, VALUE* argv, VALUE klass) {
         raise_invalid_argument_class(Get_Klass_Font());
     }
 
-    ptr = malloc(sizeof(Text));
+    TypedData_Get_Struct(self, Text, &Text_data_type, ptr);
+
     ptr->text = sfText_create(Get_Font_Struct(rb_font));
     ptr->rb_font = rb_font;
 
     if (ptr->text == NULL) {
-        free(ptr);
         rb_raise(rb_eRuntimeError, "failed to create text");
     }
 
-    self = TypedData_Wrap_Struct(klass, &Text_data_type, ptr);
-
     if (!NIL_P(rb_string)) {
         sfText_setString(ptr->text, StringValueCStr(rb_string));
     }
@@ -531,16 +550,14 @@ static VALUE Text_get_global_bounds(VALUE self) {
  *   RenderState
  */
 static VALUE Text_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
-    if (!rb_obj_is_kind_of(rb_target, Get_Klass_Target())) {
-        raise_invalid_argument_class(Get_Klass_Target());
-    }
+    TargetView view = Get_RenderTarget_View(rb_target);
 
     if (!rb_obj_is_kind_of(rb_state, Get_Klass_RenderState())) {
         raise_invalid_argument_class(Get_Klass_RenderState());
     }
 
-    TARGET_DRAW(Get_Target_Struct(rb_target), sfRenderWindow_drawText, sfRenderTexture_drawText,
-                Get_Text_Struct(self), Get_RenderState_Struct(rb_state));
+    TARGET_DRAW(view, sfRenderWindow_drawText, sfRenderTexture_drawText, Get_Text_Struct(self),
+                Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
@@ -594,9 +611,12 @@ static VALUE Text_draw(VALUE self, VALUE rb_target, VALUE rb_state) {
 void Init_Text(VALUE rb_mSFML) {
     rb_cText = rb_define_class_under(rb_mSFML, "Text", rb_cObject);
 
+    rb_define_alloc_func(rb_cText, Text_alloc);
+
     rb_include_module(rb_cText, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cText, "new", Text_new, -1);
+    rb_define_method(rb_cText, "initialize", Text_initialize, -1);
+    rb_define_private_method(rb_cText, "initialize_copy", Text_initialize_copy, 1);
 
     rb_define_method(rb_cText, "copy", Text_copy, 0);
     rb_define_method(rb_cText, "font", Text_get_font, 0);

data/ext/graphics/texture.c

@@ -76,6 +76,24 @@ static const sfIntRect* Texture_area_ptr(VALUE rb_area, sfIntRect* storage) {
     return storage;
 }
 
+static VALUE Texture_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
+
+static VALUE Texture_alloc(VALUE klass) {
+    Texture* ptr = malloc(sizeof(Texture));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate texture");
+    }
+
+    ptr->texture = NULL;
+    ptr->owns = false;
+
+    return TypedData_Wrap_Struct(klass, &Texture_data_type, ptr);
+}
+
 /* call-seq:
  *   Texture.new(size) -> Texture
  *
@@ -84,8 +102,19 @@ static const sfIntRect* Texture_area_ptr(VALUE rb_area, sfIntRect* storage) {
  * @return [Texture] an empty texture of +size+ (a Vector2 or 2-element Array)
  * @raise [RuntimeError] if creation fails
  */
-static VALUE Texture_new(VALUE klass, VALUE rb_size) {
-    return Texture_wrap(klass, sfTexture_create(vec2u_from_rb(rb_size)));
+static VALUE Texture_initialize(VALUE self, VALUE rb_size) {
+    Texture* ptr;
+    sfTexture* texture = sfTexture_create(vec2u_from_rb(rb_size));
+
+    if (texture == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create texture");
+    }
+
+    TypedData_Get_Struct(self, Texture, &Texture_data_type, ptr);
+    ptr->texture = texture;
+    ptr->owns = true;
+
+    return self;
 }
 
 /* call-seq:
@@ -590,7 +619,9 @@ static VALUE Texture_maximum_size(VALUE klass) {
 void Init_Texture(VALUE rb_mSFML) {
     rb_cTexture = rb_define_class_under(rb_mSFML, "Texture", rb_cObject);
 
-    rb_define_singleton_method(rb_cTexture, "new", Texture_new, 1);
+    rb_define_alloc_func(rb_cTexture, Texture_alloc);
+    rb_define_method(rb_cTexture, "initialize", Texture_initialize, 1);
+    rb_define_private_method(rb_cTexture, "initialize_copy", Texture_initialize_copy, 1);
     rb_define_singleton_method(rb_cTexture, "from_file", Texture_from_file, -1);
     rb_define_singleton_method(rb_cTexture, "from_memory", Texture_from_memory, -1);
     rb_define_singleton_method(rb_cTexture, "from_stream", Texture_from_stream, -1);

data/ext/graphics/transformable.c

@@ -24,31 +24,22 @@ static const rb_data_type_t Transformable_data_type = {
     .function = {.dmark = NULL, .dfree = Transformable_free, .dsize = NULL},
     .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
-/* call-seq:
- *   Transformable.new -> Transformable
- *
- * Creates a transformable object with a default position, rotation and scale.
- *
- * @return [Transformable]
- */
-static VALUE Transformable_new(VALUE klass) {
-    VALUE self;
-    sfTransformable* transformable;
+static VALUE Transformable_alloc(VALUE klass) {
+    sfTransformable* transformable = Transformable_create();
 
-    transformable = Transformable_create();
-    self = TypedData_Wrap_Struct(klass, &Transformable_data_type, transformable);
+    if (transformable == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create transformable");
+    }
 
-    rb_obj_call_init(self, 0, NULL);
-
-    return self;
+    return TypedData_Wrap_Struct(klass, &Transformable_data_type, transformable);
 }
 
-/* call-seq: initialize -> self
+/* call-seq:
+ *   Transformable.new -> Transformable
  *
- * Initializes the transformable state, including position, rotation and scale.
+ * Creates a transformable object with a default position, rotation and scale.
  *
- * @private No-op; called internally by .new.
- * @return [self]
+ * @return [Transformable]
  */
 static VALUE Transformable_init(VALUE self) {
     return self;
@@ -258,7 +249,7 @@ static VALUE Transformable_copy(VALUE self) {
 void Init_Transformable(VALUE rb_mSFML) {
     rb_cTransformable = rb_define_class_under(rb_mSFML, "Transformable", rb_cObject);
 
-    rb_define_singleton_method(rb_cTransformable, "new", Transformable_new, 0);
+    rb_define_alloc_func(rb_cTransformable, Transformable_alloc);
     rb_define_method(rb_cTransformable, "initialize", Transformable_init, 0);
 
     rb_define_method(rb_cTransformable, "position=", Transformable_set_position, 1);