sfml3-rb 0.0.1 → 0.2.2

data/ext/{transformable.c → graphics/transformable.c}

@@ -1,145 +1,169 @@
-#include "ext/klass/transformable.h"
-
-#include <ruby.h>
-#include <stdio.h>
-
-#include "ext/module/transform.h"
-#include "ext/vec2.h"
-#include "ext/rect.h"
-#include "ext/module.h"
-#include "ext/sfml.h"
-
-static VALUE rb_cTransformable;
-
-static sfTransformable *Transformable_create() {
-    return sfTransformable_create();
-}
-
-static void Transformable_free(void *ptr) {
-    sfTransformable_destroy((sfTransformable *) ptr);
-}
-
-static VALUE Transformable_new(VALUE klass) {
-    VALUE self;
-    sfTransformable *transformable;
-
-    transformable = Transformable_create();
-    self = Data_Wrap_Struct(klass, 0, Transformable_free, transformable);
-
-    rb_obj_call_init(self, 0, NULL);
-
-    return self;
-}
-
-static VALUE Transformable_init(VALUE self) {
-    return self;
-}
-
-static VALUE Transformable_set_position(VALUE self, VALUE rb_position) {
-    sfVector2f position = VEC2_RB2C(rb_position);
-    sfTransformable_setPosition(Get_Transformable_Struct(self), position);
-
-    return self;
-}
-
-static VALUE Transformable_set_rotation(VALUE self, VALUE rb_angle) {
-    sfTransformable_setRotation(Get_Transformable_Struct(self), NUM2DBL(rb_angle));
-
-    return self;
-}
-
-static VALUE Transformable_set_scale(VALUE self, VALUE rb_scale) {
-    sfVector2f scale = VEC2_RB2C(rb_scale);
-    sfTransformable_setScale(Get_Transformable_Struct(self), scale);
-
-    return self;
-}
-
-static VALUE Transformable_set_origin(VALUE self, VALUE rb_origin) {
-    sfVector2f origin = VEC2_RB2C(rb_origin);
-    sfTransformable_setOrigin(Get_Transformable_Struct(self), origin);
-
-    return self;
-}
-
-static VALUE Transformable_get_position(VALUE self) {
-    sfVector2f position = sfTransformable_getPosition(Get_Transformable_Struct(self));
-
-    return VEC2_C2RB(position);
-}
-
-static VALUE Transformable_get_rotation(VALUE self) {
-    return DBL2NUM(sfTransformable_getRotation(Get_Transformable_Struct(self)));
-}
-
-static VALUE Transformable_get_scale(VALUE self) {
-    sfVector2f scale = sfTransformable_getScale(Get_Transformable_Struct(self));
-
-    return VEC2_C2RB(scale);
-}
-
-static VALUE Transformable_get_origin(VALUE self) {
-    sfVector2f origin = sfTransformable_getOrigin(Get_Transformable_Struct(self));
-
-    return VEC2_C2RB(origin);
-}
-
-static VALUE Transformable_move(VALUE self, VALUE rb_move) {
-    sfVector2f move = VEC2_RB2C(rb_move);
-    sfTransformable_move(Get_Transformable_Struct(self), move);
-
-    return self;
-}
-
-static VALUE Transformable_rotate(VALUE self, VALUE rb_angle) {
-    sfTransformable_rotate(Get_Transformable_Struct(self), NUM2DBL(rb_angle));
-
-    return self;
-}
-
-static VALUE Transformable_scale(VALUE self, VALUE rb_scale) {
-    sfVector2f scale = VEC2_RB2C(rb_scale);
-    sfTransformable_scale(Get_Transformable_Struct(self), scale);
-
-    return self;
-}
-
-static VALUE Transformable_get_matrix(VALUE self) {
-    sfTransformable *transformable = Get_Transformable_Struct(self);
-    sfTransform transform = sfTransformable_getTransform(transformable);
-
-    return Transform_MatrixToArray(transform.matrix);
-}
-
-void Init_Transformable(VALUE rb_module) {
-    rb_cTransformable = rb_define_class_under(rb_module, "Transformable", rb_cObject);
-
-    rb_define_singleton_method(rb_cTransformable, "new", Transformable_new, 0);
-    rb_define_method(rb_cTransformable, "initialize", Transformable_init, 0);
-
-    rb_define_method(rb_cTransformable, "position=", Transformable_set_position, 1);
-    rb_define_method(rb_cTransformable, "angle=", Transformable_set_rotation, 1);
-    rb_define_method(rb_cTransformable, "scale=", Transformable_set_scale, 1);
-    rb_define_method(rb_cTransformable, "origin=", Transformable_set_origin, 1);
-
-    rb_define_method(rb_cTransformable, "position", Transformable_get_position, 0);
-    rb_define_method(rb_cTransformable, "angle", Transformable_get_rotation, 0);
-    rb_define_method(rb_cTransformable, "scale", Transformable_get_scale, 0);
-    rb_define_method(rb_cTransformable, "origin", Transformable_get_origin, 0);
-
-    rb_define_method(rb_cTransformable, "move", Transformable_move, 1);
-    rb_define_method(rb_cTransformable, "rotate", Transformable_rotate, 1);
-    rb_define_method(rb_cTransformable, "escalate", Transformable_scale, 1);
-
-    rb_define_method(rb_cTransformable, "matrix", Transformable_get_matrix, 0);
-}
-
-void *Get_Transformable_Struct(VALUE self) {
-    sfTransformable *transform;
-    Data_Get_Struct(self, sfTransformable, transform);
-    return transform;
-}
-
-VALUE Get_Klass_Transformable() {
-    return rb_cTransformable;
+#include "graphics/transformable.h"
+
+#include <ruby.h>
+#include <stdio.h>
+
+#include "graphics/transform.h"
+#include "system/vec2.h"
+#include "graphics/rect.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+static VALUE rb_cTransformable;
+
+static sfTransformable* Transformable_create() {
+    return sfTransformable_create();
+}
+
+static void Transformable_free(void* ptr) {
+    sfTransformable_destroy((sfTransformable*)ptr);
+}
+
+static const rb_data_type_t Transformable_data_type = {
+    .wrap_struct_name = "SFML::Transformable",
+    .function = {.dmark = NULL, .dfree = Transformable_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE Transformable_new(VALUE klass) {
+    VALUE self;
+    sfTransformable* transformable;
+
+    transformable = Transformable_create();
+    self = TypedData_Wrap_Struct(klass, &Transformable_data_type, transformable);
+
+    rb_obj_call_init(self, 0, NULL);
+
+    return self;
+}
+
+static VALUE Transformable_init(VALUE self) {
+    return self;
+}
+
+static VALUE Transformable_set_position(VALUE self, VALUE rb_position) {
+    sfVector2f position = VEC2_RB2C(rb_position);
+    sfTransformable_setPosition(Get_Transformable_Struct(self), position);
+
+    return self;
+}
+
+static VALUE Transformable_set_rotation(VALUE self, VALUE rb_angle) {
+    sfTransformable_setRotation(Get_Transformable_Struct(self), NUM2DBL(rb_angle));
+
+    return self;
+}
+
+static VALUE Transformable_set_scale(VALUE self, VALUE rb_scale) {
+    sfVector2f scale = VEC2_RB2C(rb_scale);
+    sfTransformable_setScale(Get_Transformable_Struct(self), scale);
+
+    return self;
+}
+
+static VALUE Transformable_set_origin(VALUE self, VALUE rb_origin) {
+    sfVector2f origin = VEC2_RB2C(rb_origin);
+    sfTransformable_setOrigin(Get_Transformable_Struct(self), origin);
+
+    return self;
+}
+
+static VALUE Transformable_get_position(VALUE self) {
+    sfVector2f position = sfTransformable_getPosition(Get_Transformable_Struct(self));
+
+    return VEC2_C2RB(position);
+}
+
+static VALUE Transformable_get_rotation(VALUE self) {
+    return DBL2NUM(sfTransformable_getRotation(Get_Transformable_Struct(self)));
+}
+
+static VALUE Transformable_get_scale(VALUE self) {
+    sfVector2f scale = sfTransformable_getScale(Get_Transformable_Struct(self));
+
+    return VEC2_C2RB(scale);
+}
+
+static VALUE Transformable_get_origin(VALUE self) {
+    sfVector2f origin = sfTransformable_getOrigin(Get_Transformable_Struct(self));
+
+    return VEC2_C2RB(origin);
+}
+
+static VALUE Transformable_move(VALUE self, VALUE rb_move) {
+    sfVector2f move = VEC2_RB2C(rb_move);
+    sfTransformable_move(Get_Transformable_Struct(self), move);
+
+    return self;
+}
+
+static VALUE Transformable_rotate(VALUE self, VALUE rb_angle) {
+    sfTransformable_rotate(Get_Transformable_Struct(self), NUM2DBL(rb_angle));
+
+    return self;
+}
+
+static VALUE Transformable_scale(VALUE self, VALUE rb_scale) {
+    sfVector2f scale = VEC2_RB2C(rb_scale);
+    sfTransformable_scale(Get_Transformable_Struct(self), scale);
+
+    return self;
+}
+
+static VALUE Transformable_get_matrix(VALUE self) {
+    sfTransformable* transformable = Get_Transformable_Struct(self);
+    sfTransform transform = sfTransformable_getTransform(transformable);
+
+    return Transform_MatrixToArray(transform.matrix);
+}
+
+static VALUE Transformable_get_inverse_matrix(VALUE self) {
+    sfTransform transform = sfTransformable_getInverseTransform(Get_Transformable_Struct(self));
+
+    return Transform_MatrixToArray(transform.matrix);
+}
+
+static VALUE Transformable_copy(VALUE self) {
+    sfTransformable* copy = sfTransformable_copy(Get_Transformable_Struct(self));
+    VALUE other = TypedData_Wrap_Struct(rb_cTransformable, &Transformable_data_type, copy);
+
+    rb_obj_call_init(other, 0, NULL);
+
+    return other;
+}
+
+void Init_Transformable(VALUE rb_module) {
+    rb_cTransformable = rb_define_class_under(rb_module, "Transformable", rb_cObject);
+
+    rb_define_singleton_method(rb_cTransformable, "new", Transformable_new, 0);
+    rb_define_method(rb_cTransformable, "initialize", Transformable_init, 0);
+
+    rb_define_method(rb_cTransformable, "position=", Transformable_set_position, 1);
+    rb_define_method(rb_cTransformable, "rotation=", Transformable_set_rotation, 1);
+    rb_define_method(rb_cTransformable, "scale=", Transformable_set_scale, 1);
+    rb_define_method(rb_cTransformable, "origin=", Transformable_set_origin, 1);
+
+    rb_define_method(rb_cTransformable, "position", Transformable_get_position, 0);
+    rb_define_method(rb_cTransformable, "rotation", Transformable_get_rotation, 0);
+    rb_define_method(rb_cTransformable, "scale", Transformable_get_scale, 0);
+    rb_define_method(rb_cTransformable, "origin", Transformable_get_origin, 0);
+
+    rb_define_method(rb_cTransformable, "move", Transformable_move, 1);
+    rb_define_method(rb_cTransformable, "rotate", Transformable_rotate, 1);
+    rb_define_method(rb_cTransformable, "scale!", Transformable_scale, 1);
+
+    rb_define_method(rb_cTransformable, "transform", Transformable_get_matrix, 0);
+    rb_define_method(rb_cTransformable, "matrix", Transformable_get_matrix, 0);
+    rb_define_method(rb_cTransformable, "inverse_transform", Transformable_get_inverse_matrix, 0);
+
+    rb_define_method(rb_cTransformable, "copy", Transformable_copy, 0);
+}
+
+void* Get_Transformable_Struct(VALUE self) {
+    sfTransformable* transform;
+    TypedData_Get_Struct(self, sfTransformable, &Transformable_data_type, transform);
+    return transform;
+}
+
+VALUE Get_Klass_Transformable() {
+    return rb_cTransformable;
 }

data/ext/{ext/klass → graphics}/transformable.h

@@ -1,5 +1,5 @@
-#ifndef SFML_RB_TRANSFORMABLE_H
-#define SFML_RB_TRANSFORMABLE_H
+#ifndef SFML_RB_GRAPHICS_TRANSFORMABLE_H
+#define SFML_RB_GRAPHICS_TRANSFORMABLE_H
 
 #include <ruby.h>
 
@@ -10,4 +10,4 @@ void *Get_Transformable_Struct(VALUE self);
 
 VALUE Get_Klass_Transformable();
 
-#endif //SFML_RB_TRANSFORMABLE_H
+#endif //SFML_RB_GRAPHICS_TRANSFORMABLE_H

data/ext/graphics/vertex.c

@@ -0,0 +1,179 @@
+#include "graphics/vertex.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/color.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfVertex vertex;
+} Vertex;
+
+static VALUE rb_cVertex;
+
+static void Vertex_free(void* ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Vertex_data_type = {
+    .wrap_struct_name = "SFML::Vertex",
+    .function = {.dmark = NULL, .dfree = Vertex_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE Vertex_wrap(sfVertex vertex) {
+    Vertex* ptr = malloc(sizeof(Vertex));
+
+    ptr->vertex = vertex;
+
+    return TypedData_Wrap_Struct(rb_cVertex, &Vertex_data_type, ptr);
+}
+
+static VALUE Vertex_new(int argc, VALUE* argv, VALUE klass) {
+    VALUE rb_position, rb_color, rb_tex_coords;
+    sfVertex vertex = {{0, 0}, {255, 255, 255, 255}, {0, 0}};
+
+    rb_scan_args(argc, argv, "03", &rb_position, &rb_color, &rb_tex_coords);
+
+    if (!NIL_P(rb_position)) {
+        vertex.position = vec2f_from_rb(rb_position);
+    }
+
+    if (!NIL_P(rb_color)) {
+        vertex.color = color_from_rb(rb_color);
+    }
+
+    if (!NIL_P(rb_tex_coords)) {
+        vertex.texCoords = vec2f_from_rb(rb_tex_coords);
+    }
+
+    return Vertex_wrap(vertex);
+}
+
+static VALUE Vertex_get_position(VALUE self) {
+    return vec2f_to_rb(((Vertex*)Get_Vertex_Struct(self))->vertex.position);
+}
+
+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;
+}
+
+static VALUE Vertex_get_color(VALUE self) {
+    return color_to_rb(((Vertex*)Get_Vertex_Struct(self))->vertex.color);
+}
+
+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;
+}
+
+static VALUE Vertex_get_tex_coords(VALUE self) {
+    return vec2f_to_rb(((Vertex*)Get_Vertex_Struct(self))->vertex.texCoords);
+}
+
+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;
+}
+
+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));
+}
+
+static VALUE Vertex_eql(VALUE self, VALUE rb_other) {
+    sfVertex a = ((Vertex*)Get_Vertex_Struct(self))->vertex;
+    sfVertex b;
+
+    if (!rb_obj_is_kind_of(rb_other, rb_cVertex)) {
+        return Qfalse;
+    }
+
+    b = ((Vertex*)Get_Vertex_Struct(rb_other))->vertex;
+
+    return BOOL2RB(a.position.x == b.position.x && a.position.y == b.position.y &&
+                   a.color.r == b.color.r && a.color.g == b.color.g && a.color.b == b.color.b &&
+                   a.color.a == b.color.a && a.texCoords.x == b.texCoords.x &&
+                   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);
+
+    rb_define_method(rb_cVertex, "position", Vertex_get_position, 0);
+    rb_define_method(rb_cVertex, "color", Vertex_get_color, 0);
+    rb_define_method(rb_cVertex, "tex_coords", Vertex_get_tex_coords, 0);
+    rb_define_method(rb_cVertex, "position=", Vertex_set_position, 1);
+    rb_define_method(rb_cVertex, "color=", Vertex_set_color, 1);
+    rb_define_method(rb_cVertex, "tex_coords=", Vertex_set_tex_coords, 1);
+    rb_define_method(rb_cVertex, "to_a", Vertex_to_a, 0);
+    rb_define_method(rb_cVertex, "==", Vertex_eql, 1);
+}
+
+VALUE Get_Klass_Vertex(void) {
+    return rb_cVertex;
+}
+
+void* Get_Vertex_Struct(VALUE self) {
+    Vertex* ptr;
+    TypedData_Get_Struct(self, Vertex, &Vertex_data_type, ptr);
+    return ptr;
+}
+
+sfVertex vertex_from_rb(VALUE rb_vertex) {
+    if (rb_obj_is_kind_of(rb_vertex, rb_cVertex)) {
+        return ((Vertex*)Get_Vertex_Struct(rb_vertex))->vertex;
+    }
+
+    if (RB_TYPE_P(rb_vertex, T_ARRAY)) {
+        return vertex_from_rb(rb_funcall(rb_cVertex, rb_intern("new"), 1, rb_vertex));
+    }
+
+    raise_invalid_argument_class(rb_cVertex);
+
+    return (sfVertex){{0, 0}, {0, 0, 0, 0}, {0, 0}};
+}
+
+VALUE vertex_to_rb(sfVertex c_vertex) {
+    return Vertex_wrap(c_vertex);
+}
+
+sfVertex* vertices_from_rb(VALUE rb_vertices, size_t* count) {
+    VALUE normalized;
+    sfVertex* vertices;
+    long i, len;
+
+    Check_Type(rb_vertices, T_ARRAY);
+
+    len = RARRAY_LEN(rb_vertices);
+    normalized = rb_ary_new_capa(len);
+
+    /* Normalize -- and so raise on a bad element -- before allocating anything:
+       vertex_from_rb builds a Vertex out of a plain Array and can raise, and a
+       raise after ALLOC_N would leak the buffer. */
+    for (i = 0; i < len; i++) {
+        VALUE entry = rb_ary_entry(rb_vertices, i);
+
+        if (!rb_obj_is_kind_of(entry, rb_cVertex)) {
+            entry = rb_funcall(rb_cVertex, rb_intern("new"), 1, entry);
+        }
+
+        rb_ary_push(normalized, entry);
+    }
+
+    vertices = ALLOC_N(sfVertex, len);
+
+    for (i = 0; i < len; i++) {
+        vertices[i] = vertex_from_rb(rb_ary_entry(normalized, i));
+    }
+
+    *count = (size_t)len;
+
+    return vertices;
+}

