wip

examples/Demo/src/TestColorFont.h

@@ -111,7 +111,7 @@ private:
     {
         Material::setCurrent(rs.material);
 
-        STDRenderer* renderer = STDRenderer::instance;
+        STDRenderer* renderer = STDRenderer::getCurrent();
         _adata = rs.alpha;
         shader->setShaderUniformsCallback(CLOSURE(this, &ShaderTextField::setUniforms));
         renderer->setUberShaderProgram(shader);

examples/Demo/src/TestMask.h

@@ -2,6 +2,7 @@
 #include "test.h"
 #include "Polygon.h"
 #include "TestPolygon.h"
+#include "TweenOutline.h"
 
 class TestMask: public Test
 {
@@ -59,6 +60,7 @@ public:
         text->setText("Oxygine. Masked sky demo");
         text->setStyle(style);
 
+        text->addTween(TweenOutline(Color::Green), 3000, -1, true);
 
         const Test::toggle sm[] = {Test::toggle("hide mask", 0), Test::toggle("show mask", 1), };
         addToggle("show_mask", sm, 2);

examples/Demo/src/TestRender2Texture.h

@@ -61,7 +61,7 @@ public:
         if (!left && !right)
             return;
 
-        STDRenderer& renderer = *STDRenderer::instance;
+        STDRenderer& renderer = *STDRenderer::getCurrent();
 
 #if 1
         renderer.begin(texture);

examples/Demo/src/TestTiled.h

@@ -143,7 +143,7 @@ public:
 
         Color color(Color::White);
 
-        STDRenderer* renderer = STDRenderer::instance;
+        STDRenderer* renderer = STDRenderer::getCurrent();
 
         float tw = 1.0f / nt->getWidth();
         float th = 1.0f / nt->getHeight();
@@ -202,7 +202,7 @@ public:
     {
         Material::setCurrent(rs.material);
 
-        STDRenderer* renderer = STDRenderer::instance;
+        STDRenderer* renderer = STDRenderer::getCurrent();
         renderer->setTexture(nt);
         renderer->setTransform(rs.transform);
         renderer->setBlendMode(blend_premultiplied_alpha);

oxygine/src/Box9Sprite.cpp

@@ -291,7 +291,7 @@ namespace oxygine
         //_vstyle._apply(rs);
         const Diffuse& df = _frame.getDiffuse();
 
-        STDRenderer* renderer = safeCast<STDMaterial*>(rs.material)->getRenderer();
+        STDRenderer* renderer = STDRenderer::getCurrent();
         Material::setCurrent(rs.material);
 
         if (df.base)

oxygine/src/Polygon.cpp

@@ -81,7 +81,7 @@ namespace oxygine
 
         const Diffuse& df = _frame.getDiffuse();
 
-        STDRenderer* renderer = (safeCast<STDMaterial*>(rs.material))->getRenderer();
+        STDRenderer* renderer = STDRenderer::getCurrent();
 
         renderer->setTexture(df.base, df.alpha, df.premultiplied);
         renderer->setBlendMode(getBlendMode());

oxygine/src/ProgressBar.cpp

@@ -118,8 +118,7 @@ namespace oxygine
         //rs.material->doRender(this, rs);
         ///*
 
-        STDRenderer* renderer = safeCast<STDMaterial*>(rs.material)->getRenderer();
-        //STDRenderer* renderer = STDRenderer::instance;
+        STDRenderer* renderer = STDRenderer::getCurrent();
 
         const Diffuse& df = _frame.getDiffuse();
         if (df.base)

oxygine/src/STDMaterial.cpp

@@ -31,11 +31,6 @@ namespace oxygine
         }
     }
 
-    void STDMaterial::setViewProj(const Matrix& vp)
-    {
-        _renderer->setViewProjTransform(vp);
-    }
-
     void STDMaterial::render(ClipRectActor* actor, const RenderState& parentRS)
     {
         //Material::render(actor, parentRS);
@@ -49,12 +44,14 @@ namespace oxygine
         rs.clip = &clippedRect;
 
         Rect scissorRect(0, 0, 0, 0);
-        bool scissorEnabled = _renderer->getDriver()->getScissorRect(scissorRect);
+        STDRenderer* renderer = STDRenderer::getCurrent();
+        IVideoDriver* driver = renderer->getDriver();
+        bool scissorEnabled = driver->getScissorRect(scissorRect);
 
         bool vis = true;
         if (actor->getClipping())
         {
-            _renderer->drawBatch();
+            renderer->drawBatch();
 
             RectF ss_rect = getActorTransformedDestRect(actor, actor->getTransform() * parentRS.transform);
 
@@ -67,13 +64,13 @@ namespace oxygine
                                    int(clippedRect.size.x + 0.01f),
                                    int(clippedRect.size.y + 0.01f));
 
-                if (!_renderer->getDriver()->getRenderTarget()->getHandle())
+                if (!driver->getRenderTarget()->getHandle())
                 {
                     Point vp_size = core::getDisplaySize();
                     gl_rect.pos.y = vp_size.y - gl_rect.getBottom();
                 }
 
-                _renderer->getDriver()->setScissorRect(&gl_rect);
+                driver->setScissorRect(&gl_rect);
             }
             else
             {
@@ -87,9 +84,8 @@ namespace oxygine
 
         if (actor->getClipping())
         {
-            _renderer->drawBatch();
-
-            _renderer->getDriver()->setScissorRect(scissorEnabled ? &scissorRect : 0);
+            renderer->drawBatch();
+            driver->setScissorRect(scissorEnabled ? &scissorRect : 0);
         }
     }
 
@@ -112,18 +108,25 @@ namespace oxygine
             bool rchannel       = useR ? true    : (df.alpha ? true     : false);
             spNativeTexture msk = useR ? df.base : (df.alpha ? df.alpha : df.base);
 
-            STDRenderer* original = _renderer;
+            STDRenderer* original = STDRenderer::getCurrent();
+
+            original->drawBatch();
+            original->end();
+
 
-            _renderer->drawBatch();
 
             MaskedRenderer mr(msk, maskSrc, maskDest, t, rchannel, original->getDriver());
-            mr.begin(_renderer);
-            _renderer = &mr;
+            original->swapVerticesData(mr);
+
+            mr.setViewProjTransform(original->getViewProjection());
+            mr.begin();
+
             RenderState rs = parentRS;
             sprite->Sprite::render(rs);
             mr.end();
 
-            _renderer = original;
+            original->swapVerticesData(mr);
+            original->begin();
         }
         else
         {
@@ -148,19 +151,19 @@ namespace oxygine
         if (base)
 #endif
         {
-            _renderer->setBlendMode(sprite->getBlendMode());
+            STDRenderer* r = STDRenderer::getCurrent();
+            r->setBlendMode(sprite->getBlendMode());
 #ifndef EMSCRIPTEN
-            _renderer->setTexture(df.base, df.alpha, df.premultiplied);//preload
+            r->setTexture(df.base, df.alpha, df.premultiplied);//preload
 #endif
 
-            _renderer->setTransform(rs.transform);
-            _renderer->draw(rs.getFinalColor(sprite->getColor()), frame.getSrcRect(), sprite->getDestRect());
+            r->setTransform(rs.transform);
+            r->draw(rs.getFinalColor(sprite->getColor()), frame.getSrcRect(), sprite->getDestRect());
         }
     }
 
     void STDMaterial::doRender(TextField* tf, const RenderState& rs)
     {
-
         float scale = sqrtf(rs.transform.a * rs.transform.a + rs.transform.c * rs.transform.c);
 
         text::Node* root = tf->getRootNode(scale);
@@ -173,12 +176,14 @@ namespace oxygine
 
         text::DrawContext dc;
 
+        STDRenderer* renderer = STDRenderer::getCurrent();
+
         dc.primary = rs.getFinalColor(tf->getColor()).premultiplied();
         dc.color = tf->getStyle().color * dc.primary;
-        dc.renderer = _renderer;
+        dc.renderer = renderer;
 
-        _renderer->setBlendMode(tf->getBlendMode());
-        _renderer->setTransform(rs.transform);
+        renderer->setBlendMode(tf->getBlendMode());
+        renderer->setTransform(rs.transform);
 
         int sdfSize;
         if (tf->getFont()->isSDF(sdfSize))
@@ -191,13 +196,13 @@ namespace oxygine
             float offset = tf->getWeight();
             float outline = tf->getWeight() - tf->getOutline();
 
-            _renderer->beginSDFont(contrast, offset, tf->getOutlineColor(), outline);
+            renderer->beginSDFont(contrast, offset, tf->getOutlineColor(), outline);
             root->draw(dc);
-            _renderer->endSDFont();
+            renderer->endSDFont();
         }
         else
         {
-            _renderer->beginElementRendering(true);
+            renderer->beginElementRendering(true);
             root->draw(dc);
         }
     }
