LiteRGSS 0.1.3

data/ext/LiteRGSS/CViewport_Element.h

@@ -0,0 +1,57 @@
+#ifndef CViewport_Element_H
+#define CViewport_Element_H
+#include "CDrawable_Element.h"
+#include "CSprite_Element.h"
+
+class CViewport_Element : public CDrawable_Element {
+    protected:
+        long ox, oy;
+        sf::View view;
+        std::vector<CDrawable_Element*> stack;
+        sf::Glsl::Vec4 tone;
+        CTone_Element* linkedTone;
+        /*sf::RenderTexture* render;
+		sf::Shader* shader;*/
+		sf::Color* color_copy;
+        bool visible;
+		sf::RenderStates* render_states;
+    public:
+		CViewport_Element();
+        ~CViewport_Element();
+        void draw(sf::RenderTarget& target) const override;
+        void drawFast(sf::RenderTarget& target) const override;
+		bool isViewport() const override;
+		bool isPureSprite() const override;
+        sf::View* getView() {return &view;};
+		sf::RenderStates* getRenderStates();
+		void setRenderStates(sf::RenderStates* states);
+        long getOx() {return ox;};
+        long getOy() {return oy;};
+        void setOx(long nox) {ox = nox;};
+        void setOy(long noy) {oy = noy;};
+        void bind(CDrawable_Element* sprite);
+        void clearStack();
+        sf::Glsl::Vec4* getTone();
+		void updatetone();
+		void setLinkedTone(CTone_Element* _tone);
+		CTone_Element* getLinkedTone();
+        // void reset_render();
+        void create_render();
+		void setVisible(bool value);
+        bool getVisible() { return visible; };
+		const std::vector<CDrawable_Element*>* getStack();
+        /* Ruby Ivar */
+        VALUE rRect;
+        VALUE rTone;
+        VALUE rColor;
+        VALUE rZ;
+		VALUE rAngle;
+		VALUE rZoom;
+		VALUE rRenderState;
+        /* Shader related stuff */
+		static sf::RenderTexture* render;
+		static sf::Sprite* render_sprite;
+	private:
+		sf::Color* check_up_color() const;
+};
+#endif

data/ext/LiteRGSS/Color.cpp