data/ext/graphics/vertex.h

@@ -0,0 +1,23 @@
+#ifndef SFML_RB_GRAPHICS_VERTEX_H
+#define SFML_RB_GRAPHICS_VERTEX_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Vertex(VALUE rb_module);
+
+VALUE Get_Klass_Vertex(void);
+
+void* Get_Vertex_Struct(VALUE self);
+
+sfVertex vertex_from_rb(VALUE rb_vertex);
+
+VALUE vertex_to_rb(sfVertex c_vertex);
+
+/* Converts an Array of Vertex into a freshly allocated C array; the caller
+   xfree()s it. Every element is validated before anything is allocated, so a
+   bad element raises without leaking. */
+sfVertex* vertices_from_rb(VALUE rb_vertices, size_t* count);
+
+#endif // SFML_RB_GRAPHICS_VERTEX_H

data/ext/graphics/vertex_array.c

@@ -0,0 +1,127 @@
+#include "graphics/vertex_array.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/drawable.h"
+#include "graphics/target.h"
+#include "graphics/render_state.h"
+#include "graphics/rect.h"
+#include "graphics/vertex.h"
+#include "graphics/enums.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cVertexArray;
+
+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
+};
+
+static VALUE VertexArray_wrap(VALUE klass, sfVertexArray *array) {
+    if (array == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create vertex array");
+    }
+
+    return TypedData_Wrap_Struct(klass, &VertexArray_data_type, array);
+}
+
+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_copy(VALUE self) {
+    return VertexArray_wrap(Get_Klass_VertexArray(), sfVertexArray_copy(Get_VertexArray_Struct(self)));
+}
+
+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 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);
+    return rb_vertex;
+}
+
+static VALUE VertexArray_append(VALUE self, VALUE rb_vertex) {
+    sfVertexArray_append(Get_VertexArray_Struct(self), vertex_from_rb(rb_vertex));
+    return self;
+}
+
+static VALUE VertexArray_clear(VALUE self) {
+    sfVertexArray_clear(Get_VertexArray_Struct(self));
+    return self;
+}
+
+static VALUE VertexArray_resize(VALUE self, VALUE rb_count) {
+    sfVertexArray_resize(Get_VertexArray_Struct(self), (size_t) NUM2SIZET(rb_count));
+    return self;
+}
+
+static VALUE VertexArray_get_primitive_type(VALUE self) {
+    return ID2SYM(rb_intern(primitive_type_name(sfVertexArray_getPrimitiveType(Get_VertexArray_Struct(self)))));
+}
+
+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;
+}
+
+static VALUE VertexArray_get_bounds(VALUE self) {
+    return rect_to_rb(sfVertexArray_getBounds(Get_VertexArray_Struct(self)));
+}
+
+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());
+    }
+
+    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,
+                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);
+
+    rb_include_module(rb_cVertexArray, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cVertexArray, "new", VertexArray_new, 0);
+
+    rb_define_method(rb_cVertexArray, "copy", VertexArray_copy, 0);
+    rb_define_method(rb_cVertexArray, "vertex_count", VertexArray_get_vertex_count, 0);
+    rb_define_method(rb_cVertexArray, "vertex", VertexArray_get_vertex, 1);
+    rb_define_method(rb_cVertexArray, "set_vertex", VertexArray_set_vertex, 2);
+    rb_define_method(rb_cVertexArray, "append", VertexArray_append, 1);
+    rb_define_method(rb_cVertexArray, "clear!", VertexArray_clear, 0);
+    rb_define_method(rb_cVertexArray, "resize", VertexArray_resize, 1);
+    rb_define_method(rb_cVertexArray, "primitive", VertexArray_get_primitive_type, 0);
+    rb_define_method(rb_cVertexArray, "primitive=", VertexArray_set_primitive_type, 1);
+    rb_define_method(rb_cVertexArray, "bounds", VertexArray_get_bounds, 0);
+    rb_define_method(rb_cVertexArray, "draw", VertexArray_draw, 2);
+}
+
+VALUE Get_Klass_VertexArray(void) {
+    return rb_cVertexArray;
+}

data/ext/graphics/vertex_array.h

@@ -0,0 +1,10 @@
+#ifndef SFML_RB_GRAPHICS_VERTEX_ARRAY_H
+#define SFML_RB_GRAPHICS_VERTEX_ARRAY_H
+
+#include <ruby.h>
+
+void Init_VertexArray(VALUE rb_module);
+
+VALUE Get_Klass_VertexArray(void);
+
+#endif //SFML_RB_GRAPHICS_VERTEX_ARRAY_H