@@ -206,10 +211,12 @@ namespace oxygine
     {
         Material::setCurrent(this);
 
-        _renderer->setBlendMode(sprite->getBlendMode());
-        _renderer->setTexture(STDRenderer::white);
-        _renderer->setTransform(rs.transform);
-        _renderer->draw(rs.getFinalColor(sprite->getColor()), RectF(0, 0, 1, 1), sprite->getDestRect());
+        STDRenderer* renderer = STDRenderer::getCurrent();
+
+        renderer->setBlendMode(sprite->getBlendMode());
+        renderer->setTexture(STDRenderer::white);
+        renderer->setTransform(rs.transform);
+        renderer->draw(rs.getFinalColor(sprite->getColor()), RectF(0, 0, 1, 1), sprite->getDestRect());
     }
 
     void STDMaterial::doRender(ProgressBar*, const RenderState& rs)
@@ -219,14 +226,15 @@ namespace oxygine
 
     void STDMaterial::apply(Material* prev)
     {
-        _renderer->begin(0);
-        _renderer->setUberShaderProgram(&STDRenderer::uberShader);
+        STDRenderer* cur = STDRenderer::getCurrent();
+        if (!cur)
+            cur = STDRenderer::instance;
+        cur->begin();
+        cur->setUberShaderProgram(&STDRenderer::uberShader);
     }
 
     void STDMaterial::finish()
     {
-        if (!_renderer)
-            return;
-        _renderer->end();
+        STDRenderer::getCurrent()->end();
     }
 }

