wip

examples/Demo/src/TestColorFont.h

@@ -12,13 +12,13 @@ public:
 
     void rehash(size_t& hash) const override
     {
-        data.init(hash);
+        STDMaterialX::rehash(hash);
         hash_combine(hash, uniformBlack.x, uniformBlack.y, uniformBlack.z, uniformBlack.w);
     }
 
     static bool cmp(const ColoredShaderMat& a, const ColoredShaderMat& b)
     {
-        if (!MaterialTX<STDMatData>::cmp(a, b))
+        if (!STDMaterialX::cmp(a, b))
             return false;
 
         return a.uniformBlack == b.uniformBlack;
@@ -26,7 +26,7 @@ public:
 
     void xapply() override
     {
-        MaterialTX<STDMatData>::xapply();
+        STDMaterialX::xapply();
         IVideoDriver::instance->setUniform("_black", uniformBlack);
     }
 };
@@ -64,7 +64,7 @@ public:
 
     ShaderTextField() : _outer(Color::White)
     {
-        mat.data._uberShader = shader;
+        mat._uberShader = shader;
         mat.uniformBlack = _outer.toVector();
         _mat = mc().cache(mat);
     }

examples/Demo/src/TestUserShader.h

@@ -2,7 +2,7 @@
 #include "test.h"
 
 
-class CustomUniformMat : public MaterialTX<STDMatData>
+class CustomUniformMat : public STDMaterialX
 {
 public:
     MATX(CustomUniformMat);
@@ -12,21 +12,21 @@ public:
 
     void rehash(size_t& hash) const override
     {
-        data.init(hash);
+        STDMaterialX::rehash(hash);
         hash_combine(hash, uniform.x, uniform.y, uniform.z, uniform.w);
     }
 
     static bool cmp(const CustomUniformMat& a, const CustomUniformMat& b)
     {
-        if (!MaterialTX<STDMatData>::cmp(a, b))
+        if (!STDMaterialX::cmp(a, b))
             return false;
 
         return a.uniform == b.uniform;
     }
 
-    void apply()
+    void xapply()
     {
-        MaterialTX<STDMatData>::apply();
+        STDMaterialX::xapply();
         IVideoDriver::instance->setUniform("userValue", uniform);
     }
 };
@@ -142,8 +142,9 @@ public:
             UberShaderProgram* shader = (UberShaderProgram*)data->data;
 
             CustomUniformMat mat;
-            mat.data = _sprite->_mat->data;
-            mat.data._uberShader = shader;
+            _sprite->_mat->copyTo(mat);
+
+            mat._uberShader = shader;
             _sprite->_mat = mc().cache(mat);
 
             _sprite->addTween(TweenUniform(), TweenOptions(3000).twoSides(true).loops(-1));

oxygine/src/oxygine/ColorRectSprite.cpp

@@ -14,7 +14,7 @@ namespace oxygine
     ColorRectSprite::ColorRectSprite()
     {
         STDMaterialX mat;
-        mat.data._base = STDRenderer::white;
+        mat._base = STDRenderer::white;
 
         _mat = mc().cache(mat);
     }

oxygine/src/oxygine/MaterialX.cpp