@@ -0,0 +1,200 @@
+#include "LiteRGSS.h"
+
+VALUE rb_cColor = Qnil;
+
+#define COLOR_PROTECT if(RDATA(self)->data == nullptr) \
+{\
+    rb_raise(rb_eRGSSError, "Freed Color."); \
+}
+
+#define GET_COLOR sf::Color* color; \
+    Data_Get_Struct(self, sf::Color, color); \
+    COLOR_PROTECT
+
+void rb_Color_Free(void* data)
+{
+    sf::Color* color = reinterpret_cast<sf::Color*>(data);
+    if(color)
+    {
+        delete color;
+    }
+}
+
+VALUE rb_Color_Alloc(VALUE klass)
+{
+    sf::Color* color = new sf::Color();
+    color->a = 255;
+    return Data_Wrap_Struct(klass, NULL, rb_Color_Free, color);
+}
+
+void Init_Color()
+{
+    rb_cColor = rb_define_class_under(rb_mLiteRGSS, "Color", rb_cObject);
+    rb_define_alloc_func(rb_cColor, rb_Color_Alloc);
+
+    rb_define_method(rb_cColor, "initialize", _rbf rb_Color_Initialize, -1);
+    rb_define_method(rb_cColor, "set", _rbf rb_Color_Initialize, -1);
+    rb_define_method(rb_cColor, "initialize_copy", _rbf rb_Color_InitializeCopy, 1);
+    rb_define_method(rb_cColor, "red", _rbf rb_Color_getRed, 0);
+    rb_define_method(rb_cColor, "red=", _rbf rb_Color_setRed, 1);
+    rb_define_method(rb_cColor, "green", _rbf rb_Color_getGreen, 0);
+    rb_define_method(rb_cColor, "green=", _rbf rb_Color_setGreen, 1);
+    rb_define_method(rb_cColor, "blue", _rbf rb_Color_getBlue, 0);
+    rb_define_method(rb_cColor, "blue=", _rbf rb_Color_setBlue, 1);
+    rb_define_method(rb_cColor, "alpha", _rbf rb_Color_getAlpha, 0);
+    rb_define_method(rb_cColor, "alpha=", _rbf rb_Color_setAlpha, 1);
+    rb_define_method(rb_cColor, "==", _rbf rb_Color_eql, 1);
+    rb_define_method(rb_cColor, "===", _rbf rb_Color_eql, 1);
+    rb_define_method(rb_cColor, "eql?", _rbf rb_Color_eql, 1);
+    rb_define_method(rb_cColor, "to_s", _rbf rb_Color_to_s, 0);
+    rb_define_method(rb_cColor, "inspect", _rbf rb_Color_to_s, 0);
+    rb_define_method(rb_cColor, "_dump", _rbf rb_Color_Save, 1);
+    rb_define_singleton_method(rb_cColor, "_load", _rbf rb_Color_Load, 1);
+}
+
+VALUE rb_Color_Initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE red, green, blue, alpha;
+    rb_scan_args(argc, argv, "13", &red, &green, &blue, &alpha);
+    GET_COLOR
+    if(RTEST(red))
+        color->r = normalize_long(rb_num2long(red), 0, 255);
+    if(RTEST(green))
+        color->g = normalize_long(rb_num2long(green), 0, 255);
+    if(RTEST(blue))
+        color->b = normalize_long(rb_num2long(blue), 0, 255);
+    if(RTEST(alpha))
+        color->a = normalize_long(rb_num2long(alpha), 0, 255);
+    return self;
+}
+
+VALUE rb_Color_InitializeCopy(VALUE self, VALUE original)
+{
+    GET_COLOR
+    sf::Color* coloro;
+    Data_Get_Struct(original, sf::Color, coloro);
+    if(RDATA(original)->data == nullptr)
+        rb_raise(rb_eRGSSError, "Freed Color.");
+    color->r = coloro->r;
+    color->g = coloro->g;
+    color->b = coloro->b;
+    color->a = coloro->a;
+    return self;
+}
+
+VALUE rb_Color_getRed(VALUE self)
+{
+    GET_COLOR
+    return rb_int2inum(color->r);
+}
+
+VALUE rb_Color_setRed(VALUE self, VALUE red)
+{
+    GET_COLOR
+    color->r = normalize_long(rb_num2long(red), 0, 255);
+    return self;
+}
+
+VALUE rb_Color_getGreen(VALUE self)
+{
+    GET_COLOR
+    return rb_int2inum(color->g);
+}
+
+VALUE rb_Color_setGreen(VALUE self, VALUE red)
+{
+    GET_COLOR
+    color->g = normalize_long(rb_num2long(red), 0, 255);
+    return self;
+}
+
+VALUE rb_Color_getBlue(VALUE self)
+{
+    GET_COLOR
+    return rb_int2inum(color->b);
+}
+
+VALUE rb_Color_setBlue(VALUE self, VALUE red)
+{
+    GET_COLOR
+    color->b = normalize_long(rb_num2long(red), 0, 255);
+    return self;
+}
+
+VALUE rb_Color_getAlpha(VALUE self)
+{
+    GET_COLOR
+    return rb_int2inum(color->a);
+}
+
+VALUE rb_Color_setAlpha(VALUE self, VALUE red)
+{
+    GET_COLOR
+    color->a = normalize_long(rb_num2long(red), 0, 255);
+    return self;
+}
+
+
+VALUE rb_Color_eql(VALUE self, VALUE other)
+{
+    if(rb_obj_is_kind_of(other, rb_cColor) != Qtrue)
+        return Qfalse;
+    GET_COLOR
+    sf::Color* color2;
+    Data_Get_Struct(other, sf::Color, color2);
+    if(color2 == nullptr)
+        return Qfalse;
+    if(*color != *color2)
+        return Qfalse;
+    return Qtrue;
+}
+
+VALUE rb_Color_Load(VALUE self, VALUE str)
+{
+    rb_check_type(str, T_STRING);
+    VALUE arr[4];
+    if(RSTRING_LEN(str) < (sizeof(double) * 4))
+    {
+        arr[2] = arr[1] = arr[0] = LONG2FIX(1);
+        return rb_class_new_instance(3, arr, self);
+    }
+    double* color_data = reinterpret_cast<double*>(RSTRING_PTR(str));
+    arr[0] = rb_int2inum(static_cast<long>(color_data[0]));
+    arr[1] = rb_int2inum(static_cast<long>(color_data[1]));
+    arr[2] = rb_int2inum(static_cast<long>(color_data[2]));
+    arr[3] = rb_int2inum(static_cast<long>(color_data[3]));
+    return rb_class_new_instance(4, arr, self);
+}
+
+VALUE rb_Color_Save(VALUE self, VALUE limit)
+{
+    GET_COLOR
+    double color_data[4];
+    color_data[0] = static_cast<double>(color->r);
+    color_data[1] = static_cast<double>(color->g);
+    color_data[2] = static_cast<double>(color->b);
+    color_data[3] = static_cast<double>(color->a);
+    return rb_str_new(reinterpret_cast<const char*>(color_data), sizeof(double) * 4);
+}
+
+VALUE rb_Color_to_s(VALUE self)
+{
+    GET_COLOR
+    return rb_sprintf("(%d, %d, %d, %d)", color->r, color->g, color->b, color->a);
+}
+
+sf::Color* rb_Color_get_color(VALUE self)
+{
+	rb_Color_test_color(self);
+	GET_COLOR;
+	return color;
+}
+
+void rb_Color_test_color(VALUE self)
+{
+
+	if (rb_obj_is_kind_of(self, rb_cColor) != Qtrue)
+	{
+		rb_raise(rb_eTypeError, "Expected Color got %s.", RSTRING_PTR(rb_class_name(CLASS_OF(self))));
+	}
+}

