new render

added global render state cache

examples/Demo/src/TestMask.h

@@ -59,7 +59,7 @@ public:
         text->setText("Oxygine. Masked sky demo");
         text->setStyle(style);
 
-        text->addTween(TweenOutline(Color::Green), 3000, -1, true);
+        //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

@@ -89,12 +89,12 @@ public:
         ResAnim* brush = resources.getResAnim("brush");
         AnimationFrame frame = brush->getFrame(0);
         const Diffuse& df = frame.getDiffuse();
-        renderer.setTextureNew(0, df.base);
+        rc().setTexture(0, df.base);
         if (paint)
-            renderer.setBlendMode(blend_premultiplied_alpha);
+            rc().setBlendMode(blend_premultiplied_alpha);
         else
         {
-            renderer.setBlendMode(blend_add);
+            rc().setBlendMode(blend_add);
             oxglBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
         }
 

oxygine/src/oxygine/Box9Sprite.cpp

@@ -298,7 +298,7 @@ namespace oxygine
             if (_guidesX.size() >= 2 || _guidesY.size() >= 2)
             {
                 //renderer->setTexture(df.base, df.alpha, df.premultiplied);
-                renderer->setBlendMode(getBlendMode());
+                rc().setBlendMode(getBlendMode());
                 renderer->setTransform(rs.transform);
 
                 Color color = rs.getFinalColor(getColor());

oxygine/src/oxygine/MaterialX.cpp

@@ -43,9 +43,9 @@ namespace oxygine
         STDRenderer* r = STDRenderer::getCurrent();
         r->setUberShaderProgram(_uberShader);
         r->setShaderFlags(_flags);
-        r->setTextureNew(UberShaderProgram::SAMPLER_BASE, _base);
-        r->setTextureNew(UberShaderProgram::SAMPLER_ALPHA, _alpha);
-        r->setBlendMode(_blend);
+        rc().setTexture(UberShaderProgram::SAMPLER_BASE, _base);
+        rc().setTexture(UberShaderProgram::SAMPLER_ALPHA, _alpha);
+        rc().setBlendMode(_blend);
     }
 
     void STDMaterialX::xflush()

oxygine/src/oxygine/ProgressBar.cpp