@@ -7,27 +7,29 @@ namespace oxygine
 {
     spMaterialX MaterialX::current;
 
-    bool STDMatData::cmp(const STDMatData& b) const
+    bool STDMaterialX::cmp(const STDMaterialX& a, const STDMaterialX& b)
     {
-        if (_base != b._base)
+        if (a._base != b._base)
             return false;
-        if (_alpha != b._alpha)
+        if (a._alpha != b._alpha)
             return false;
-        if (_blend != b._blend)
+        if (a._blend != b._blend)
             return false;
-        if (_flags != b._flags)
+        if (a._flags != b._flags)
             return false;
-        if (_uberShader != b._uberShader)
+        if (a._uberShader != b._uberShader)
             return false;
         return true;
     }
 
-    STDMatData::STDMatData() : _blend(blend_premultiplied_alpha), _flags(0), _uberShader(&STDRenderer::uberShader)
+    void STDMaterialX::init()
     {
-
+        _blend = blend_premultiplied_alpha;
+        _flags = 0;
+        _uberShader = &STDRenderer::uberShader;
     }
 
-    void STDMatData::init(size_t& hash) const
+    void STDMaterialX::rehash(size_t& hash) const
     {
         hash_combine(hash, _base.get());
         hash_combine(hash, _alpha.get());
@@ -36,7 +38,7 @@ namespace oxygine
         hash_combine(hash, _uberShader);
     }
 
-    void STDMatData::apply()
+    void STDMaterialX::xapply()
     {
         STDRenderer* r = STDRenderer::getCurrent();
         r->setUberShaderProgram(_uberShader);
@@ -46,7 +48,7 @@ namespace oxygine
         r->setBlendMode(_blend);
     }
 
-    void STDMatData::flush()
+    void STDMaterialX::xflush()
     {
         STDRenderer::getCurrent()->drawBatch();
     }
@@ -67,7 +69,7 @@ namespace oxygine
 
     }
 
-    void MaterialX::render(const AffineTransform &tr, const Color& c, const RectF& src, const RectF& dest)
+    void MaterialX::render(const AffineTransform& tr, const Color& c, const RectF& src, const RectF& dest)
     {
         STDRenderer::getCurrent()->setTransform(tr);
         STDRenderer::getCurrent()->draw(c, src, dest);

oxygine/src/oxygine/MaterialX.h

@@ -4,7 +4,7 @@
 
 namespace oxygine
 {
-
+    class MaterialCache;
 
 #define MATX(cl) \
     cl(){\
@@ -14,6 +14,7 @@ namespace oxygine
         init();\
     }\
     void copyFrom(const MaterialX &r) override {*this = (cl&)r;}\
+    void copyTo(cl &d) const{d = *this;}\
     cl* clone() const override {return new cl(*this);}\
     void update(size_t &hash, compare &cm) const override {\
         typedef bool (*fn)(const cl&a, const cl&b);\
@@ -44,7 +45,7 @@ namespace oxygine
         compare _compare;
 
         virtual void init() {}
-        
+
         virtual void xapply() {}
         virtual void xflush() {}
 
@@ -53,55 +54,25 @@ namespace oxygine
         virtual void update(size_t& hash, compare&) const = 0;
         virtual void rehash(size_t& hash) const = 0;
 
-        virtual void render(const AffineTransform &tr, const Color& c, const RectF& src, const RectF& dest);
+        virtual void render(const AffineTransform& tr, const Color& c, const RectF& src, const RectF& dest);
         virtual void render(const Color& c, const RectF& src, const RectF& dest);
 
         void apply();
         void flush();
 
-    };
-
-    typedef intrusive_ptr<MaterialX> spMaterialX;
-
-    template<class T>
-    class MaterialTX : public MaterialX
-    {
-    public:
-        MATX(MaterialTX<T>);
-
-        typedef bool(*fcmp)(const MaterialTX<T>& a, const MaterialTX<T>& b);
-
-        T data;
-
 
-        MaterialTX(const T& dat) : data(dat)
+        template <class T>
+        void apply2(const T& f)
         {
+            apply();
+            f();
         }
+    };
 
-        void rehash(size_t& hash) const override
-        {
-            data.init(hash);
-        }
-
-        template<class C>
-        static bool cmp(const MaterialTX<C>& a, const MaterialTX<C>& b)
-        {
-            return a.data.cmp(b.data);
-        }
-
-        void xapply() override
-        {
-            data.apply();
-        }
+    typedef intrusive_ptr<MaterialX> spMaterialX;
 
-        void xflush() override
-        {
-            data.flush();
-        }
 
-    };
 
-    /*
     class STDMaterialX: public MaterialX
     {
     public:
@@ -113,8 +84,16 @@ namespace oxygine
         UberShaderProgram* _uberShader;
         int                _flags;
 
+        static bool cmp(const STDMaterialX& a, const STDMaterialX& b);
+
+        void init() override;
+        void rehash(size_t& hash) const override;
+
+        void xapply() override;
+        void xflush() override;
     };
-    */
+
+    DECLARE_SMART(STDMaterialX, spSTDMaterialX);
 
 
 
@@ -128,27 +107,6 @@ namespace oxygine
         hash_combine(seed, rest...);
     }
 
