LiteRGSS 0.1.3

data/ext/LiteRGSS/BlendMode.h

@@ -0,0 +1,20 @@
+#ifndef L_BLENDMODE_HEADER
+#define L_BLENDMODE_HEADER
+
+VALUE rb_BlendMode_setColorSrcFactor(VALUE self, VALUE val);
+VALUE rb_BlendMode_getColorSrcFactor(VALUE self);
+VALUE rb_BlendMode_setColorDestFactor(VALUE self, VALUE val);
+VALUE rb_BlendMode_getColorDestFactor(VALUE self);
+VALUE rb_BlendMode_setAlphaSrcFactor(VALUE self, VALUE val);
+VALUE rb_BlendMode_getAlphaSrcFactor(VALUE self);
+VALUE rb_BlendMode_setAlphaDestFactor(VALUE self, VALUE val);
+VALUE rb_BlendMode_getAlphaDestFactor(VALUE self);
+VALUE rb_BlendMode_setColorEquation(VALUE self, VALUE val);
+VALUE rb_BlendMode_getColorEquation(VALUE self);
+VALUE rb_BlendMode_setAlphaEquation(VALUE self, VALUE val);
+VALUE rb_BlendMode_getAlphaEquation(VALUE self);
+VALUE rb_BlendMode_setBlendType(VALUE self, VALUE val);
+VALUE rb_BlendMode_getBlendType(VALUE self);
+VALUE rb_BlendMode_Copy(VALUE self);
+
+#endif

data/ext/LiteRGSS/CBitmap_Element.cpp

@@ -0,0 +1,50 @@
+#include "CBitmap_Element.h"
+
+
+CBitmap_Element::CBitmap_Element()
+{
+    text = new sf::Texture();
+    //img = nullptr;
+}
+
+CBitmap_Element::~CBitmap_Element()
+{
+    if(text != nullptr)
+    {
+        delete text;
+        text = nullptr;
+    }
+    /*if(img != nullptr)
+    {
+        delete img;
+        img = nullptr;
+    }*/
+}
+
+sf::Texture* CBitmap_Element::getTexture()
+{
+    return text;
+}
+
+void CBitmap_Element::copy(CBitmap_Element* original) {
+    sf::Image img = original->getTexture()->copyToImage();
+    text->loadFromImage(img);
+}
+
+sf::Image* CBitmap_Element::getImage()
+{
+    /*if(img == nullptr)
+    {
+        if(text->getSize().x > 0)
+        {
+
+        }
+        else
+            img = new sf::Image();
+    }*/
+    if(!has_image())
+    {
+        img = text->copyToImage();
+    }
+    return &img;
+}

data/ext/LiteRGSS/CBitmap_Element.h

@@ -0,0 +1,17 @@
+#ifndef CBITMAP_ELEMENT_H
+#define CBITMAP_ELEMENT_H
+#include <SFML/Graphics.hpp>
+
+class CBitmap_Element {
+    sf::Texture* text;
+    sf::Image img;
+    public:
+        CBitmap_Element();
+        ~CBitmap_Element();
+        sf::Texture* getTexture();
+        sf::Image* getImage();
+        void copy(CBitmap_Element* original);
+        bool has_image() { return img.getSize().x != 0; }; //return img != nullptr; };
+};
+
+#endif

data/ext/LiteRGSS/CDrawable_Element.cpp

@@ -0,0 +1,38 @@
+#include "CDrawable_Element.h"
+#include <iostream>
+
+CDrawable_Element::CDrawable_Element()
+{
+    origin_stack = nullptr;
+    linkedRect = nullptr;
+    index = 0;
+}
+
+void CDrawable_Element::setOriginStack(std::vector<CDrawable_Element*> *o) 
+{
+    /* Removing from the old stack */
+    if(origin_stack != nullptr)
+    {
+        auto it = std::find(origin_stack->begin(), origin_stack->end(), this);
+        if(it != origin_stack->end())
+            origin_stack->erase(it);
+    }
+    origin_stack = o;
+    if(o != nullptr)
+    {
+        origin_stack->push_back(this);
+        if(index == 0)
+            index = o->size();
+    }
+}
+
+
+void CDrawable_Element::setIndex(unsigned long nindex)
+{
+    index = nindex;
+}
+
+unsigned long CDrawable_Element::getIndex()
+{
+    return index;
+}

data/ext/LiteRGSS/CDrawable_Element.h

