LiteRGSS 0.1.3

data/ext/LiteRGSS/Rect.h

@@ -0,0 +1,24 @@
+#ifndef L_RECT_HEADER
+#define L_RECT_HEADER
+
+VALUE rb_Rect_initialize(int argc, VALUE* argv, VALUE self);
+VALUE rb_Rect_initialize_copy(VALUE self, VALUE other);
+VALUE rb_Rect_set(int argc, VALUE* argv, VALUE self);
+VALUE rb_Rect_getX(VALUE self);
+VALUE rb_Rect_setX(VALUE self, VALUE val);
+VALUE rb_Rect_getY(VALUE self);
+VALUE rb_Rect_setY(VALUE self, VALUE val);
+VALUE rb_Rect_getWidth(VALUE self);
+VALUE rb_Rect_setWidth(VALUE self, VALUE val);
+VALUE rb_Rect_getHeight(VALUE self);
+VALUE rb_Rect_setHeight(VALUE self, VALUE val);
+VALUE rb_Rect_load(VALUE self, VALUE str);
+VALUE rb_Rect_save(VALUE self, VALUE limit);
+VALUE rb_Rect_eql(VALUE self, VALUE other);
+VALUE rb_Rect_empty(VALUE self);
+VALUE rb_Rect_to_s(VALUE self);
+
+CRect_Element* rb_Rect_get_rect(VALUE self);
+void rb_Rect_test_rect(VALUE self);
+
+#endif

data/ext/LiteRGSS/Shader.cpp

