sfml3-rb 0.2.2 → 0.3.1

data/ext/graphics/vertex.c

@@ -31,7 +31,30 @@ static VALUE Vertex_wrap(sfVertex vertex) {
     return TypedData_Wrap_Struct(rb_cVertex, &Vertex_data_type, ptr);
 }
 
-static VALUE Vertex_new(int argc, VALUE* argv, VALUE klass) {
+static VALUE Vertex_alloc(VALUE klass) {
+    Vertex* ptr = malloc(sizeof(Vertex));
+
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "failed to allocate vertex");
+    }
+
+    ptr->vertex = (sfVertex){{0, 0}, {0, 0, 0, 0}, {0, 0}};
+
+    return TypedData_Wrap_Struct(klass, &Vertex_data_type, ptr);
+}
+
+/* call-seq:
+ *   Vertex.new                              -> Vertex
+ *   Vertex.new(position)                    -> Vertex
+ *   Vertex.new(position, color)             -> Vertex
+ *   Vertex.new(position, color, tex_coords) -> Vertex
+ *
+ * Any omitted argument defaults to position +(0, 0)+, color white, and
+ * tex_coords +(0, 0)+.
+ *
+ * @return [Vertex]
+ */
+static VALUE Vertex_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_position, rb_color, rb_tex_coords;
     sfVertex vertex = {{0, 0}, {255, 255, 255, 255}, {0, 0}};
 
@@ -49,42 +72,96 @@ static VALUE Vertex_new(int argc, VALUE* argv, VALUE klass) {
         vertex.texCoords = vec2f_from_rb(rb_tex_coords);
     }
 
-    return Vertex_wrap(vertex);
+    ((Vertex*)Get_Vertex_Struct(self))->vertex = vertex;
+
+    return self;
 }
 
+/* call-seq: position -> Vector2
+ *
+ * Returns the object's position.
+ *
+ * @return [Vector2]
+ */
 static VALUE Vertex_get_position(VALUE self) {
     return vec2f_to_rb(((Vertex*)Get_Vertex_Struct(self))->vertex.position);
 }
 
+/* call-seq:
+ *   position=(value) -> Vector2
+ *
+ * Sets the object's position.
+ *
+ * @return [Vector2] +value+
+ */
 static VALUE Vertex_set_position(VALUE self, VALUE rb_position) {
     ((Vertex*)Get_Vertex_Struct(self))->vertex.position = vec2f_from_rb(rb_position);
     return rb_position;
 }
 
+/* call-seq: color -> Color
+ *
+ * Returns the object's color.
+ *
+ * @return [Color]
+ */
 static VALUE Vertex_get_color(VALUE self) {
     return color_to_rb(((Vertex*)Get_Vertex_Struct(self))->vertex.color);
 }
 
+/* call-seq:
+ *   color=(value) -> Color
+ *
+ * Sets the object's color.
+ *
+ * @return [Color] +value+
+ */
 static VALUE Vertex_set_color(VALUE self, VALUE rb_color) {
     ((Vertex*)Get_Vertex_Struct(self))->vertex.color = color_from_rb(rb_color);
     return rb_color;
 }
 
+/* call-seq: tex_coords -> Vector2
+ *
+ * Returns the vertex's texture coordinates.
+ *
+ * @return [Vector2]
+ */
 static VALUE Vertex_get_tex_coords(VALUE self) {
     return vec2f_to_rb(((Vertex*)Get_Vertex_Struct(self))->vertex.texCoords);
 }
 
+/* call-seq:
+ *   tex_coords=(value) -> Vector2
+ *
+ * Sets the vertex's texture coordinates.
+ *
+ * @return [Vector2] +value+
+ */
 static VALUE Vertex_set_tex_coords(VALUE self, VALUE rb_tex_coords) {
     ((Vertex*)Get_Vertex_Struct(self))->vertex.texCoords = vec2f_from_rb(rb_tex_coords);
     return rb_tex_coords;
 }
 
+/* call-seq: to_a -> [Vector2, Color]
+ *
+ * Returns the object as an Array.
+ *
+ * @return [Array] +[position, color]+
+ */
 static VALUE Vertex_to_a(VALUE self) {
     Vertex* v = Get_Vertex_Struct(self);
 
     return rb_ary_new_from_args(2, vec2f_to_rb(v->vertex.position), color_to_rb(v->vertex.color));
 }
 
