LiteRGSS 0.1.3

data/ext/LiteRGSS/Tone.cpp

@@ -0,0 +1,228 @@
+#include "LiteRGSS.h"
+#include "CTone_Element.h"
+
+VALUE rb_cTone = Qnil;
+
+#define TONE_PROTECT if(RDATA(self)->data == nullptr) \
+{\
+    rb_raise(rb_eRGSSError, "Freed Tone."); \
+}
+
+#define GET_TONE CTone_Element* tone; \
+    Data_Get_Struct(self, CTone_Element, tone); \
+    TONE_PROTECT \
+    sf::Glsl::Vec4* tonev = tone->getTone();
+
+void __Tone_Check_LinkedObject(CTone_Element* tone);
+
+void rb_Tone_Free(void* data)
+{
+    CTone_Element* tone = reinterpret_cast<CTone_Element*>(data);
+    if(tone)
+    {
+        CViewport_Element* viewport = tone->getElement();
+        if(viewport != nullptr)
+        {
+            viewport->setLinkedRect(nullptr);
+        }
+        delete tone;
+    }
+}
+
+VALUE rb_Tone_Alloc(VALUE klass)
+{
+    CTone_Element* tone = new CTone_Element();
+    return Data_Wrap_Struct(klass, NULL, rb_Tone_Free, tone);
+}
+
+void Init_Tone()
+{
+    rb_cTone = rb_define_class_under(rb_mLiteRGSS, "Tone", rb_cObject);
+    rb_define_alloc_func(rb_cTone, rb_Tone_Alloc);
+
+    rb_define_method(rb_cTone, "initialize", _rbf rb_Tone_Initialize, -1);
+    rb_define_method(rb_cTone, "set", _rbf rb_Tone_Initialize, -1);
+    rb_define_method(rb_cTone, "initialize_copy", _rbf rb_Tone_InitializeCopy, 1);
+    rb_define_method(rb_cTone, "red", _rbf rb_Tone_getRed, 0);
+    rb_define_method(rb_cTone, "red=", _rbf rb_Tone_setRed, 1);
+    rb_define_method(rb_cTone, "green", _rbf rb_Tone_getGreen, 0);
+    rb_define_method(rb_cTone, "green=", _rbf rb_Tone_setGreen, 1);
+    rb_define_method(rb_cTone, "blue", _rbf rb_Tone_getBlue, 0);
+    rb_define_method(rb_cTone, "blue=", _rbf rb_Tone_setBlue, 1);
+    rb_define_method(rb_cTone, "gray", _rbf rb_Tone_getGray, 0);
+    rb_define_method(rb_cTone, "gray=", _rbf rb_Tone_setGray, 1);
+    rb_define_method(rb_cTone, "==", _rbf rb_Tone_eql, 1);
+    rb_define_method(rb_cTone, "===", _rbf rb_Tone_eql, 1);
+    rb_define_method(rb_cTone, "eql?", _rbf rb_Tone_eql, 1);
+    rb_define_method(rb_cTone, "to_s", _rbf rb_Tone_to_s, 0);
+    rb_define_method(rb_cTone, "inspect", _rbf rb_Tone_to_s, 0);
+    rb_define_method(rb_cTone, "_dump", _rbf rb_Tone_Save, 1);
+    rb_define_singleton_method(rb_cTone, "_load", _rbf rb_Tone_Load, 1);
+}
+
+VALUE rb_Tone_Initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE red, green, blue, alpha;
+    rb_scan_args(argc, argv, "13", &red, &green, &blue, &alpha);
+    GET_TONE
+    if(RTEST(red))
+        tonev->x = normalize_long(rb_num2long(red), -255, 255) / 255.0f;
+    if(RTEST(green))
+        tonev->y = normalize_long(rb_num2long(green), -255, 255) / 255.0f;
+    if(RTEST(blue))
+        tonev->z = normalize_long(rb_num2long(blue), -255, 255) / 255.0f;
+    if(RTEST(alpha))
+        tonev->w = normalize_long(rb_num2long(alpha), 0, 255) / 255.0f;
+    __Tone_Check_LinkedObject(tone);
+    return self;
+}
+
+VALUE rb_Tone_InitializeCopy(VALUE self, VALUE original)
+{
+    GET_TONE
+    CTone_Element* toneo;
+    Data_Get_Struct(original, CTone_Element, toneo);
+    TONE_PROTECT
+    if(RDATA(original)->data == nullptr)
+        rb_raise(rb_eRGSSError, "Freed Tone.");
+    tone_copy(tonev, toneo->getTone());
+    return self;
+}
+
+VALUE rb_Tone_getRed(VALUE self)
+{
+    GET_TONE
+    return rb_int2inum(static_cast<long>(tonev->x * 255.0f));
+}
+
+VALUE rb_Tone_setRed(VALUE self, VALUE val)
+{
+    GET_TONE
+    tonev->x = normalize_long(rb_num2long(val), -255, 255) / 255.0f;
+    __Tone_Check_LinkedObject(tone);
+    return self;
+}
+
+VALUE rb_Tone_getGreen(VALUE self)
+{
+    GET_TONE
+    return rb_int2inum(static_cast<long>(tonev->y * 255.0f));
+}
+
+VALUE rb_Tone_setGreen(VALUE self, VALUE val)
+{
+    GET_TONE
+    tonev->y = normalize_long(rb_num2long(val), -255, 255) / 255.0f;
+    __Tone_Check_LinkedObject(tone);
+    return self;
+}
+
+VALUE rb_Tone_getBlue(VALUE self)
+{
+    GET_TONE
+    return rb_int2inum(static_cast<long>(tonev->z * 255.0f));
+}
+
+VALUE rb_Tone_setBlue(VALUE self, VALUE val)
+{
+    GET_TONE
+    tonev->z = normalize_long(rb_num2long(val), -255, 255) / 255.0f;
+    __Tone_Check_LinkedObject(tone);
+    return self;
+}
+
+VALUE rb_Tone_getGray(VALUE self)
+{
+    GET_TONE
+    return rb_int2inum(static_cast<long>(tonev->w * 255.0f));
+}
+
+VALUE rb_Tone_setGray(VALUE self, VALUE val)
+{
+    GET_TONE
+    tonev->w = normalize_long(rb_num2long(val), 0, 255) / 255.0f;
+    __Tone_Check_LinkedObject(tone);
+    return self;
+}
+
+VALUE rb_Tone_eql(VALUE self, VALUE other)
+{
+    if(rb_obj_is_kind_of(other, rb_cTone) != Qtrue)
+        return Qfalse;
+    GET_TONE
+    CTone_Element* otone;
+    Data_Get_Struct(other, CTone_Element, otone);
+    if(otone == nullptr)
+        return Qfalse;
+    sf::Glsl::Vec4* otonev = otone->getTone();
+    if(tonev->x != otonev->x)
+        return Qfalse;
+    if(tonev->y != otonev->y)
+        return Qfalse;
+    if(tonev->z != otonev->z)
+        return Qfalse;
+    if(tonev->w != otonev->w)
+        return Qfalse;
+    return Qtrue;
+}
+
+VALUE rb_Tone_to_s(VALUE self)
+{
+    GET_TONE
+    return rb_sprintf("(%d, %d, %d, %d)", static_cast<int>(tonev->x * 255), 
+        static_cast<int>(tonev->y * 255),
+        static_cast<int>(tonev->z * 255),
+        static_cast<int>(tonev->w * 255));
+}
+
+CTone_Element* rb_Tone_get_tone(VALUE self)
+{
+	rb_Tone_test_tone(self);
+	GET_TONE;
+	return tone;
+}
+
+void rb_Tone_test_tone(VALUE self)
+{
+	if (rb_obj_is_kind_of(self, rb_cTone) != Qtrue)
+	{
+		rb_raise(rb_eTypeError, "Expected Tone got %s.", RSTRING_PTR(rb_class_name(CLASS_OF(self))));
+	}
+}
+
+VALUE rb_Tone_Load(VALUE self, VALUE str)
+{
+    rb_check_type(str, T_STRING);
+    VALUE arr[4];
+    if(RSTRING_LEN(str) < (sizeof(double) * 4))
+    {
+        arr[3] = arr[2] = arr[1] = arr[0] = LONG2FIX(0);
+        return rb_class_new_instance(4, arr, self);
+    }
+    double* tone_data = reinterpret_cast<double*>(RSTRING_PTR(str));
+    arr[0] = rb_int2inum(static_cast<long>(tone_data[0]));
+    arr[1] = rb_int2inum(static_cast<long>(tone_data[1]));
+    arr[2] = rb_int2inum(static_cast<long>(tone_data[2]));
+    arr[3] = rb_int2inum(static_cast<long>(tone_data[3]));
+    return rb_class_new_instance(4, arr, self);
+}
+
+VALUE rb_Tone_Save(VALUE self, VALUE limit)
+{
+    GET_TONE
+    double tone_data[4];
+    tone_data[0] = static_cast<double>(tonev->x * 255);
+    tone_data[1] = static_cast<double>(tonev->y * 255);
+    tone_data[2] = static_cast<double>(tonev->z * 255);
+    tone_data[3] = static_cast<double>(tonev->w * 255);
+    return rb_str_new(reinterpret_cast<const char*>(tone_data), sizeof(double) * 4);
+}
+
+void __Tone_Check_LinkedObject(CTone_Element* tone)
+{
+    CViewport_Element* view = tone->getElement();
+    if(view == nullptr)
+        return;
+    tone_copy(view->getTone(), tone->getTone());
+	view->updatetone();
+}