@@ -0,0 +1,279 @@
+#include "LiteRGSS.h"
+#include "CTone_Element.h"
+
+VALUE rb_cShader = Qnil;
+
+#define SHADER_PROTECT if(RDATA(self)->data == nullptr) \
+{\
+    rb_raise(rb_eRGSSError, "Disposed Shader."); \
+    return self; \
+}
+
+#define GET_SHADER sf::RenderStates* render_state; \
+    Data_Get_Struct(self, sf::RenderStates, render_state); \
+    SHADER_PROTECT \
+	sf::Shader* shader = const_cast<sf::Shader*>(render_state->shader);
+
+void rb_Shader_Free(void* data)
+{
+	sf::RenderStates* render_state = reinterpret_cast<sf::RenderStates*>(data);
+	if (render_state != nullptr)
+	{
+		if (render_state->shader != nullptr)
+		{
+			delete render_state->shader;
+		}
+		delete render_state;
+	}
+}
+
+VALUE rb_Shader_Alloc(VALUE klass)
+{
+	sf::Shader* shader = new sf::Shader();
+	sf::RenderStates* render_state = new sf::RenderStates(shader);
+	return Data_Wrap_Struct(klass, NULL, rb_Shader_Free, render_state);
+}
+
+void Init_Shader()
+{
+	rb_cShader = rb_define_class_under(rb_mLiteRGSS, "Shader", rb_cBlendMode); //<--- Should inherit of rb_cBlendMode
+	rb_define_alloc_func(rb_cShader, rb_Shader_Alloc);
+	rb_define_method(rb_cShader, "initialize", _rbf rb_Shader_loadFromMemory, -1);
+	rb_define_method(rb_cShader, "load", _rbf rb_Shader_loadFromMemory, -1);
+	rb_define_method(rb_cShader, "set_float_uniform", _rbf rb_Shader_setFloatUniform, 2);
+	rb_define_method(rb_cShader, "set_int_uniform", _rbf rb_Shader_setIntUniform, 2);
+	rb_define_method(rb_cShader, "set_bool_uniform", _rbf rb_Shader_setBoolUniform, 2);
+	rb_define_method(rb_cShader, "set_texture_uniform", _rbf rb_Shader_setTextureUniform, 2);
+	rb_define_method(rb_cShader, "set_matrix_uniform", _rbf rb_Shader_setMatrixUniform, 2);
+	rb_define_method(rb_cShader, "set_float_array_uniform", _rbf rb_Shader_setFloatArrayUniform, 2);
+
+	rb_define_method(rb_cShader, "clone", _rbf rb_Shader_Copy, 0);
+	rb_define_method(rb_cShader, "dup", _rbf rb_Shader_Copy, 0);
+	
+	rb_define_singleton_method(rb_cShader, "is_geometry_available?", _rbf rb_Shader_isGeometryAvailable, 0);
+
+	rb_define_const(rb_cShader, "Fragment", LONG2FIX(sf::Shader::Type::Fragment));
+	rb_define_const(rb_cShader, "Vertex", LONG2FIX(sf::Shader::Type::Vertex));
+	rb_define_const(rb_cShader, "Geometry", LONG2FIX(sf::Shader::Type::Geometry));
+}
+
+VALUE rb_Shader_loadFromMemory(int argc, VALUE *argv, VALUE self)
+{
+	VALUE arg1, arg2, arg3;
+	GET_SHADER
+	rb_scan_args(argc, argv, "12", &arg1, &arg2, &arg3);
+	rb_check_type(arg1, T_STRING);
+	if (RTEST(arg2))
+	{
+		if (rb_obj_is_kind_of(arg2, rb_cInteger) == Qtrue)
+		{
+			shader->loadFromMemory(rb_string_value_cstr(&arg1), static_cast<sf::Shader::Type>(NUM2LONG(arg2)));
+		}
+		else
+		{
+			rb_check_type(arg2, T_STRING);
+			if (argc == 2)
+			{
+				shader->loadFromMemory(rb_string_value_cstr(&arg1), rb_string_value_cstr(&arg2));
+			}
+			else if (argc == 3)
+			{
+				rb_check_type(arg3, T_STRING);
+				shader->loadFromMemory(rb_string_value_cstr(&arg1), rb_string_value_cstr(&arg2), rb_string_value_cstr(&arg3));
+			}
+		}
+	}
+	else
+	{
+		shader->loadFromMemory(rb_string_value_cstr(&arg1), sf::Shader::Type::Fragment);
+	}
+	//rb_obj_is_kind_of(other, rb_cBitmap)
+	return self;
+}
+
+VALUE rb_Shader_setFloatUniform(VALUE self, VALUE name, VALUE uniform)
+{
+	GET_SHADER;
+	rb_check_type(name, T_STRING);
+	if (rb_obj_is_kind_of(uniform, rb_cArray) == Qtrue)
+	{
+		long arylen = RARRAY_LEN(uniform);
+		if (arylen == 4)
+		{
+			sf::Glsl::Vec4 vect4(NUM2DBL(rb_ary_entry(uniform, 0)), NUM2DBL(rb_ary_entry(uniform, 1)), NUM2DBL(rb_ary_entry(uniform, 2)), NUM2DBL(rb_ary_entry(uniform, 3)));
+			shader->setUniform(rb_string_value_cstr(&name), vect4);
+		}
+		else if (arylen == 3)
+		{
+			sf::Glsl::Vec3 vect3(NUM2DBL(rb_ary_entry(uniform, 0)), NUM2DBL(rb_ary_entry(uniform, 1)), NUM2DBL(rb_ary_entry(uniform, 2)));
+			shader->setUniform(rb_string_value_cstr(&name), vect3);
+		}
+		else if(arylen == 2)
+		{
+			sf::Glsl::Vec2 vect2(NUM2DBL(rb_ary_entry(uniform, 0)), NUM2DBL(rb_ary_entry(uniform, 1)));
+			shader->setUniform(rb_string_value_cstr(&name), vect2);
+		}
+	}
+	else if (rb_obj_is_kind_of(uniform, rb_cColor) == Qtrue)
+	{
+		sf::Color* color;
+		Data_Get_Struct(uniform, sf::Color, color);
+		if (color != nullptr)
+		{
+			sf::Glsl::Vec4 vect4(color->r / 255.0, color->g / 255.0, color->b / 255.0, color->a / 255.0);
+			shader->setUniform(rb_string_value_cstr(&name), vect4);
+		}
+	}
+	else if (rb_obj_is_kind_of(uniform, rb_cTone) == Qtrue)
+	{
+		CTone_Element* tone;
+		Data_Get_Struct(uniform, CTone_Element, tone);
+		if(tone != nullptr)
+			shader->setUniform(rb_string_value_cstr(&name), *tone->getTone());
+	}
+	else
+	{
+		shader->setUniform(rb_string_value_cstr(&name), static_cast<float>(NUM2DBL(uniform)));
+	}
+	return self;
+}
+
+VALUE rb_Shader_setIntUniform(VALUE self, VALUE name, VALUE uniform)
+{
+	GET_SHADER;
+	rb_check_type(name, T_STRING);
+	if (rb_obj_is_kind_of(uniform, rb_cArray) == Qtrue)
+	{
+		long arylen = RARRAY_LEN(uniform);
+		if (arylen == 4)
+		{
+			sf::Glsl::Ivec4 vect4(rb_num2long(rb_ary_entry(uniform, 0)), rb_num2long(rb_ary_entry(uniform, 1)), rb_num2long(rb_ary_entry(uniform, 2)), rb_num2long(rb_ary_entry(uniform, 3)));
+			shader->setUniform(rb_string_value_cstr(&name), vect4);
+		}
+		else if (arylen == 3)
+		{
+			sf::Glsl::Ivec3 vect3(rb_num2long(rb_ary_entry(uniform, 0)), rb_num2long(rb_ary_entry(uniform, 1)), rb_num2long(rb_ary_entry(uniform, 2)));
+			shader->setUniform(rb_string_value_cstr(&name), vect3);
+		}
+		else if(arylen == 2)
+		{
+			sf::Glsl::Ivec2 vect2(rb_num2long(rb_ary_entry(uniform, 0)), rb_num2long(rb_ary_entry(uniform, 1)));
+			shader->setUniform(rb_string_value_cstr(&name), vect2);
+		}
+	}
+	else
+	{
+		shader->setUniform(rb_string_value_cstr(&name), static_cast<int>(rb_num2long(uniform)));
+	}
+	return self;
+}
+
+
+VALUE rb_Shader_setBoolUniform(VALUE self, VALUE name, VALUE uniform)
+{
+	GET_SHADER;
+	rb_check_type(name, T_STRING);
+	if (rb_obj_is_kind_of(uniform, rb_cArray) == Qtrue)
+	{
+		long arylen = RARRAY_LEN(uniform);
+		if (arylen == 4)
+		{
+			sf::Glsl::Bvec4 vect4(RTEST(rb_ary_entry(uniform, 0)), RTEST(rb_ary_entry(uniform, 1)), RTEST(rb_ary_entry(uniform, 2)), RTEST(rb_ary_entry(uniform, 3)));
+			shader->setUniform(rb_string_value_cstr(&name), vect4);
+		}
+		else if (arylen == 3)
+		{
+			sf::Glsl::Bvec3 vect3(RTEST(rb_ary_entry(uniform, 0)), RTEST(rb_ary_entry(uniform, 1)), RTEST(rb_ary_entry(uniform, 2)));
+			shader->setUniform(rb_string_value_cstr(&name), vect3);
+		}
+		else if(arylen == 2)
+		{ 
+			sf::Glsl::Bvec2 vect2(RTEST(rb_ary_entry(uniform, 0)), RTEST(rb_ary_entry(uniform, 1)));
+			shader->setUniform(rb_string_value_cstr(&name), vect2);
+		}
+	}
+	else
+	{
+		shader->setUniform(rb_string_value_cstr(&name), RTEST(uniform));
+	}
+	return self;
+}
+
+VALUE rb_Shader_setTextureUniform(VALUE self, VALUE name, VALUE uniform)
+{
+	GET_SHADER;
+	rb_check_type(name, T_STRING);
+	if (rb_obj_is_kind_of(uniform, rb_cBitmap) == Qtrue)
+	{
+		sf::Texture* texture = rb_Bitmap_getTexture(uniform);
+		if (texture != nullptr)
+		{
+			shader->setUniform(rb_string_value_cstr(&name), *texture);
+		}
+	}
+	else
+	{
+		shader->setUniform(rb_string_value_cstr(&name), sf::Shader::CurrentTexture);
+	}
+	return self;
+}
+
+VALUE rb_Shader_setMatrixUniform(VALUE self, VALUE name, VALUE uniform)
+{
+	GET_SHADER;
+	unsigned long i;
+	rb_check_type(name, T_STRING);
+	rb_check_type(uniform, T_ARRAY);
+	long arylen = RARRAY_LEN(uniform);
+	float floats[16];
+	if (arylen == 9)
+	{
+		for (i = 0; i < 9; i++)
+		{
+			floats[i] = NUM2DBL(rb_ary_entry(uniform, i));
+		}
+		sf::Glsl::Mat3 matrix3(floats);
+		shader->setUniform(rb_string_value_cstr(&name), matrix3);
+	}
+	else if(arylen == 16)
+	{
+		for (i = 0; i < 16; i++)
+		{
+			floats[i] = NUM2DBL(rb_ary_entry(uniform, i));
+		}
+		sf::Glsl::Mat4 matrix4(floats);
+		shader->setUniform(rb_string_value_cstr(&name), matrix4);
+	}
+
+	return self;
+}
+
+VALUE rb_Shader_setFloatArrayUniform(VALUE self, VALUE name, VALUE uniform)
+{
+	GET_SHADER;
+	rb_check_type(name, T_STRING);
+	rb_check_type(uniform, T_ARRAY);
+	unsigned int len = RARRAY_LEN(uniform);
+	float* floats = new float[len];
+	for (unsigned int i = 0; i < len; i++)
+	{
+		VALUE val = rb_ary_entry(uniform, i);
+		rb_check_type(val, T_FLOAT);
+		floats[i] = static_cast<float>(NUM2DBL(val));
+	}
+	shader->setUniformArray(rb_string_value_cstr(&name), floats, len);
+	delete floats;
+	return self;
+}
+
+VALUE rb_Shader_isGeometryAvailable(VALUE self)
+{
+	return sf::Shader::isAvailable() ? Qtrue : Qfalse;
+}
+
+
+VALUE rb_Shader_Copy(VALUE self)
+{
+	rb_raise(rb_eRGSSError, "Shaders cannot be cloned or duplicated.");
+	return self;
+}