oxygine/src/STDMaterial.h

@@ -11,7 +11,7 @@ namespace oxygine
     public:
         static STDMaterial* instance;
 
-        STDMaterial(STDRenderer* r): _renderer(r) {}
+        STDMaterial() {}
 
         void apply(Material* prev) override;
         void finish() override;
@@ -23,12 +23,10 @@ namespace oxygine
         void doRender(ColorRectSprite*, const RenderState& rs) override;
         void doRender(ProgressBar*, const RenderState& rs) override;
 
-        void setViewProj(const Matrix& vp);
 
-        STDRenderer* getRenderer() { return _renderer; }
+        STDRenderer* getRenderer() { return STDRenderer::getCurrent(); }
 
     protected:
-        STDRenderer* _renderer;
     };
 
 }

oxygine/src/STDRenderer.cpp

@@ -24,6 +24,7 @@ namespace oxygine
 {
     bool _restored = false;
     STDRenderer* STDRenderer::instance = 0;
+    STDRenderer* STDRenderer::current = 0;
 
 
     spNativeTexture STDRenderer::white;
@@ -188,6 +189,11 @@ namespace oxygine
     }
 
 
+    STDRenderer* STDRenderer::getCurrent()
+    {
+        return current;
+    }
+
     STDRenderer::~STDRenderer()
     {
         drawBatch();
@@ -269,17 +275,10 @@ namespace oxygine
         _program = 0;
     }
 
-    void STDRenderer::begin(STDRenderer* prev)
+    void STDRenderer::begin()
     {
         OX_ASSERT(!_drawing);
         OX_ASSERT(_vertices.empty() == true);
-        _previous = prev;
-        if (_previous)
-        {
-            _previous->end();
-            _vp = _previous->_vp;
-        }
-
         _program = 0;
         _vertices.clear();
         _transform.identity();
@@ -288,6 +287,8 @@ namespace oxygine
         _begin();
 
         _drawing = true;
+
+        current = this;
     }
 
     void STDRenderer::end()
@@ -300,10 +301,9 @@ namespace oxygine
             _prevRT = 0;
         }
 
-        _drawing = false;
+        current = 0;
 
-        if (_previous)
-            _previous->begin(0);
+        _drawing = false;
     }
 
     void STDRenderer::setVertexDeclaration(const VertexDeclaration* decl)
@@ -401,14 +401,10 @@ namespace oxygine
         if (driver)
             setDriver(driver);
 