-    class STDMatData
-    {
-    public:
-        STDMatData();
-
-        spNativeTexture    _base;
-        spNativeTexture    _alpha;
-        blend_mode         _blend;
-        UberShaderProgram* _uberShader;
-        int                _flags;
-
-        void init(size_t& hash) const;
-        void apply();
-        void flush();
-        bool cmp(const STDMatData& b) const;
-    };
-
-
-    typedef MaterialTX<STDMatData> STDMaterialX;
-
-    typedef intrusive_ptr< MaterialTX<STDMatData> > spSTDMaterialX;
 
     class MaterialCache
     {

oxygine/src/oxygine/Polygon.cpp

@@ -77,36 +77,34 @@ namespace oxygine
         if (!_verticesSize)
             return;
 
-        _mat->apply();
 
 
-        //Material::setCurrent(rs.material);
+        _mat->apply2([ = ]()
+        {
 
-        const Diffuse& df = _frame.getDiffuse();
+            STDRenderer* renderer = STDRenderer::getCurrent();
 
-        STDRenderer* renderer = STDRenderer::getCurrent();
 
-        renderer->setTexture(df.base, df.alpha, df.premultiplied);
-        renderer->setBlendMode(getBlendMode());
+            static std::vector<unsigned char> buff;
+            buff.clear();
 
-        static std::vector<unsigned char> buff;
-        buff.clear();
+            buff.reserve(_verticesSize);
+            int num = _verticesSize / _vdecl->size;
 
-        buff.reserve(_verticesSize);
-        int num = _verticesSize / _vdecl->size;
+            const unsigned char* ptr = (const unsigned char*)_verticesData;
+            for (int i = 0; i < num; ++i)
+            {
+                const Vector2* pos = (Vector2*)ptr;
+                Vector2 t = rs.transform.transform(*pos);
 
-        const unsigned char* ptr = (const unsigned char*)_verticesData;
-        for (int i = 0; i < num; ++i)
-        {
-            const Vector2* pos = (Vector2*)ptr;
-            Vector2 t = rs.transform.transform(*pos);
+                append(buff, t);
+                buff.insert(buff.end(), ptr + sizeof(t), ptr + sizeof(t) + _vdecl->size - sizeof(t));
 
-            append(buff, t);
-            buff.insert(buff.end(), ptr + sizeof(t), ptr + sizeof(t) + _vdecl->size - sizeof(t));
+                ptr += _vdecl->size;
+            }
 
-            ptr += _vdecl->size;
-        }
+            renderer->addVertices(&buff.front(), (unsigned int)buff.size());
 
-        renderer->addVertices(&buff.front(), (unsigned int) buff.size());
+        });
     }
 }

oxygine/src/oxygine/STDMaterial.cpp