data/ext/LiteRGSS/Color.h

@@ -0,0 +1,22 @@
+#ifndef L_COLOR_H
+#define L_COLOR_H
+
+VALUE rb_Color_Initialize(int argc, VALUE* argv, VALUE self); // Also .set
+VALUE rb_Color_InitializeCopy(VALUE self, VALUE original);
+VALUE rb_Color_getRed(VALUE self);
+VALUE rb_Color_setRed(VALUE self, VALUE red);
+VALUE rb_Color_getGreen(VALUE self);
+VALUE rb_Color_setGreen(VALUE self, VALUE red);
+VALUE rb_Color_getBlue(VALUE self);
+VALUE rb_Color_setBlue(VALUE self, VALUE red);
+VALUE rb_Color_getAlpha(VALUE self);
+VALUE rb_Color_setAlpha(VALUE self, VALUE red);
+VALUE rb_Color_eql(VALUE self, VALUE other);
+VALUE rb_Color_Load(VALUE self, VALUE str);
+VALUE rb_Color_Save(VALUE self, VALUE limit);
+VALUE rb_Color_to_s(VALUE self);
+
+sf::Color* rb_Color_get_color(VALUE self);
+void rb_Color_test_color(VALUE self);
+
+#endif

data/ext/LiteRGSS/Fonts.cpp

