sfml3-rb 0.0.1 → 0.2.1

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

@@ -1,18 +1,18 @@
-#include "ext/module/drawable/drawable.h"
+#include "graphics/drawable.h"
 
 #include <ruby.h>
 #include <stdio.h>
 
-#include "ext/module/transform.h"
-#include "ext/klass/transformable.h"
-#include "ext/klass/render_state.h"
-#include "ext/klass/target.h"
-#include "ext/klass/window.h"
-#include <ext/exceptions.h>
-#include "ext/vec2.h"
-#include "ext/rect.h"
-#include "ext/module.h"
-#include "ext/sfml.h"
+#include "graphics/transform.h"
+#include "graphics/transformable.h"
+#include "graphics/render_state.h"
+#include "graphics/target.h"
+#include "window/window.h"
+#include "core/exceptions.h"
+#include "system/vec2.h"
+#include "graphics/rect.h"
+#include "core/macros.h"
+#include "core/sfml.h"
 
 static VALUE rb_mDrawable;
 

data/ext/graphics/drawable.h

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

data/ext/graphics/enums.c

@@ -0,0 +1,123 @@
+#include "graphics/enums.h"
+
+#include <ruby.h>
+#include <string.h>
+
+#include "core/exceptions.h"
+
+static const char *primitive_names[] = {
+    "points", "lines", "line_strip", "triangles", "triangle_strip", "triangle_fan"
+};
+
+const char *coordinate_type_name(sfCoordinateType type) {
+    return (type == sfCoordinateTypePixels) ? "pixels" : "normalized";
+}
+
+sfCoordinateType coordinate_type_from_rb(VALUE rb_type) {
+    if (SYMBOL_P(rb_type)) {
+        const char *name = rb_id2name(SYM2ID(rb_type));
+
+        if (strcmp(name, "pixels") == 0) {
+            return sfCoordinateTypePixels;
+        }
+
+        if (strcmp(name, "normalized") == 0) {
+            return sfCoordinateTypeNormalized;
+        }
+    }
+
+    if (RB_INTEGER_TYPE_P(rb_type)) {
+        return (sfCoordinateType) NUM2INT(rb_type);
+    }
+
+    rb_raise(rb_eArgError, "expected :normalized or :pixels");
+    return sfCoordinateTypeNormalized;
+}
+
+const char *primitive_type_name(sfPrimitiveType type) {
+    if (type >= sfPoints && type <= sfTriangleFan) {
+        return primitive_names[type];
+    }
+
+    return "points";
+}
+
+sfPrimitiveType primitive_type_from_rb(VALUE rb_type) {
+    if (SYMBOL_P(rb_type)) {
+        const char *name = rb_id2name(SYM2ID(rb_type));
+        size_t i;
+
+        for (i = 0; i < sizeof(primitive_names) / sizeof(primitive_names[0]); i++) {
+            if (strcmp(name, primitive_names[i]) == 0) {
+                return (sfPrimitiveType) i;
+            }
+        }
+    }
+
+    if (RB_INTEGER_TYPE_P(rb_type)) {
+        return (sfPrimitiveType) NUM2INT(rb_type);
+    }
+
+    rb_raise(rb_eArgError, "expected a primitive type symbol");
+    return sfPoints;
+}
+
+VALUE text_style_to_rb(uint32_t style) {
+    VALUE array = rb_ary_new();
+
+    if ((style & sfTextBold) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("bold")));
+    }
+
+    if ((style & sfTextItalic) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("italic")));
+    }
+
+    if ((style & sfTextUnderlined) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("underlined")));
+    }
+
+    if ((style & sfTextStrikeThrough) != 0) {
+        rb_ary_push(array, ID2SYM(rb_intern("strike_through")));
+    }
+
+    return array;
+}
+
+uint32_t text_style_from_rb(VALUE rb_style) {
+    uint32_t style = 0;
+
+    if (SYMBOL_P(rb_style) || RB_TYPE_P(rb_style, T_STRING)) {
+        rb_style = rb_ary_new_from_args(1, rb_style);
+    }
+
+    if (RB_INTEGER_TYPE_P(rb_style)) {
+        return (uint32_t) NUM2UINT(rb_style);
+    }
+
+    if (!RB_TYPE_P(rb_style, T_ARRAY)) {
+        rb_raise(rb_eArgError, "expected a text style symbol or array of symbols");
+    }
+
+    for (long i = 0; i < RARRAY_LEN(rb_style); i++) {
+        const char *name = rb_id2name(SYM2ID(rb_ary_entry(rb_style, i)));
+
+        if (strcmp(name, "regular") == 0) {
+            continue;
+        }
+
+        if (strcmp(name, "bold") == 0) {
+            style |= sfTextBold;
+        } else if (strcmp(name, "italic") == 0) {
+            style |= sfTextItalic;
+        } else if (strcmp(name, "underlined") == 0 || strcmp(name, "underline") == 0) {
+            style |= sfTextUnderlined;
+        } else if (strcmp(name, "strike_through") == 0 || strcmp(name, "strikethrough") == 0) {
+            style |= sfTextStrikeThrough;
+        } else {
+            rb_raise(rb_eArgError, "unknown text style: %s", name);
+        }
+    }
+
+    return style;
+}