@@ -189,6 +189,8 @@ namespace oxygine
 
     void STDMaterial::doRender(ColorRectSprite* sprite, const RenderState& rs)
     {
+        sprite->_mat->apply();
+
         Color color = rs.getFinalColor(sprite->getColor());
 
         sprite->_mat->render(rs.transform, color, sprite->getAnimFrame().getSrcRect(), sprite->getDestRect());

oxygine/src/oxygine/STDRenderer.cpp

@@ -38,7 +38,7 @@ namespace oxygine
 
 
 
-    
+
 
     /*
 
@@ -642,7 +642,7 @@ namespace oxygine
 
     void STDRenderer::draw(MaterialX* mat, vertexPCT2 vert[4])
     {
-#ifdef EXP_SORT
+    #ifdef EXP_SORT
         batch& b = draw(mat);
 
         b.vertices.insert(b.vertices.end(), vert, vert + 4);
@@ -650,13 +650,13 @@ namespace oxygine
         {
             b.bbox.unite(Vector2(vert[i].x, vert[i].y));
         }
-#else
+    #else
         _vertices.insert(_vertices.end(), (unsigned char*)vert, (unsigned char*)(vert + 4));
 
-#endif
+    #endif
     }
 
-#ifdef EXP_SORT
+    #ifdef EXP_SORT
 
     STDRenderer::batch& STDRenderer::draw(spMaterialX mat)
     {
@@ -708,8 +708,8 @@ namespace oxygine
             }
         }
     }
-#endif
-*/
+    #endif
+    */
     void STDRenderer::flush()
     {
 #ifdef EXP_SORT
@@ -836,23 +836,23 @@ namespace oxygine
 
     void SDFMaterial::init()
     {
-        data._flags = UberShaderProgram::SDF;
+        _flags = UberShaderProgram::SDF;
         //if (outlineOffset < offset)
-        data._flags |= UberShaderProgram::SDF_OUTLINE;
+        _flags |= UberShaderProgram::SDF_OUTLINE;
         outlineParams = Vector4(0.25f, 6.25f, 0.15f, 12.5f);
         outlineColor = Vector4(1, 1, 1, 1);
     }
 
     void SDFMaterial::rehash(size_t& hash) const
     {
-        data.init(hash);
+        STDMaterialX::rehash(hash);
         hash_combine(hash, outlineColor.x, outlineColor.y, outlineColor.z, outlineColor.w);
         hash_combine(hash, outlineParams.x, outlineParams.y, outlineParams.z, outlineParams.w);
     }
 
     bool SDFMaterial::cmp(const SDFMaterial& a, const SDFMaterial& b)
     {
-        if (!MaterialTX<STDMatData>::cmp(a, b))
+        if (!STDMaterialX::cmp(a, b))
             return false;
 
         return a.outlineColor == b.outlineColor && a.outlineParams == b.outlineParams;
@@ -867,7 +867,7 @@ namespace oxygine
 
     void SDFMaterial::render(const Color& c, const RectF& src, const RectF& dest)
     {
-        //STDRenderer::getCurrent()->draw(this, c, src, dest);
+        STDRenderer::getCurrent()->draw(c, src, dest);
     }
 
 }

oxygine/src/oxygine/STDRenderer.h

@@ -20,7 +20,7 @@ namespace oxygine
 
         static bool cmp(const SDFMaterial& a, const SDFMaterial& b);
 
-        void xapply();
+        void xapply() override;
         void render(const Color& c, const RectF& src, const RectF& dest) override;
     };
 

oxygine/src/oxygine/Sprite.cpp

@@ -225,9 +225,9 @@ namespace oxygine
 
 
         spSTDMaterialX mat = _mat->clone();
-        mat->data._base = _frame.getDiffuse().base;
-        mat->data._alpha = _frame.getDiffuse().alpha;
-        mat->data._flags = _frame.getDiffuse().premultiplied ? 0 : UberShaderProgram::ALPHA_PREMULTIPLY;
+        mat->_base = _frame.getDiffuse().base;
+        mat->_alpha = _frame.getDiffuse().alpha;
+        mat->_flags = _frame.getDiffuse().premultiplied ? 0 : UberShaderProgram::ALPHA_PREMULTIPLY;
 
         _mat = mc().cache(*mat.get());
 

oxygine/src/oxygine/VisualStyle.cpp

@@ -14,8 +14,8 @@ namespace oxygine
 
     VStyleActor::VStyleActor()
     {
-        MaterialTX<STDMatData> mat;
-        mat.data._blend = blend_premultiplied_alpha;
+        STDMaterialX mat;
+        mat._blend = blend_premultiplied_alpha;
 
         _mat = mc().cache(mat);
     }
@@ -92,7 +92,7 @@ namespace oxygine
         _vstyle.setBlendMode(mode);
 
         _mat = _mat->clone();
-        _mat->data._blend = mode;
+        _mat->_blend = mode;
         _mat = mc().cache(*_mat.get());
         matChanged();
     }

oxygine/src/oxygine/text_utils/Node.cpp

@@ -203,7 +203,7 @@ namespace oxygine
 
                         spSTDMaterialX mat = rd.mat->clone();
 
-                        mat->data._base = gl->texture;
+                        mat->_base = gl->texture;
 
 
                         s.mat = mc().cache(*mat.get());