@@ -0,0 +1,126 @@
+#include "LiteRGSS.h"
+
+VALUE rb_mFonts = Qnil;
+
+ID rb_Fonts_ivSize = Qnil;
+ID rb_Fonts_ivFColor = Qnil;
+ID rb_Fonts_ivOColor = Qnil;
+ID rb_Fonts_ivSColor = Qnil;
+
+std::vector<unsigned int> rb_Fonts_Size_Tbl;
+std::vector<sf::Font> rb_Fonts_font_tbl;
+
+void Init_Fonts()
+{
+    rb_mFonts = rb_define_module_under(rb_mLiteRGSS, "Fonts");
+
+    rb_define_module_function(rb_mFonts, "load_font", _rbf rb_Fonts_load_font, 2);
+    rb_define_module_function(rb_mFonts, "set_default_size", _rbf rb_Fonts_set_default_size, 2);
+    rb_define_module_function(rb_mFonts, "define_fill_color", _rbf rb_Fonts_define_fill_color, 2);
+    rb_define_module_function(rb_mFonts, "define_outline_color", _rbf rb_Fonts_define_outline_color, 2);
+    rb_define_module_function(rb_mFonts, "define_shadow_color", _rbf rb_Fonts_define_shadow_color, 2);
+    rb_define_module_function(rb_mFonts, "get_default_size", _rbf rb_Fonts_get_default_size, 1);
+    rb_define_module_function(rb_mFonts, "get_fill_color", _rbf rb_Fonts_get_fill_color, 1);
+    rb_define_module_function(rb_mFonts, "get_outline_color", _rbf rb_Fonts_get_outline_color, 1);
+    rb_define_module_function(rb_mFonts, "get_shadow_color", _rbf rb_Fonts_get_shadow_color, 1);
+
+    rb_Fonts_ivSize = rb_intern("@default_size");
+    rb_Fonts_ivFColor = rb_intern("@fill_color");
+    rb_Fonts_ivOColor = rb_intern("@outline_color");
+    rb_Fonts_ivSColor = rb_intern("@shadow_color");
+
+    rb_ivar_set(rb_mFonts, rb_Fonts_ivSize, rb_ary_new());
+    rb_ivar_set(rb_mFonts, rb_Fonts_ivFColor, rb_ary_new());
+    rb_ivar_set(rb_mFonts, rb_Fonts_ivOColor, rb_ary_new());
+    rb_ivar_set(rb_mFonts, rb_Fonts_ivSColor, rb_ary_new());
+}
+
+
+VALUE rb_Fonts_load_font(VALUE self, VALUE id, VALUE str)
+{
+    unsigned long position = normalize_long(rb_num2long(id), 0, 255);
+    rb_check_type(str, T_STRING);
+    while(rb_Fonts_font_tbl.size() <= position)
+    {
+        rb_Fonts_font_tbl.push_back(sf::Font());
+    }
+    rb_Fonts_font_tbl[position].loadFromFile(RSTRING_PTR(str));
+    return self;
+}
+
+sf::Font& rb_Fonts_get_font(unsigned long id)
+{
+    if(rb_Fonts_font_tbl.size() <= id)
+    {
+        rb_raise(rb_eRGSSError, "Unable to fetch font n°%d.", static_cast<int>(id));
+    }
+    return rb_Fonts_font_tbl[id];
+}
+
+VALUE rb_Fonts_set_default_size(VALUE self, VALUE id, VALUE size)
+{
+    unsigned long position = rb_num2long(id);
+    while(rb_Fonts_Size_Tbl.size() <= position)
+        rb_Fonts_Size_Tbl.push_back(16);
+    rb_Fonts_Size_Tbl[position] = static_cast<unsigned int>(rb_num2long(size));
+    return self;
+}
+
+VALUE rb_Fonts_define_fill_color(VALUE self, VALUE id, VALUE color)
+{
+    if(rb_obj_is_kind_of(color, rb_cColor) != Qtrue)
+    {
+        rb_raise(rb_eTypeError, "Expected Color got %s.", RSTRING_PTR(rb_class_name(CLASS_OF(color))));
+        return self;
+    }
+    rb_ary_store(rb_ivar_get(rb_mFonts, rb_Fonts_ivFColor), rb_num2long(id), color);
+    return self;
+}
+
+VALUE rb_Fonts_define_outline_color(VALUE self, VALUE id, VALUE color)
+{
+    if(rb_obj_is_kind_of(color, rb_cColor) != Qtrue)
+    {
+        rb_raise(rb_eTypeError, "Expected Color got %s.", RSTRING_PTR(rb_class_name(CLASS_OF(color))));
+        return self;
+    }
+    rb_ary_store(rb_ivar_get(rb_mFonts, rb_Fonts_ivOColor), rb_num2long(id), color);
+    return self;
+}
+
+VALUE rb_Fonts_define_shadow_color(VALUE self, VALUE id, VALUE color)
+{
+    if(rb_obj_is_kind_of(color, rb_cColor) != Qtrue)
+    {
+        rb_raise(rb_eTypeError, "Expected Color got %s.", RSTRING_PTR(rb_class_name(CLASS_OF(color))));
+        return self;
+    }
+    rb_ary_store(rb_ivar_get(rb_mFonts, rb_Fonts_ivSColor), rb_num2long(id), color);
+    return self;
+}
+
+
+VALUE rb_Fonts_get_default_size(VALUE self, VALUE id)
+{
+    long lid = rb_num2long(id);
+    if(lid >= rb_Fonts_Size_Tbl.size())
+    {
+        return LONG2FIX(16);
+    }
+    return rb_int2inum(static_cast<long>(rb_Fonts_Size_Tbl[lid]));
+}
+
+VALUE rb_Fonts_get_fill_color(VALUE self, VALUE id)
+{
+    return rb_ary_aref(1, &id, rb_ivar_get(rb_mFonts, rb_Fonts_ivFColor));
+}
+
+VALUE rb_Fonts_get_outline_color(VALUE self, VALUE id)
+{
+    return rb_ary_aref(1, &id, rb_ivar_get(rb_mFonts, rb_Fonts_ivOColor));
+}
+
+VALUE rb_Fonts_get_shadow_color(VALUE self, VALUE id)
+{
+    return rb_ary_aref(1, &id, rb_ivar_get(rb_mFonts, rb_Fonts_ivSColor));
+}