data/ext/LiteRGSS/Shader.h

@@ -0,0 +1,13 @@
+#ifndef L_SHADER_HEADER
+#define L_SHADER_HEADER
+
+VALUE rb_Shader_isGeometryAvailable(VALUE self);
+VALUE rb_Shader_loadFromMemory(int argc, VALUE *argv, VALUE self);
+VALUE rb_Shader_Copy(VALUE self);
+VALUE rb_Shader_setFloatUniform(VALUE self, VALUE name, VALUE uniform);
+VALUE rb_Shader_setIntUniform(VALUE self, VALUE name, VALUE uniform);
+VALUE rb_Shader_setBoolUniform(VALUE self, VALUE name, VALUE uniform);
+VALUE rb_Shader_setTextureUniform(VALUE self, VALUE name, VALUE uniform);
+VALUE rb_Shader_setMatrixUniform(VALUE self, VALUE name, VALUE uniform);
+VALUE rb_Shader_setFloatArrayUniform(VALUE self, VALUE name, VALUE uniform);
+#endif // !L_SHADER_HEADER

data/ext/LiteRGSS/ShaderSprite.cpp

@@ -0,0 +1,78 @@
+#include "LiteRGSS.h"
+#include "CBitmap_Element.h"
+#include "CRect_Element.h"
+
+VALUE rb_cShaderSprite = Qnil;
+
+#define SHADER_SPRITE_PROTECT if(RDATA(self)->data == nullptr) \
+{\
+    rb_raise(rb_eRGSSError, "Disposed Sprite."); \
+    return self; \
+}
+
+#define GET_SHADER_SPRITE CShaderSprite_Element* sprite; \
+    Data_Get_Struct(self, CShaderSprite_Element, sprite); \
+    SHADER_SPRITE_PROTECT
+
+void rb_ShaderSprite_Mark(CShaderSprite_Element* sprite)
+{
+    if(sprite == nullptr)
+        return;
+    rb_gc_mark(sprite->rViewport);
+    rb_gc_mark(sprite->rBitmap);
+    rb_gc_mark(sprite->rX);
+    rb_gc_mark(sprite->rY);
+    rb_gc_mark(sprite->rZ);
+    rb_gc_mark(sprite->rOX);
+    rb_gc_mark(sprite->rOY);
+    rb_gc_mark(sprite->rAngle);
+    rb_gc_mark(sprite->rZoomX);
+    rb_gc_mark(sprite->rZoomY);
+    rb_gc_mark(sprite->rRect);
+	rb_gc_mark(sprite->rRenderStates);
+}
+
+VALUE rb_ShaderSprite_Alloc(VALUE klass)
+{
+	CShaderSprite_Element* sprite = new CShaderSprite_Element();
+    sprite->getSprite()->setColor(sf::Color(255, 255, 255, 255));
+    sprite->setLinkedRect(nullptr);
+	sprite->rRenderStates = Qnil;
+    return Data_Wrap_Struct(klass, rb_ShaderSprite_Mark, rb_Sprite_Free, sprite);
+}
+
+void Init_ShaderSprite() {
+	rb_cShaderSprite = rb_define_class_under(rb_mLiteRGSS, "ShaderedSprite", rb_cSprite);
+    rb_define_alloc_func(rb_cShaderSprite, rb_ShaderSprite_Alloc);
+
+	rb_define_method(rb_cShaderSprite, "shader", _rbf rb_ShaderSprite_getShader, 0);
+	rb_define_method(rb_cShaderSprite, "shader=", _rbf rb_ShaderSprite_setShader, 1);
+
+	rb_define_method(rb_cShaderSprite, "blendmode", _rbf rb_ShaderSprite_getShader, 0);
+	rb_define_method(rb_cShaderSprite, "blendmode=", _rbf rb_ShaderSprite_setShader, 1);
+}
+
+VALUE rb_ShaderSprite_getShader(VALUE self)
+{
+	GET_SHADER_SPRITE;
+	return sprite->rRenderStates;
+}
+
+VALUE rb_ShaderSprite_setShader(VALUE self, VALUE shader)
+{
+	sf::RenderStates* render_state;
+	GET_SHADER_SPRITE;
+	if (rb_obj_is_kind_of(shader, rb_cBlendMode) == Qtrue) 
+	{
+		Data_Get_Struct(shader, sf::RenderStates, render_state);
+		if (render_state != nullptr)
+		{
+			sprite->rRenderStates = shader;
+			sprite->setRenderState(render_state);
+			return self;
+		}
+	}
+	sprite->rRenderStates = Qnil;
+	sprite->setRenderState(nullptr);
+	return self;
+}