@@ -0,0 +1,30 @@
+#ifndef CDrawable_Element_H
+#define CDrawable_Element_H
+#include "ruby.h" // Windows Build Patch
+#include <SFML/Graphics.hpp>
+#include "sf_Text2.hpp"
+#include <vector>
+#include <algorithm>
+
+class CRect_Element;
+class CTone_Element;
+
+class CDrawable_Element {
+    protected:
+        std::vector<CDrawable_Element*> *origin_stack;
+        CRect_Element* linkedRect;
+        unsigned long index;
+    public:
+        CDrawable_Element();
+        void setOriginStack(std::vector<CDrawable_Element*> *o);
+        void overrideOrigineStack(std::vector<CDrawable_Element*> *o) {origin_stack = o;};
+        void setIndex(unsigned long nindex);
+        unsigned long getIndex();
+        virtual void draw(sf::RenderTarget& target) const = 0;
+        virtual void drawFast(sf::RenderTarget& target) const = 0;
+        virtual bool isViewport() const = 0;
+        virtual bool isPureSprite() const = 0;
+        void setLinkedRect(CRect_Element* _rect) { linkedRect = _rect; };
+        CRect_Element* getLinkedRect() { return linkedRect; };
+};
+#endif

data/ext/LiteRGSS/CRect_Element.h

@@ -0,0 +1,15 @@
+#ifndef CRECT_ELEMENT_H
+#define CRECT_ELEMENT_H
+#include <SFML/Graphics.hpp>
+#include "CDrawable_Element.h"
+class CRect_Element {
+    private:
+    sf::IntRect rect;
+    CDrawable_Element* target;
+    public:
+    sf::IntRect* getRect() { return &rect; };
+    void setElement(CDrawable_Element* _target) {target = _target;};
+    CDrawable_Element* getElement() { return target; };
+};
+
+#endif

data/ext/LiteRGSS/CShaderSprite_Element.cpp

@@ -0,0 +1,17 @@
+#include "CShaderSprite_Element.h"
+
+void CShaderSprite_Element::draw(sf::RenderTarget& target) const
+{
+    if(drawable && visible)
+    {
+		if (render_states == nullptr)
+			target.draw(sprite);
+		else
+			target.draw(sprite, *render_states);//, render_states->shader);
+    }
+}
+
+void CShaderSprite_Element::drawFast(sf::RenderTarget& target) const
+{
+	draw(target);
+}

data/ext/LiteRGSS/CShaderSprite_Element.h

@@ -0,0 +1,17 @@
+#ifndef CShaderSprite_Element_H
+#define CShaderSprite_Element_H
+#include "CSprite_Element.h"
+
+class CShaderSprite_Element : public CSprite_Element {
+	protected:
+		sf::RenderStates* render_states;
+    public:
+		CShaderSprite_Element() : CSprite_Element(), render_states(nullptr) {};
+        void draw(sf::RenderTarget& target) const override;
+        void drawFast(sf::RenderTarget& target) const override;
+        bool isViewport() const override { return false; };
+        bool isPureSprite() const override { return true; };
+		void setRenderState(sf::RenderStates* states) { render_states = states; };
+		VALUE rRenderStates;
+};
+#endif

data/ext/LiteRGSS/CSprite_Element.cpp

@@ -0,0 +1,15 @@
+#include "CViewport_Element.h"
+#include <iostream>
+
+void CSprite_Element::draw(sf::RenderTarget& target) const 
+{
+	CSprite_Element::drawFast(target);
+}
+
+void CSprite_Element::drawFast(sf::RenderTarget& target) const 
+{
+    if(drawable && visible)
+    {
+        target.draw(sprite);
+    }
+}

data/ext/LiteRGSS/CSprite_Element.h

@@ -0,0 +1,36 @@
+#ifndef CSprite_Element_H
+#define CSprite_Element_H
+#include "ruby.h"
+#include "CDrawable_Element.h"
+
+class CSprite_Element : public CDrawable_Element {
+    protected:
+        sf::Sprite sprite;
+        bool drawable;
+        bool visible;
+    public:
+        CSprite_Element() : CDrawable_Element(), drawable(false), visible(true) {};
+        void draw(sf::RenderTarget& target) const override;
+        void drawFast(sf::RenderTarget& target) const override;
+        bool isViewport() const override { return false; };
+        bool isPureSprite() const override { return true; };
+        sf::Sprite* getSprite() { return &sprite;};
+        void setDrawable(bool value) { drawable = value;};
+        bool getDrawable() { return drawable; };
+        void setVisible(bool value) { visible = value;};
+        bool getVisible() { return visible; };
+        /* Instance variable for Ruby */
+        VALUE rViewport;
+        VALUE rBitmap;
+        VALUE rX;
+        VALUE rY;
+        VALUE rZ;
+        VALUE rOX;
+        VALUE rOY;
+        VALUE rAngle;
+        VALUE rZoomX;
+        VALUE rZoomY;
+        VALUE rRect;
+		VALUE rMirror;
+};
+#endif

data/ext/LiteRGSS/CText_Element.cpp