data/ext/LiteRGSS/Tone.h

@@ -0,0 +1,22 @@
+#ifndef L_TONE_H
+#define L_TONE_H
+
+VALUE rb_Tone_Initialize(int argc, VALUE* argv, VALUE self); // Also .set
+VALUE rb_Tone_InitializeCopy(VALUE self, VALUE original);
+VALUE rb_Tone_getRed(VALUE self);
+VALUE rb_Tone_setRed(VALUE self, VALUE val);
+VALUE rb_Tone_getGreen(VALUE self);
+VALUE rb_Tone_setGreen(VALUE self, VALUE val);
+VALUE rb_Tone_getBlue(VALUE self);
+VALUE rb_Tone_setBlue(VALUE self, VALUE val);
+VALUE rb_Tone_getGray(VALUE self);
+VALUE rb_Tone_setGray(VALUE self, VALUE val);
+VALUE rb_Tone_eql(VALUE self, VALUE other);
+VALUE rb_Tone_to_s(VALUE self);
+VALUE rb_Tone_Load(VALUE self, VALUE str);
+VALUE rb_Tone_Save(VALUE self, VALUE limit);
+
+CTone_Element* rb_Tone_get_tone(VALUE self);
+void rb_Tone_test_tone(VALUE self);
+
+#endif

