sfml3-rb 0.0.1 → 0.2.2

data/ext/graphics/polygon.c

@@ -0,0 +1,300 @@
+#include "graphics/polygon.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/drawable.h"
+#include "graphics/target.h"
+#include "graphics/render_state.h"
+#include "graphics/transform.h"
+#include "graphics/color.h"
+#include "graphics/rect.h"
+#include "graphics/texture.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfConvexShape *shape;
+    VALUE rb_texture;
+} ConvexShape;
+
+static VALUE rb_cConvexShape;
+
+static void ConvexShape_mark(void *ptr) {
+    rb_gc_mark(((ConvexShape *) ptr)->rb_texture);
+}
+
+static void ConvexShape_free(void *ptr) {
+    sfConvexShape_destroy(((ConvexShape *) ptr)->shape);
+    free(ptr);
+}
+
+static const rb_data_type_t ConvexShape_data_type = {
+    .wrap_struct_name = "SFML::ConvexShape",
+    .function = {.dmark = ConvexShape_mark, .dfree = ConvexShape_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static ConvexShape *Get_ConvexShape(VALUE self) {
+    ConvexShape *ptr;
+    TypedData_Get_Struct(self, ConvexShape, &ConvexShape_data_type, ptr);
+    return ptr;
+}
+
+static sfConvexShape *Get_ConvexShape_Struct(VALUE self) {
+    return Get_ConvexShape(self)->shape;
+}
+
+static VALUE ConvexShape_wrap(VALUE klass, sfConvexShape *shape) {
+    ConvexShape *ptr;
+
+    if (shape == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create convex shape");
+    }
+
+    ptr = malloc(sizeof(ConvexShape));
+    ptr->shape = shape;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &ConvexShape_data_type, ptr);
+}
+
+static VALUE ConvexShape_new(int argc, VALUE *argv, VALUE klass) {
+    sfConvexShape *shape = sfConvexShape_create();
+    VALUE rb_point_count;
+
+    rb_scan_args(argc, argv, "01", &rb_point_count);
+
+    if (!NIL_P(rb_point_count)) {
+        sfConvexShape_setPointCount(shape, (size_t) NUM2SIZET(rb_point_count));
+    }
+
+    return ConvexShape_wrap(klass, shape);
+}
+
+static VALUE ConvexShape_copy(VALUE self) {
+    ConvexShape *ptr = Get_ConvexShape(self);
+    VALUE copy = ConvexShape_wrap(Get_Klass_ConvexShape(), sfConvexShape_copy(ptr->shape));
+
+    if (!NIL_P(ptr->rb_texture)) {
+        ConvexShape *copy_ptr = Get_ConvexShape(copy);
+
+        copy_ptr->rb_texture = ptr->rb_texture;
+        sfConvexShape_setTexture(copy_ptr->shape, Get_Texture_Struct(ptr->rb_texture), false);
+    }
+
+    return copy;
+}
+
+static VALUE ConvexShape_get_point_count(VALUE self) {
+    return SIZET2NUM(sfConvexShape_getPointCount(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_point_count(VALUE self, VALUE rb_count) {
+    sfConvexShape_setPointCount(Get_ConvexShape_Struct(self), (size_t) NUM2SIZET(rb_count));
+    return rb_count;
+}
+
+static VALUE ConvexShape_get_point(VALUE self, VALUE rb_index) {
+    return vec2f_to_rb(sfConvexShape_getPoint(Get_ConvexShape_Struct(self), (size_t) NUM2SIZET(rb_index)));
+}
+
+static VALUE ConvexShape_set_point(VALUE self, VALUE rb_index, VALUE rb_point) {
+    sfConvexShape_setPoint(Get_ConvexShape_Struct(self), (size_t) NUM2SIZET(rb_index), vec2f_from_rb(rb_point));
+    return rb_point;
+}
+
+static VALUE ConvexShape_get_position(VALUE self) {
+    return vec2f_to_rb(sfConvexShape_getPosition(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_position(VALUE self, VALUE rb_position) {
+    sfConvexShape_setPosition(Get_ConvexShape_Struct(self), vec2f_from_rb(rb_position));
+    return rb_position;
+}
+
+static VALUE ConvexShape_get_rotation(VALUE self) {
+    return DBL2NUM(sfConvexShape_getRotation(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_rotation(VALUE self, VALUE rb_rotation) {
+    sfConvexShape_setRotation(Get_ConvexShape_Struct(self), NUM2DBL(rb_rotation));
+    return rb_rotation;
+}
+
+static VALUE ConvexShape_get_scale(VALUE self) {
+    return vec2f_to_rb(sfConvexShape_getScale(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_scale(VALUE self, VALUE rb_scale) {
+    sfConvexShape_setScale(Get_ConvexShape_Struct(self), vec2f_from_rb(rb_scale));
+    return rb_scale;
+}
+
+static VALUE ConvexShape_get_origin(VALUE self) {
+    return vec2f_to_rb(sfConvexShape_getOrigin(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_origin(VALUE self, VALUE rb_origin) {
+    sfConvexShape_setOrigin(Get_ConvexShape_Struct(self), vec2f_from_rb(rb_origin));
+    return rb_origin;
+}
+
+static VALUE ConvexShape_move(VALUE self, VALUE rb_offset) {
+    sfConvexShape_move(Get_ConvexShape_Struct(self), vec2f_from_rb(rb_offset));
+    return self;
+}
+
+static VALUE ConvexShape_rotate(VALUE self, VALUE rb_angle) {
+    sfConvexShape_rotate(Get_ConvexShape_Struct(self), NUM2DBL(rb_angle));
+    return self;
+}
+
+static VALUE ConvexShape_scale(VALUE self, VALUE rb_factors) {
+    sfConvexShape_scale(Get_ConvexShape_Struct(self), vec2f_from_rb(rb_factors));
+    return self;
+}
+
+static VALUE ConvexShape_get_transform(VALUE self) {
+    return Transform_MatrixToArray(sfConvexShape_getTransform(Get_ConvexShape_Struct(self)).matrix);
+}
+
+static VALUE ConvexShape_get_inverse_transform(VALUE self) {
+    return Transform_MatrixToArray(sfConvexShape_getInverseTransform(Get_ConvexShape_Struct(self)).matrix);
+}
+
+static VALUE ConvexShape_get_fill_color(VALUE self) {
+    return color_to_rb(sfConvexShape_getFillColor(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_fill_color(VALUE self, VALUE rb_color) {
+    sfConvexShape_setFillColor(Get_ConvexShape_Struct(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE ConvexShape_get_outline_color(VALUE self) {
+    return color_to_rb(sfConvexShape_getOutlineColor(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_outline_color(VALUE self, VALUE rb_color) {
+    sfConvexShape_setOutlineColor(Get_ConvexShape_Struct(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE ConvexShape_get_outline_thickness(VALUE self) {
+    return DBL2NUM(sfConvexShape_getOutlineThickness(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_outline_thickness(VALUE self, VALUE rb_thickness) {
+    sfConvexShape_setOutlineThickness(Get_ConvexShape_Struct(self), NUM2DBL(rb_thickness));
+    return rb_thickness;
+}
+
+static VALUE ConvexShape_set_texture(VALUE self, VALUE rb_texture) {
+    ConvexShape *ptr = Get_ConvexShape(self);
+
+    if (NIL_P(rb_texture)) {
+        ptr->rb_texture = Qnil;
+        sfConvexShape_setTexture(ptr->shape, NULL, false);
+        return rb_texture;
+    }
+
+    if (!rb_obj_is_kind_of(rb_texture, Get_Klass_Texture())) {
+        raise_invalid_argument_class(Get_Klass_Texture());
+    }
+
+    ptr->rb_texture = rb_texture;
+    sfConvexShape_setTexture(ptr->shape, Get_Texture_Struct(rb_texture), false);
+
+    return rb_texture;
+}
+
+static VALUE ConvexShape_get_texture(VALUE self) {
+    return Get_ConvexShape(self)->rb_texture;
+}
+
+static VALUE ConvexShape_get_texture_rect(VALUE self) {
+    return int_rect_to_rb(sfConvexShape_getTextureRect(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_set_texture_rect(VALUE self, VALUE rb_rect) {
+    sfConvexShape_setTextureRect(Get_ConvexShape_Struct(self), int_rect_from_rb(rb_rect));
+    return rb_rect;
+}
+
+static VALUE ConvexShape_get_geometric_center(VALUE self) {
+    return vec2f_to_rb(sfConvexShape_getGeometricCenter(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_get_local_bounds(VALUE self) {
+    return rect_to_rb(sfConvexShape_getLocalBounds(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_get_global_bounds(VALUE self) {
+    return rect_to_rb(sfConvexShape_getGlobalBounds(Get_ConvexShape_Struct(self)));
+}
+
+static VALUE ConvexShape_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_drawConvexShape, sfRenderTexture_drawConvexShape,
+                Get_ConvexShape_Struct(self), Get_RenderState_Struct(rb_state));
+
+    return Qnil;
+}
+
+void Init_ConvexShape(VALUE rb_module) {
+    rb_cConvexShape = rb_define_class_under(rb_module, "ConvexShape", rb_cObject);
+
+    rb_include_module(rb_cConvexShape, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cConvexShape, "new", ConvexShape_new, -1);
+
+    rb_define_method(rb_cConvexShape, "copy", ConvexShape_copy, 0);
+
+    rb_define_method(rb_cConvexShape, "point_count", ConvexShape_get_point_count, 0);
+    rb_define_method(rb_cConvexShape, "point", ConvexShape_get_point, 1);
+    rb_define_method(rb_cConvexShape, "position", ConvexShape_get_position, 0);
+    rb_define_method(rb_cConvexShape, "rotation", ConvexShape_get_rotation, 0);
+    rb_define_method(rb_cConvexShape, "scale", ConvexShape_get_scale, 0);
+    rb_define_method(rb_cConvexShape, "origin", ConvexShape_get_origin, 0);
+    rb_define_method(rb_cConvexShape, "fill_color", ConvexShape_get_fill_color, 0);
+    rb_define_method(rb_cConvexShape, "outline_color", ConvexShape_get_outline_color, 0);
+    rb_define_method(rb_cConvexShape, "outline_thickness", ConvexShape_get_outline_thickness, 0);
+    rb_define_method(rb_cConvexShape, "texture", ConvexShape_get_texture, 0);
+    rb_define_method(rb_cConvexShape, "texture_rect", ConvexShape_get_texture_rect, 0);
+    rb_define_method(rb_cConvexShape, "geometric_center", ConvexShape_get_geometric_center, 0);
+    rb_define_method(rb_cConvexShape, "local_bounds", ConvexShape_get_local_bounds, 0);
+    rb_define_method(rb_cConvexShape, "global_bounds", ConvexShape_get_global_bounds, 0);
+    rb_define_method(rb_cConvexShape, "transform", ConvexShape_get_transform, 0);
+    rb_define_method(rb_cConvexShape, "inverse_transform", ConvexShape_get_inverse_transform, 0);
+    rb_define_method(rb_cConvexShape, "matrix", ConvexShape_get_transform, 0);
+
+    rb_define_method(rb_cConvexShape, "point_count=", ConvexShape_set_point_count, 1);
+    rb_define_method(rb_cConvexShape, "set_point", ConvexShape_set_point, 2);
+    rb_define_method(rb_cConvexShape, "position=", ConvexShape_set_position, 1);
+    rb_define_method(rb_cConvexShape, "rotation=", ConvexShape_set_rotation, 1);
+    rb_define_method(rb_cConvexShape, "scale=", ConvexShape_set_scale, 1);
+    rb_define_method(rb_cConvexShape, "origin=", ConvexShape_set_origin, 1);
+    rb_define_method(rb_cConvexShape, "fill_color=", ConvexShape_set_fill_color, 1);
+    rb_define_method(rb_cConvexShape, "outline_color=", ConvexShape_set_outline_color, 1);
+    rb_define_method(rb_cConvexShape, "outline_thickness=", ConvexShape_set_outline_thickness, 1);
+    rb_define_method(rb_cConvexShape, "texture=", ConvexShape_set_texture, 1);
+    rb_define_method(rb_cConvexShape, "texture_rect=", ConvexShape_set_texture_rect, 1);
+
+    rb_define_method(rb_cConvexShape, "move", ConvexShape_move, 1);
+    rb_define_method(rb_cConvexShape, "rotate", ConvexShape_rotate, 1);
+    rb_define_method(rb_cConvexShape, "scale!", ConvexShape_scale, 1);
+    rb_define_method(rb_cConvexShape, "draw", ConvexShape_draw, 2);
+}
+
+VALUE Get_Klass_ConvexShape(void) {
+    return rb_cConvexShape;
+}

data/ext/graphics/polygon.h

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

data/ext/graphics/rect.c

@@ -0,0 +1,287 @@
+#include "graphics/rect.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "system/vec2.h"
+
+typedef struct {
+    sfFloatRect rect;
+} Rect;
+
+static VALUE rb_cRect;
+
+static void Rect_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Rect_data_type = {
+    .wrap_struct_name = "SFML::Rect",
+    .function = {.dmark = NULL, .dfree = Rect_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Rect_wrap(sfFloatRect rect) {
+    Rect *ptr = malloc(sizeof(Rect));
+
+    ptr->rect = rect;
+
+    return TypedData_Wrap_Struct(rb_cRect, &Rect_data_type, ptr);
+}
+
+static VALUE Rect_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE self;
+    Rect *ptr;
+    sfFloatRect rect = {{0, 0}, {0, 0}};
+
+    if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cRect)) {
+        rect = ((Rect *) Get_Rect_Struct(argv[0]))->rect;
+    } else if (argc == 1 && RB_TYPE_P(argv[0], T_ARRAY)) {
+        rect = rect_from_rb(argv[0]);
+    } else if (argc == 2) {
+        rect = (sfFloatRect) {
+            {(float) NUM2DBL(argv[0]), (float) NUM2DBL(argv[1])},
+            {0, 0}
+        };
+    } else if (argc == 4) {
+        rect = (sfFloatRect) {
+            {(float) NUM2DBL(argv[0]), (float) NUM2DBL(argv[1])},
+            {(float) NUM2DBL(argv[2]), (float) NUM2DBL(argv[3])}
+        };
+    } else if (argc != 0) {
+        raise_invalid_arguments_excepted(4, argc);
+    }
+
+    ptr = malloc(sizeof(Rect));
+    ptr->rect = rect;
+
+    self = TypedData_Wrap_Struct(klass, &Rect_data_type, ptr);
+
+    return self;
+}
+
+static VALUE Rect_get_left(VALUE self) {
+    return DBL2NUM(((Rect *) Get_Rect_Struct(self))->rect.position.x);
+}
+
+static VALUE Rect_get_top(VALUE self) {
+    return DBL2NUM(((Rect *) Get_Rect_Struct(self))->rect.position.y);
+}
+
+static VALUE Rect_get_width(VALUE self) {
+    return DBL2NUM(((Rect *) Get_Rect_Struct(self))->rect.size.x);
+}
+
+static VALUE Rect_get_height(VALUE self) {
+    return DBL2NUM(((Rect *) Get_Rect_Struct(self))->rect.size.y);
+}
+
+static VALUE Rect_set_left(VALUE self, VALUE rb_value) {
+    ((Rect *) Get_Rect_Struct(self))->rect.position.x = NUM2DBL(rb_value);
+    return rb_value;
+}
+
+static VALUE Rect_set_top(VALUE self, VALUE rb_value) {
+    ((Rect *) Get_Rect_Struct(self))->rect.position.y = NUM2DBL(rb_value);
+    return rb_value;
+}
+
+static VALUE Rect_set_width(VALUE self, VALUE rb_value) {
+    ((Rect *) Get_Rect_Struct(self))->rect.size.x = NUM2DBL(rb_value);
+    return rb_value;
+}
+
+static VALUE Rect_set_height(VALUE self, VALUE rb_value) {
+    ((Rect *) Get_Rect_Struct(self))->rect.size.y = NUM2DBL(rb_value);
+    return rb_value;
+}
+
+static VALUE Rect_get_position(VALUE self) {
+    sfFloatRect rect = ((Rect *) Get_Rect_Struct(self))->rect;
+
+    return vec2f_to_rb(rect.position);
+}
+
+static VALUE Rect_get_size(VALUE self) {
+    sfFloatRect rect = ((Rect *) Get_Rect_Struct(self))->rect;
+
+    return vec2f_to_rb(rect.size);
+}
+
+static VALUE Rect_set_position(VALUE self, VALUE rb_position) {
+    ((Rect *) Get_Rect_Struct(self))->rect.position = vec2f_from_rb(rb_position);
+    return rb_position;
+}
+
+static VALUE Rect_set_size(VALUE self, VALUE rb_size) {
+    ((Rect *) Get_Rect_Struct(self))->rect.size = vec2f_from_rb(rb_size);
+    return rb_size;
+}
+
+static VALUE Rect_contains(int argc, VALUE *argv, VALUE self) {
+    sfFloatRect rect = ((Rect *) Get_Rect_Struct(self))->rect;
+    sfVector2f point;
+
+    if (argc == 1) {
+        point = vec2f_from_rb(argv[0]);
+    } else if (argc == 2) {
+        point = (sfVector2f) {(float) NUM2DBL(argv[0]), (float) NUM2DBL(argv[1])};
+    } else {
+        raise_invalid_arguments_excepted(2, argc);
+        return Qfalse;
+    }
+
+    return BOOL2RB(sfFloatRect_contains(&rect, point));
+}
+
+static VALUE Rect_intersection(VALUE self, VALUE rb_other) {
+    sfFloatRect a = ((Rect *) Get_Rect_Struct(self))->rect;
+    sfFloatRect b = rect_from_rb(rb_other);
+    sfFloatRect intersection;
+
+    if (sfFloatRect_intersects(&a, &b, &intersection)) {
+        return Rect_wrap(intersection);
+    }
+
+    return Qnil;
+}
+
+static VALUE Rect_intersects(VALUE self, VALUE rb_other) {
+    return BOOL2RB(Rect_intersection(self, rb_other) != Qnil);
+}
+
+static VALUE Rect_to_a(VALUE self) {
+    sfFloatRect rect = ((Rect *) Get_Rect_Struct(self))->rect;
+
+    return rb_ary_new_from_args(4, DBL2NUM(rect.position.x), DBL2NUM(rect.position.y),
+                                DBL2NUM(rect.size.x), DBL2NUM(rect.size.y));
+}
+
+static VALUE Rect_each(VALUE self) {
+    VALUE array = Rect_to_a(self);
+    long i;
+
+    for (i = 0; i < 4; i++) {
+        rb_yield(rb_ary_entry(array, i));
+    }
+
+    return self;
+}
+
+static VALUE Rect_eql(VALUE self, VALUE rb_other) {
+    sfFloatRect a = ((Rect *) Get_Rect_Struct(self))->rect;
+    sfFloatRect b;
+
+    if (rb_obj_is_kind_of(rb_other, rb_cRect)) {
+        b = ((Rect *) Get_Rect_Struct(rb_other))->rect;
+    } else if (RB_TYPE_P(rb_other, T_ARRAY) && RARRAY_LEN(rb_other) >= 4) {
+        b = rect_from_rb(rb_other);
+    } else {
+        return Qfalse;
+    }
+
+    return BOOL2RB(a.position.x == b.position.x && a.position.y == b.position.y &&
+                   a.size.x == b.size.x && a.size.y == b.size.y);
+}
+
+static VALUE Rect_to_s(VALUE self) {
+    sfFloatRect rect = ((Rect *) Get_Rect_Struct(self))->rect;
+    char buffer[96];
+
+    snprintf(buffer, sizeof(buffer), "(%g, %g, %g, %g)", rect.position.x, rect.position.y, rect.size.x, rect.size.y);
+
+    return rb_str_new2(buffer);
+}
+
+void Init_Rect(VALUE rb_module) {
+    rb_cRect = rb_define_class_under(rb_module, "Rect", rb_cObject);
+
+    rb_include_module(rb_cRect, rb_mEnumerable);
+
+    rb_define_singleton_method(rb_cRect, "new", Rect_new, -1);
+
+    rb_define_method(rb_cRect, "left", Rect_get_left, 0);
+    rb_define_method(rb_cRect, "top", Rect_get_top, 0);
+    rb_define_method(rb_cRect, "width", Rect_get_width, 0);
+    rb_define_method(rb_cRect, "height", Rect_get_height, 0);
+    rb_define_method(rb_cRect, "left=", Rect_set_left, 1);
+    rb_define_method(rb_cRect, "top=", Rect_set_top, 1);
+    rb_define_method(rb_cRect, "width=", Rect_set_width, 1);
+    rb_define_method(rb_cRect, "height=", Rect_set_height, 1);
+
+    rb_define_method(rb_cRect, "position", Rect_get_position, 0);
+    rb_define_method(rb_cRect, "size", Rect_get_size, 0);
+    rb_define_method(rb_cRect, "position=", Rect_set_position, 1);
+    rb_define_method(rb_cRect, "size=", Rect_set_size, 1);
+
+    rb_define_method(rb_cRect, "contains?", Rect_contains, -1);
+    rb_define_method(rb_cRect, "intersects?", Rect_intersects, 1);
+    rb_define_method(rb_cRect, "intersection", Rect_intersection, 1);
+
+    rb_define_method(rb_cRect, "to_a", Rect_to_a, 0);
+    rb_define_method(rb_cRect, "to_ary", Rect_to_a, 0);
+    rb_define_method(rb_cRect, "each", Rect_each, 0);
+    rb_define_method(rb_cRect, "==", Rect_eql, 1);
+    rb_define_method(rb_cRect, "to_s", Rect_to_s, 0);
+}
+
+VALUE Get_Klass_Rect(void) {
+    return rb_cRect;
+}
+
+void *Get_Rect_Struct(VALUE self) {
+    Rect *ptr;
+    TypedData_Get_Struct(self, Rect, &Rect_data_type, ptr);
+    return ptr;
+}
+
+sfFloatRect rect_from_rb(VALUE rb_rect) {
+    if (rb_obj_is_kind_of(rb_rect, rb_cRect)) {
+        return ((Rect *) Get_Rect_Struct(rb_rect))->rect;
+    }
+
+    if (RB_TYPE_P(rb_rect, T_ARRAY)) {
+        if (RARRAY_LEN(rb_rect) < 4) {
+            raise_invalid_array_length(4);
+        }
+
+        return (sfFloatRect) {
+            {(float) NUM2DBL(rb_ary_entry(rb_rect, 0)), (float) NUM2DBL(rb_ary_entry(rb_rect, 1))},
+            {(float) NUM2DBL(rb_ary_entry(rb_rect, 2)), (float) NUM2DBL(rb_ary_entry(rb_rect, 3))}
+        };
+    }
+
+    raise_invalid_argument_class(rb_cRect);
+
+    return (sfFloatRect) {{0, 0}, {0, 0}};
+}
+
+VALUE rect_to_rb(sfFloatRect c_rect) {
+    return Rect_wrap(c_rect);
+}
+
+sfIntRect int_rect_from_rb(VALUE rb_rect) {
+    sfFloatRect rect = rect_from_rb(rb_rect);
+
+    return (sfIntRect) {
+        {(int) rect.position.x, (int) rect.position.y},
+        {(int) rect.size.x, (int) rect.size.y}
+    };
+}
+
+VALUE int_rect_to_rb(sfIntRect c_rect) {
+    return Rect_wrap((sfFloatRect) {
+        {(float) c_rect.position.x, (float) c_rect.position.y},
+        {(float) c_rect.size.x, (float) c_rect.size.y}
+    });
+}
+
+void Rect_check(VALUE rb_rect) {
+    if (rb_obj_is_kind_of(rb_rect, rb_cRect) || RB_TYPE_P(rb_rect, T_ARRAY)) {
+        return;
+    }
+
+    raise_invalid_argument_class(rb_cRect);
+}

data/ext/graphics/rect.h

@@ -0,0 +1,30 @@
+#ifndef SFML_RB_GRAPHICS_RECT_H
+#define SFML_RB_GRAPHICS_RECT_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+#define RECT_UNPACK(c_rect) (c_rect).position.x, (c_rect).position.y, (c_rect).size.x, (c_rect).size.y
+
+#define RECT_C2RB(c_rect) rect_to_rb(c_rect)
+
+#define RECT_RB2C(rb_rect) rect_from_rb(rb_rect)
+
+void Init_Rect(VALUE rb_module);
+
+VALUE Get_Klass_Rect(void);
+
+void *Get_Rect_Struct(VALUE self);
+
+sfFloatRect rect_from_rb(VALUE rb_rect);
+
+VALUE rect_to_rb(sfFloatRect c_rect);
+
+sfIntRect int_rect_from_rb(VALUE rb_rect);
+
+VALUE int_rect_to_rb(sfIntRect c_rect);
+
+void Rect_check(VALUE rb_rect);
+
+#endif //SFML_RB_GRAPHICS_RECT_H