@@ -0,0 +1,12 @@
+#include "CText_Element.h"
+
+void CText_Element::draw(sf::RenderTarget& target) const
+{
+    drawFast(target);
+}
+
+void CText_Element::drawFast(sf::RenderTarget& target) const
+{
+    if(visible)
+        target.draw(text);
+}

data/ext/LiteRGSS/CText_Element.h

@@ -0,0 +1,29 @@
+#ifndef CText_Element_H
+#define CText_Element_H
+#include "ruby.h"
+#include "CDrawable_Element.h"
+
+class CText_Element : public CDrawable_Element {
+    private:
+        sf::Text2 text;
+        bool visible;
+    public:
+        CText_Element() : CDrawable_Element(), visible(true) {};
+        void draw(sf::RenderTarget& target) const override;
+        void drawFast(sf::RenderTarget& target) const override;
+        bool isViewport() const override { return false; };
+        bool isPureSprite() const override { return false; };
+        sf::Text2* getText() { return &text;};
+        void setVisible(bool value) { visible = value;};
+        bool getVisible() { return visible; };
+        /* Instance variable for Ruby */
+        VALUE rViewport;
+        VALUE rX;
+        VALUE rY;
+        VALUE rZ;
+        VALUE rwidth;
+        VALUE rheight;
+        VALUE rtext;
+        VALUE rAlign;
+};
+#endif

data/ext/LiteRGSS/CTone_Element.h

@@ -0,0 +1,17 @@
+#ifndef CTONE_ELEMENT_H
+#define CTONE_ELEMENT_H
+#include <SFML/Graphics.hpp>
+#include "CViewport_Element.h"
+
+class CTone_Element {
+    private:
+        sf::Glsl::Vec4 tonevalues;
+        CViewport_Element* target;
+    public:
+        sf::Glsl::Vec4* getTone() { return &tonevalues; };
+        void setElement(CViewport_Element* element) {target = element;};
+        CViewport_Element* getElement() { return target;};
+};
+
+
+#endif

data/ext/LiteRGSS/CViewport_Element.cpp