data/ext/LiteRGSS/Viewport.cpp

@@ -0,0 +1,491 @@
+#include "LiteRGSS.h"
+#include "CViewport_Element.h"
+#include "CRect_Element.h"
+#include "CTone_Element.h"
+
+VALUE rb_cViewport = Qnil;
+
+#define VIEWPORT_PROTECT if(RDATA(self)->data == nullptr) \
+{\
+    rb_raise(rb_eRGSSError, "Disposed Viewport."); \
+    return self; \
+}
+
+#define GET_VIEWPORT CViewport_Element* viewport; \
+    Data_Get_Struct(self, CViewport_Element, viewport); \
+    VIEWPORT_PROTECT
+
+void rb_Viewport_Free(void* data)
+{
+    CViewport_Element* viewport = reinterpret_cast<CViewport_Element*>(data);
+    if(viewport != nullptr)
+    {
+        viewport->setOriginStack(nullptr);
+        CRect_Element* rect = viewport->getLinkedRect();
+        if(rect != nullptr)
+            rect->setElement(nullptr);
+        CTone_Element* tone = viewport->getLinkedTone();
+        if(tone != nullptr)
+            tone->setElement(nullptr);
+        delete viewport;
+    }
+}
+
+void rb_Viewport_Mark(CViewport_Element* viewport)
+{
+    if(viewport == nullptr)
+        return;
+    rb_gc_mark(viewport->rRect);
+    rb_gc_mark(viewport->rTone);
+    rb_gc_mark(viewport->rColor);
+    rb_gc_mark(viewport->rZ);
+	rb_gc_mark(viewport->rAngle);
+	rb_gc_mark(viewport->rZoom);
+	rb_gc_mark(viewport->rRenderState);
+}
+
+VALUE rb_Viewport_Alloc(VALUE klass)
+{
+    CViewport_Element* viewport = new CViewport_Element();
+    viewport->setLinkedRect(nullptr);
+    viewport->setLinkedTone(nullptr);
+	viewport->setVisible(true);
+    viewport->rZ = LONG2FIX(0);
+    return Data_Wrap_Struct(klass, rb_Viewport_Mark, rb_Viewport_Free, viewport);
+}
+
+void Init_Viewport()
+{
+    rb_cViewport = rb_define_class_under(rb_mLiteRGSS, "Viewport", rb_cObject);
+
+    rb_define_alloc_func(rb_cViewport, rb_Viewport_Alloc);
+
+    rb_define_method(rb_cViewport, "initialize", _rbf rb_Viewport_Initialize, -1);
+    rb_define_method(rb_cViewport, "ox", _rbf rb_Viewport_getOX, 0);
+    rb_define_method(rb_cViewport, "ox=", _rbf rb_Viewport_setOX, 1);
+    rb_define_method(rb_cViewport, "oy", _rbf rb_Viewport_getOY, 0);
+    rb_define_method(rb_cViewport, "oy=", _rbf rb_Viewport_setOY, 1);
+    rb_define_method(rb_cViewport, "rect", _rbf rb_Viewport_getRect, 0);
+    rb_define_method(rb_cViewport, "rect=", _rbf rb_Viewport_setRect, 1);
+    rb_define_method(rb_cViewport, "dispose", _rbf rb_Viewport_Dispose, 0);
+    rb_define_method(rb_cViewport, "disposed?", _rbf rb_Viewport_Disposed, 0);
+    rb_define_method(rb_cViewport, "tone", _rbf rb_Viewport_getTone, 0);
+    rb_define_method(rb_cViewport, "tone=", _rbf rb_Viewport_setTone, 1);
+    rb_define_method(rb_cViewport, "color", _rbf rb_Viewport_getColor, 0);
+    rb_define_method(rb_cViewport, "color=", _rbf rb_Viewport_setColor, 1);
+    rb_define_method(rb_cViewport, "update", _rbf rb_Viewport_Update, 0);
+    rb_define_method(rb_cViewport, "visible", _rbf rb_Viewport_getVisible, 0);
+    rb_define_method(rb_cViewport, "visible=", _rbf rb_Viewport_setVisible, 1);
+    rb_define_method(rb_cViewport, "z", _rbf rb_Viewport_getZ, 0);
+    rb_define_method(rb_cViewport, "z=", _rbf rb_Viewport_setZ, 1);
+    rb_define_method(rb_cViewport, "zoom", _rbf rb_Viewport_getZoom, 0);
+    rb_define_method(rb_cViewport, "zoom=", _rbf rb_Viewport_setZoom, 1);
+    rb_define_method(rb_cViewport, "angle", _rbf rb_Viewport_getAngle, 0);
+    rb_define_method(rb_cViewport, "angle=", _rbf rb_Viewport_setAngle, 1);
+    rb_define_method(rb_cViewport, "shader", _rbf rb_Viewport_getRenderState, 0);
+    rb_define_method(rb_cViewport, "shader=", _rbf rb_Viewport_setRenderState, 1);
+	rb_define_method(rb_cViewport, "blendmode", _rbf rb_Viewport_getRenderState, 0);
+	rb_define_method(rb_cViewport, "blendmode=", _rbf rb_Viewport_setRenderState, 1);
+    rb_define_method(rb_cViewport, "reload_stack", _rbf rb_Viewport_ReloadStack, 0);
+    rb_define_method(rb_cViewport, "__index__", _rbf rb_Viewport_Index, 0);
+
+    rb_define_method(rb_cViewport, "clone", _rbf rb_Viewport_Copy, 0);
+    rb_define_method(rb_cViewport, "dup", _rbf rb_Viewport_Copy, 0);
+}
+
+VALUE rb_Viewport_Copy(VALUE self)
+{
+    rb_raise(rb_eRGSSError, "Viewports can not be cloned or duplicated.");
+    return self;
+}
+
+VALUE rb_Viewport_Initialize(int argc, VALUE* argv, VALUE self)
+{
+    VALUE x, y, width, height;
+    rb_scan_args(argc, argv, "22", &x, &y, &width, &height);
+    /* Parameter normalization */
+    if(NIL_P(width))
+    {
+        width = x;
+        height = y;
+        x = LONG2FIX(0);
+        y = LONG2FIX(0);
+    }
+    else if(NIL_P(height))
+    {
+        height = width;
+        width = y;
+        y = LONG2FIX(0);
+    }
+    /* Sprite table creation */
+    rb_ivar_set(self, rb_iElementTable, rb_ary_new());
+    /* Viewport setting */
+    GET_VIEWPORT
+    VALUE table;
+    global_Graphics_Bind(viewport);
+    table = rb_ivar_get(rb_mGraphics, rb_iElementTable);
+    rb_ary_push(table, self);
+    viewport->setOx(0);
+    viewport->setOy(0);
+	viewport->rAngle = LONG2FIX(0);
+	viewport->rZoom = LONG2FIX(1);
+    Viewport_SetView(viewport, rb_num2long(x), rb_num2long(y), rb_num2long(width), rb_num2long(height));
+    /* Creating rect */
+    VALUE rc = rb_class_new_instance(argc, argv, rb_cRect);
+    /* Fetching data */
+    CRect_Element* rect;
+    Data_Get_Struct(rc, CRect_Element, rect);
+    rect->setElement(viewport);
+    viewport->setLinkedRect(rect);
+    viewport->rRect = rc;
+    viewport->rTone = Qnil;
+    viewport->rColor = Qnil;
+    viewport->clearStack();
+    return self;
+}
+
+void __Viewport_Dispose_AllSprite(VALUE table)
+{
+    rb_check_type(table, T_ARRAY);
+    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_cSprite) == Qtrue)
+            rb_Sprite_DisposeFromViewport(ori[i]);
+        else
+            rb_Text_DisposeFromViewport(ori[i]);
+    }
+    rb_ary_clear(table);
+}
+
+VALUE rb_Viewport_Dispose(VALUE self)
+{
+    GET_VIEWPORT
+    RDATA(self)->data = nullptr;
+    VALUE table = rb_ivar_get(rb_mGraphics, rb_iElementTable);
+    rb_ary_delete(table, self);
+    viewport->clearStack();
+    __Viewport_Dispose_AllSprite(rb_ivar_get(self, rb_iElementTable));
+    rb_Viewport_Free(reinterpret_cast<void*>(viewport));
+    return self;
+}
+
+VALUE rb_Viewport_Disposed(VALUE self)
+{
+    rb_check_type(self, T_DATA);
+    return (RDATA(self)->data == nullptr ? Qtrue : Qfalse);
+}
+
+void Viewport_AdjustOXY(CViewport_Element* viewport, VALUE rect)
+{
+    if(RDATA(rect)->data == nullptr)
+        return;
+    CRect_Element* srect;
+    Data_Get_Struct(rect, CRect_Element, srect);
+    sf::IntRect* rc = srect->getRect();
+    sf::View* view = viewport->getView();
+    view->setCenter(std::roundf(static_cast<float>(viewport->getOx()) + static_cast<float>(rc->width) / 2.0f),
+                    std::roundf(static_cast<float>(viewport->getOy()) + static_cast<float>(rc->height) / 2.0f));
+}
+
+VALUE rb_Viewport_getOX(VALUE self)
+{
+    GET_VIEWPORT
+    return rb_int2inum(viewport->getOx());
+}
+
+VALUE rb_Viewport_setOX(VALUE self, VALUE val)
+{
+	GET_VIEWPORT
+    viewport->setOx(rb_num2long(val));
+    Viewport_AdjustOXY(viewport, viewport->rRect);
+    return val;
+}
+
+VALUE rb_Viewport_getOY(VALUE self)
+{
+    GET_VIEWPORT
+    return rb_int2inum(viewport->getOy());
+}
+
+VALUE rb_Viewport_setOY(VALUE self, VALUE val)
+{
+    GET_VIEWPORT
+    viewport->setOy(rb_num2long(val));
+    Viewport_AdjustOXY(viewport, viewport->rRect);
+    return val;
+}
+
+VALUE rb_Viewport_getRect(VALUE self)
+{
+    GET_VIEWPORT
+    return viewport->rRect;
+}
+
+VALUE rb_Viewport_setRect(VALUE self, VALUE val)
+{
+    VALUE rc = rb_Viewport_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; }
+    CViewport_Element* viewport;
+    Data_Get_Struct(self, CViewport_Element, viewport);
+    /* 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());
+    /* Updating the viewport view */
+    Viewport_SetView(viewport, rect_target->left, rect_target->top, rect_target->width, rect_target->height);
+    return val;
+
+}
+
+VALUE rb_Viewport_getTone(VALUE self)
+{
+    GET_VIEWPORT
+    VALUE tn = viewport->rTone;
+    if(!NIL_P(tn))
+        return tn;
+    /* New tone */
+    VALUE argv[4] = {LONG2FIX(0), LONG2FIX(0), LONG2FIX(0), LONG2FIX(0)};
+    viewport->rColor = rb_class_new_instance(4, argv, rb_cColor);
+    tn = rb_class_new_instance(4, argv, rb_cTone);
+    CTone_Element* tone;
+    Data_Get_Struct(tn, CTone_Element, tone);
+    tone->setElement(viewport);
+    viewport->setLinkedTone(tone);
+    viewport->rTone = tn;
+    viewport->create_render();
+    return tn;
+}
+
+VALUE rb_Viewport_setTone(VALUE self, VALUE val)
+{
+    VALUE tn = rb_Viewport_getTone(self);
+    if(RDATA(tn)->data == nullptr) { return Qnil; }
+    if(rb_obj_is_kind_of(val, rb_cTone) != Qtrue)
+    {
+        rb_raise(rb_eTypeError, "Expected Tone, got %s", RSTRING_PTR(rb_class_name(CLASS_OF(val))));
+        return Qnil;
+    }
+    if(RDATA(val)->data == nullptr) { return Qnil; }
+    GET_VIEWPORT
+    CTone_Element* tonesrc;
+    Data_Get_Struct(val, CTone_Element, tonesrc);
+    CTone_Element* tonedest;
+    Data_Get_Struct(tn, CTone_Element, tonedest);
+	sf::Glsl::Vec4* stone = tonesrc->getTone();
+	sf::Glsl::Vec4* vtone = viewport->getTone();
+	if (vtone->x != stone->x || vtone->y != stone->y || vtone->z != stone->z || vtone->w != vtone->w)
+	{
+		tone_copy(tonedest->getTone(), stone);
+		tone_copy(vtone, stone);
+		viewport->updatetone();
+	}
+    return val;
+}
+
+VALUE rb_Viewport_getColor(VALUE self)
+{
+    VALUE tn = rb_Viewport_getTone(self);
+    GET_VIEWPORT
+    return viewport->rColor;
+}
+
+VALUE rb_Viewport_setColor(VALUE self, VALUE val)
+{
+    VALUE tn = rb_Viewport_getTone(self);
+    GET_VIEWPORT
+    if(rb_obj_is_kind_of(val, rb_cColor) != Qtrue)
+    {
+        rb_raise(rb_eTypeError, "Expected Color, got %s", RSTRING_PTR(rb_class_name(CLASS_OF(val))));
+        return Qnil;
+    }
+    viewport->rColor = val;
+    return self;
+}
+
+VALUE rb_Viewport_getVisible(VALUE self)
+{
+    GET_VIEWPORT
+    return (viewport->getVisible() ? Qtrue : Qfalse);
+}
+
+VALUE rb_Viewport_setVisible(VALUE self, VALUE val)
+{
+    GET_VIEWPORT
+    viewport->setVisible(RTEST(val));
+    return self;
+}
+
+VALUE rb_Viewport_Update(VALUE self)
+{
+    GET_VIEWPORT
+    return self;
+}
+
+VALUE rb_Viewport_getZ(VALUE self)
+{
+    GET_VIEWPORT
+    return viewport->rZ;
+}
+
+VALUE rb_Viewport_setZ(VALUE self, VALUE val)
+{
+    GET_VIEWPORT
+    rb_num2long(val);
+    viewport->rZ = val;
+    return self;
+}
+
+void Viewport_AdjustZoomAngle(CViewport_Element* viewport, VALUE rect)
+{
+	if (RDATA(rect)->data == nullptr)
+		return;
+	long x, y, width, height;
+	CRect_Element* srect;
+	Data_Get_Struct(rect, CRect_Element, srect);
+	sf::IntRect* rc = srect->getRect();
+	sf::View* view = viewport->getView();
+	x = rc->left;
+	y = rc->top;
+	width = rc->width;
+	height = rc->height;
+	if (width & 1)
+		width++;
+	if (height & 1)
+		height++;
+	view->setCenter(static_cast<float>(viewport->getOx() + width / 2),
+		static_cast<float>(viewport->getOy() + height / 2));
+	view->setSize(static_cast<float>(width), static_cast<float>(height));
+	view->setRotation(-NUM2DBL(viewport->rAngle));
+	view->zoom(NUM2DBL(viewport->rZoom));
+	float sw = static_cast<float>(ScreenWidth);
+	float sh = static_cast<float>(ScreenHeight);
+	sf::FloatRect frect(x / sw, y / sh, width / sw, height / sh);
+	view->setViewport(frect);
+}
+
+VALUE rb_Viewport_getAngle(VALUE self)
+{
+	GET_VIEWPORT;
+	return viewport->rAngle;
+}
+
+VALUE rb_Viewport_setAngle(VALUE self, VALUE val)
+{
+	GET_VIEWPORT;
+	viewport->rAngle = LONG2NUM(NUM2LONG(val) % 360);
+	Viewport_AdjustZoomAngle(viewport, viewport->rRect);
+	return self;
+}
+
+VALUE rb_Viewport_getZoom(VALUE self)
+{
+	GET_VIEWPORT;
+	return viewport->rZoom;
+}
+
+VALUE rb_Viewport_setZoom(VALUE self, VALUE val)
+{
+	GET_VIEWPORT;
+	viewport->rZoom = DBL2NUM(1.0 / normalize_double(NUM2DBL(val), 0.001, 1000.0));
+	Viewport_AdjustZoomAngle(viewport, viewport->rRect);
+	return self;
+}
+
+VALUE rb_Viewport_getRenderState(VALUE self)
+{
+	GET_VIEWPORT;
+	return viewport->rRenderState;
+}
+
+VALUE rb_Viewport_setRenderState(VALUE self, VALUE val)
+{
+	sf::RenderStates* render_state;
+	GET_VIEWPORT;
+	if (rb_obj_is_kind_of(val, rb_cBlendMode) == Qtrue)
+	{
+		Data_Get_Struct(val, sf::RenderStates, render_state);
+		if (render_state)
+		{
+			viewport->setRenderStates(render_state);
+			viewport->rRenderState = val;
+			viewport->create_render(); // Make sure the global render is initialized
+			viewport->updatetone();
+			return self;
+		}
+	}
+	viewport->setRenderStates(nullptr);
+	if (viewport->rColor != Qnil && viewport->rTone != Qnil)
+	{
+		viewport->rRenderState = Qnil;
+		viewport->create_render(); // Restore the old render
+		viewport->updatetone();
+	}
+	else
+		viewport->rRenderState = Qfalse; // False to prevent intempestive delete
+	return self;
+}
+
+VALUE rb_Viewport_ReloadStack(VALUE self)
+{
+    GET_VIEWPORT
+    VALUE table = rb_ivar_get(self, rb_iElementTable);
+    rb_check_type(table, T_ARRAY);
+    for(auto it = viewport->getStack()->begin(); it != viewport->getStack()->end(); it++)
+    {
+        (*it)->overrideOrigineStack(nullptr);
+    }
+    viewport->clearStack();
+    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)
+            {
+                viewport->bind(reinterpret_cast<CDrawable_Element*>(RDATA(ori[i])->data));
+            }
+        }
+    }
+    return self;
+}
+
+VALUE rb_Viewport_Index(VALUE self)
+{
+    GET_VIEWPORT
+    return rb_uint2inum(viewport->getIndex());
+}
+
+void Viewport_SetView(CViewport_Element* viewport, long x, long y, long width, long height)
+{
+    sf::View* view = viewport->getView();
+    /* Adjustment for text */
+    if(width & 1)
+        width++;
+    if(height & 1)
+        height++;
+    view->setCenter(static_cast<float>(viewport->getOx() + width / 2), 
+                    static_cast<float>(viewport->getOy() + height / 2));
+    view->setSize(static_cast<float>(width), static_cast<float>(height));
+	view->setRotation(-NUM2DBL(viewport->rAngle));
+	view->zoom(NUM2DBL(viewport->rZoom));
+    float sw = static_cast<float>(ScreenWidth);
+    float sh = static_cast<float>(ScreenHeight);
+    sf::FloatRect frect(x / sw, y / sh, width / sw, height / sh);
+    view->setViewport(frect);
+    // viewport->reset_render();
+}