sfml3-rb 0.2.2 → 0.3.1

data/ext/system/vec2.c

@@ -13,19 +13,43 @@ typedef struct {
 
 static VALUE rb_cVector2;
 
-static void Vector2_free(void *ptr) {
+static void Vector2_free(void* ptr) {
     free(ptr);
 }
 
 static const rb_data_type_t Vector2_data_type = {
     .wrap_struct_name = "SFML::Vector2",
     .function = {.dmark = NULL, .dfree = Vector2_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
-static VALUE Vector2_new(int argc, VALUE *argv, VALUE klass) {
-    VALUE self;
-    Vector2 *ptr;
+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)
+ *   Vector2.new([x, y])        -> Vector2(x, y)
+ *   Vector2.new(other_vector2) -> copy of +other_vector2+
+ *
+ * Creates a new 2D vector from two coordinates, a 2-element Array, or
+ * another Vector2.
+ *
+ * @return [Vector2]
+ * @raise [ArgumentError] if given an Array shorter than 2 elements, or an
+ *   argument count other than 0, 1 or 2
+ */
+static VALUE Vector2_initialize(int argc, VALUE* argv, VALUE self) {
+    Vector2* ptr;
     float x = 0;
     float y = 0;
 
@@ -47,41 +71,77 @@ static VALUE Vector2_new(int argc, VALUE *argv, VALUE klass) {
         raise_invalid_arguments_excepted(2, argc);
     }
 
-    ptr = malloc(sizeof(Vector2));
+    ptr = Get_Vector2_Struct(self);
     ptr->vec.x = x;
     ptr->vec.y = y;
 
-    self = TypedData_Wrap_Struct(klass, &Vector2_data_type, ptr);
-
     return self;
 }
 
+/* call-seq: x -> Float
+ *
+ * Returns the X component of the vector.
+ *
+ * @return [Float] the X component
+ */
 static VALUE Vector2_get_x(VALUE self) {
-    return DBL2NUM(((Vector2 *) Get_Vector2_Struct(self))->vec.x);
+    return DBL2NUM(((Vector2*)Get_Vector2_Struct(self))->vec.x);
 }
 
+/* call-seq: y -> Float
+ *
+ * Returns the Y component of the vector.
+ *
+ * @return [Float] the Y component
+ */
 static VALUE Vector2_get_y(VALUE self) {
-    return DBL2NUM(((Vector2 *) Get_Vector2_Struct(self))->vec.y);
+    return DBL2NUM(((Vector2*)Get_Vector2_Struct(self))->vec.y);
 }
 
+/* call-seq:
+ *   x=(value) -> Float
+ *
+ * Sets the X component. +value+ is any Float-convertible number.
+ *
+ * @return [Float] +value+
+ */
 static VALUE Vector2_set_x(VALUE self, VALUE rb_x) {
-    ((Vector2 *) Get_Vector2_Struct(self))->vec.x = NUM2DBL(rb_x);
+    ((Vector2*)Get_Vector2_Struct(self))->vec.x = NUM2DBL(rb_x);
     return rb_x;
 }
 
+/* call-seq:
+ *   y=(value) -> Float
+ *
+ * Sets the Y component. +value+ is any Float-convertible number.
+ *
+ * @return [Float] +value+
+ */
 static VALUE Vector2_set_y(VALUE self, VALUE rb_y) {
-    ((Vector2 *) Get_Vector2_Struct(self))->vec.y = NUM2DBL(rb_y);
+    ((Vector2*)Get_Vector2_Struct(self))->vec.y = NUM2DBL(rb_y);
     return rb_y;
 }
 
+/* call-seq: to_a -> [Float, Float]
+ *
+ * Returns the vector's components as a two-element Array.
+ *
+ * @return [Array<Float>] +[x, y]+
+ */
 static VALUE Vector2_to_a(VALUE self) {
-    Vector2 *vec = Get_Vector2_Struct(self);
+    Vector2* vec = Get_Vector2_Struct(self);
 
     return rb_ary_new_from_args(2, DBL2NUM(vec->vec.x), DBL2NUM(vec->vec.y));
 }
 
+/* call-seq: each { |component| ... } -> self
+ *
+ * Yields +x+ then +y+.
+ *
+ * @return [self]
+ */
 static VALUE Vector2_each(VALUE self) {
-    Vector2 *vec = Get_Vector2_Struct(self);
+    Vector2* vec = Get_Vector2_Struct(self);
 
     rb_yield(DBL2NUM(vec->vec.x));
     rb_yield(DBL2NUM(vec->vec.y));
@@ -89,20 +149,40 @@ static VALUE Vector2_each(VALUE self) {
     return self;
 }
 
+/* call-seq:
+ *   [](index) -> Float
+ *
+ * Returns the component stored at +index+.
+ *
+ * @return [Float] +x+ for index 0, +y+ for index 1
+ */
 static VALUE Vector2_aref(VALUE self, VALUE rb_index) {
     return rb_ary_entry(Vector2_to_a(self), NUM2LONG(rb_index));
 }
 
+/* call-seq: size -> Integer
+ *
+ * Returns the number of components, always 2.
+ *
+ * @return [Integer] always 2
+ */
 static VALUE Vector2_size(VALUE self) {
     return INT2NUM(2);
 }
 
+/* call-seq:
+ *   self == other -> true or false
+ *
+ * +other+ may be a Vector2 or a 2-element Array.
+ *
+ * @return [Boolean]
+ */
 static VALUE Vector2_eql(VALUE self, VALUE rb_other) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     sfVector2f b;
 
     if (rb_obj_is_kind_of(rb_other, rb_cVector2)) {
-        b = ((Vector2 *) Get_Vector2_Struct(rb_other))->vec;
+        b = ((Vector2*)Get_Vector2_Struct(rb_other))->vec;
     } else if (RB_TYPE_P(rb_other, T_ARRAY) && RARRAY_LEN(rb_other) >= 2) {
         b = vec2f_from_rb(rb_other);
     } else {
@@ -112,29 +192,56 @@ static VALUE Vector2_eql(VALUE self, VALUE rb_other) {
     return BOOL2RB(a->vec.x == b.x && a->vec.y == b.y);
 }
 
+/* call-seq:
+ *   self + other -> Vector2
+ *
+ * +other+ may be a Vector2 or a 2-element Array.
+ *
+ * @return [Vector2] componentwise sum
+ */
 static VALUE Vector2_add(VALUE self, VALUE rb_other) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     sfVector2f b = vec2f_from_rb(rb_other);
 
-    return vec2f_to_rb((sfVector2f) {a->vec.x + b.x, a->vec.y + b.y});
+    return vec2f_to_rb((sfVector2f){a->vec.x + b.x, a->vec.y + b.y});
 }
 
+/* call-seq:
+ *   self - other -> Vector2
+ *
+ * +other+ may be a Vector2 or a 2-element Array.
+ *
+ * @return [Vector2] componentwise difference
+ */
 static VALUE Vector2_sub(VALUE self, VALUE rb_other) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     sfVector2f b = vec2f_from_rb(rb_other);
 
-    return vec2f_to_rb((sfVector2f) {a->vec.x - b.x, a->vec.y - b.y});
+    return vec2f_to_rb((sfVector2f){a->vec.x - b.x, a->vec.y - b.y});
 }
 
+/* call-seq:
+ *   self * scalar -> Vector2
+ *
+ * Multiplies both components by +scalar+.
+ *
+ * @return [Vector2]
+ */
 static VALUE Vector2_mul(VALUE self, VALUE rb_scalar) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     float scalar = NUM2DBL(rb_scalar);
 
-    return vec2f_to_rb((sfVector2f) {a->vec.x * scalar, a->vec.y * scalar});
+    return vec2f_to_rb((sfVector2f){a->vec.x * scalar, a->vec.y * scalar});
 }
 
+/* call-seq: to_s -> String
+ *
+ * Returns a human-readable +"(x, y)"+ representation.
+ *
+ * @return [String] +"(x, y)"+
+ */
 static VALUE Vector2_to_s(VALUE self) {
-    Vector2 *a = Get_Vector2_Struct(self);
+    Vector2* a = Get_Vector2_Struct(self);
     char buffer[64];
 
     snprintf(buffer, sizeof(buffer), "(%g, %g)", a->vec.x, a->vec.y);
@@ -142,12 +249,30 @@ static VALUE Vector2_to_s(VALUE self) {
     return rb_str_new2(buffer);
 }
 
-void Init_Vector2(VALUE rb_module) {
-    rb_cVector2 = rb_define_class_under(rb_module, "Vector2", rb_cObject);
+/* Document-class: SFML::Vector2
+ * A 2D vector of floats, used throughout the library for positions, sizes,
+ * scale factors and directions.
+ *
+ * Includes +Enumerable+ and behaves like a 2-element sequence: it responds to
+ * #each, #to_a and #[], and can be compared or combined with a plain
+ * +[x, y]+ Array anywhere a Vector2 is accepted.
+ *
+ * @!attribute x
+ *   Returns the X component.
+ *
+ *   @return [Float] the X component
+ * @!attribute y
+ *   Returns the Y component.
+ *
+ *   @return [Float] the Y component
+ */
+void Init_Vector2(VALUE rb_mSFML) {
+    rb_cVector2 = rb_define_class_under(rb_mSFML, "Vector2", rb_cObject);
 
     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);
@@ -171,15 +296,15 @@ VALUE Get_Klass_Vector2(void) {
     return rb_cVector2;
 }
 
-void *Get_Vector2_Struct(VALUE self) {
-    Vector2 *ptr;
+void* Get_Vector2_Struct(VALUE self) {
+    Vector2* ptr;
     TypedData_Get_Struct(self, Vector2, &Vector2_data_type, ptr);
     return ptr;
 }
 
 sfVector2f vec2f_from_rb(VALUE rb_vec) {
     if (rb_obj_is_kind_of(rb_vec, rb_cVector2)) {
-        return ((Vector2 *) Get_Vector2_Struct(rb_vec))->vec;
+        return ((Vector2*)Get_Vector2_Struct(rb_vec))->vec;
     }
 
     if (RB_TYPE_P(rb_vec, T_ARRAY)) {
@@ -187,31 +312,33 @@ sfVector2f vec2f_from_rb(VALUE rb_vec) {
             raise_invalid_array_length(2);
         }
 
-        return (sfVector2f) {
-            (float) NUM2DBL(rb_ary_entry(rb_vec, 0)),
-            (float) NUM2DBL(rb_ary_entry(rb_vec, 1))
-        };
+        return (sfVector2f){(float)NUM2DBL(rb_ary_entry(rb_vec, 0)),
+                            (float)NUM2DBL(rb_ary_entry(rb_vec, 1))};
     }
 
     raise_invalid_argument_class(rb_cVector2);
 
-    return (sfVector2f) {0, 0};
+    return (sfVector2f){0, 0};
 }
 
 sfVector2i vec2i_from_rb(VALUE rb_vec) {
     sfVector2f vec = vec2f_from_rb(rb_vec);
 
-    return (sfVector2i) {(int) vec.x, (int) vec.y};
+    return (sfVector2i){(int)vec.x, (int)vec.y};
 }
 
 sfVector2u vec2u_from_rb(VALUE rb_vec) {
     sfVector2f vec = vec2f_from_rb(rb_vec);
 
-    return (sfVector2u) {(unsigned) vec.x, (unsigned) vec.y};
+    return (sfVector2u){(unsigned)vec.x, (unsigned)vec.y};
 }
 
 VALUE vec2f_to_rb(sfVector2f c_vec) {
-    Vector2 *ptr = malloc(sizeof(Vector2));
+    Vector2* ptr = malloc(sizeof(Vector2));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vector");
+    }
 
     ptr->vec = c_vec;
 
@@ -219,7 +346,7 @@ VALUE vec2f_to_rb(sfVector2f c_vec) {
 }
 
 VALUE vec2_new(float x, float y) {
-    return vec2f_to_rb((sfVector2f) {x, y});
+    return vec2f_to_rb((sfVector2f){x, y});
 }
 
 void vec2_check(VALUE rb_arr) {

data/ext/system/vec3.c

@@ -12,19 +12,44 @@ typedef struct {
 
 static VALUE rb_cVector3;
 
-static void Vector3_free(void *ptr) {
+static void Vector3_free(void* ptr) {
     free(ptr);
 }
 
 static const rb_data_type_t Vector3_data_type = {
     .wrap_struct_name = "SFML::Vector3",
     .function = {.dmark = NULL, .dfree = Vector3_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
-static VALUE Vector3_new(int argc, VALUE *argv, VALUE klass) {
-    VALUE self;
-    Vector3 *ptr;
+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)
+ *   Vector3.new([x, y, z])     -> Vector3(x, y, z)
+ *   Vector3.new(other_vector3) -> copy of +other_vector3+
+ *
+ * Creates a new 3D vector from three coordinates, a 3-element Array, or
+ * another Vector3.
+ *
+ * @return [Vector3]
+ * @raise [ArgumentError] if given an Array shorter than 3 elements, or an
+ *   argument count other than 0, 1 or 3
+ */
+static VALUE Vector3_initialize(int argc, VALUE* argv, VALUE self) {
+    Vector3* ptr;
     float x = 0;
     float y = 0;
     float z = 0;
@@ -50,51 +75,100 @@ static VALUE Vector3_new(int argc, VALUE *argv, VALUE klass) {
         raise_invalid_arguments_excepted(3, argc);
     }
 
-    ptr = malloc(sizeof(Vector3));
+    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;
 }
 
+/* call-seq: x -> Float
+ *
+ * Returns the X component of the vector.
+ *
+ * @return [Float] the X component
+ */
 static VALUE Vector3_get_x(VALUE self) {
-    return DBL2NUM(((Vector3 *) Get_Vector3_Struct(self))->vec.x);
+    return DBL2NUM(((Vector3*)Get_Vector3_Struct(self))->vec.x);
 }
 
+/* call-seq: y -> Float
+ *
+ * Returns the Y component of the vector.
+ *
+ * @return [Float] the Y component
+ */
 static VALUE Vector3_get_y(VALUE self) {
-    return DBL2NUM(((Vector3 *) Get_Vector3_Struct(self))->vec.y);
+    return DBL2NUM(((Vector3*)Get_Vector3_Struct(self))->vec.y);
 }
 
+/* call-seq: z -> Float
+ *
+ * Returns the Z component of the vector.
+ *
+ * @return [Float] the Z component
+ */
 static VALUE Vector3_get_z(VALUE self) {
-    return DBL2NUM(((Vector3 *) Get_Vector3_Struct(self))->vec.z);
+    return DBL2NUM(((Vector3*)Get_Vector3_Struct(self))->vec.z);
 }
 
+/* call-seq:
+ *   x=(value) -> Float
+ *
+ * Sets the X component. +value+ is any Float-convertible number.
+ *
+ * @return [Float] +value+
+ */
 static VALUE Vector3_set_x(VALUE self, VALUE rb_x) {
-    ((Vector3 *) Get_Vector3_Struct(self))->vec.x = NUM2DBL(rb_x);
+    ((Vector3*)Get_Vector3_Struct(self))->vec.x = NUM2DBL(rb_x);
     return rb_x;
 }
 
+/* call-seq:
+ *   y=(value) -> Float
+ *
+ * Sets the Y component. +value+ is any Float-convertible number.
+ *
+ * @return [Float] +value+
+ */
 static VALUE Vector3_set_y(VALUE self, VALUE rb_y) {
-    ((Vector3 *) Get_Vector3_Struct(self))->vec.y = NUM2DBL(rb_y);
+    ((Vector3*)Get_Vector3_Struct(self))->vec.y = NUM2DBL(rb_y);
     return rb_y;
 }
 
+/* call-seq:
+ *   z=(value) -> Float
+ *
+ * Sets the Z component. +value+ is any Float-convertible number.
+ *
+ * @return [Float] +value+
+ */
 static VALUE Vector3_set_z(VALUE self, VALUE rb_z) {
-    ((Vector3 *) Get_Vector3_Struct(self))->vec.z = NUM2DBL(rb_z);
+    ((Vector3*)Get_Vector3_Struct(self))->vec.z = NUM2DBL(rb_z);
     return rb_z;
 }
 
+/* call-seq: to_a -> Array
+ *
+ * Returns the vector's components as a three-element Array.
+ *
+ * @return [Array<Float>] +[x, y, z]+
+ */
 static VALUE Vector3_to_a(VALUE self) {
-    Vector3 *vec = Get_Vector3_Struct(self);
+    Vector3* vec = Get_Vector3_Struct(self);
 
     return rb_ary_new_from_args(3, DBL2NUM(vec->vec.x), DBL2NUM(vec->vec.y), DBL2NUM(vec->vec.z));
 }
 
+/* call-seq: each { |component| ... } -> self
+ *
+ * Yields +x+, +y+, then +z+.
+ *
+ * @return [self]
+ */
 static VALUE Vector3_each(VALUE self) {
-    Vector3 *vec = Get_Vector3_Struct(self);
+    Vector3* vec = Get_Vector3_Struct(self);
 
     rb_yield(DBL2NUM(vec->vec.x));
     rb_yield(DBL2NUM(vec->vec.y));
@@ -103,16 +177,29 @@ static VALUE Vector3_each(VALUE self) {
     return self;
 }
 
+/* call-seq: size -> Integer
+ *
+ * Returns the number of components, always 3.
+ *
+ * @return [Integer] always 3
+ */
 static VALUE Vector3_size(VALUE self) {
     return INT2NUM(3);
 }
 
+/* call-seq:
+ *   self == other -> true or false
+ *
+ * +other+ may be a Vector3 or a 3-element Array.
+ *
+ * @return [Boolean]
+ */
 static VALUE Vector3_eql(VALUE self, VALUE rb_other) {
-    Vector3 *a = Get_Vector3_Struct(self);
+    Vector3* a = Get_Vector3_Struct(self);
     sfVector3f b;
 
     if (rb_obj_is_kind_of(rb_other, rb_cVector3)) {
-        b = ((Vector3 *) Get_Vector3_Struct(rb_other))->vec;
+        b = ((Vector3*)Get_Vector3_Struct(rb_other))->vec;
     } else if (RB_TYPE_P(rb_other, T_ARRAY) && RARRAY_LEN(rb_other) >= 3) {
         b = vec3f_from_rb(rb_other);
     } else {
@@ -122,29 +209,56 @@ static VALUE Vector3_eql(VALUE self, VALUE rb_other) {
     return BOOL2RB(a->vec.x == b.x && a->vec.y == b.y && a->vec.z == b.z);
 }
 
+/* call-seq:
+ *   self + other -> Vector3
+ *
+ * +other+ may be a Vector3 or a 3-element Array.
+ *
+ * @return [Vector3] componentwise sum
+ */
 static VALUE Vector3_add(VALUE self, VALUE rb_other) {
-    Vector3 *a = Get_Vector3_Struct(self);
+    Vector3* a = Get_Vector3_Struct(self);
     sfVector3f b = vec3f_from_rb(rb_other);
 
-    return vec3f_to_rb((sfVector3f) {a->vec.x + b.x, a->vec.y + b.y, a->vec.z + b.z});
+    return vec3f_to_rb((sfVector3f){a->vec.x + b.x, a->vec.y + b.y, a->vec.z + b.z});
 }
 
+/* call-seq:
+ *   self - other -> Vector3
+ *
+ * +other+ may be a Vector3 or a 3-element Array.
+ *
+ * @return [Vector3] componentwise difference
+ */
 static VALUE Vector3_sub(VALUE self, VALUE rb_other) {
-    Vector3 *a = Get_Vector3_Struct(self);
+    Vector3* a = Get_Vector3_Struct(self);
     sfVector3f b = vec3f_from_rb(rb_other);
 
-    return vec3f_to_rb((sfVector3f) {a->vec.x - b.x, a->vec.y - b.y, a->vec.z - b.z});
+    return vec3f_to_rb((sfVector3f){a->vec.x - b.x, a->vec.y - b.y, a->vec.z - b.z});
 }
 
+/* call-seq:
+ *   self * scalar -> Vector3
+ *
+ * Multiplies all three components by +scalar+.
+ *
+ * @return [Vector3]
+ */
 static VALUE Vector3_mul(VALUE self, VALUE rb_scalar) {
-    Vector3 *a = Get_Vector3_Struct(self);
+    Vector3* a = Get_Vector3_Struct(self);
     float scalar = NUM2DBL(rb_scalar);
 
-    return vec3f_to_rb((sfVector3f) {a->vec.x * scalar, a->vec.y * scalar, a->vec.z * scalar});
+    return vec3f_to_rb((sfVector3f){a->vec.x * scalar, a->vec.y * scalar, a->vec.z * scalar});
 }
 
+/* call-seq: to_s -> String
+ *
+ * Returns a human-readable +"(x, y, z)"+ representation.
+ *
+ * @return [String] +"(x, y, z)"+
+ */
 static VALUE Vector3_to_s(VALUE self) {
-    Vector3 *a = Get_Vector3_Struct(self);
+    Vector3* a = Get_Vector3_Struct(self);
     char buffer[96];
 
     snprintf(buffer, sizeof(buffer), "(%g, %g, %g)", a->vec.x, a->vec.y, a->vec.z);
@@ -152,12 +266,34 @@ static VALUE Vector3_to_s(VALUE self) {
     return rb_str_new2(buffer);
 }
 
-void Init_Vector3(VALUE rb_module) {
-    rb_cVector3 = rb_define_class_under(rb_module, "Vector3", rb_cObject);
+/* Document-class: SFML::Vector3
+ * A 3D vector of floats, used for positions, sizes and directions in 3D
+ * space (e.g. Listener and SoundSource position/direction/velocity).
+ *
+ * Includes +Enumerable+ and behaves like a 3-element sequence: it responds to
+ * #each and #to_a, and can be compared or combined with a plain
+ * +[x, y, z]+ Array anywhere a Vector3 is accepted.
+ *
+ * @!attribute x
+ *   Returns the X component.
+ *
+ *   @return [Float] the X component
+ * @!attribute y
+ *   Returns the Y component.
+ *
+ *   @return [Float] the Y component
+ * @!attribute z
+ *   Returns the Z component.
+ *
+ *   @return [Float] the Z component
+ */
+void Init_Vector3(VALUE rb_mSFML) {
+    rb_cVector3 = rb_define_class_under(rb_mSFML, "Vector3", rb_cObject);
 
     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);
@@ -182,15 +318,15 @@ VALUE Get_Klass_Vector3(void) {
     return rb_cVector3;
 }
 
-void *Get_Vector3_Struct(VALUE self) {
-    Vector3 *ptr;
+void* Get_Vector3_Struct(VALUE self) {
+    Vector3* ptr;
     TypedData_Get_Struct(self, Vector3, &Vector3_data_type, ptr);
     return ptr;
 }
 
 sfVector3f vec3f_from_rb(VALUE rb_vec) {
     if (rb_obj_is_kind_of(rb_vec, rb_cVector3)) {
-        return ((Vector3 *) Get_Vector3_Struct(rb_vec))->vec;
+        return ((Vector3*)Get_Vector3_Struct(rb_vec))->vec;
     }
 
     if (RB_TYPE_P(rb_vec, T_ARRAY)) {
@@ -198,20 +334,22 @@ sfVector3f vec3f_from_rb(VALUE rb_vec) {
             raise_invalid_array_length(3);
         }
 
-        return (sfVector3f) {
-            (float) NUM2DBL(rb_ary_entry(rb_vec, 0)),
-            (float) NUM2DBL(rb_ary_entry(rb_vec, 1)),
-            (float) NUM2DBL(rb_ary_entry(rb_vec, 2))
-        };
+        return (sfVector3f){(float)NUM2DBL(rb_ary_entry(rb_vec, 0)),
+                            (float)NUM2DBL(rb_ary_entry(rb_vec, 1)),
+                            (float)NUM2DBL(rb_ary_entry(rb_vec, 2))};
     }
 
     raise_invalid_argument_class(rb_cVector3);
 
-    return (sfVector3f) {0, 0, 0};
+    return (sfVector3f){0, 0, 0};
 }
 
 VALUE vec3f_to_rb(sfVector3f c_vec) {
-    Vector3 *ptr = malloc(sizeof(Vector3));
+    Vector3* ptr = malloc(sizeof(Vector3));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vector");
+    }
 
     ptr->vec = c_vec;