+/* call-seq:
+ *   self == other -> true or false
+ *
+ * Returns +true+ if the two objects are equal.
+ *
+ * @return [Boolean]
+ */
 static VALUE Vertex_eql(VALUE self, VALUE rb_other) {
     sfVertex a = ((Vertex*)Get_Vertex_Struct(self))->vertex;
     sfVertex b;
@@ -101,10 +178,25 @@ static VALUE Vertex_eql(VALUE self, VALUE rb_other) {
                    a.texCoords.y == b.texCoords.y);
 }
 
-void Init_Vertex(VALUE rb_module) {
-    rb_cVertex = rb_define_class_under(rb_module, "Vertex", rb_cObject);
-
-    rb_define_singleton_method(rb_cVertex, "new", Vertex_new, -1);
+/* Document-class: SFML::Vertex
+ * A single point used to build up VertexArray and VertexBuffer primitives:
+ * a position, a color, and texture coordinates.
+ *
+ * @!attribute position
+ *   The object's position.
+ *   @return [Vector2]
+ * @!attribute color
+ *   The object's color.
+ *   @return [Color]
+ * @!attribute tex_coords
+ *   The vertex's texture coordinates.
+ *   @return [Vector2]
+ */
+void Init_Vertex(VALUE rb_mSFML) {
+    rb_cVertex = rb_define_class_under(rb_mSFML, "Vertex", rb_cObject);
+
+    rb_define_alloc_func(rb_cVertex, Vertex_alloc);
+    rb_define_method(rb_cVertex, "initialize", Vertex_initialize, -1);
 
     rb_define_method(rb_cVertex, "position", Vertex_get_position, 0);
     rb_define_method(rb_cVertex, "color", Vertex_get_color, 0);

data/ext/graphics/vertex_array.c

@@ -14,17 +14,16 @@
 
 static VALUE rb_cVertexArray;
 
-static void VertexArray_free(void *ptr) {
+static void VertexArray_free(void* ptr) {
     sfVertexArray_destroy(ptr);
 }
 
 static const rb_data_type_t VertexArray_data_type = {
     .wrap_struct_name = "SFML::VertexArray",
     .function = {.dmark = NULL, .dfree = VertexArray_free, .dsize = NULL},
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
-static VALUE VertexArray_wrap(VALUE klass, sfVertexArray *array) {
+static VALUE VertexArray_wrap(VALUE klass, sfVertexArray* array) {
     if (array == NULL) {
         rb_raise(rb_eRuntimeError, "failed to create vertex array");
     }
@@ -32,82 +31,204 @@ static VALUE VertexArray_wrap(VALUE klass, sfVertexArray *array) {
     return TypedData_Wrap_Struct(klass, &VertexArray_data_type, array);
 }
 
-static sfVertexArray *Get_VertexArray_Struct(VALUE self) {
-    sfVertexArray *ptr;
+static sfVertexArray* Get_VertexArray_Struct(VALUE self) {
+    sfVertexArray* ptr;
     TypedData_Get_Struct(self, sfVertexArray, &VertexArray_data_type, ptr);
     return ptr;
 }
 
-static VALUE VertexArray_new(VALUE klass) {
-    return VertexArray_wrap(klass, sfVertexArray_create());
+static VALUE VertexArray_alloc(VALUE klass) {
+    sfVertexArray* array = sfVertexArray_create();
+
+    if (array == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create vertex array");
+    }
+
+    return TypedData_Wrap_Struct(klass, &VertexArray_data_type, array);
+}
+
+/* call-seq:
+ *   VertexArray.new -> VertexArray
+ *
+ * Creates a vertex array using the given +primitive+ type.
+ *
+ * @return [VertexArray] an empty array of :points primitives
+ */
+static VALUE VertexArray_initialize(VALUE self) {
+    return self;
 }
 
+/* call-seq: copy -> VertexArray
+ *
+ * Returns a deep copy of the object.
+ *
+ * @return [VertexArray] an independent copy
+ */
 static VALUE VertexArray_copy(VALUE self) {
-    return VertexArray_wrap(Get_Klass_VertexArray(), sfVertexArray_copy(Get_VertexArray_Struct(self)));
+    return VertexArray_wrap(Get_Klass_VertexArray(),
+                            sfVertexArray_copy(Get_VertexArray_Struct(self)));
 }
 
+/* call-seq: vertex_count -> Integer
+ *
+ * Returns the number of vertices stored.
+ *
+ * @return [Integer]
+ */
 static VALUE VertexArray_get_vertex_count(VALUE self) {
     return SIZET2NUM(sfVertexArray_getVertexCount(Get_VertexArray_Struct(self)));
 }
 
-static VALUE VertexArray_get_vertex(VALUE self, VALUE rb_index) {
-    return vertex_to_rb(*sfVertexArray_getVertex(Get_VertexArray_Struct(self), (size_t) NUM2SIZET(rb_index)));
+static size_t VertexArray_check_index(VALUE self, VALUE rb_index) {
+    void* array = Get_VertexArray_Struct(self);
+    size_t index = (size_t)NUM2SIZET(rb_index);
+    size_t count = sfVertexArray_getVertexCount(array);
+
+    if (index >= count) {
+        rb_raise(rb_eIndexError, "index %zu outside of vertex count %zu", index, count);
+    }
+
+    return index;
 }
 
+/* call-seq:
+ *   vertex(index) -> Vertex
+ *
+ * Returns the vertex at +index+.
+ *
+ * @return [Vertex] a copy of the vertex at +index+
+ * @raise [IndexError] if +index+ is out of range
+ */
+static VALUE VertexArray_get_vertex(VALUE self, VALUE rb_index) {
+    return vertex_to_rb(*sfVertexArray_getVertex(Get_VertexArray_Struct(self),
+                                                 VertexArray_check_index(self, rb_index)));
+}
+
+/* call-seq:
+ *   set_vertex(index, vertex) -> Vertex
+ *
+ * Replaces the vertex at +index+ with +vertex+.
+ *
+ * @return [Vertex] +vertex+
+ * @raise [IndexError] if +index+ is out of range
+ */
 static VALUE VertexArray_set_vertex(VALUE self, VALUE rb_index, VALUE rb_vertex) {
-    *sfVertexArray_getVertex(Get_VertexArray_Struct(self), (size_t) NUM2SIZET(rb_index)) = vertex_from_rb(rb_vertex);
+    *sfVertexArray_getVertex(Get_VertexArray_Struct(self),
+                             VertexArray_check_index(self, rb_index)) = vertex_from_rb(rb_vertex);
     return rb_vertex;
 }
 
+/* call-seq:
+ *   append(vertex) -> self
+ *
+ * Appends +vertex+ to the array.
+ *
+ * @return [self]
+ */
 static VALUE VertexArray_append(VALUE self, VALUE rb_vertex) {
     sfVertexArray_append(Get_VertexArray_Struct(self), vertex_from_rb(rb_vertex));
     return self;
 }
 
+/* call-seq: clear! -> self
+ *
+ * Removes all vertices.
+ *
+ * @return [self]
+ */
 static VALUE VertexArray_clear(VALUE self) {
     sfVertexArray_clear(Get_VertexArray_Struct(self));
     return self;
 }
 
+/* call-seq:
+ *   resize(count) -> self
+ *
+ * Grows or shrinks the array to +count+ vertices; new vertices are default
+ * ones.
+ *
+ * @return [self]
+ */
 static VALUE VertexArray_resize(VALUE self, VALUE rb_count) {
-    sfVertexArray_resize(Get_VertexArray_Struct(self), (size_t) NUM2SIZET(rb_count));
+    sfVertexArray_resize(Get_VertexArray_Struct(self), (size_t)NUM2SIZET(rb_count));
     return self;
 }
 
+/* call-seq: primitive -> Symbol
+ *
+ * Returns the primitive type used to draw the vertices.
+ *
+ * @return [Symbol] the primitive type vertices are interpreted as (e.g.
+ *   :points, :lines, :triangles)
+ */
 static VALUE VertexArray_get_primitive_type(VALUE self) {
-    return ID2SYM(rb_intern(primitive_type_name(sfVertexArray_getPrimitiveType(Get_VertexArray_Struct(self)))));
+    return ID2SYM(rb_intern(
+        primitive_type_name(sfVertexArray_getPrimitiveType(Get_VertexArray_Struct(self)))));
 }
 
+/* call-seq:
+ *   primitive=(value) -> Symbol
+ *
+ * Sets the primitive type used to draw the vertices.
+ *
+ * @return [Symbol] +value+
+ */
 static VALUE VertexArray_set_primitive_type(VALUE self, VALUE rb_type) {
     sfVertexArray_setPrimitiveType(Get_VertexArray_Struct(self), primitive_type_from_rb(rb_type));
     return rb_type;
 }
 
+/* call-seq: bounds -> Rect
+ *
+ * Returns the axis-aligned bounding box of all vertices.
+ *
+ * @return [Rect] the axis-aligned bounding box of all vertices
+ */
 static VALUE VertexArray_get_bounds(VALUE self) {
     return rect_to_rb(sfVertexArray_getBounds(Get_VertexArray_Struct(self)));
 }
 
+/* call-seq:
+ *   draw(target, state) -> nil
+ *
+ * Part of the Drawable interface; call Target#draw instead of this
+ * directly.
+ *
+ * @return [nil]
+ * @raise [TypeError] if +target+ is not a Target or +state+ is not a
+ *   RenderState
+ */
 static VALUE VertexArray_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_drawVertexArray, sfRenderTexture_drawVertexArray,
+    TARGET_DRAW(view, sfRenderWindow_drawVertexArray, sfRenderTexture_drawVertexArray,
                 Get_VertexArray_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
 
-void Init_VertexArray(VALUE rb_module) {
-    rb_cVertexArray = rb_define_class_under(rb_module, "VertexArray", rb_cObject);
+/* Document-class: SFML::VertexArray
+ * A resizable, drawable set of Vertex objects interpreted as a given
+ * primitive type (points, lines, triangles, ...).
+ *
+ * Includes +Drawable+.
+ *
+ * @!attribute primitive
+ *   The primitive type used to draw the vertices.
+ *   @return [Symbol]
+ */
+void Init_VertexArray(VALUE rb_mSFML) {
+    rb_cVertexArray = rb_define_class_under(rb_mSFML, "VertexArray", rb_cObject);
+
+    rb_define_alloc_func(rb_cVertexArray, VertexArray_alloc);
 
     rb_include_module(rb_cVertexArray, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cVertexArray, "new", VertexArray_new, 0);
+    rb_define_method(rb_cVertexArray, "initialize", VertexArray_initialize, 0);
 
     rb_define_method(rb_cVertexArray, "copy", VertexArray_copy, 0);
     rb_define_method(rb_cVertexArray, "vertex_count", VertexArray_get_vertex_count, 0);

data/ext/graphics/vertex_buffer.c

@@ -17,7 +17,9 @@ static VALUE rb_cVertexBuffer;
 static const char* usage_names[] = {"stream", "dynamic", "static"};
 
 static void VertexBuffer_free(void* ptr) {
-    sfVertexBuffer_destroy(ptr);
+    if (ptr != NULL) {
+        sfVertexBuffer_destroy(ptr);
+    }
 }
 
 static const rb_data_type_t VertexBuffer_data_type = {
@@ -60,11 +62,35 @@ static sfVertexBufferUsage usage_from_rb(VALUE rb_usage) {
     return sfVertexBufferStatic;
 }
 
-static VALUE VertexBuffer_new(int argc, VALUE* argv, VALUE klass) {
+static VALUE VertexBuffer_initialize_copy(VALUE self, VALUE other) {
+    (void)other;
+    rb_raise(rb_eTypeError, "can't copy a %s", rb_obj_classname(self));
+}
+
+static VALUE VertexBuffer_alloc(VALUE klass) {
+    return TypedData_Wrap_Struct(klass, &VertexBuffer_data_type, NULL);
+}
+
+/* call-seq:
+ *   VertexBuffer.new                                    -> VertexBuffer
+ *   VertexBuffer.new(count)                             -> VertexBuffer
+ *   VertexBuffer.new(count, primitive)                  -> VertexBuffer
+ *   VertexBuffer.new(count, primitive, usage)            -> VertexBuffer
+ *
+ * Creates a GPU-side vertex buffer holding +count+ vertices (default 0),
+ * interpreted as +primitive+ (default :points, see VertexArray#primitive),
+ * with the given +usage+ hint (one of :stream, :dynamic, :static; default
+ * :static).
+ *
+ * @return [VertexBuffer]
+ * @raise [RuntimeError] if creation fails
+ */
+static VALUE VertexBuffer_initialize(int argc, VALUE* argv, VALUE self) {
     VALUE rb_count, rb_primitive, rb_usage;
     size_t count = 0;
     sfPrimitiveType primitive = sfPoints;
     sfVertexBufferUsage usage = sfVertexBufferStatic;
+    sfVertexBuffer* buffer;
 
     rb_scan_args(argc, argv, "03", &rb_count, &rb_primitive, &rb_usage);
 
@@ -80,18 +106,48 @@ static VALUE VertexBuffer_new(int argc, VALUE* argv, VALUE klass) {
         usage = usage_from_rb(rb_usage);
     }
 
-    return VertexBuffer_wrap(klass, sfVertexBuffer_create(count, primitive, usage));
+    buffer = sfVertexBuffer_create(count, primitive, usage);
+
+    if (buffer == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create vertex buffer");
+    }
+
+    DATA_PTR(self) = buffer;
+
+    return self;
 }
 
+/* call-seq: copy -> VertexBuffer
+ *
+ * Returns a deep copy of the object.
+ *
+ * @return [VertexBuffer] an independent copy
+ */
 static VALUE VertexBuffer_copy(VALUE self) {
     return VertexBuffer_wrap(Get_Klass_VertexBuffer(),
                              sfVertexBuffer_copy(Get_VertexBuffer_Struct(self)));
 }
 
+/* call-seq: vertex_count -> Integer
+ *
+ * Returns the number of vertices stored.
+ *
+ * @return [Integer]
+ */
 static VALUE VertexBuffer_get_vertex_count(VALUE self) {
     return SIZET2NUM(sfVertexBuffer_getVertexCount(Get_VertexBuffer_Struct(self)));
 }
 
+/* call-seq:
+ *   update(vertices)         -> true or false
+ *   update(vertices, offset) -> true or false
+ *
+ * Uploads +vertices+ (an Array of Vertex, or of anything Vertex.new
+ * accepts) into the buffer starting at +offset+ (default 0). The buffer
+ * must have enough room; use #resize (via .new) if not.
+ *
+ * @return [Boolean] whether the update succeeded
+ */
 static VALUE VertexBuffer_update(int argc, VALUE* argv, VALUE self) {
     VALUE rb_vertices, rb_offset;
     unsigned int offset = 0;
@@ -115,6 +171,15 @@ static VALUE VertexBuffer_update(int argc, VALUE* argv, VALUE self) {
     return BOOL2RB(result);
 }
 
+/* call-seq:
+ *   update_from(other) -> true or false
+ *
+ * Copies the contents of +other+ (a VertexBuffer of the same vertex count)
+ * into this buffer.
+ *
+ * @return [Boolean] whether the update succeeded
+ * @raise [TypeError] if +other+ is not a VertexBuffer
+ */
 static VALUE VertexBuffer_update_from(VALUE self, VALUE rb_other) {
     if (!rb_obj_is_kind_of(rb_other, rb_cVertexBuffer)) {
         raise_invalid_argument_class(rb_cVertexBuffer);
@@ -126,6 +191,14 @@ static VALUE VertexBuffer_update_from(VALUE self, VALUE rb_other) {
 
 /* Exchanges the two buffers' contents in place, so anything already holding
    either object sees the swap. */
+/* call-seq:
+ *   swap(other) -> self
+ *
+ * Swaps the contents with +other+.
+ *
+ * @return [self]
+ * @raise [TypeError] if +other+ is not a VertexBuffer
+ */
 static VALUE VertexBuffer_swap(VALUE self, VALUE rb_other) {
     if (!rb_obj_is_kind_of(rb_other, rb_cVertexBuffer)) {
         raise_invalid_argument_class(rb_cVertexBuffer);
@@ -136,60 +209,129 @@ static VALUE VertexBuffer_swap(VALUE self, VALUE rb_other) {
     return self;
 }
 
+/* call-seq: primitive -> Symbol
+ *
+ * Returns the primitive type used to draw the vertices.
+ *
+ * @return [Symbol] see VertexArray#primitive
+ */
 static VALUE VertexBuffer_get_primitive_type(VALUE self) {
     return ID2SYM(rb_intern(
         primitive_type_name(sfVertexBuffer_getPrimitiveType(Get_VertexBuffer_Struct(self)))));
 }
 
+/* call-seq:
+ *   primitive=(value) -> Symbol
+ *
+ * Sets the primitive type used to draw the vertices.
+ *
+ * @return [Symbol] +value+
+ */
 static VALUE VertexBuffer_set_primitive_type(VALUE self, VALUE rb_type) {
     sfVertexBuffer_setPrimitiveType(Get_VertexBuffer_Struct(self), primitive_type_from_rb(rb_type));
     return rb_type;
 }
 
+/* call-seq: usage -> Symbol
+ *
+ * Returns the buffer's usage hint.
+ *
+ * @return [Symbol] one of :stream, :dynamic, :static
+ */
 static VALUE VertexBuffer_get_usage(VALUE self) {
     return ID2SYM(rb_intern(usage_names[sfVertexBuffer_getUsage(Get_VertexBuffer_Struct(self))]));
 }
 
+/* call-seq:
+ *   usage=(value) -> Symbol
+ *
+ * Sets the buffer's usage hint.
+ *
+ * @return [Symbol] +value+
+ */
 static VALUE VertexBuffer_set_usage(VALUE self, VALUE rb_usage) {
     sfVertexBuffer_setUsage(Get_VertexBuffer_Struct(self), usage_from_rb(rb_usage));
     return rb_usage;
 }
 
+/* call-seq: native_handle -> Integer
+ *
+ * Returns the underlying OpenGL handle.
+ *
+ * @return [Integer] the underlying OpenGL buffer handle
+ */
 static VALUE VertexBuffer_get_native_handle(VALUE self) {
     return UINT2NUM(sfVertexBuffer_getNativeHandle(Get_VertexBuffer_Struct(self)));
 }
 
+/* call-seq: bind -> self
+ *
+ * Binds the buffer for drawing.
+ *
+ * @return [self]
+ */
 static VALUE VertexBuffer_bind(VALUE self) {
     sfVertexBuffer_bind(Get_VertexBuffer_Struct(self));
     return self;
 }
 
+/* call-seq:
+ *   VertexBuffer.available? -> true or false
+ *
+ * Returns +true+ if vertex buffers are supported.
+ *
+ * @return [Boolean] whether the system supports vertex buffers
+ */
 static VALUE VertexBuffer_is_available(VALUE klass) {
     return BOOL2RB(sfVertexBuffer_isAvailable());
 }
 
+/* call-seq:
+ *   draw(target, state) -> nil
+ *
+ * Part of the Drawable interface; call Target#draw instead of this
+ * directly.
+ *
+ * @return [nil]
+ * @raise [TypeError] if +target+ is not a Target or +state+ is not a
+ *   RenderState
+ */
 static VALUE VertexBuffer_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_drawVertexBuffer,
-                sfRenderTexture_drawVertexBuffer, Get_VertexBuffer_Struct(self),
-                Get_RenderState_Struct(rb_state));
+    TARGET_DRAW(view, sfRenderWindow_drawVertexBuffer, sfRenderTexture_drawVertexBuffer,
+                Get_VertexBuffer_Struct(self), Get_RenderState_Struct(rb_state));
 
     return Qnil;
 }
 
-void Init_VertexBuffer(VALUE rb_module) {
-    rb_cVertexBuffer = rb_define_class_under(rb_module, "VertexBuffer", rb_cObject);
+/* Document-class: SFML::VertexBuffer
+ * Like VertexArray, but the vertex data lives in GPU memory rather than
+ * being re-uploaded on every draw -- more efficient for large, static
+ * or semi-static vertex sets.
+ *
+ * Includes +Drawable+.
+ *
+ * @!attribute primitive
+ *   The primitive type used to draw the vertices.
+ *   @return [Symbol]
+ * @!attribute usage
+ *   The buffer's usage hint.
+ *   @return [Symbol] one of :stream, :dynamic, :static
+ */
+void Init_VertexBuffer(VALUE rb_mSFML) {
+    rb_cVertexBuffer = rb_define_class_under(rb_mSFML, "VertexBuffer", rb_cObject);
+
+    rb_define_alloc_func(rb_cVertexBuffer, VertexBuffer_alloc);
 
     rb_include_module(rb_cVertexBuffer, Get_Module_Drawable());
 
-    rb_define_singleton_method(rb_cVertexBuffer, "new", VertexBuffer_new, -1);
+    rb_define_method(rb_cVertexBuffer, "initialize", VertexBuffer_initialize, -1);
+    rb_define_private_method(rb_cVertexBuffer, "initialize_copy", VertexBuffer_initialize_copy, 1);
     rb_define_singleton_method(rb_cVertexBuffer, "available?", VertexBuffer_is_available, 0);
 
     rb_define_method(rb_cVertexBuffer, "copy", VertexBuffer_copy, 0);