sfml3-rb 0.0.1 → 0.2.2

data/ext/graphics/shape.c

@@ -0,0 +1,311 @@
+#include "graphics/shape.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 {
+    sfShape *shape;
+    VALUE rb_self;
+    VALUE rb_texture;
+} CustomShape;
+
+static VALUE rb_cCustomShape;
+
+static void CustomShape_mark(void *ptr) {
+    CustomShape *shape = ptr;
+
+    rb_gc_mark(shape->rb_self);
+    rb_gc_mark(shape->rb_texture);
+}
+
+static void CustomShape_free(void *ptr) {
+    sfShape_destroy(((CustomShape *) ptr)->shape);
+    free(ptr);
+}
+
+static const rb_data_type_t CustomShape_data_type = {
+    .wrap_struct_name = "SFML::Shape",
+    .function = {.dmark = CustomShape_mark, .dfree = CustomShape_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static CustomShape *Get_CustomShape(VALUE self) {
+    CustomShape *ptr;
+    TypedData_Get_Struct(self, CustomShape, &CustomShape_data_type, ptr);
+    return ptr;
+}
+
+static sfShape *Get_CustomShape_Struct(VALUE self) {
+    return Get_CustomShape(self)->shape;
+}
+
+/* Point access is defined in Ruby, and these callbacks are reached through
+   C++ (SFML), so exceptions are contained and reported as a degenerate
+   shape instead of unwinding into foreign frames. */
+static VALUE CustomShape_get_point_count_body(VALUE v) {
+    CustomShape *shape = (CustomShape *) v;
+
+    return rb_funcall(shape->rb_self, rb_intern("point_count"), 0);
+}
+
+static size_t CustomShape_get_point_count(void *userData) {
+    CustomShape *shape = userData;
+    int state = 0;
+    VALUE count = rb_protect(CustomShape_get_point_count_body, (VALUE) shape, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        return 0;
+    }
+
+    return (size_t) NUM2SIZET(count);
+}
+
+typedef struct {
+    CustomShape *shape;
+    size_t index;
+} PointContext;
+
+static VALUE CustomShape_get_point_body(VALUE v) {
+    PointContext *ctx = (PointContext *) v;
+
+    return rb_funcall(ctx->shape->rb_self, rb_intern("point"), 1, SIZET2NUM(ctx->index));
+}
+
+static sfVector2f CustomShape_get_point(size_t index, void *userData) {
+    CustomShape *shape = userData;
+    PointContext ctx = {.shape = shape, .index = index};
+    int state = 0;
+    VALUE point = rb_protect(CustomShape_get_point_body, (VALUE) &ctx, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        return (sfVector2f) {0, 0};
+    }
+
+    return vec2f_from_rb(point);
+}
+
+static VALUE CustomShape_new(VALUE klass) {
+    CustomShape *ptr = malloc(sizeof(CustomShape));
+    VALUE self;
+
+    ptr->rb_self = Qnil;
+    ptr->rb_texture = Qnil;
+    ptr->shape = sfShape_create(CustomShape_get_point_count, CustomShape_get_point, ptr);
+
+    if (ptr->shape == NULL) {
+        free(ptr);
+        rb_raise(rb_eRuntimeError, "failed to create shape");
+    }
+
+    self = TypedData_Wrap_Struct(klass, &CustomShape_data_type, ptr);
+    ptr->rb_self = self;
+
+    return self;
+}
+
+static VALUE CustomShape_update(VALUE self) {
+    sfShape_update(Get_CustomShape_Struct(self));
+    return self;
+}
+
+static VALUE CustomShape_get_position(VALUE self) {
+    return vec2f_to_rb(sfShape_getPosition(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_position(VALUE self, VALUE rb_position) {
+    sfShape_setPosition(Get_CustomShape_Struct(self), vec2f_from_rb(rb_position));
+    return rb_position;
+}
+
+static VALUE CustomShape_get_rotation(VALUE self) {
+    return DBL2NUM(sfShape_getRotation(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_rotation(VALUE self, VALUE rb_rotation) {
+    sfShape_setRotation(Get_CustomShape_Struct(self), NUM2DBL(rb_rotation));
+    return rb_rotation;
+}
+
+static VALUE CustomShape_get_scale(VALUE self) {
+    return vec2f_to_rb(sfShape_getScale(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_scale(VALUE self, VALUE rb_scale) {
+    sfShape_setScale(Get_CustomShape_Struct(self), vec2f_from_rb(rb_scale));
+    return rb_scale;
+}
+
+static VALUE CustomShape_get_origin(VALUE self) {
+    return vec2f_to_rb(sfShape_getOrigin(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_origin(VALUE self, VALUE rb_origin) {
+    sfShape_setOrigin(Get_CustomShape_Struct(self), vec2f_from_rb(rb_origin));
+    return rb_origin;
+}
+
+static VALUE CustomShape_move(VALUE self, VALUE rb_offset) {
+    sfShape_move(Get_CustomShape_Struct(self), vec2f_from_rb(rb_offset));
+    return self;
+}
+
+static VALUE CustomShape_rotate(VALUE self, VALUE rb_angle) {
+    sfShape_rotate(Get_CustomShape_Struct(self), NUM2DBL(rb_angle));
+    return self;
+}
+
+static VALUE CustomShape_scale(VALUE self, VALUE rb_factors) {
+    sfShape_scale(Get_CustomShape_Struct(self), vec2f_from_rb(rb_factors));
+    return self;
+}
+
+static VALUE CustomShape_get_transform(VALUE self) {
+    return Transform_MatrixToArray(sfShape_getTransform(Get_CustomShape_Struct(self)).matrix);
+}
+
+static VALUE CustomShape_get_inverse_transform(VALUE self) {
+    return Transform_MatrixToArray(sfShape_getInverseTransform(Get_CustomShape_Struct(self)).matrix);
+}
+
+static VALUE CustomShape_get_fill_color(VALUE self) {
+    return color_to_rb(sfShape_getFillColor(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_fill_color(VALUE self, VALUE rb_color) {
+    sfShape_setFillColor(Get_CustomShape_Struct(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE CustomShape_get_outline_color(VALUE self) {
+    return color_to_rb(sfShape_getOutlineColor(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_outline_color(VALUE self, VALUE rb_color) {
+    sfShape_setOutlineColor(Get_CustomShape_Struct(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE CustomShape_get_outline_thickness(VALUE self) {
+    return DBL2NUM(sfShape_getOutlineThickness(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_outline_thickness(VALUE self, VALUE rb_thickness) {
+    sfShape_setOutlineThickness(Get_CustomShape_Struct(self), NUM2DBL(rb_thickness));
+    return rb_thickness;
+}
+
+static VALUE CustomShape_set_texture(VALUE self, VALUE rb_texture) {
+    CustomShape *ptr = Get_CustomShape(self);
+
+    if (NIL_P(rb_texture)) {
+        ptr->rb_texture = Qnil;
+        sfShape_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;
+    sfShape_setTexture(ptr->shape, Get_Texture_Struct(rb_texture), false);
+
+    return rb_texture;
+}
+
+static VALUE CustomShape_get_texture(VALUE self) {
+    return Get_CustomShape(self)->rb_texture;
+}
+
+static VALUE CustomShape_get_texture_rect(VALUE self) {
+    return int_rect_to_rb(sfShape_getTextureRect(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_set_texture_rect(VALUE self, VALUE rb_rect) {
+    sfShape_setTextureRect(Get_CustomShape_Struct(self), int_rect_from_rb(rb_rect));
+    return rb_rect;
+}
+
+static VALUE CustomShape_get_geometric_center(VALUE self) {
+    return vec2f_to_rb(sfShape_getGeometricCenter(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_get_local_bounds(VALUE self) {
+    return rect_to_rb(sfShape_getLocalBounds(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_get_global_bounds(VALUE self) {
+    return rect_to_rb(sfShape_getGlobalBounds(Get_CustomShape_Struct(self)));
+}
+
+static VALUE CustomShape_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_drawShape, sfRenderTexture_drawShape,
+                Get_CustomShape_Struct(self), Get_RenderState_Struct(rb_state));
+
+    return Qnil;
+}
+
+void Init_Shape(VALUE rb_module) {
+    rb_cCustomShape = rb_define_class_under(rb_module, "Shape", rb_cObject);
+
+    rb_include_module(rb_cCustomShape, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cCustomShape, "new", CustomShape_new, 0);
+
+    rb_define_method(rb_cCustomShape, "update!", CustomShape_update, 0);
+    rb_define_method(rb_cCustomShape, "position", CustomShape_get_position, 0);
+    rb_define_method(rb_cCustomShape, "rotation", CustomShape_get_rotation, 0);
+    rb_define_method(rb_cCustomShape, "scale", CustomShape_get_scale, 0);
+    rb_define_method(rb_cCustomShape, "origin", CustomShape_get_origin, 0);
+    rb_define_method(rb_cCustomShape, "fill_color", CustomShape_get_fill_color, 0);
+    rb_define_method(rb_cCustomShape, "outline_color", CustomShape_get_outline_color, 0);
+    rb_define_method(rb_cCustomShape, "outline_thickness", CustomShape_get_outline_thickness, 0);
+    rb_define_method(rb_cCustomShape, "texture", CustomShape_get_texture, 0);
+    rb_define_method(rb_cCustomShape, "texture_rect", CustomShape_get_texture_rect, 0);
+    rb_define_method(rb_cCustomShape, "geometric_center", CustomShape_get_geometric_center, 0);
+    rb_define_method(rb_cCustomShape, "local_bounds", CustomShape_get_local_bounds, 0);
+    rb_define_method(rb_cCustomShape, "global_bounds", CustomShape_get_global_bounds, 0);
+    rb_define_method(rb_cCustomShape, "transform", CustomShape_get_transform, 0);
+    rb_define_method(rb_cCustomShape, "inverse_transform", CustomShape_get_inverse_transform, 0);
+    rb_define_method(rb_cCustomShape, "matrix", CustomShape_get_transform, 0);
+
+    rb_define_method(rb_cCustomShape, "position=", CustomShape_set_position, 1);
+    rb_define_method(rb_cCustomShape, "rotation=", CustomShape_set_rotation, 1);
+    rb_define_method(rb_cCustomShape, "scale=", CustomShape_set_scale, 1);
+    rb_define_method(rb_cCustomShape, "origin=", CustomShape_set_origin, 1);
+    rb_define_method(rb_cCustomShape, "fill_color=", CustomShape_set_fill_color, 1);
+    rb_define_method(rb_cCustomShape, "outline_color=", CustomShape_set_outline_color, 1);
+    rb_define_method(rb_cCustomShape, "outline_thickness=", CustomShape_set_outline_thickness, 1);
+    rb_define_method(rb_cCustomShape, "texture=", CustomShape_set_texture, 1);
+    rb_define_method(rb_cCustomShape, "texture_rect=", CustomShape_set_texture_rect, 1);
+
+    rb_define_method(rb_cCustomShape, "move", CustomShape_move, 1);
+    rb_define_method(rb_cCustomShape, "rotate", CustomShape_rotate, 1);
+    rb_define_method(rb_cCustomShape, "scale!", CustomShape_scale, 1);
+    rb_define_method(rb_cCustomShape, "draw", CustomShape_draw, 2);
+}
+
+VALUE Get_Klass_Shape(void) {
+    return rb_cCustomShape;
+}

data/ext/graphics/shape.h

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

data/ext/graphics/sprite.c

@@ -0,0 +1,249 @@
+#include "graphics/sprite.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 {
+    sfSprite *sprite;
+    VALUE rb_texture;
+} Sprite;
+
+static VALUE rb_cSprite;
+
+static void Sprite_mark(void *ptr) {
+    rb_gc_mark(((Sprite *) ptr)->rb_texture);
+}
+
+static void Sprite_free(void *ptr) {
+    sfSprite_destroy(((Sprite *) ptr)->sprite);
+    free(ptr);
+}
+
+static const rb_data_type_t Sprite_data_type = {
+    .wrap_struct_name = "SFML::Sprite",
+    .function = {.dmark = Sprite_mark, .dfree = Sprite_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static Sprite *Get_Sprite(VALUE self) {
+    Sprite *ptr;
+    TypedData_Get_Struct(self, Sprite, &Sprite_data_type, ptr);
+    return ptr;
+}
+
+static sfSprite *Get_Sprite_Struct(VALUE self) {
+    return Get_Sprite(self)->sprite;
+}
+
+static VALUE Sprite_wrap(VALUE klass, sfSprite *sprite) {
+    Sprite *ptr;
+
+    if (sprite == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sprite");
+    }
+
+    ptr = malloc(sizeof(Sprite));
+    ptr->sprite = sprite;
+    ptr->rb_texture = Qnil;
+
+    return TypedData_Wrap_Struct(klass, &Sprite_data_type, ptr);
+}
+
+static VALUE Sprite_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE rb_texture, self;
+    Sprite *ptr;
+
+    rb_scan_args(argc, argv, "01", &rb_texture);
+
+    if (!NIL_P(rb_texture) && !rb_obj_is_kind_of(rb_texture, Get_Klass_Texture())) {
+        raise_invalid_argument_class(Get_Klass_Texture());
+    }
+
+    ptr = malloc(sizeof(Sprite));
+    ptr->sprite = sfSprite_create(NIL_P(rb_texture) ? NULL : Get_Texture_Struct(rb_texture));
+    ptr->rb_texture = NIL_P(rb_texture) ? Qnil : rb_texture;
+
+    self = TypedData_Wrap_Struct(klass, &Sprite_data_type, ptr);
+
+    return self;
+}
+
+static VALUE Sprite_copy(VALUE self) {
+    Sprite *ptr = Get_Sprite(self);
+
+    return Sprite_wrap(Get_Klass_Sprite(), sfSprite_copy(ptr->sprite));
+}
+
+static VALUE Sprite_set_texture(VALUE self, VALUE rb_texture) {
+    Sprite *ptr = Get_Sprite(self);
+
+    if (NIL_P(rb_texture)) {
+        ptr->rb_texture = Qnil;
+        sfSprite_setTexture(ptr->sprite, 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;
+    sfSprite_setTexture(ptr->sprite, Get_Texture_Struct(rb_texture), false);
+
+    return rb_texture;
+}
+
+static VALUE Sprite_get_texture(VALUE self) {
+    return Get_Sprite(self)->rb_texture;
+}
+
+static VALUE Sprite_get_texture_rect(VALUE self) {
+    return int_rect_to_rb(sfSprite_getTextureRect(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_set_texture_rect(VALUE self, VALUE rb_rect) {
+    sfSprite_setTextureRect(Get_Sprite_Struct(self), int_rect_from_rb(rb_rect));
+    return rb_rect;
+}
+
+static VALUE Sprite_get_color(VALUE self) {
+    return color_to_rb(sfSprite_getColor(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_set_color(VALUE self, VALUE rb_color) {
+    sfSprite_setColor(Get_Sprite_Struct(self), color_from_rb(rb_color));
+    return rb_color;
+}
+
+static VALUE Sprite_get_position(VALUE self) {
+    return vec2f_to_rb(sfSprite_getPosition(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_set_position(VALUE self, VALUE rb_position) {
+    sfSprite_setPosition(Get_Sprite_Struct(self), vec2f_from_rb(rb_position));
+    return rb_position;
+}
+
+static VALUE Sprite_get_rotation(VALUE self) {
+    return DBL2NUM(sfSprite_getRotation(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_set_rotation(VALUE self, VALUE rb_rotation) {
+    sfSprite_setRotation(Get_Sprite_Struct(self), NUM2DBL(rb_rotation));
+    return rb_rotation;
+}
+
+static VALUE Sprite_get_scale(VALUE self) {
+    return vec2f_to_rb(sfSprite_getScale(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_set_scale(VALUE self, VALUE rb_scale) {
+    sfSprite_setScale(Get_Sprite_Struct(self), vec2f_from_rb(rb_scale));
+    return rb_scale;
+}
+
+static VALUE Sprite_get_origin(VALUE self) {
+    return vec2f_to_rb(sfSprite_getOrigin(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_set_origin(VALUE self, VALUE rb_origin) {
+    sfSprite_setOrigin(Get_Sprite_Struct(self), vec2f_from_rb(rb_origin));
+    return rb_origin;
+}
+
+static VALUE Sprite_move(VALUE self, VALUE rb_offset) {
+    sfSprite_move(Get_Sprite_Struct(self), vec2f_from_rb(rb_offset));
+    return self;
+}
+
+static VALUE Sprite_rotate(VALUE self, VALUE rb_angle) {
+    sfSprite_rotate(Get_Sprite_Struct(self), NUM2DBL(rb_angle));
+    return self;
+}
+
+static VALUE Sprite_scale(VALUE self, VALUE rb_factors) {
+    sfSprite_scale(Get_Sprite_Struct(self), vec2f_from_rb(rb_factors));
+    return self;
+}
+
+static VALUE Sprite_get_transform(VALUE self) {
+    return Transform_MatrixToArray(sfSprite_getTransform(Get_Sprite_Struct(self)).matrix);
+}
+
+static VALUE Sprite_get_inverse_transform(VALUE self) {
+    return Transform_MatrixToArray(sfSprite_getInverseTransform(Get_Sprite_Struct(self)).matrix);
+}
+
+static VALUE Sprite_get_local_bounds(VALUE self) {
+    return rect_to_rb(sfSprite_getLocalBounds(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_get_global_bounds(VALUE self) {
+    return rect_to_rb(sfSprite_getGlobalBounds(Get_Sprite_Struct(self)));
+}
+
+static VALUE Sprite_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_drawSprite, sfRenderTexture_drawSprite,
+                Get_Sprite_Struct(self), Get_RenderState_Struct(rb_state));
+
+    return Qnil;
+}
+
+void Init_Sprite(VALUE rb_module) {
+    rb_cSprite = rb_define_class_under(rb_module, "Sprite", rb_cObject);
+
+    rb_include_module(rb_cSprite, Get_Module_Drawable());
+
+    rb_define_singleton_method(rb_cSprite, "new", Sprite_new, -1);
+
+    rb_define_method(rb_cSprite, "copy", Sprite_copy, 0);
+
+    rb_define_method(rb_cSprite, "texture", Sprite_get_texture, 0);
+    rb_define_method(rb_cSprite, "texture_rect", Sprite_get_texture_rect, 0);
+    rb_define_method(rb_cSprite, "color", Sprite_get_color, 0);
+    rb_define_method(rb_cSprite, "position", Sprite_get_position, 0);
+    rb_define_method(rb_cSprite, "rotation", Sprite_get_rotation, 0);
+    rb_define_method(rb_cSprite, "scale", Sprite_get_scale, 0);
+    rb_define_method(rb_cSprite, "origin", Sprite_get_origin, 0);
+    rb_define_method(rb_cSprite, "transform", Sprite_get_transform, 0);
+    rb_define_method(rb_cSprite, "inverse_transform", Sprite_get_inverse_transform, 0);
+    rb_define_method(rb_cSprite, "matrix", Sprite_get_transform, 0);
+    rb_define_method(rb_cSprite, "local_bounds", Sprite_get_local_bounds, 0);
+    rb_define_method(rb_cSprite, "global_bounds", Sprite_get_global_bounds, 0);
+
+    rb_define_method(rb_cSprite, "texture=", Sprite_set_texture, 1);
+    rb_define_method(rb_cSprite, "texture_rect=", Sprite_set_texture_rect, 1);
+    rb_define_method(rb_cSprite, "color=", Sprite_set_color, 1);
+    rb_define_method(rb_cSprite, "position=", Sprite_set_position, 1);
+    rb_define_method(rb_cSprite, "rotation=", Sprite_set_rotation, 1);
+    rb_define_method(rb_cSprite, "scale=", Sprite_set_scale, 1);
+    rb_define_method(rb_cSprite, "origin=", Sprite_set_origin, 1);
+
+    rb_define_method(rb_cSprite, "move", Sprite_move, 1);
+    rb_define_method(rb_cSprite, "rotate", Sprite_rotate, 1);
+    rb_define_method(rb_cSprite, "scale!", Sprite_scale, 1);
+    rb_define_method(rb_cSprite, "draw", Sprite_draw, 2);
+}
+
+VALUE Get_Klass_Sprite(void) {
+    return rb_cSprite;
+}

data/ext/graphics/sprite.h

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