@@ -119,7 +119,7 @@ namespace oxygine
         const Diffuse& df = _frame.getDiffuse();
         if (df.base)
         {
-            renderer->setBlendMode(getBlendMode());
+            rc().setBlendMode(getBlendMode());
             //renderer->setTexture(df.base, df.alpha, df.premultiplied);
 
             RectF destRect = inherited::getDestRect();

oxygine/src/oxygine/STDRenderer.cpp

@@ -37,35 +37,58 @@ namespace oxygine
     std::vector<unsigned char> STDRenderer::uberShaderBody;
 
 
+    RenderStateCache& rc()
+    {
+        static RenderStateCache r(IVideoDriver::instance);
+        return r;
+    }
 
+    RenderStateCache::RenderStateCache(IVideoDriver* d) : _driver(d), _program(0)
+    {
+        _blend = blend_disabled;
+    }
 
 
-    /*
-
-
-    unsigned int shaderFlags = _shaderFlags;
-    shaderFlags |= UberShaderProgram::SDF;
+    void RenderStateCache::setTexture(int sampler, const spNativeTexture& t)
+    {
+        OX_ASSERT(sampler < MAX_TEXTURES);
+        if (_textures[sampler] == t)
+            return;
+        _textures[sampler] = t;
+        _driver->setTexture(sampler, t);
+    }
 
-    if (outlineOffset < offset)
-        shaderFlags |= UberShaderProgram::SDF_OUTLINE;
 
-    if (_shaderFlags != shaderFlags)
+    void RenderStateCache::setBlendMode(blend_mode blend)
     {
-        drawBatch();
-    }
+        if (_blend == blend)
+            return;
 
-    _shaderFlags = shaderFlags;
+        //drawBatch();
 
-    ShaderProgram* prog = _uberShader->getShaderProgram(_shaderFlags);
-    setShader(prog);
+        if (blend == 0)
+            _driver->setState(IVideoDriver::STATE_BLEND, 0);
+        else
+        {
+            IVideoDriver::BLEND_TYPE src = static_cast<IVideoDriver::BLEND_TYPE>(blend >> 16);
+            IVideoDriver::BLEND_TYPE dest = static_cast<IVideoDriver::BLEND_TYPE>(blend & 0xFFFF);
+            _driver->setBlendFunc(src, dest);
+            _driver->setState(IVideoDriver::STATE_BLEND, 1);
+        }
+        _blend = blend;
 
-    Vector4 c = outlineColor.toVector();
-    _driver->setUniform("sdf_outline_color", c);
+    }
 
-    c = Vector4(offset, contrast, outlineOffset, contrast);
-    _driver->setUniform("sdf_params", c);
-    */
 
+    bool RenderStateCache::setShader(ShaderProgram* prog)
+    {
+        if (_program == prog)
+            return false;
+
+        _program = prog;
+        _driver->setShaderProgram(prog);
+        return true;
+    }
 
     void nullTextureHook(const spNativeTexture&)
     {
@@ -236,10 +259,8 @@ namespace oxygine
 
     void STDRenderer::setShader(ShaderProgram* prog)
     {
-        if (prog != _program)
+        if (rc().setShader(prog))
         {
-            _program = prog;
-            _driver->setShaderProgram(prog);
             _driver->setUniform("mat", _vp);
             shaderProgramChanged();
         }
@@ -248,12 +269,12 @@ namespace oxygine
 
     void STDRenderer::xdrawBatch()
     {
-        size_t count = _vertices.size() / _vdecl->size;
+        size_t count = _verticesData.size() / _vdecl->size;
         size_t indices = (count * 3) / 2;
 
-        getDriver()->draw(IVideoDriver::PT_TRIANGLES, _vdecl, &_vertices.front(), (unsigned int)count, &indices16.front(), (unsigned int)indices);
+        getDriver()->draw(IVideoDriver::PT_TRIANGLES, _vdecl, &_verticesData.front(), (unsigned int)count, &indices16.front(), (unsigned int)indices);
 
-        _vertices.clear();
+        _verticesData.clear();
     }
 
     void STDRenderer::initCoordinateSystem(int width, int height, bool flipU)
@@ -294,20 +315,16 @@ namespace oxygine
     void STDRenderer::resetSettings()
     {
         xresetSettings();
-        _driver->setState(IVideoDriver::STATE_BLEND, 0);
-        _blend = blend_disabled;
-        _program = 0;
+        //_driver->setState(IVideoDriver::STATE_BLEND, 0);
     }
 
     void STDRenderer::begin()
     {
         //OX_ASSERT(!_drawing);
-        OX_ASSERT(_vertices.empty() == true);
-        _program = 0;
-        _vertices.clear();
+        OX_ASSERT(_verticesData.empty() == true);
+        _verticesData.clear();
         _transform.identity();
-        for (int i = 0; i < MAX_TEXTURES; ++i)
-            _textures[i] = 0;
+
         MaterialX::current = 0;
         resetSettings();
 
@@ -352,12 +369,12 @@ namespace oxygine
 
     void STDRenderer::xaddVertices(const void* data, unsigned int size)
     {
-        _vertices.insert(_vertices.end(), (const unsigned char*)data, (const unsigned char*)data + size);
+        _verticesData.insert(_verticesData.end(), (const unsigned char*)data, (const unsigned char*)data + size);
     }
 
     void STDRenderer::checkDrawBatch()
     {
-        if (_vertices.size() / sizeof(_vdecl->size) >= maxVertices)
+        if (_verticesData.size() / sizeof(_vdecl->size) >= maxVertices)
             flush();
     }
 
@@ -424,7 +441,7 @@ namespace oxygine
 
 
 
-    STDRenderer::STDRenderer(IVideoDriver* driver) : _driver(driver), _program(0), _vdecl(0), _previous(0), _uberShader(0), _shaderFlags(0), _blend(blend_disabled)
+    STDRenderer::STDRenderer(IVideoDriver* driver) : _driver(driver), _vdecl(0), _uberShader(0), _shaderFlags(0)
     {
         if (!driver)
             driver = IVideoDriver::instance;
@@ -440,27 +457,6 @@ namespace oxygine
         _baseShaderFlags = 0;
     }
 
-    void STDRenderer::setBlendMode(blend_mode blend)
-    {
-        if (_blend == blend)
-            return;
-
-        //drawBatch();
-
-        if (blend == 0)
-        {
-            _driver->setState(IVideoDriver::STATE_BLEND, 0);
-        }
-        else
-        {
-            IVideoDriver::BLEND_TYPE src  = static_cast<IVideoDriver::BLEND_TYPE>(blend >> 16);
-            IVideoDriver::BLEND_TYPE dest = static_cast<IVideoDriver::BLEND_TYPE>(blend & 0xFFFF);
-            _driver->setBlendFunc(src, dest);
-            _driver->setState(IVideoDriver::STATE_BLEND, 1);
-        }
-        _blend = blend;
-
-    }
 
     template <class T>
     void append(std::vector<unsigned char>& buff, const T& t)
@@ -480,47 +476,14 @@ namespace oxygine
 
     void STDRenderer::swapVerticesData(STDRenderer& r)
     {
-        std::swap(_vertices, r._vertices);
+        std::swap(_verticesData, r._verticesData);
     }
 
     void STDRenderer::swapVerticesData(std::vector<unsigned char>& data)
     {
-        std::swap(data, _vertices);
-    }
-
-
-    void STDRenderer::setTexture(const spNativeTexture& base_, const spNativeTexture& alpha, bool basePremultiplied)
-    {
-        if (base_ == _base && _alpha == alpha)
-            return;
-
-        flush();
-
-        _renderTextureHook(base_);
-        _renderTextureHook(alpha);
-
-        spNativeTexture base = base_;
-        if (base == 0 || base->getHandle() == 0)
-            base = white;
-
-        if (basePremultiplied)
-            _shaderFlags &= ~UberShaderProgram::ALPHA_PREMULTIPLY;
-        else
-            _shaderFlags |= UberShaderProgram::ALPHA_PREMULTIPLY;
-
-        if (alpha)
-            _shaderFlags |= UberShaderProgram::SEPARATE_ALPHA;
-        else
-            _shaderFlags &= ~UberShaderProgram::SEPARATE_ALPHA;
-
-        _base = base;
-        _alpha = alpha;
+        std::swap(data, _verticesData);
     }
 
-    void STDRenderer::setTexture(const spNativeTexture& base_, bool basePremultiplied)
-    {
-        setTexture(base_, 0, basePremultiplied);
-    }
 
     void STDRenderer::setTransform(const Transform& tr)
     {
@@ -529,9 +492,6 @@ namespace oxygine
 
     void STDRenderer::xbegin()
     {
-        _base = 0;
-        _alpha = 0;
-        _blend = blend_disabled;
     }
 
     void STDRenderer::begin(spNativeTexture nt, const Rect* viewport)
@@ -565,8 +525,8 @@ namespace oxygine
         vertexPCT2 v[4];
         fillQuadT(v, srcRect, destRect, _transform, color.rgba());
 
-
-#ifdef OXYGINE_DEBUG_T2P
+        /*
+        #ifdef OXYGINE_DEBUG_T2P
         if (_base != white && _showTexel2PixelErrors)
         {
             Rect viewport;
@@ -580,18 +540,12 @@ namespace oxygine
                 fillQuadT(v, srcRect, destRect, _transform, b.rgba());
             }
         }
-#endif
+        #endif
+        */
 
         addVertices(v, sizeof(v));
     }
 
-    void STDRenderer::setTextureNew(int sampler, const spNativeTexture& t)
-    {
-        if (_textures[sampler] == t)
-            return;
-        _textures[sampler] = t;
-        _driver->setTexture(sampler, t);
-    }
 
     void STDRenderer::setShaderFlags(int flags)
     {
@@ -711,15 +665,15 @@ namespace oxygine
         //log::messageln("batches %d", _batches.size());
         _batches.clear();
 #else
-        size_t indices = (_vertices.size() / sizeof(vertexPCT2) * 3) / 2;
+        size_t indices = (_verticesData.size() / sizeof(vertexPCT2) * 3) / 2;
         if (!indices)
             return;
 
         IVideoDriver::instance->draw(IVideoDriver::PT_TRIANGLES, _vdecl,
-                                     &_vertices.front(), (unsigned int)_vertices.size(),
+                                     &_verticesData.front(), (unsigned int)_verticesData.size(),
                                      &STDRenderer::indices16.front(), (unsigned int)indices);
 
-        _vertices.clear();
+        _verticesData.clear();
 #endif
     }
 
@@ -736,6 +690,7 @@ namespace oxygine
 
     void STDRenderer::applySimpleMode(bool basePremultiplied)
     {
+        /*
         if (_alpha)
         {
             flush();
@@ -754,10 +709,13 @@ namespace oxygine
         {
             flush();
         }
+        */
+        OX_ASSERT(0);
     }
 
     void STDRenderer::draw(const spNativeTexture& texture, unsigned int color, const RectF& src, const RectF& dest)
     {
+        /*
         if (_base != texture)
         {
             flush();
@@ -767,5 +725,9 @@ namespace oxygine
         vertexPCT2 v[4];
         fillQuadT(v, src, dest, _transform, color);
         addVertices(v, sizeof(v));
+        */
+        OX_ASSERT(0);
     }
+
+
 }

oxygine/src/oxygine/STDRenderer.h

@@ -5,6 +5,26 @@
 
 namespace oxygine
 {
+    class RenderStateCache
+    {
+    public:
+        RenderStateCache(IVideoDriver* d);
+
+        void setTexture(int sampler, const spNativeTexture& t);
+        void setBlendMode(blend_mode blend);
+        bool setShader(ShaderProgram* prog);
+
+    protected:
+        enum { MAX_TEXTURES = 8 };
+
+        blend_mode      _blend;
+        spNativeTexture _textures[MAX_TEXTURES];
+        ShaderProgram*  _program;
+        IVideoDriver* _driver;
+    };
+
+    RenderStateCache& rc();
+
     class STDRenderer : public IElementRenderer
     {
     public:
@@ -49,26 +69,15 @@ namespace oxygine
         void setViewProj(const Matrix& viewProj);
         void setVertexDeclaration(const VertexDeclaration* decl);
         void setUberShaderProgram(UberShaderProgram* pr);
-        /**Sets blend mode. Default value is blend_premultiplied_alpha*/
-        void setBlendMode(blend_mode blend);
-        /**Sets texture. If texture is null White texture would be used.*/
-        void setTexture(const spNativeTexture& base, const spNativeTexture& alpha, bool basePremultiplied = true);
-        void setTexture(const spNativeTexture& base, bool basePremultiplied = true);
+
         /**Sets World transformation.*/
         void setTransform(const Transform& world);
         void draw(const Color&, const RectF& srcRect, const RectF& destRect);
-        void setTextureNew(int sampler, const spNativeTexture& t);
 
         void applySimpleMode(bool basePremultiplied);
         /**used in pair with applySimpleMode/applySDF, fast, don't have excess checks*/
         void draw(const spNativeTexture& texture, unsigned int color, const RectF& src, const RectF& dest) override;
 
-        /*
-        void draw(MaterialX* mat, const Color& color, const RectF& src, const RectF& dest) override;
-        void draw(MaterialX* mat, const AffineTransform& transform, const Color& color, const RectF& src, const RectF& dest);
-        void draw(MaterialX* mat, vertexPCT2 vert[4]);
-        */
-
         /**Begins rendering into RenderTexture or into primary framebuffer if rt is null*/
         void begin();
         void begin(spNativeTexture renderTarget, const Rect* viewport = 0);
@@ -77,8 +86,6 @@ namespace oxygine
         /**initializes View + Projection matrices where TopLeft is (0,0) and RightBottom is (width, height). use flipU = true for render to texture*/
         void initCoordinateSystem(int width, int height, bool flipU = false);
         void resetSettings();
-        void process();
-        void process(int);
 
         /**Draws existing batch immediately.*/
         void flush();
@@ -110,15 +117,11 @@ namespace oxygine
         typedef std::vector<batch> batches;
         batches _batches;
 
-        enum { MAX_TEXTURES = 4 };
-        spNativeTexture _textures[MAX_TEXTURES];
 
         batch& draw(spMaterialX mat);
 
-        int _baseShaderFlags;
         Transform _transform;
 
-        STDRenderer* _previous;
         void setShader(ShaderProgram* prog);
 
         void xdrawBatch();
@@ -127,23 +130,20 @@ namespace oxygine
         void xaddVertices(const void* data, unsigned int size);
         void checkDrawBatch();
 
-        std::vector<unsigned char> _vertices;
+        std::vector<unsigned char> _verticesData;
 
         const VertexDeclaration* _vdecl;
 
         IVideoDriver* _driver;
-        ShaderProgram* _program;
         Matrix _vp;
 
         virtual void xbegin();
         virtual void xresetSettings();
-        //virtual
-        spNativeTexture _base;
-        spNativeTexture _alpha;
 
-        blend_mode _blend;
 
         UberShaderProgram* _uberShader;
+
+        unsigned int _baseShaderFlags;
         unsigned int _shaderFlags;
 
         bool _drawing;

oxygine/src/oxygine/TweenGlow.cpp

@@ -38,7 +38,7 @@ namespace oxygine
 
             RectF dest = _pp._screen.cast<RectF>();
 
-            renderer->setBlendMode(blend_premultiplied_alpha);
+            rc().setBlendMode(blend_premultiplied_alpha);
 
 
             AffineTransform tr = _pp._transform * _actor->computeGlobalTransform();
@@ -46,7 +46,7 @@ namespace oxygine
             renderer->applySimpleMode(true);
             Color color = Color(Color::White).withAlpha(255).premultiplied();
             color = Color::White;
-            renderer->setBlendMode(blend_add);
+            rc().setBlendMode(blend_add);
             renderer->draw(_pp._rt, color.rgba(), src, dest);
             renderer->flush();
         }