data/ext/graphics/enums.h

@@ -0,0 +1,20 @@
+#ifndef SFML_RB_GRAPHICS_ENUMS_H
+#define SFML_RB_GRAPHICS_ENUMS_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+const char *coordinate_type_name(sfCoordinateType type);
+
+sfCoordinateType coordinate_type_from_rb(VALUE rb_type);
+
+const char *primitive_type_name(sfPrimitiveType type);
+
+sfPrimitiveType primitive_type_from_rb(VALUE rb_type);
+
+VALUE text_style_to_rb(uint32_t style);
+
+uint32_t text_style_from_rb(VALUE rb_style);
+
+#endif //SFML_RB_GRAPHICS_ENUMS_H

data/ext/graphics/font.c

@@ -0,0 +1,148 @@
+#include "graphics/font.h"
+
+#include <ruby.h>
+
+#include "graphics/glyph.h"
+#include "graphics/texture.h"
+#include "system/input_stream.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cFont;
+
+static void Font_free(void *ptr) {
+    sfFont_destroy(ptr);
+}
+
+static const rb_data_type_t Font_data_type = {
+    .wrap_struct_name = "SFML::Font",
+    .function = {.dmark = NULL, .dfree = Font_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Font_wrap(VALUE klass, sfFont *font) {
+    if (font == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to load font");
+    }
+
+    return TypedData_Wrap_Struct(klass, &Font_data_type, font);
+}
+
+static VALUE Font_from_file(VALUE klass, VALUE rb_path) {
+    return Font_wrap(klass, sfFont_createFromFile(StringValueCStr(rb_path)));
+}
+
+static VALUE Font_from_memory(VALUE klass, VALUE rb_data) {
+    StringValue(rb_data);
+
+    return Font_wrap(klass, sfFont_createFromMemory(RSTRING_PTR(rb_data), (size_t) RSTRING_LEN(rb_data)));
+}
+
+static VALUE Font_from_stream(VALUE klass, VALUE rb_stream) {
+    VALUE holder = Qnil;
+    sfInputStream *stream = input_stream_from_rb(rb_stream, &holder);
+
+    (void) holder;
+
+    return Font_wrap(klass, sfFont_createFromStream(stream));
+}
+
+static VALUE Font_copy(VALUE self) {
+    return Font_wrap(Get_Klass_Font(), sfFont_copy(Get_Font_Struct(self)));
+}
+
+static VALUE Font_get_glyph(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_codepoint, rb_size, rb_bold, rb_outline;
+    bool bold = false;
+    float outline = 0;
+
+    rb_scan_args(argc, argv, "22", &rb_codepoint, &rb_size, &rb_bold, &rb_outline);
+
+    if (!NIL_P(rb_bold)) {
+        bold = RTEST(rb_bold);
+    }
+
+    if (!NIL_P(rb_outline)) {
+        outline = NUM2DBL(rb_outline);
+    }
+
+    return glyph_from_c(sfFont_getGlyph(Get_Font_Struct(self), (uint32_t) NUM2UINT(rb_codepoint),
+                                        (unsigned int) NUM2UINT(rb_size), bold, outline));
+}
+
+static VALUE Font_has_glyph(VALUE self, VALUE rb_codepoint) {
+    return BOOL2RB(sfFont_hasGlyph(Get_Font_Struct(self), (uint32_t) NUM2UINT(rb_codepoint)));
+}
+
+static VALUE Font_get_kerning(VALUE self, VALUE rb_first, VALUE rb_second, VALUE rb_size) {
+    return DBL2NUM(sfFont_getKerning(Get_Font_Struct(self), (uint32_t) NUM2UINT(rb_first),
+                                     (uint32_t) NUM2UINT(rb_second), (unsigned int) NUM2UINT(rb_size)));
+}
+
+static VALUE Font_get_bold_kerning(VALUE self, VALUE rb_first, VALUE rb_second, VALUE rb_size) {
+    return DBL2NUM(sfFont_getBoldKerning(Get_Font_Struct(self), (uint32_t) NUM2UINT(rb_first),
+                                         (uint32_t) NUM2UINT(rb_second), (unsigned int) NUM2UINT(rb_size)));
+}
+
+static VALUE Font_get_line_spacing(VALUE self, VALUE rb_size) {
+    return DBL2NUM(sfFont_getLineSpacing(Get_Font_Struct(self), (unsigned int) NUM2UINT(rb_size)));
+}
+
+static VALUE Font_get_underline_position(VALUE self, VALUE rb_size) {
+    return DBL2NUM(sfFont_getUnderlinePosition(Get_Font_Struct(self), (unsigned int) NUM2UINT(rb_size)));
+}
+
+static VALUE Font_get_underline_thickness(VALUE self, VALUE rb_size) {
+    return DBL2NUM(sfFont_getUnderlineThickness(Get_Font_Struct(self), (unsigned int) NUM2UINT(rb_size)));
+}
+
+static VALUE Font_get_texture(VALUE self, VALUE rb_size) {
+    return texture_from_borrowed(sfFont_getTexture((sfFont *) Get_Font_Struct(self),
+                                                   (unsigned int) NUM2UINT(rb_size)));
+}
+
+static VALUE Font_set_smooth(VALUE self, VALUE rb_smooth) {
+    sfFont_setSmooth((sfFont *) Get_Font_Struct(self), RTEST(rb_smooth));
+    return rb_smooth;
+}
+
+static VALUE Font_is_smooth(VALUE self) {
+    return BOOL2RB(sfFont_isSmooth(Get_Font_Struct(self)));
+}
+
+static VALUE Font_get_info(VALUE self) {
+    sfFontInfo info = sfFont_getInfo(Get_Font_Struct(self));
+
+    return rb_str_new_cstr(info.family != NULL ? info.family : "");
+}
+
+void Init_Font(VALUE rb_module) {
+    rb_cFont = rb_define_class_under(rb_module, "Font", rb_cObject);
+
+    rb_define_singleton_method(rb_cFont, "from_file", Font_from_file, 1);
+    rb_define_singleton_method(rb_cFont, "from_memory", Font_from_memory, 1);
+    rb_define_singleton_method(rb_cFont, "from_stream", Font_from_stream, 1);
+
+    rb_define_method(rb_cFont, "copy", Font_copy, 0);
+    rb_define_method(rb_cFont, "glyph", Font_get_glyph, -1);
+    rb_define_method(rb_cFont, "has_glyph?", Font_has_glyph, 1);
+    rb_define_method(rb_cFont, "kerning", Font_get_kerning, 3);
+    rb_define_method(rb_cFont, "bold_kerning", Font_get_bold_kerning, 3);
+    rb_define_method(rb_cFont, "line_spacing", Font_get_line_spacing, 1);
+    rb_define_method(rb_cFont, "underline_position", Font_get_underline_position, 1);
+    rb_define_method(rb_cFont, "underline_thickness", Font_get_underline_thickness, 1);
+    rb_define_method(rb_cFont, "texture", Font_get_texture, 1);
+    rb_define_method(rb_cFont, "smooth=", Font_set_smooth, 1);
+    rb_define_method(rb_cFont, "smooth?", Font_is_smooth, 0);
+    rb_define_method(rb_cFont, "info", Font_get_info, 0);
+}
+
+VALUE Get_Klass_Font(void) {
+    return rb_cFont;
+}
+
+const sfFont *Get_Font_Struct(VALUE self) {
+    sfFont *ptr;
+    TypedData_Get_Struct(self, sfFont, &Font_data_type, ptr);
+    return ptr;
+}

data/ext/graphics/font.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_GRAPHICS_FONT_H
+#define SFML_RB_GRAPHICS_FONT_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Font(VALUE rb_module);
+
+VALUE Get_Klass_Font(void);
+
+const sfFont *Get_Font_Struct(VALUE self);
+
+#endif //SFML_RB_GRAPHICS_FONT_H

data/ext/graphics/glyph.c

@@ -0,0 +1,60 @@
+#include "graphics/glyph.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/rect.h"
+
+typedef struct {
+    sfGlyph glyph;
+} Glyph;
+
+static VALUE rb_cGlyph;
+
+static void Glyph_free(void *ptr) {
+    free(ptr);
+}
+
+static const rb_data_type_t Glyph_data_type = {
+    .wrap_struct_name = "SFML::Glyph",
+    .function = {.dmark = NULL, .dfree = Glyph_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+VALUE glyph_from_c(sfGlyph glyph) {
+    Glyph *ptr = malloc(sizeof(Glyph));
+
+    ptr->glyph = glyph;
+
+    return TypedData_Wrap_Struct(rb_cGlyph, &Glyph_data_type, ptr);
+}
+
+static Glyph *Get_Glyph(VALUE self) {
+    Glyph *ptr;
+    TypedData_Get_Struct(self, Glyph, &Glyph_data_type, ptr);
+    return ptr;
+}
+
+static VALUE Glyph_get_advance(VALUE self) {
+    return DBL2NUM(Get_Glyph(self)->glyph.advance);
+}
+
+static VALUE Glyph_get_bounds(VALUE self) {
+    return rect_to_rb(Get_Glyph(self)->glyph.bounds);
+}
+
+static VALUE Glyph_get_texture_rect(VALUE self) {
+    return int_rect_to_rb(Get_Glyph(self)->glyph.textureRect);
+}
+
+void Init_Glyph(VALUE rb_module) {
+    rb_cGlyph = rb_define_class_under(rb_module, "Glyph", rb_cObject);
+
+    rb_define_method(rb_cGlyph, "advance", Glyph_get_advance, 0);
+    rb_define_method(rb_cGlyph, "bounds", Glyph_get_bounds, 0);
+    rb_define_method(rb_cGlyph, "texture_rect", Glyph_get_texture_rect, 0);
+}
+
+VALUE Get_Klass_Glyph(void) {
+    return rb_cGlyph;
+}

data/ext/graphics/glyph.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_GRAPHICS_GLYPH_H
+#define SFML_RB_GRAPHICS_GLYPH_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Glyph(VALUE rb_module);
+
+VALUE Get_Klass_Glyph(void);
+
+VALUE glyph_from_c(sfGlyph glyph);
+
+#endif //SFML_RB_GRAPHICS_GLYPH_H

data/ext/graphics/image.c

@@ -0,0 +1,205 @@
+#include "graphics/image.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "graphics/color.h"
+#include "graphics/rect.h"
+#include "system/buffer.h"
+#include "system/input_stream.h"
+#include "system/vec2.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+
+static VALUE rb_cImage;
+
+static void Image_free(void *ptr) {
+    sfImage_destroy(ptr);
+}
+
+static const rb_data_type_t Image_data_type = {
+    .wrap_struct_name = "SFML::Image",
+    .function = {.dmark = NULL, .dfree = Image_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Image_wrap(VALUE klass, sfImage *image) {
+    if (image == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create image");
+    }
+
+    return TypedData_Wrap_Struct(klass, &Image_data_type, image);
+}
+
+static VALUE Image_new(VALUE klass, VALUE rb_size) {
+    return Image_wrap(klass, sfImage_create(vec2u_from_rb(rb_size)));
+}
+
+static VALUE Image_from_color(VALUE klass, VALUE rb_size, VALUE rb_color) {
+    return Image_wrap(klass, sfImage_createFromColor(vec2u_from_rb(rb_size), color_from_rb(rb_color)));
+}
+
+static VALUE Image_from_pixels(VALUE klass, VALUE rb_size, VALUE rb_pixels) {
+    sfVector2u size = vec2u_from_rb(rb_size);
+    size_t expected = (size_t) size.x * size.y * 4;
+    sfImage *image;
+
+    StringValue(rb_pixels);
+
+    if ((size_t) RSTRING_LEN(rb_pixels) < expected) {
+        rb_raise(rb_eArgError, "pixel data too short: expected %lu bytes", (unsigned long) expected);
+    }
+
+    image = sfImage_createFromPixels(size, (const uint8_t *) RSTRING_PTR(rb_pixels));
+
+    return Image_wrap(klass, image);
+}
+
+static VALUE Image_from_file(VALUE klass, VALUE rb_path) {
+    return Image_wrap(klass, sfImage_createFromFile(StringValueCStr(rb_path)));
+}
+
+static VALUE Image_from_memory(VALUE klass, VALUE rb_data) {
+    StringValue(rb_data);
+
+    return Image_wrap(klass, sfImage_createFromMemory(RSTRING_PTR(rb_data), (size_t) RSTRING_LEN(rb_data)));
+}
+
+static VALUE Image_from_stream(VALUE klass, VALUE rb_stream) {
+    VALUE holder = Qnil;
+    sfInputStream *stream = input_stream_from_rb(rb_stream, &holder);
+
+    (void) holder;
+
+    return Image_wrap(klass, sfImage_createFromStream(stream));
+}
+
+static VALUE Image_copy(VALUE self) {
+    return Image_wrap(Get_Klass_Image(), sfImage_copy(Get_Image_Struct(self)));
+}
+
+static VALUE Image_get_size(VALUE self) {
+    return vec2f_to_rb((sfVector2f) {
+        (float) sfImage_getSize(Get_Image_Struct(self)).x,
+        (float) sfImage_getSize(Get_Image_Struct(self)).y
+    });
+}
+
+static VALUE Image_save_to_file(VALUE self, VALUE rb_path) {
+    return BOOL2RB(sfImage_saveToFile(Get_Image_Struct(self), StringValueCStr(rb_path)));
+}
+
+static VALUE Image_save_to_memory(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_buffer;
+    const char *format = "png";
+    if (argc > 1) {
+        raise_invalid_arguments_excepted(1, argc);
+    }
+
+    if (argc == 1 && !NIL_P(argv[0])) {
+        format = StringValueCStr(argv[0]);
+    }
+
+    rb_buffer = rb_funcall(Get_Klass_Buffer(), rb_intern("new"), 0);
+
+    if (sfImage_saveToMemory(Get_Image_Struct(self), Get_Buffer_Struct(rb_buffer), format)) {
+        return rb_buffer;
+    }
+
+    return Qnil;
+}
+
+static VALUE Image_create_mask_from_color(VALUE self, VALUE rb_color, VALUE rb_alpha) {
+    sfImage_createMaskFromColor((sfImage *) Get_Image_Struct(self), color_from_rb(rb_color), (uint8_t) NUM2INT(rb_alpha));
+    return self;
+}
+
+static VALUE Image_copy_image(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_source, rb_dest, rb_source_rect, rb_apply_alpha;
+    bool apply_alpha = true;
+
+    rb_scan_args(argc, argv, "31", &rb_source, &rb_dest, &rb_source_rect, &rb_apply_alpha);
+
+    if (!rb_obj_is_kind_of(rb_source, rb_cImage)) {
+        raise_invalid_argument_class(rb_cImage);
+    }
+
+    if (!NIL_P(rb_apply_alpha)) {
+        apply_alpha = RTEST(rb_apply_alpha);
+    }
+
+    return BOOL2RB(sfImage_copyImage((sfImage *) Get_Image_Struct(self), Get_Image_Struct(rb_source),
+                                     vec2u_from_rb(rb_dest), int_rect_from_rb(rb_source_rect), apply_alpha));
+}
+
+static VALUE Image_get_pixel(VALUE self, VALUE rb_x, VALUE rb_y) {
+    sfColor color = sfImage_getPixel(Get_Image_Struct(self),
+                                     (sfVector2u) {(unsigned) NUM2UINT(rb_x), (unsigned) NUM2UINT(rb_y)});
+
+    return color_to_rb(color);
+}
+
+static VALUE Image_set_pixel(VALUE self, VALUE rb_x, VALUE rb_y, VALUE rb_color) {
+    sfImage_setPixel((sfImage *) Get_Image_Struct(self),
+                     (sfVector2u) {(unsigned) NUM2UINT(rb_x), (unsigned) NUM2UINT(rb_y)}, color_from_rb(rb_color));
+    return self;
+}
+
+static VALUE Image_get_pixels(VALUE self) {
+    const sfImage *image = Get_Image_Struct(self);
+    sfVector2u size = sfImage_getSize(image);
+    const uint8_t *pixels = sfImage_getPixelsPtr(image);
+
+    if (pixels == NULL) {
+        return rb_str_new("", 0);
+    }
+
+    return rb_str_new((const char *) pixels, (long) (size.x * size.y * 4));
+}
+
+static VALUE Image_flip_horizontally(VALUE self) {
+    sfImage_flipHorizontally((sfImage *) Get_Image_Struct(self));
+    return self;
+}
+
+static VALUE Image_flip_vertically(VALUE self) {
+    sfImage_flipVertically((sfImage *) Get_Image_Struct(self));
+    return self;
+}
+
+void Init_Image(VALUE rb_module) {
+    rb_cImage = rb_define_class_under(rb_module, "Image", rb_cObject);
+
+    rb_define_singleton_method(rb_cImage, "new", Image_new, 1);
+    rb_define_singleton_method(rb_cImage, "from_color", Image_from_color, 2);
+    rb_define_singleton_method(rb_cImage, "from_pixels", Image_from_pixels, 2);
+    rb_define_singleton_method(rb_cImage, "from_file", Image_from_file, 1);
+    rb_define_singleton_method(rb_cImage, "from_memory", Image_from_memory, 1);
+    rb_define_singleton_method(rb_cImage, "from_stream", Image_from_stream, 1);
+
+    rb_define_method(rb_cImage, "copy", Image_copy, 0);
+    rb_define_method(rb_cImage, "size", Image_get_size, 0);
+    rb_define_method(rb_cImage, "save_to_file", Image_save_to_file, 1);
+    rb_define_method(rb_cImage, "save_to_memory", Image_save_to_memory, -1);
+    rb_define_method(rb_cImage, "create_mask_from_color", Image_create_mask_from_color, 2);
+    rb_define_method(rb_cImage, "copy_image", Image_copy_image, -1);
+    rb_define_method(rb_cImage, "pixel", Image_get_pixel, 2);
+    rb_define_method(rb_cImage, "set_pixel", Image_set_pixel, 3);
+    rb_define_method(rb_cImage, "pixels", Image_get_pixels, 0);
+    rb_define_method(rb_cImage, "flip_horizontally!", Image_flip_horizontally, 0);
+    rb_define_method(rb_cImage, "flip_vertically!", Image_flip_vertically, 0);
+}
+
+VALUE Get_Klass_Image(void) {
+    return rb_cImage;
+}
+
+const sfImage *Get_Image_Struct(VALUE self) {
+    sfImage *ptr;
+    TypedData_Get_Struct(self, sfImage, &Image_data_type, ptr);
+    return ptr;
+}
+
+VALUE image_from_c(sfImage *image) {
+    return Image_wrap(Get_Klass_Image(), image);
+}

data/ext/graphics/image.h

@@ -0,0 +1,16 @@
+#ifndef SFML_RB_GRAPHICS_IMAGE_H
+#define SFML_RB_GRAPHICS_IMAGE_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Image(VALUE rb_module);
+
+VALUE Get_Klass_Image(void);
+
+const sfImage *Get_Image_Struct(VALUE self);
+
+VALUE image_from_c(sfImage *image);
+
+#endif //SFML_RB_GRAPHICS_IMAGE_H