-        _vertices.reserve(32 * 1000);
-
         _vp.identity();
 
         _vdecl = _driver->getVertexDeclaration(vertexPCT2::FORMAT);
 
-
-
         _uberShader = &uberShader;
         _transform.identity();
         _drawing = false;

oxygine/src/STDRenderer.h

@@ -8,6 +8,7 @@ namespace oxygine
     {
     public:
 
+        static STDRenderer* current;
         static STDRenderer* instance;
         /**Sets default rendering OpenGL options for 2D*/
         static void setDefaultSettings();
@@ -22,6 +23,9 @@ namespace oxygine
         /**restore after lost context*/
         static void restore();
 
+        /**returns activated renderer with STDRenderer::begin*/
+        static STDRenderer* getCurrent();
+
         /**White 4x4 Texture*/
         static spNativeTexture white;
         static spNativeTexture invisible;
@@ -63,7 +67,7 @@ namespace oxygine
         void drawBatch();
 
         /**Begins rendering into RenderTexture or into primary framebuffer if rt is null*/
-        void begin(STDRenderer* prev = 0);
+        void begin();
         void begin(spNativeTexture nt, const Rect* viewport = 0);
         /**Completes started rendering and restores previous Frame Buffer.*/
         void end();
@@ -81,6 +85,9 @@ namespace oxygine
         static void showTexel2PixelErrors(bool show);
 #endif
 
+        void swapVerticesData(std::vector<unsigned char>& data) { std::swap(data, _vertices); }
+        void swapVerticesData(STDRenderer& r) { std::swap(_vertices, r._vertices); }
+
     protected:
         Transform _transform;
 

oxygine/src/core/oxygine.cpp

@@ -489,7 +489,7 @@ namespace oxygine
             Resources::registerResourceType(ResStarlingAtlas::create, "starling");
 
             STDRenderer::instance = new STDRenderer;
-            STDMaterial::instance = new STDMaterial(STDRenderer::instance);
+            STDMaterial::instance = new STDMaterial;
 
             CHECKGL();
 

oxygine/src/dev_tools/TreeInspectorPreview.cpp

@@ -66,34 +66,34 @@ namespace oxygine
 
         VideoDriverCache& cache = _videoCache;
 
+
+        STDRenderer* original = STDRenderer::getCurrent();
+
         STDRenderer renderer(&cache);
+        //STDRenderer::current = &renderer;
         renderer.setViewProjTransform(STDRenderer::instance->getViewProjection());
-        STDMaterial mat(&renderer);
+        //renderer.begin();
+        STDRenderer::current = &renderer;
+        //STDMaterial mat;
 
         RenderState rs;
-        rs.material = &mat;
+        rs.material = STDMaterial::instance;
         RectF clip = RectF::huge();
         rs.clip = &clip;
-        //renderer.begin(0);
+
         if (child)
         {
-            STDMaterial* originalMat = STDMaterial::instance;
-
-            STDMaterial::instance = &mat;
-
             bool vis = item->getVisible();
             item->setVisible(true);
             rs.transform = rs.transform * item->getTransformInvert();
             item->render(rs);
             item->setVisible(vis);
 
-            STDMaterial::instance = originalMat;
+            //STDMaterial::instance = originalMat;
         }
         else
             item->doRender(rs);
 
-        //renderer.end();
-        //renderer.drawBatch();
 
         Material::setCurrent(0);
 
@@ -118,6 +118,9 @@ namespace oxygine
 
         cache.transform(transform);
 
+        STDRenderer::current = original;
+
+        //OX_ASSERT(STDRenderer::current);
         _render2cache = false;
         return ns;
     }
@@ -153,14 +156,10 @@ namespace oxygine
         Sprite::doRender(parentRenderState);
         Material::setCurrent(0);
 
-        STDMaterial::instance->getRenderer()->drawBatch();
-        if (getParent() == getStage().get())
-        {
-            int q = 0;
-        }
+        //STDMaterial::instance->getRenderer()->drawBatch();
         _videoCache.render(parentRenderState.transform);
-        STDMaterial::instance->getRenderer()->drawBatch();
-        STDMaterial::instance->getRenderer()->resetSettings();
+        //STDMaterial::instance->getRenderer()->drawBatch();
+        //STDMaterial::instance->getRenderer()->resetSettings();
     }
 
     VideoDriverCache::VideoDriverCache()