sfml3-rb 0.0.1 → 0.2.2

data/ext/graphics/circle.c

@@ -0,0 +1,319 @@
+#include "graphics/circle.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/drawable.h"
+#include "graphics/target.h"
+#include "graphics/render_state.h"
+#include "core/exceptions.h"
+#include "graphics/transform.h"
+#include "graphics/transformable.h"
+#include "graphics/color.h"
+#include "graphics/rect.h"
+#include "graphics/texture.h"
+#include "system/vec2.h"
+#include "core/macros.h"
+#include "core/sfml.h"
+
+typedef struct {
+    sfCircleShape* shape;
+    VALUE rb_texture;
+} Circle;
+
+static VALUE rb_cCircle;
+
+static void Circle_mark(void* ptr) {
+    rb_gc_mark(((Circle*)ptr)->rb_texture);
+}
+
+static void Circle_free(void* ptr) {
+    sfCircleShape_destroy(((Circle*)ptr)->shape);
+    free(ptr);
+}
+
+static const rb_data_type_t Circle_data_type = {
+    .wrap_struct_name = "SFML::Circle",
+    .function = {.dmark = Circle_mark, .dfree = Circle_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static Circle* Get_Circle(VALUE self) {
+    Circle* ptr;
+    TypedData_Get_Struct(self, Circle, &Circle_data_type, ptr);
+    return ptr;
+}
+
+static sfCircleShape* Get_Circle_Shape(VALUE self) {
+    return Get_Circle(self)->shape;
+}
+
+static VALUE Circle_wrap(VALUE klass, sfCircleShape* shape) {
+    Circle* ptr;
+
+    if (shape == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create circle shape");
+    }
+
+    ptr = malloc(sizeof(Circle));
+    ptr->shape = shape;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &Circle_data_type, ptr);
+}
+
+static VALUE Circle_new(int argc, VALUE* argv, VALUE klass) {
+    VALUE rb_radius;
+    sfCircleShape* shape;
+
+    rb_scan_args(argc, argv, "01", &rb_radius);
+
+    shape = sfCircleShape_create();
+
+    if (!NIL_P(rb_radius)) {
+        sfCircleShape_setRadius(shape, NUM2DBL(rb_radius));
+    }
+
+    return Circle_wrap(klass, shape);
+}
+
+static VALUE Circle_copy(VALUE self) {
+    Circle* ptr = Get_Circle(self);
+    VALUE copy = Circle_wrap(Get_Klass_Circle(), sfCircleShape_copy(ptr->shape));
+
+    if (!NIL_P(ptr->rb_texture)) {
+        Circle* copy_ptr = Get_Circle(copy);
+
+        copy_ptr->rb_texture = ptr->rb_texture;
+        sfCircleShape_setTexture(copy_ptr->shape, Get_Texture_Struct(ptr->rb_texture), false);
+    }
+
+    return copy;
+}
+
+static VALUE Circle_set_fill_color(VALUE self, VALUE rb_color) {
+    sfCircleShape_setFillColor(Get_Circle_Shape(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE Circle_get_fill_color(VALUE self) {
+    return color_to_rb(sfCircleShape_getFillColor(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_set_outline_color(VALUE self, VALUE rb_color) {
+    sfCircleShape_setOutlineColor(Get_Circle_Shape(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE Circle_get_outline_color(VALUE self) {
+    return color_to_rb(sfCircleShape_getOutlineColor(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_set_outline_thickness(VALUE self, VALUE rb_thickness) {
+    sfCircleShape_setOutlineThickness(Get_Circle_Shape(self), NUM2DBL(rb_thickness));
+    return rb_thickness;
+}
+
+static VALUE Circle_get_outline_thickness(VALUE self) {
+    return DBL2NUM(sfCircleShape_getOutlineThickness(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_set_radius(VALUE self, VALUE rb_radius) {
+    sfCircleShape_setRadius(Get_Circle_Shape(self), NUM2DBL(rb_radius));
+    return rb_radius;
+}
+
+static VALUE Circle_set_position(VALUE self, VALUE rb_position) {
+    sfCircleShape_setPosition(Get_Circle_Shape(self), vec2f_from_rb(rb_position));
+    return rb_position;
+}
+
+static VALUE Circle_set_rotation(VALUE self, VALUE rb_angle) {
+    sfCircleShape_setRotation(Get_Circle_Shape(self), NUM2DBL(rb_angle));
+    return rb_angle;
+}
+
+static VALUE Circle_set_origin(VALUE self, VALUE rb_origin) {
+    sfCircleShape_setOrigin(Get_Circle_Shape(self), vec2f_from_rb(rb_origin));
+    return rb_origin;
+}
+
+static VALUE Circle_set_scale(VALUE self, VALUE rb_scale) {
+    sfCircleShape_setScale(Get_Circle_Shape(self), vec2f_from_rb(rb_scale));
+    return rb_scale;
+}
+
+static VALUE Circle_get_radius(VALUE self) {
+    return DBL2NUM(sfCircleShape_getRadius(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_get_position(VALUE self) {
+    return vec2f_to_rb(sfCircleShape_getPosition(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_get_rotation(VALUE self) {
+    return DBL2NUM(sfCircleShape_getRotation(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_get_scale(VALUE self) {
+    return vec2f_to_rb(sfCircleShape_getScale(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_get_origin(VALUE self) {
+    return vec2f_to_rb(sfCircleShape_getOrigin(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_move(VALUE self, VALUE rb_move) {
+    sfCircleShape_move(Get_Circle_Shape(self), vec2f_from_rb(rb_move));
+    return self;
+}
+
+static VALUE Circle_rotate(VALUE self, VALUE rb_angle) {
+    sfCircleShape_rotate(Get_Circle_Shape(self), NUM2DBL(rb_angle));
+    return self;
+}
+
+static VALUE Circle_scale(VALUE self, VALUE rb_scale) {
+    sfCircleShape_scale(Get_Circle_Shape(self), vec2f_from_rb(rb_scale));
+    return self;
+}
+
+static VALUE Circle_get_transform(VALUE self) {
+    return Transform_MatrixToArray(sfCircleShape_getTransform(Get_Circle_Shape(self)).matrix);
+}
+
+static VALUE Circle_get_inverse_transform(VALUE self) {
+    return Transform_MatrixToArray(
+        sfCircleShape_getInverseTransform(Get_Circle_Shape(self)).matrix);
+}
+
+static VALUE Circle_set_texture(VALUE self, VALUE rb_texture) {
+    Circle* ptr = Get_Circle(self);
+
+    if (NIL_P(rb_texture)) {
+        ptr->rb_texture = Qnil;
+        sfCircleShape_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;
+    sfCircleShape_setTexture(ptr->shape, Get_Texture_Struct(rb_texture), false);
+
+    return rb_texture;
+}
+
+static VALUE Circle_get_texture(VALUE self) {
+    return Get_Circle(self)->rb_texture;
+}
+
+static VALUE Circle_get_texture_rect(VALUE self) {
+    return int_rect_to_rb(sfCircleShape_getTextureRect(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_set_texture_rect(VALUE self, VALUE rb_rect) {
+    sfCircleShape_setTextureRect(Get_Circle_Shape(self), int_rect_from_rb(rb_rect));
+    return rb_rect;
+}
+
+static VALUE Circle_get_point_count(VALUE self) {
+    return SIZET2NUM(sfCircleShape_getPointCount(Get_Circle_Shape(self)));
+}
+
+/* The number of segments the circle is approximated with -- more for a smoother
+   outline, fewer for a polygon (3 gives a triangle). */
+static VALUE Circle_set_point_count(VALUE self, VALUE rb_count) {
+    sfCircleShape_setPointCount(Get_Circle_Shape(self), NUM2SIZET(rb_count));
+
+    return self;
+}
+
+static VALUE Circle_get_point(VALUE self, VALUE rb_index) {
+    return vec2f_to_rb(sfCircleShape_getPoint(Get_Circle_Shape(self), (size_t)NUM2SIZET(rb_index)));
+}
+
+static VALUE Circle_get_geometric_center(VALUE self) {
+    return vec2f_to_rb(sfCircleShape_getGeometricCenter(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_get_local_bounds(VALUE self) {
+    return rect_to_rb(sfCircleShape_getLocalBounds(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_get_global_bounds(VALUE self) {
+    return rect_to_rb(sfCircleShape_getGlobalBounds(Get_Circle_Shape(self)));
+}
+
+static VALUE Circle_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_drawCircleShape,
+                sfRenderTexture_drawCircleShape, Get_Circle_Shape(self),
+                Get_RenderState_Struct(rb_state));
+
+    return Qnil;
+}
+
+void Init_Circle(VALUE rb_module) {
+    rb_cCircle = rb_define_class_under(rb_module, "Circle", rb_cObject);
+
+    rb_include_module(rb_cCircle, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cCircle, "new", Circle_new, -1);
+
+    // methods
+    rb_define_method(rb_cCircle, "copy", Circle_copy, 0);
+    rb_define_method(rb_cCircle, "move", Circle_move, 1);
+    rb_define_method(rb_cCircle, "rotate", Circle_rotate, 1);
+    rb_define_method(rb_cCircle, "scale!", Circle_scale, 1);
+    rb_define_method(rb_cCircle, "draw", Circle_draw, 2);
+
+    // setters
+    rb_define_method(rb_cCircle, "radius=", Circle_set_radius, 1);
+    rb_define_method(rb_cCircle, "position=", Circle_set_position, 1);
+    rb_define_method(rb_cCircle, "rotation=", Circle_set_rotation, 1);
+    rb_define_method(rb_cCircle, "scale=", Circle_set_scale, 1);
+    rb_define_method(rb_cCircle, "origin=", Circle_set_origin, 1);
+    rb_define_method(rb_cCircle, "fill_color=", Circle_set_fill_color, 1);
+    rb_define_method(rb_cCircle, "outline_color=", Circle_set_outline_color, 1);
+    rb_define_method(rb_cCircle, "outline_thickness=", Circle_set_outline_thickness, 1);
+    rb_define_method(rb_cCircle, "texture=", Circle_set_texture, 1);
+    rb_define_method(rb_cCircle, "texture_rect=", Circle_set_texture_rect, 1);
+
+    // getters
+    rb_define_method(rb_cCircle, "radius", Circle_get_radius, 0);
+    rb_define_method(rb_cCircle, "position", Circle_get_position, 0);
+    rb_define_method(rb_cCircle, "rotation", Circle_get_rotation, 0);
+    rb_define_method(rb_cCircle, "scale", Circle_get_scale, 0);
+    rb_define_method(rb_cCircle, "origin", Circle_get_origin, 0);
+    rb_define_method(rb_cCircle, "fill_color", Circle_get_fill_color, 0);
+    rb_define_method(rb_cCircle, "outline_color", Circle_get_outline_color, 0);
+    rb_define_method(rb_cCircle, "outline_thickness", Circle_get_outline_thickness, 0);
+    rb_define_method(rb_cCircle, "texture", Circle_get_texture, 0);
+    rb_define_method(rb_cCircle, "texture_rect", Circle_get_texture_rect, 0);
+    rb_define_method(rb_cCircle, "point_count", Circle_get_point_count, 0);
+    rb_define_method(rb_cCircle, "point_count=", Circle_set_point_count, 1);
+    rb_define_method(rb_cCircle, "point", Circle_get_point, 1);
+    rb_define_method(rb_cCircle, "geometric_center", Circle_get_geometric_center, 0);
+    rb_define_method(rb_cCircle, "local_bounds", Circle_get_local_bounds, 0);
+    rb_define_method(rb_cCircle, "global_bounds", Circle_get_global_bounds, 0);
+    rb_define_method(rb_cCircle, "transform", Circle_get_transform, 0);
+    rb_define_method(rb_cCircle, "inverse_transform", Circle_get_inverse_transform, 0);
+    rb_define_method(rb_cCircle, "matrix", Circle_get_transform, 0);
+}
+
+void* Get_Circle_Struct(VALUE self) {
+    return Get_Circle_Shape(self);
+}
+
+VALUE Get_Klass_Circle() {
+    return rb_cCircle;
+}

data/ext/{ext/klass/drawable → graphics}/circle.h

@@ -1,5 +1,5 @@
-#ifndef SFML_RB_CIRCLE_H
-#define SFML_RB_CIRCLE_H
+#ifndef SFML_RB_GRAPHICS_CIRCLE_H
+#define SFML_RB_GRAPHICS_CIRCLE_H
 
 #include <ruby.h>
 
@@ -9,4 +9,4 @@ void *Get_Circle_Struct(VALUE self);
 
 VALUE Get_Klass_Circle();
 
-#endif //SFML_RB_CIRCLE_H
+#endif //SFML_RB_GRAPHICS_CIRCLE_H

data/ext/graphics/color.c

@@ -0,0 +1,318 @@
+#include "graphics/color.h"
+
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfColor color;
+} Color;
+
+static VALUE rb_cColor;
+
+static void Color_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Color_data_type = {
+    .wrap_struct_name = "SFML::Color",
+    .function = {.dmark = NULL, .dfree = Color_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static unsigned char clamp_channel(int value) {
+    if (value < 0) {
+        return 0;
+    }
+
+    if (value > 255) {
+        return 255;
+    }
+
+    return (unsigned char) value;
+}
+
+static VALUE Color_wrap(sfColor color) {
+    Color *ptr = malloc(sizeof(Color));
+
+    ptr->color = color;
+
+    return TypedData_Wrap_Struct(rb_cColor, &Color_data_type, ptr);
+}
+
+static sfColor Color_from_integer(VALUE rb_integer) {
+    unsigned int value = (unsigned int) NUM2UINT(rb_integer);
+
+    if (value <= 0xFFFFFF) {
+        return (sfColor) {
+            (unsigned char) ((value >> 16) & 0xFF),
+            (unsigned char) ((value >> 8) & 0xFF),
+            (unsigned char) (value & 0xFF),
+            255
+        };
+    }
+
+    return (sfColor) {
+        (unsigned char) ((value >> 24) & 0xFF),
+        (unsigned char) ((value >> 16) & 0xFF),
+        (unsigned char) ((value >> 8) & 0xFF),
+        (unsigned char) (value & 0xFF)
+    };
+}
+
+static VALUE Color_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE self;
+    Color *ptr;
+    sfColor color = {0, 0, 0, 255};
+
+    if (argc == 1 && rb_obj_is_kind_of(argv[0], rb_cColor)) {
+        color = ((Color *) Get_Color_Struct(argv[0]))->color;
+    } else if (argc == 1 && RB_TYPE_P(argv[0], T_ARRAY)) {
+        color = color_from_rb(argv[0]);
+    } else if (argc == 1 && RB_INTEGER_TYPE_P(argv[0])) {
+        color = Color_from_integer(argv[0]);
+    } else if (argc == 3 || argc == 4) {
+        color.r = clamp_channel(NUM2INT(argv[0]));
+        color.g = clamp_channel(NUM2INT(argv[1]));
+        color.b = clamp_channel(NUM2INT(argv[2]));
+        color.a = (argc == 4) ? clamp_channel(NUM2INT(argv[3])) : 255;
+    } else if (argc != 0) {
+        raise_invalid_arguments_excepted(4, argc);
+    }
+
+    ptr = malloc(sizeof(Color));
+    ptr->color = color;
+
+    self = TypedData_Wrap_Struct(klass, &Color_data_type, ptr);
+
+    return self;
+}
+
+static VALUE Color_from_rgb(VALUE klass, VALUE rb_integer) {
+    return Color_wrap((sfColor) {
+        (unsigned char) ((NUM2UINT(rb_integer) >> 16) & 0xFF),
+        (unsigned char) ((NUM2UINT(rb_integer) >> 8) & 0xFF),
+        (unsigned char) (NUM2UINT(rb_integer) & 0xFF),
+        255
+    });
+}
+
+static VALUE Color_from_rgba(VALUE klass, VALUE rb_integer) {
+    return Color_wrap(Color_from_integer(rb_integer));
+}
+
+static VALUE Color_get_r(VALUE self) {
+    return INT2NUM(((Color *) Get_Color_Struct(self))->color.r);
+}
+
+static VALUE Color_get_g(VALUE self) {
+    return INT2NUM(((Color *) Get_Color_Struct(self))->color.g);
+}
+
+static VALUE Color_get_b(VALUE self) {
+    return INT2NUM(((Color *) Get_Color_Struct(self))->color.b);
+}
+
+static VALUE Color_get_a(VALUE self) {
+    return INT2NUM(((Color *) Get_Color_Struct(self))->color.a);
+}
+
+static VALUE Color_set_r(VALUE self, VALUE rb_value) {
+    ((Color *) Get_Color_Struct(self))->color.r = clamp_channel(NUM2INT(rb_value));
+    return rb_value;
+}
+
+static VALUE Color_set_g(VALUE self, VALUE rb_value) {
+    ((Color *) Get_Color_Struct(self))->color.g = clamp_channel(NUM2INT(rb_value));
+    return rb_value;
+}
+
+static VALUE Color_set_b(VALUE self, VALUE rb_value) {
+    ((Color *) Get_Color_Struct(self))->color.b = clamp_channel(NUM2INT(rb_value));
+    return rb_value;
+}
+
+static VALUE Color_set_a(VALUE self, VALUE rb_value) {
+    ((Color *) Get_Color_Struct(self))->color.a = clamp_channel(NUM2INT(rb_value));
+    return rb_value;
+}
+
+static VALUE Color_to_i(VALUE self) {
+    sfColor color = ((Color *) Get_Color_Struct(self))->color;
+
+    return UINT2NUM(((unsigned int) color.r << 24) | ((unsigned int) color.g << 16) |
+                    ((unsigned int) color.b << 8) | (unsigned int) color.a);
+}
+
+static VALUE Color_to_a(VALUE self) {
+    sfColor color = ((Color *) Get_Color_Struct(self))->color;
+
+    return rb_ary_new_from_args(4, INT2NUM(color.r), INT2NUM(color.g), INT2NUM(color.b), INT2NUM(color.a));
+}
+
+static VALUE Color_eql(VALUE self, VALUE rb_other) {
+    sfColor a = ((Color *) Get_Color_Struct(self))->color;
+    sfColor b;
+
+    if (!rb_obj_is_kind_of(rb_other, rb_cColor)) {
+        return Qfalse;
+    }
+
+    b = ((Color *) Get_Color_Struct(rb_other))->color;
+
+    return BOOL2RB(a.r == b.r && a.g == b.g && a.b == b.b && a.a == b.a);
+}
+
+static VALUE Color_add(VALUE self, VALUE rb_other) {
+    sfColor a = ((Color *) Get_Color_Struct(self))->color;
+    sfColor b = color_from_rb(rb_other);
+
+    return Color_wrap((sfColor) {
+        clamp_channel(a.r + b.r), clamp_channel(a.g + b.g),
+        clamp_channel(a.b + b.b), clamp_channel(a.a + b.a)
+    });
+}
+
+static VALUE Color_sub(VALUE self, VALUE rb_other) {
+    sfColor a = ((Color *) Get_Color_Struct(self))->color;
+    sfColor b = color_from_rb(rb_other);
+
+    return Color_wrap((sfColor) {
+        clamp_channel(a.r - b.r), clamp_channel(a.g - b.g),
+        clamp_channel(a.b - b.b), clamp_channel(a.a - b.a)
+    });
+}
+
+static VALUE Color_mul(VALUE self, VALUE rb_other) {
+    sfColor a = ((Color *) Get_Color_Struct(self))->color;
+    sfColor b = color_from_rb(rb_other);
+
+    return Color_wrap((sfColor) {
+        (unsigned char) ((a.r * b.r) / 255), (unsigned char) ((a.g * b.g) / 255),
+        (unsigned char) ((a.b * b.b) / 255), (unsigned char) ((a.a * b.a) / 255)
+    });
+}
+
+static VALUE Color_to_s(VALUE self) {
+    sfColor c = ((Color *) Get_Color_Struct(self))->color;
+    char buffer[64];
+
+    snprintf(buffer, sizeof(buffer), "(%u, %u, %u, %u)", c.r, c.g, c.b, c.a);
+
+    return rb_str_new2(buffer);
+}
+
+static void Color_define_predefined(VALUE klass, const char *name, sfColor color) {
+    rb_define_const(klass, name, Color_wrap(color));
+}
+
+void Init_Color(VALUE rb_module) {
+    rb_cColor = rb_define_class_under(rb_module, "Color", rb_cObject);
+
+    rb_define_singleton_method(rb_cColor, "new", Color_new, -1);
+    rb_define_singleton_method(rb_cColor, "from_rgb", Color_from_rgb, 1);
+    rb_define_singleton_method(rb_cColor, "from_rgba", Color_from_rgba, 1);
+    rb_define_singleton_method(rb_cColor, "from_integer", Color_from_rgba, 1);
+
+    rb_define_method(rb_cColor, "r", Color_get_r, 0);
+    rb_define_method(rb_cColor, "g", Color_get_g, 0);
+    rb_define_method(rb_cColor, "b", Color_get_b, 0);
+    rb_define_method(rb_cColor, "a", Color_get_a, 0);
+    rb_define_method(rb_cColor, "r=", Color_set_r, 1);
+    rb_define_method(rb_cColor, "g=", Color_set_g, 1);
+    rb_define_method(rb_cColor, "b=", Color_set_b, 1);
+    rb_define_method(rb_cColor, "a=", Color_set_a, 1);
+
+    rb_define_method(rb_cColor, "to_i", Color_to_i, 0);
+    rb_define_method(rb_cColor, "to_a", Color_to_a, 0);
+    rb_define_method(rb_cColor, "to_ary", Color_to_a, 0);
+    rb_define_method(rb_cColor, "==", Color_eql, 1);
+    rb_define_method(rb_cColor, "+", Color_add, 1);
+    rb_define_method(rb_cColor, "-", Color_sub, 1);
+    rb_define_method(rb_cColor, "*", Color_mul, 1);
+    rb_define_method(rb_cColor, "to_s", Color_to_s, 0);
+
+    Color_define_predefined(rb_cColor, "BLACK", sfBlack);
+    Color_define_predefined(rb_cColor, "WHITE", sfWhite);
+    Color_define_predefined(rb_cColor, "RED", sfRed);
+    Color_define_predefined(rb_cColor, "GREEN", sfGreen);
+    Color_define_predefined(rb_cColor, "BLUE", sfBlue);
+    Color_define_predefined(rb_cColor, "YELLOW", sfYellow);
+    Color_define_predefined(rb_cColor, "MAGENTA", sfMagenta);
+    Color_define_predefined(rb_cColor, "CYAN", sfCyan);
+    Color_define_predefined(rb_cColor, "TRANSPARENT", sfTransparent);
+}
+
+VALUE Get_Klass_Color(void) {
+    return rb_cColor;
+}
+
+void *Get_Color_Struct(VALUE self) {
+    Color *ptr;
+    TypedData_Get_Struct(self, Color, &Color_data_type, ptr);
+    return ptr;
+}
+
+sfColor color_from_rb(VALUE rb_color) {
+    if (rb_obj_is_kind_of(rb_color, rb_cColor)) {
+        return ((Color *) Get_Color_Struct(rb_color))->color;
+    }
+
+    if (RB_TYPE_P(rb_color, T_ARRAY)) {
+        long length = RARRAY_LEN(rb_color);
+
+        if (length != 3 && length != 4) {
+            raise_invalid_array_length(VALID_LENGTH_COLOR);
+        }
+
+        return (sfColor) {
+            clamp_channel(NUM2INT(rb_ary_entry(rb_color, 0))),
+            clamp_channel(NUM2INT(rb_ary_entry(rb_color, 1))),
+            clamp_channel(NUM2INT(rb_ary_entry(rb_color, 2))),
+            (length == 4) ? clamp_channel(NUM2INT(rb_ary_entry(rb_color, 3))) : 255
+        };
+    }
+
+    if (RB_INTEGER_TYPE_P(rb_color)) {
+        return Color_from_integer(rb_color);
+    }
+
+    raise_invalid_argument_class(rb_cColor);
+
+    return (sfColor) {0, 0, 0, 255};
+}
+
+VALUE color_to_rb(sfColor color) {
+    return Color_wrap(color);
+}
+
+VALUE color_new(int r, int g, int b, int a) {
+    return Color_wrap((sfColor) {clamp_channel(r), clamp_channel(g), clamp_channel(b), clamp_channel(a)});
+}
+
+void color_check(VALUE rb_color) {
+    if (rb_obj_is_kind_of(rb_color, rb_cColor) || RB_TYPE_P(rb_color, T_ARRAY) || RB_INTEGER_TYPE_P(rb_color)) {
+        return;
+    }
+
+    raise_invalid_argument_class(rb_cColor);
+}
+
+void color_swap(sfColor *color_a, sfColor *color_b) {
+    sfColor c;
+
+    c = *color_b;
+    *color_b = *color_a;
+    *color_a = c;
+}
+
+sfColor color_new_from_rb(VALUE rb_color) {
+    return color_from_rb(rb_color);
+}
+
+VALUE color_new_from_c(sfColor color) {
+    return Color_wrap(color);
+}

data/ext/graphics/color.h

@@ -0,0 +1,37 @@
+#ifndef SFML_RB_GRAPHICS_COLOR_H
+#define SFML_RB_GRAPHICS_COLOR_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+#define VALID_LENGTH_COLOR      4
+
+#define UNPACK_COLOR(c_color) \
+    (unsigned char) c_color.r, (unsigned char) c_color.g, (unsigned char) c_color.b, (unsigned char) c_color.a
+
+#define COLOR_C2RB(c_color) color_to_rb(c_color)
+
+#define COLOR_RB2C(rb_color) color_from_rb(rb_color)
+
+void Init_Color(VALUE rb_module);
+
+VALUE Get_Klass_Color(void);
+
+void *Get_Color_Struct(VALUE self);
+
+sfColor color_from_rb(VALUE rb_color);
+
+VALUE color_to_rb(sfColor color);
+
+VALUE color_new(int r, int g, int b, int a);
+
+void color_check(VALUE rb_color);
+
+void color_swap(sfColor *color_a, sfColor *color_b);
+
+sfColor color_new_from_rb(VALUE rb_color);
+
+VALUE color_new_from_c(sfColor color);
+
+#endif //SFML_RB_GRAPHICS_COLOR_H