data/ext/LiteRGSS/ShaderSprite.h

@@ -0,0 +1,8 @@
+#ifndef L_SHADER_SPRITE_HEADER
+#define L_SHADER_SPRITE_HEADER
+#include "Graphics.h"
+
+VALUE rb_ShaderSprite_getShader(VALUE self);
+VALUE rb_ShaderSprite_setShader(VALUE self, VALUE shader);
+
+#endif

data/ext/LiteRGSS/Sprite.cpp

@@ -0,0 +1,495 @@
+#include "LiteRGSS.h"
+#include "CBitmap_Element.h"
+#include "CRect_Element.h"
+
+VALUE rb_cSprite = Qnil;
+
+#define SPRITE_PROTECT if(RDATA(self)->data == nullptr) \
+{\
+    rb_raise(rb_eRGSSError, "Disposed Sprite."); \
+    return self; \
+}
+
+#define GET_SPRITE CSprite_Element* sprite; \
+    Data_Get_Struct(self, CSprite_Element, sprite); \
+    SPRITE_PROTECT
+
+void rb_Sprite_Free(void* data)
+{
+    CSprite_Element* sprite = reinterpret_cast<CSprite_Element*>(data);
+    if(sprite != nullptr)
+    {
+        if(NIL_P(sprite->rViewport)) // I can drop a sprite from the viewport it's stored in its table
+            sprite->setOriginStack(nullptr);
+        CRect_Element* rect = sprite->getLinkedRect();
+        if(rect != nullptr)
+            rect->setElement(nullptr);
+        delete sprite;
+    }
+}
+
+void rb_Sprite_Mark(CSprite_Element* sprite)
+{
+    if(sprite == nullptr)
+        return;
+    rb_gc_mark(sprite->rViewport);
+    rb_gc_mark(sprite->rBitmap);
+    rb_gc_mark(sprite->rX);
+    rb_gc_mark(sprite->rY);
+    rb_gc_mark(sprite->rZ);
+    rb_gc_mark(sprite->rOX);
+    rb_gc_mark(sprite->rOY);
+    rb_gc_mark(sprite->rAngle);
+    rb_gc_mark(sprite->rZoomX);
+    rb_gc_mark(sprite->rZoomY);
+    rb_gc_mark(sprite->rRect);
+}
+
+VALUE rb_Sprite_Alloc(VALUE klass)
+{
+    CSprite_Element* sprite = new CSprite_Element();
+    sprite->getSprite()->setColor(sf::Color(255, 255, 255, 255));
+    sprite->setLinkedRect(nullptr);
+    return Data_Wrap_Struct(klass, rb_Sprite_Mark, rb_Sprite_Free, sprite);
+}
+
+void Init_Sprite() {
+    rb_cSprite = rb_define_class_under(rb_mLiteRGSS, "Sprite", rb_cObject);
+    rb_define_alloc_func(rb_cSprite, rb_Sprite_Alloc);
+
+    rb_define_method(rb_cSprite, "initialize", _rbf rb_Sprite_Initialize, -1);
+    rb_define_method(rb_cSprite, "dispose", _rbf rb_Sprite_Dispose, 0);
+    rb_define_method(rb_cSprite, "bitmap", _rbf rb_Sprite_getBitmap, 0);
+    rb_define_method(rb_cSprite, "bitmap=", _rbf rb_Sprite_setBitmap, 1);
+    rb_define_method(rb_cSprite, "x", _rbf rb_Sprite_getX, 0);
+    rb_define_method(rb_cSprite, "x=", _rbf rb_Sprite_setX, 1);
+    rb_define_method(rb_cSprite, "y", _rbf rb_Sprite_getY, 0);
+    rb_define_method(rb_cSprite, "y=", _rbf rb_Sprite_setY, 1);
+    rb_define_method(rb_cSprite, "z", _rbf rb_Sprite_getZ, 0);
+    rb_define_method(rb_cSprite, "z=", _rbf rb_Sprite_setZ, 1);
+    rb_define_method(rb_cSprite, "ox", _rbf rb_Sprite_getOX, 0);
+    rb_define_method(rb_cSprite, "ox=", _rbf rb_Sprite_setOX, 1);
+    rb_define_method(rb_cSprite, "oy", _rbf rb_Sprite_getOY, 0);
+    rb_define_method(rb_cSprite, "oy=", _rbf rb_Sprite_setOY, 1);
+    rb_define_method(rb_cSprite, "visible", _rbf rb_Sprite_getVisible, 0);
+    rb_define_method(rb_cSprite, "visible=", _rbf rb_Sprite_setVisible, 1);
+    rb_define_method(rb_cSprite, "angle", _rbf rb_Sprite_getAngle, 0);
+    rb_define_method(rb_cSprite, "angle=", _rbf rb_Sprite_setAngle, 1);
+    rb_define_method(rb_cSprite, "zoom_x", _rbf rb_Sprite_getZoomX, 0);
+    rb_define_method(rb_cSprite, "zoom_x=", _rbf rb_Sprite_setZoomX, 1);
+    rb_define_method(rb_cSprite, "zoom_y", _rbf rb_Sprite_getZoomY, 0);
+    rb_define_method(rb_cSprite, "zoom_y=", _rbf rb_Sprite_setZoomY, 1);
+    rb_define_method(rb_cSprite, "set_position", _rbf rb_Sprite_setPosition, 2);
+    rb_define_method(rb_cSprite, "set_origin", _rbf rb_Sprite_setOrigin, 2);
+    rb_define_method(rb_cSprite, "zoom=", _rbf rb_Sprite_setZoom, 1);
+    rb_define_method(rb_cSprite, "opacity", _rbf rb_Sprite_getOpacity, 0);
+    rb_define_method(rb_cSprite, "opacity=", _rbf rb_Sprite_setOpacity, 1);
+    rb_define_method(rb_cSprite, "src_rect", _rbf rb_Sprite_getRect, 0);
+    rb_define_method(rb_cSprite, "src_rect=", _rbf rb_Sprite_setRect, 1);
+    rb_define_method(rb_cSprite, "disposed?", _rbf rb_Sprite_Disposed, 0);
+    rb_define_method(rb_cSprite, "viewport", _rbf rb_Sprite_Viewport, 0);
+	rb_define_method(rb_cSprite, "mirror", _rbf rb_Sprite_getMirror, 0);
+	rb_define_method(rb_cSprite, "mirror=", _rbf rb_Sprite_setMirror, 1);
+	rb_define_method(rb_cSprite, "width", _rbf rb_Sprite_width, 0);
+	rb_define_method(rb_cSprite, "height", _rbf rb_Sprite_height, 0);
+    rb_define_method(rb_cSprite, "__index__", _rbf rb_Sprite_Index, 0);
+
+    rb_define_method(rb_cSprite, "clone", _rbf rb_Sprite_Copy, 0);
+    rb_define_method(rb_cSprite, "dup", _rbf rb_Sprite_Copy, 0);
+}
+
+VALUE rb_Sprite_Initialize(int argc, VALUE* argv, VALUE self)
+{
+    GET_SPRITE
+    VALUE table;
+    /* If a viewport was specified */
+    if(argc == 1 && rb_obj_is_kind_of(argv[0], rb_cViewport) == Qtrue)
+    {
+        CViewport_Element* viewport;
+        Data_Get_Struct(argv[0], CViewport_Element, viewport);
+        viewport->bind(sprite);
+        table = rb_ivar_get(argv[0], rb_iElementTable);
+        sprite->rViewport = argv[0];
+    }
+    /* Otherwise */
+    else
+    {
+        global_Graphics_Bind(sprite);
+        table = rb_ivar_get(rb_mGraphics, rb_iElementTable);
+        sprite->rViewport = Qnil;
+    }
+    /* Ajout à la table de sauvegarde */
+    rb_ary_push(table, self);
+    /* Initializing Instance variables */
+    sprite->rX = LONG2FIX(0);
+    sprite->rY = LONG2FIX(0);
+    sprite->rZ = LONG2FIX(0);
+    sprite->rOX = LONG2FIX(0);
+    sprite->rOY = LONG2FIX(0);
+    sprite->rAngle = LONG2FIX(0);
+    sprite->rZoomX = LONG2FIX(1);
+    sprite->rZoomY = LONG2FIX(1);
+    sprite->rBitmap = Qnil;
+    sprite->rRect = Qnil;
+	sprite->rMirror = Qfalse;
+    return self;
+}
+
+VALUE rb_Sprite_Copy(VALUE self)
+{
+    rb_raise(rb_eRGSSError, "Sprites cannot be cloned or duplicated.");
+    return self;
+}
+
+VALUE rb_Sprite_Dispose(VALUE self)
+{
+    GET_SPRITE
+    RDATA(self)->data = nullptr;
+    /* Suppression du sprite de ses stacks */
+    VALUE viewport = sprite->rViewport;
+    VALUE table;
+    if(NIL_P(viewport))
+        table = rb_ivar_get(rb_mGraphics, rb_iElementTable);
+    else
+        table = rb_ivar_get(viewport, rb_iElementTable);
+    rb_ary_delete(table, self);
+    sprite->setOriginStack(nullptr); // Ensure the sprite has been removed from the sprite stack
+    rb_Sprite_Free(reinterpret_cast<void*>(sprite));
+    return self;
+}
+
+VALUE rb_Sprite_DisposeFromViewport(VALUE self)
+{
+    if(RDATA(self)->data == nullptr)
+        return self;
+    GET_SPRITE
+    RDATA(self)->data = nullptr;
+    rb_Sprite_Free(reinterpret_cast<void*>(sprite));
+    return self;
+}
+
+VALUE rb_Sprite_Disposed(VALUE self)
+{
+    rb_check_type(self, T_DATA);
+    return (RDATA(self)->data == nullptr ? Qtrue : Qfalse);
+}
+
+VALUE rb_Sprite_setBitmap(VALUE self, VALUE bitmap)
+{
+    GET_SPRITE
+    if(rb_obj_is_kind_of(bitmap, rb_cBitmap) == Qfalse)
+    {
+        if(bitmap == Qnil)
+        {
+            sprite->setDrawable(false);
+            sprite->rBitmap = bitmap;
+        }
+        else
+            rb_raise(rb_eTypeError, "Expected a Bitmap.");
+        return self;
+    }
+    /* Bitmap Protection */
+    if(RDATA(bitmap)->data == nullptr)
+    {
+        rb_raise(rb_eRGSSError, "Disposed Bitmap."); 
+        return self;
+    }
+    /* Retreiving Bitmap Objecy */
+    CBitmap_Element* bmp;
+    Data_Get_Struct(bitmap, CBitmap_Element, bmp);
+    sf::Sprite* sp = sprite->getSprite();
+    sp->setTexture(*bmp->getTexture(), true);
+    sprite->setDrawable(true);
+    sprite->rBitmap = bitmap;
+	if (!NIL_P(sprite->rRect))
+	{
+		CRect_Element* rect;
+		Data_Get_Struct(sprite->rRect, CRect_Element, rect);
+		/* Setting rect parameter */
+		const sf::IntRect rectorigin = sp->getTextureRect();
+		rect_copy(rect->getRect(), &rectorigin);
+	}
+    return self;
+}
+
+VALUE rb_Sprite_getBitmap(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rBitmap;
+}
+
+VALUE rb_Sprite_setX(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Vector2f vect = sp->getPosition();
+    sp->setPosition(static_cast<float>(rb_num2long(val)), vect.y);
+    sprite->rX = val;
+    return val;
+}
+
+VALUE rb_Sprite_getX(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rX;
+}
+
+VALUE rb_Sprite_setY(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Vector2f vect = sp->getPosition();
+    sp->setPosition(vect.x, static_cast<float>(rb_num2long(val)));
+    sprite->rY = val;
+    return val;
+}
+
+VALUE rb_Sprite_getY(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rY;
+}
+
+VALUE rb_Sprite_setZ(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    rb_num2long(val);
+    sprite->rZ = val;
+    return val;
+}
+
+VALUE rb_Sprite_getZ(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rZ;
+}
+
+VALUE rb_Sprite_setOX(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Vector2f vect = sp->getOrigin();
+    sp->setOrigin(static_cast<float>(rb_num2long(val)), vect.y);
+    sprite->rOX = val;
+    return val;
+}
+
+VALUE rb_Sprite_getOX(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rOX;
+}
+
+VALUE rb_Sprite_setOY(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Vector2f vect = sp->getOrigin();
+    sp->setOrigin(vect.x, static_cast<float>(rb_num2long(val)));
+    sprite->rOY = val;
+    return val;
+}
+
+VALUE rb_Sprite_getOY(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rOY;
+}
+
+VALUE rb_Sprite_setVisible(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sprite->setVisible(RTEST(val));
+    return val;
+}
+
+VALUE rb_Sprite_getVisible(VALUE self)
+{
+    GET_SPRITE
+    return sprite->getVisible() ? Qtrue : Qfalse;
+}
+
+VALUE rb_Sprite_setAngle(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sprite->getSprite()->setRotation(static_cast<float>(-NUM2DBL(val))); // RGSS rotation is trigo, SFML looks like anti-trigo
+    sprite->rAngle = val;
+    return val;
+}
+
+VALUE rb_Sprite_getAngle(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rAngle;
+}
+
+VALUE rb_Sprite_setZoomX(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Vector2f vect = sp->getScale();
+    sp->setScale(static_cast<float>(rb_num2dbl(val)), vect.y);
+    sprite->rZoomX = val;
+    return val;
+}
+
+VALUE rb_Sprite_getZoomX(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rZoomX;
+}
+
+VALUE rb_Sprite_setZoomY(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Vector2f vect = sp->getScale();
+    sp->setScale(vect.x, static_cast<float>(rb_num2dbl(val)));
+    sprite->rZoomY = val;
+    return val;
+}
+
+VALUE rb_Sprite_getZoomY(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rZoomY;
+}
+
+
+VALUE rb_Sprite_setPosition(VALUE self, VALUE x, VALUE y)
+{
+    GET_SPRITE
+    sprite->getSprite()->setPosition(static_cast<float>(rb_num2long(x)), static_cast<float>(rb_num2long(y)));
+    sprite->rX = x;
+    sprite->rY = y;
+    return self;
+}
+
+VALUE rb_Sprite_setOrigin(VALUE self, VALUE x, VALUE y)
+{
+    GET_SPRITE
+    sprite->getSprite()->setOrigin(static_cast<float>(rb_num2long(x)), static_cast<float>(rb_num2long(y)));
+    sprite->rOX = x;
+    sprite->rOY = y;
+    return self;
+}
+
+VALUE rb_Sprite_setZoom(VALUE self, VALUE zoom)
+{
+    GET_SPRITE
+    float scale = static_cast<float>(rb_num2dbl(zoom));
+    sprite->getSprite()->setScale(scale, scale);
+    sprite->rZoomX = zoom;
+    sprite->rZoomY = zoom;
+    return zoom;
+}
+
+VALUE rb_Sprite_setOpacity(VALUE self, VALUE val)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Color col = sp->getColor();
+    sp->setColor(sf::Color(col.r, col.g, col.b, normalize_long(rb_num2long(val), 0, 255)));
+    return val;
+}
+
+VALUE rb_Sprite_getOpacity(VALUE self)
+{
+    GET_SPRITE
+    sf::Sprite* sp = sprite->getSprite();
+    const sf::Color col = sp->getColor();
+    return rb_int2inum(col.a);
+}
+
+VALUE rb_Sprite_getRect(VALUE self)
+{
+    GET_SPRITE
+    VALUE rc = sprite->rRect;
+    if(!NIL_P(rc))
+        return rc;
+    /* Creating rect */
+    VALUE argv[2];
+    argv[0] = argv[1] = LONG2FIX(0);
+    rc = rb_class_new_instance(2, argv, rb_cRect);
+    /* Fetching data */
+    CRect_Element* rect;
+    Data_Get_Struct(rc, CRect_Element, rect);
+    /* Setting rect parameter */
+    const sf::IntRect rectorigin = sprite->getSprite()->getTextureRect();
+    rect_copy(rect->getRect(), &rectorigin);
+    /* Linking Rect */
+    rect->setElement(sprite);
+    sprite->setLinkedRect(rect);
+    sprite->rRect = rc;
+    return rc;
+}
+
+VALUE rb_Sprite_setRect(VALUE self, VALUE val)
+{
+    VALUE rc = rb_Sprite_getRect(self);
+    if(RDATA(rc)->data == nullptr) { return Qnil; }
+    if(rb_obj_is_kind_of(val, rb_cRect) != Qtrue)
+    {
+        rb_raise(rb_eTypeError, "Expected Rect got %s.", RSTRING_PTR(rb_class_name(CLASS_OF(val))));
+        return Qnil;
+    }
+    if(RDATA(val)->data == nullptr) { return Qnil; }
+    CSprite_Element* sprite;
+    Data_Get_Struct(self, CSprite_Element, sprite);
+    /* Getting data to update the rect */
+    CRect_Element* rect1;
+    Data_Get_Struct(val, CRect_Element, rect1);
+    CRect_Element* rect2;
+    Data_Get_Struct(rc, CRect_Element, rect2);
+    /* Copying the rect */
+    sf::IntRect* rect_target = rect2->getRect();
+    rect_copy(rect_target, rect1->getRect());
+	/* Mirror management */
+	sf::IntRect rect_setter = *rect_target;
+	if (RTEST(sprite->rMirror))
+	{
+		rect_setter.left += rect_setter.width;
+		rect_setter.width = -rect_setter.width;
+	}
+    /* Updating the texture rect */
+    sprite->getSprite()->setTextureRect(rect_setter);
+    return val;
+}
+
+VALUE rb_Sprite_getMirror(VALUE self)
+{
+	GET_SPRITE;
+	return sprite->rMirror;
+}
+
+VALUE rb_Sprite_setMirror(VALUE self, VALUE val)
+{
+	GET_SPRITE;
+	sprite->rMirror = RTEST(val) ? Qtrue : Qfalse;
+	rb_Sprite_setRect(self, rb_Sprite_getRect(self));
+	return self;
+}
+
+VALUE rb_Sprite_Viewport(VALUE self)
+{
+    GET_SPRITE
+    return sprite->rViewport;
+}
+
+VALUE rb_Sprite_Index(VALUE self)
+{
+    GET_SPRITE
+    return rb_uint2inum(sprite->getIndex());
+}
+
+VALUE rb_Sprite_width(VALUE self)
+{
+	VALUE rc = rb_Sprite_getRect(self);
+	return rb_Rect_getWidth(rc);
+}
+
+VALUE rb_Sprite_height(VALUE self)
+{
+	VALUE rc = rb_Sprite_getRect(self);
+	return rb_Rect_getHeight(rc);
+}