data/ext/LiteRGSS/Fonts.h

@@ -0,0 +1,20 @@
+#ifndef L_FONTS_HEADER
+#define L_FONTS_HEADER
+
+extern ID rb_Fonts_ivSize;
+extern ID rb_Fonts_ivFColor;
+extern ID rb_Fonts_ivOColor;
+extern ID rb_Fonts_ivSColor;
+
+VALUE rb_Fonts_load_font(VALUE self, VALUE id, VALUE str);
+sf::Font& rb_Fonts_get_font(unsigned long id);
+VALUE rb_Fonts_set_default_size(VALUE self, VALUE id, VALUE size);
+VALUE rb_Fonts_define_fill_color(VALUE self, VALUE id, VALUE color);
+VALUE rb_Fonts_define_outline_color(VALUE self, VALUE id, VALUE color);
+VALUE rb_Fonts_define_shadow_color(VALUE self, VALUE id, VALUE color);
+VALUE rb_Fonts_get_default_size(VALUE self, VALUE id);
+VALUE rb_Fonts_get_fill_color(VALUE self, VALUE id);
+VALUE rb_Fonts_get_outline_color(VALUE self, VALUE id);
+VALUE rb_Fonts_get_shadow_color(VALUE self, VALUE id);
+
+#endif

data/ext/LiteRGSS/Graphics.cpp