@@ -0,0 +1,224 @@
+#include "LiteRGSS.h"
+#include "CViewport_Element.h"
+#include "Graphics.local.h"
+
+sf::RenderTexture* CViewport_Element::render = nullptr;
+sf::Sprite* CViewport_Element::render_sprite = nullptr;
+
+CViewport_Element::CViewport_Element() : CDrawable_Element() 
+{
+	linkedTone = nullptr;
+	render_states = nullptr;
+	color_copy = nullptr;
+	rRenderState = Qnil;
+}
+
+CViewport_Element::~CViewport_Element() 
+{
+    if(!game_window || !game_window->isOpen())
+        std::cerr << "Game window release thus viewport " << this << " not freed." << std::endl;
+	if (rRenderState == Qnil && render_states)
+	{
+		if (render_states->shader)
+		{
+			delete render_states->shader;
+			render_states->shader = nullptr;
+		}
+		delete render_states;
+	}
+	if(color_copy)
+		delete color_copy;
+};
+
+void CViewport_Element::draw(sf::RenderTarget& target) const
+{
+	if (!visible)
+		return;
+    if(render_states)
+    {
+		sf::Color* col;
+        // Loading Window View
+       /* sf::View wview = view;
+        wview.setRotation(0);
+		wview.setViewport(sf::FloatRect(0.f, 0.f, 1.f, 1.f));
+		wview.setSize(ScreenWidth, ScreenHeight);
+        target.setView(wview);*/
+		// Loading Target view
+		const sf::Vector2f view_size = view.getSize();
+		sf::View tview = view;
+		//tview.setViewport(sf::FloatRect(0.0f, 0.0f, view_size.x / ScreenWidth, view_size.y / ScreenHeight));
+		render->setView(tview);
+		// Clearing render
+		if (render_states->shader)
+			col = check_up_color();
+		else
+			col = const_cast<sf::Color*>(&sf::Color::Transparent);
+        render->clear(*col);
+        // Drawing sprites
+        for(auto sp = stack.begin();sp != stack.end();sp++)
+            (*sp)->drawFast(*render);
+        render->display();
+		// Update internal texture & draw result to Window
+		render_sprite->setTexture(render->getTexture());
+		//render_sprite->setTextureRect(sf::IntRect(0, 0, static_cast<int>(view_size.x), static_cast<int>(view_size.y)));
+		target.draw(*render_sprite, *render_states);
+		/*sf::Sprite sp(render->getTexture());
+		sp.setTextureRect(sf::IntRect(0, 0, static_cast<int>(view_size.x), static_cast<int>(view_size.y)));
+        target.draw(sp, *render_states);*/
+    }
+    else
+    {
+        target.setView(view);
+        drawFast(target);
+    }
+}
+
+void CViewport_Element::drawFast(sf::RenderTarget& target) const 
+{
+    for(auto sp = stack.begin();sp != stack.end();sp++)
+    {
+        (*sp)->drawFast(target);
+    }
+}
+
+bool CViewport_Element::isViewport() const
+{
+	return true;
+}
+
+bool CViewport_Element::isPureSprite() const
+{
+	return false;
+}
+
+sf::RenderStates * CViewport_Element::getRenderStates()
+{
+	return render_states;
+}
+
+void CViewport_Element::setRenderStates(sf::RenderStates * states)
+{
+	if (rRenderState == Qnil && render_states)
+	{
+		if (render_states->shader)
+		{
+			delete render_states->shader;
+			render_states->shader = nullptr;
+		}
+	}
+	render_states = states;
+}
+
+void CViewport_Element::bind(CDrawable_Element* sprite)
+{
+    //stack.push_back(sprite);
+    sprite->setOriginStack(&stack);
+}
+
+void CViewport_Element::clearStack() 
+{
+    stack.clear();
+}
+
+sf::Glsl::Vec4* CViewport_Element::getTone() 
+{
+	return &tone; 
+};
+
+void CViewport_Element::updatetone()
+{
+	if(render_states && render_states->shader)
+		const_cast<sf::Shader*>(render_states->shader)->setUniform("tone", tone);
+}
+
+void CViewport_Element::setLinkedTone(CTone_Element * _tone)
+{
+	linkedTone = _tone;
+}
+
+CTone_Element * CViewport_Element::getLinkedTone()
+{
+	return linkedTone;
+}
+
+sf::Color* CViewport_Element::check_up_color() const
+{
+	sf::Color* col = reinterpret_cast<sf::Color*>(RDATA(rColor)->data);
+	if (*col != *color_copy)
+	{
+		sf::Glsl::Vec4 color(col->r / 255.0f, col->g / 255.0f, col->b / 255.0f, col->a / 255.0f);
+		const_cast<sf::Shader*>(render_states->shader)->setUniform("color", color);
+		color_copy->r = col->r;
+		color_copy->g = col->g;
+		color_copy->b = col->b;
+		color_copy->a = col->a;
+	}
+	return col;
+}
+
+/* ---- Shader Part ---- */
+/* Thaks to https://github.com/Ancurio/mkxp/blob/master/shader/sprite.frag (Ancurio & urkle) */
+const std::string ViewportGlobalFragmentShader = \
+    "uniform sampler2D texture;" \
+    "uniform vec4 tone;" \
+    "uniform vec4 color;" \
+    "const vec3 lumaF = vec3(.299, .587, .114);" \
+    "void main()" \
+    "{" \
+    "   vec4 frag = texture2D(texture, gl_TexCoord[0].xy);" \
+    /*"   frag.rgb = mix(frag.rgb, gl_Color.rgb, cola);" \*/
+    "   frag.rgb = mix(frag.rgb, color.rgb, color.a);" \
+    "   float luma = dot(frag.rgb, lumaF);" \
+    "   frag.rgb += tone.rgb;" \
+    "   frag.rgb = mix(frag.rgb, vec3(luma), tone.w);" \
+    "   frag.a *= gl_Color.a;" \
+    "   gl_FragColor = frag;" \
+    "}";
+
+
+sf::Glsl::Vec4 __Viewport_reset_tone(0.0f, 0.0f, 0.0f, 0.0f);
+
+
+/*void CViewport_Element::reset_render()
+{
+    if(render == nullptr)
+        return;
+    const sf::Vector2f sz = getView()->getSize();
+    render->create(static_cast<unsigned int>(sz.x), static_cast<unsigned int>(sz.y));
+}*/
+
+void CViewport_Element::create_render()
+{
+	// If the global viewport render doesn't exist, we create it
+	if (!render)
+	{
+		render = new sf::RenderTexture();
+		render->create(ScreenWidth, ScreenHeight);
+		render->setSmooth(SmoothScreen);
+		render_sprite = new sf::Sprite();
+	}
+	// Return if the render texture (internal_texture) is already created
+    if(render_states != nullptr)
+        return;
+	// Creation of the render states
+	render_states = new sf::RenderStates(new sf::Shader());
+	// Shader initialialization
+	sf::Shader* shader = const_cast<sf::Shader*>(render_states->shader);
+	if (shader->loadFromMemory(ViewportGlobalFragmentShader, sf::Shader::Fragment))
+	{
+		shader->setUniform("texture", sf::Shader::CurrentTexture);
+		shader->setUniform("tone", __Viewport_reset_tone);
+		shader->setUniform("color", __Viewport_reset_tone);
+	}
+	color_copy = new sf::Color(0, 0, 0, 0);
+}
+
+void CViewport_Element::setVisible(bool value)
+{
+	visible = value;
+}
+
+const std::vector<CDrawable_Element*>* CViewport_Element::getStack()
+{
+	return &stack;
+}