@@ -0,0 +1,314 @@
+#include "LiteRGSS.h"
+#include "ruby/thread.h"
+#include "Graphics.local.h"
+#include "CBitmap_Element.h"
+#include "CViewport_Element.h"
+
+/* Variables definition */
+VALUE rb_mGraphics = Qnil;
+VALUE rb_eStoppedGraphics = Qnil;
+VALUE rb_eClosedWindow = Qnil;
+ID rb_iGraphicsShader = Qnil;
+
+long ScreenWidth = 640;
+long ScreenHeight = 480;
+unsigned long frame_count = 0;
+unsigned long frame_rate = 60;
+
+sf::RenderWindow* game_window = nullptr;
+bool InsideGraphicsUpdate = false;
+std::vector<CDrawable_Element*> Graphics_stack;
+
+sf::Texture* Graphics_freeze_texture = nullptr;
+sf::Sprite* Graphics_freeze_sprite = nullptr;
+sf::Shader* Graphics_freeze_shader = nullptr;
+
+/* Macro Definition */
+#define GRAPHICS_PROTECT if(game_window == nullptr) { \
+    rb_raise(rb_eStoppedGraphics, "Graphics is not started, window closed thus no Graphics operation allowed. Please call Graphics.start before using other Graphics functions."); \
+    return self; \
+}
+
+void Init_Graphics()
+{
+    rb_mGraphics = rb_define_module_under(rb_mLiteRGSS, "Graphics");
+    /* Defining the Stopped Graphics Error */
+    rb_eStoppedGraphics = rb_define_class_under(rb_mGraphics, "StoppedError", rb_eStandardError);
+    rb_eClosedWindow = rb_define_class_under(rb_mGraphics, "ClosedWindowError", rb_eStandardError);
+    /* Defining the Graphics functions */
+    rb_define_module_function(rb_mGraphics, "start", _rbf rb_Graphics_start, 0);
+    rb_define_module_function(rb_mGraphics, "stop", _rbf rb_Graphics_stop, 0);
+    rb_define_module_function(rb_mGraphics, "update", _rbf rb_Graphics_update, 0);
+    rb_define_module_function(rb_mGraphics, "snap_to_bitmap", _rbf rb_Graphics_snap_to_bitmap, 0);
+    rb_define_module_function(rb_mGraphics, "freeze", _rbf rb_Graphics_freeze, 0);
+    rb_define_module_function(rb_mGraphics, "transition", _rbf rb_Graphics_transition, -1);
+    rb_define_module_function(rb_mGraphics, "list_resolutions", _rbf rb_Graphics_list_res, 0);
+    rb_define_module_function(rb_mGraphics, "frame_count", _rbf rb_Graphics_get_frame_count, 0);
+    rb_define_module_function(rb_mGraphics, "frame_count=", _rbf rb_Graphics_set_frame_count, 1);
+    rb_define_module_function(rb_mGraphics, "width", _rbf rb_Graphics_width, 0);
+    rb_define_module_function(rb_mGraphics, "height", _rbf rb_Graphics_height, 0);
+    rb_define_module_function(rb_mGraphics, "reload_stack", _rbf rb_Graphics_ReloadStack, 0);
+    rb_define_module_function(rb_mGraphics, "update_no_input", _rbf rb_Graphics_update_no_input_count, 0);
+    rb_define_module_function(rb_mGraphics, "update_only_input", _rbf rb_Graphics_update_only_input, 0);
+    rb_define_module_function(rb_mGraphics, "brightness", _rbf rb_Graphics_getBrightness, 0);
+    rb_define_module_function(rb_mGraphics, "brightness=", _rbf rb_Graphics_setBrightness, 1);
+    rb_define_module_function(rb_mGraphics, "shader", _rbf rb_Graphics_getShader, 0);
+    rb_define_module_function(rb_mGraphics, "shader=", _rbf rb_Graphics_setShader, 1);
+    /* creating the element table */
+    rb_ivar_set(rb_mGraphics, rb_iElementTable, rb_ary_new());
+	rb_iGraphicsShader = rb_intern("@__GraphicsShader");
+	/* Store the max texture size */
+	rb_define_const(rb_mGraphics, "MAX_TEXTURE_SIZE", LONG2FIX(sf::Texture::getMaximumSize()));
+}
+
+VALUE rb_Graphics_start(VALUE self)
+{
+    unsigned int framerate;
+    if(game_window != nullptr)
+        return Qnil;
+    /* Shader Testing */
+    if (!sf::Shader::isAvailable())
+        rb_raise(rb_eRGSSError, "Shaders are not available :(");
+    /* Window Loading */
+    sf::VideoMode vmode(640, 480, 32);
+    local_LoadVideoModeFromConfigs(vmode);
+    local_LoadSmoothScreenFromConfigs();
+    sf::Uint32 style = sf::Style::Close | sf::Style::Titlebar; // sf::Style::Resize = text issues !
+    if(local_LoadFullScreenFromConfigs())
+        style = sf::Style::Fullscreen;
+    game_window = new sf::RenderWindow(vmode, local_LoadTitleFromConfigs(), style);
+    game_window->setMouseCursorVisible(false);
+	framerate = local_LoadFrameRateFromConfigs();
+	/* VSYNC choice */
+	if(local_LoadVSYNCFromConfigs())
+		game_window->setVerticalSyncEnabled(true);
+	else
+	{
+		game_window->setVerticalSyncEnabled(false);
+		game_window->setFramerateLimit(framerate);
+	}
+	/* Input adjustement */
+    L_Input_Reset_Clocks();
+    L_Input_Setusec_threshold(1000000 / framerate);
+    frame_count = 0;
+	frame_rate = framerate;
+	/* Shader loading */
+	local_Graphics_LoadShader();
+    return self;
+}
+
+VALUE rb_Graphics_stop(VALUE self)
+{
+    GRAPHICS_PROTECT
+    if(InsideGraphicsUpdate) // Prevent a Thread from calling stop during the Graphics.update process
+        return self;
+    /* Clear the stack */
+    local_Graphics_Clear_Stack();
+    /* Close the window */
+    game_window->close();
+    delete game_window;
+    game_window = nullptr;
+    /* Unfreezing Graphics */
+    if(Graphics_freeze_texture != nullptr)
+    {
+        delete Graphics_freeze_sprite;
+        Graphics_freeze_sprite = nullptr;
+        delete Graphics_freeze_texture;
+        Graphics_freeze_texture = nullptr;
+    }
+	if (Graphics_freeze_shader != nullptr)
+	{
+		delete Graphics_freeze_shader;
+		Graphics_freeze_shader = nullptr;
+	}
+}
+
+VALUE rb_Graphics_snap_to_bitmap(VALUE self)
+{
+    GRAPHICS_PROTECT
+    if(InsideGraphicsUpdate)
+        return Qnil;
+    VALUE bmp = rb_obj_alloc(rb_cBitmap);
+    CBitmap_Element* bitmap;
+    Data_Get_Struct(bmp, CBitmap_Element, bitmap);
+    if(bitmap == nullptr)
+        return Qnil;
+    sf::Texture* text = bitmap->getTexture();
+    local_Graphics_Take_Snapshot(text);
+    return bmp;
+}
+
+VALUE rb_Graphics_freeze(VALUE self)
+{
+    GRAPHICS_PROTECT
+    if(Graphics_freeze_texture != nullptr)
+        return self;
+    rb_Graphics_update(self);
+    Graphics_freeze_texture = new sf::Texture();
+    local_Graphics_Take_Snapshot(Graphics_freeze_texture);
+    Graphics_freeze_sprite = new sf::Sprite(*Graphics_freeze_texture);
+    Graphics_freeze_sprite->setScale(1.0f / Graphics_Scale, 1.0f / Graphics_Scale);
+    return self;
+}
+
+VALUE rb_Graphics_transition(int argc, VALUE* argv, VALUE self)
+{
+    GRAPHICS_PROTECT
+    if(Graphics_freeze_sprite == nullptr)
+        return self;
+	long time = 8; //< RGSS doc
+    if(argc >= 1)
+		time = rb_num2long(argv[0]);
+    time = normalize_long(time, 1, 0xFFFF);
+	if (argc < 2 || rb_obj_is_kind_of(argv[1], rb_cBitmap) != Qtrue)
+		local_Graphics_TransitionBasic(self, time);
+	else
+		local_Graphics_TransitionRGSS(self, time, argv[1]);
+    delete Graphics_freeze_sprite;
+    Graphics_freeze_sprite = nullptr;
+    delete Graphics_freeze_texture;
+    Graphics_freeze_texture = nullptr;
+    return self;
+}
+
+
+VALUE rb_Graphics_list_res(VALUE self)
+{
+    VALUE array = rb_ary_new();
+    auto modes = sf::VideoMode::getFullscreenModes();
+    for(int i = 0; i < modes.size(); i++)
+    {
+        if(modes[i].bitsPerPixel == 32)
+            rb_ary_push(array, rb_ary_new3(2, rb_int2inum(modes[i].width), rb_int2inum(modes[i].height)));
+    }
+    return array;
+}
+
+VALUE rb_Graphics_update(VALUE self)
+{
+    GRAPHICS_PROTECT
+    if(InsideGraphicsUpdate) // Prevent a Thread from calling Graphics.update during Graphics.update process
+        return self;
+    InsideGraphicsUpdate = true;
+    /* Graphics.update real process */
+    GraphicUpdateMessage* message = 
+        reinterpret_cast<GraphicUpdateMessage*>(rb_thread_call_without_gvl(local_Graphics_Update_Internal, (void*)&Graphics_stack, NULL, NULL));
+    /* Message Processing */
+    local_Graphics_Update_Process_Event(message);
+    if(message != nullptr)
+        return local_Graphics_Update_RaiseError(self, message);
+    /* End of Graphics.update process */
+    InsideGraphicsUpdate = false;
+    /* Update the frame count */
+    frame_count++;
+    return self;
+}
+
+VALUE rb_Graphics_update_no_input_count(VALUE self)
+{
+	GRAPHICS_PROTECT
+		if (InsideGraphicsUpdate) // Prevent a Thread from calling Graphics.update during Graphics.update process
+			return self;
+	InsideGraphicsUpdate = true;
+	/* Graphics.update real process */
+	GraphicUpdateMessage* message =
+		reinterpret_cast<GraphicUpdateMessage*>(rb_thread_call_without_gvl(local_Graphics_Update_Internal, (void*)&Graphics_stack, NULL, NULL));
+	if (message != nullptr)
+		return local_Graphics_Update_RaiseError(self, message);
+	/* End of Graphics.update process */
+	InsideGraphicsUpdate = false;
+	return self;
+}
+
+VALUE rb_Graphics_update_only_input(VALUE self)
+{
+	GRAPHICS_PROTECT
+	InsideGraphicsUpdate = true;
+	GraphicUpdateMessage* message = nullptr;
+	local_Graphics_Update_Process_Event(message);
+	if (message != nullptr)
+		return local_Graphics_Update_RaiseError(self, message);
+	InsideGraphicsUpdate = false;
+	return self;
+}
+
+VALUE rb_Graphics_get_frame_count(VALUE self)
+{
+    return RB_UINT2NUM(frame_count);
+}
+
+VALUE rb_Graphics_set_frame_count(VALUE self, VALUE val)
+{
+    frame_count = rb_num2ulong(val);
+    return val;
+}
+
+VALUE rb_Graphics_width(VALUE self)
+{
+    return rb_int2inum(ScreenWidth);
+}
+
+VALUE rb_Graphics_height(VALUE self)
+{
+    return rb_int2inum(ScreenHeight);
+}
+
+VALUE rb_Graphics_ReloadStack(VALUE self)
+{
+    VALUE table = rb_ivar_get(rb_mGraphics, rb_iElementTable);
+    rb_check_type(table, T_ARRAY);
+    for(auto it = Graphics_stack.begin(); it != Graphics_stack.end(); it++)
+    {
+        (*it)->overrideOrigineStack(nullptr);
+    }
+    Graphics_stack.clear();
+    long sz = RARRAY_LEN(table);
+    VALUE* ori = RARRAY_PTR(table);
+    for(long i = 0; i < sz; i++)
+    {
+        if(rb_obj_is_kind_of(ori[i], rb_cViewport) == Qtrue ||
+            rb_obj_is_kind_of(ori[i], rb_cSprite) == Qtrue ||
+            rb_obj_is_kind_of(ori[i], rb_cText) == Qtrue)
+        {
+            if(RDATA(ori[i])->data != nullptr)
+            {
+                global_Graphics_Bind(reinterpret_cast<CDrawable_Element*>(RDATA(ori[i])->data));
+            }
+        }
+    }
+    return self;
+}
+
+VALUE rb_Graphics_getBrightness(VALUE self)
+{
+	return LONG2FIX(Graphics_Brightness);
+}
+
+VALUE rb_Graphics_setBrightness(VALUE self, VALUE brightness)
+{
+	Graphics_Brightness = normalize_long(rb_num2long(brightness), 0, 255);
+	return self;
+}
+
+VALUE rb_Graphics_getShader(VALUE self)
+{
+	return rb_ivar_get(self, rb_iGraphicsShader);
+}
+
+VALUE rb_Graphics_setShader(VALUE self, VALUE shader)
+{
+	GRAPHICS_PROTECT;
+	sf::RenderStates* render_state;
+	if (rb_obj_is_kind_of(shader, rb_cBlendMode) == Qtrue)
+	{
+		rb_ivar_set(self, rb_iGraphicsShader, shader);
+		Data_Get_Struct(shader, sf::RenderStates, render_state);
+		Graphics_States = render_state;
+		local_Graphics_initRender();
+	}
+}
+
+void global_Graphics_Bind(CDrawable_Element* element)
+{
+    element->setOriginStack(&Graphics_stack);
+}