diff --git a/src/common/tvgMath.cpp b/src/common/tvgMath.cpp
index d22232ee..d2936723 100644
--- a/src/common/tvgMath.cpp
+++ b/src/common/tvgMath.cpp
@@ -37,6 +37,17 @@ float mathAtan2(float y, float x)
 }
 
 
+Matrix mathMultiply(const Matrix* lhs, const Matrix* rhs)
+{
+    Matrix out;
+    if (lhs && rhs) out = *lhs * *rhs;
+    else if (lhs) out = *lhs;
+    else if (rhs) out = *rhs;
+    else mathIdentity(&out);
+    return out;
+}
+
+
 bool mathInverse(const Matrix* m, Matrix* out)
 {
     auto det = m->e11 * (m->e22 * m->e33 - m->e32 * m->e23) -
diff --git a/src/common/tvgMath.h b/src/common/tvgMath.h
index 668260c6..4f74a65f 100644
--- a/src/common/tvgMath.h
+++ b/src/common/tvgMath.h
@@ -75,6 +75,7 @@ static inline bool mathEqual(float a, float b)
 void mathRotate(Matrix* m, float degree);
 bool mathInverse(const Matrix* m, Matrix* out);
 bool mathIdentity(const Matrix* m);
+Matrix mathMultiply(const Matrix* lhs, const Matrix* rhs);
 Matrix operator*(const Matrix& lhs, const Matrix& rhs);
 bool operator==(const Matrix& lhs, const Matrix& rhs);
 
diff --git a/src/renderer/gl_engine/tvgGlGeometry.cpp b/src/renderer/gl_engine/tvgGlGeometry.cpp
index fc6d1a09..81733017 100644
--- a/src/renderer/gl_engine/tvgGlGeometry.cpp
+++ b/src/renderer/gl_engine/tvgGlGeometry.cpp
@@ -215,13 +215,10 @@ bool GlGeometry::draw(GlRenderTask* task, GlStageBuffer* gpuBuffer, RenderUpdate
 }
 
 
-void GlGeometry::updateTransform(const RenderTransform* transform)
+void GlGeometry::updateTransform(const Matrix* m)
 {
-    if (transform) {
-        mMatrix = transform->m;
-    } else {
-        mMatrix = Matrix{1, 0, 0, 0, 1, 0, 0, 0, 1};
-    }
+    if (m) mMatrix = *m;
+    else mathIdentity(&mMatrix);
 }
 
 void GlGeometry::setViewport(const RenderRegion& viewport)
diff --git a/src/renderer/gl_engine/tvgGlGeometry.h b/src/renderer/gl_engine/tvgGlGeometry.h
index 97fee915..a04e175a 100644
--- a/src/renderer/gl_engine/tvgGlGeometry.h
+++ b/src/renderer/gl_engine/tvgGlGeometry.h
@@ -193,7 +193,7 @@ public:
     bool tesselate(const Surface* image, const RenderMesh* mesh, RenderUpdateFlag flag);
     void disableVertex(uint32_t location);
     bool draw(GlRenderTask* task, GlStageBuffer* gpuBuffer, RenderUpdateFlag flag);
-    void updateTransform(const RenderTransform* transform);
+    void updateTransform(const Matrix* m);
     void setViewport(const RenderRegion& viewport);
     const RenderRegion& getViewport();
     const Matrix& getTransformMatrix();
diff --git a/src/renderer/gl_engine/tvgGlRenderer.cpp b/src/renderer/gl_engine/tvgGlRenderer.cpp
index a7c39ecc..cd5e4612 100644
--- a/src/renderer/gl_engine/tvgGlRenderer.cpp
+++ b/src/renderer/gl_engine/tvgGlRenderer.cpp
@@ -417,7 +417,7 @@ static GLuint _genTexture(Surface* image)
     return tex;
 }
 
-RenderData GlRenderer::prepare(Surface* image, const RenderMesh* mesh, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+RenderData GlRenderer::prepare(Surface* image, const RenderMesh* mesh, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     if (flags == RenderUpdateFlag::None) return data;
 
@@ -448,14 +448,14 @@ RenderData GlRenderer::prepare(Surface* image, const RenderMesh* mesh, RenderDat
 }
 
 
-RenderData GlRenderer::prepare(TVG_UNUSED const Array<RenderData>& scene, TVG_UNUSED RenderData data, TVG_UNUSED const RenderTransform* transform, TVG_UNUSED Array<RenderData>& clips, TVG_UNUSED uint8_t opacity, TVG_UNUSED RenderUpdateFlag flags)
+RenderData GlRenderer::prepare(TVG_UNUSED const Array<RenderData>& scene, TVG_UNUSED RenderData data, TVG_UNUSED const Matrix* transform, TVG_UNUSED Array<RenderData>& clips, TVG_UNUSED uint8_t opacity, TVG_UNUSED RenderUpdateFlag flags)
 {
     //TODO:
     return nullptr;
 }
 
 
-RenderData GlRenderer::prepare(const RenderShape& rshape, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper)
+RenderData GlRenderer::prepare(const RenderShape& rshape, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper)
 {
     // If prepare for clip, only path is meaningful.
     if (clipper) flags = RenderUpdateFlag::Path;
@@ -1238,4 +1238,4 @@ void GlRenderer::endRenderPass(Compositor* cmp)
         task->setParentSize(static_cast<uint32_t>(currentPass()->getViewport().w), static_cast<uint32_t>(currentPass()->getViewport().h));
         currentPass()->addRenderTask(std::move(task));
     }
-}
+}
\ No newline at end of file
diff --git a/src/renderer/gl_engine/tvgGlRenderer.h b/src/renderer/gl_engine/tvgGlRenderer.h
index 11823cf8..de3f27f3 100644
--- a/src/renderer/gl_engine/tvgGlRenderer.h
+++ b/src/renderer/gl_engine/tvgGlRenderer.h
@@ -53,9 +53,9 @@ public:
         RT_None,
     };
 
-    RenderData prepare(const RenderShape& rshape, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
-    RenderData prepare(const Array<RenderData>& scene, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
-    RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(const RenderShape& rshape, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
+    RenderData prepare(const Array<RenderData>& scene, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
     bool preRender() override;
     bool renderShape(RenderData data) override;
     bool renderImage(RenderData data) override;
diff --git a/src/renderer/sw_engine/tvgSwRenderer.cpp b/src/renderer/sw_engine/tvgSwRenderer.cpp
index 350f3334..327e59ce 100644
--- a/src/renderer/sw_engine/tvgSwRenderer.cpp
+++ b/src/renderer/sw_engine/tvgSwRenderer.cpp
@@ -714,7 +714,7 @@ void SwRenderer::dispose(RenderData data)
 }
 
 
-void* SwRenderer::prepareCommon(SwTask* task, const RenderTransform* transform, const Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+void* SwRenderer::prepareCommon(SwTask* task, const Matrix* transform, const Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     if (!surface) return task;
     if (flags == RenderUpdateFlag::None) return task;
@@ -730,7 +730,7 @@ void* SwRenderer::prepareCommon(SwTask* task, const RenderTransform* transform,
 
     if (transform) {
         if (!task->transform) task->transform = static_cast<Matrix*>(malloc(sizeof(Matrix)));
-        *task->transform = transform->m;
+        *task->transform = *transform;
     } else {
         if (task->transform) free(task->transform);
         task->transform = nullptr;
@@ -762,7 +762,7 @@ void* SwRenderer::prepareCommon(SwTask* task, const RenderTransform* transform,
 }
 
 
-RenderData SwRenderer::prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+RenderData SwRenderer::prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     //prepare task
     auto task = static_cast<SwImageTask*>(data);
@@ -776,7 +776,7 @@ RenderData SwRenderer::prepare(Surface* surface, const RenderMesh* mesh, RenderD
 }
 
 
-RenderData SwRenderer::prepare(const Array<RenderData>& scene, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+RenderData SwRenderer::prepare(const Array<RenderData>& scene, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     //prepare task
     auto task = static_cast<SwSceneTask*>(data);
@@ -796,7 +796,7 @@ RenderData SwRenderer::prepare(const Array<RenderData>& scene, RenderData data,
 }
 
 
-RenderData SwRenderer::prepare(const RenderShape& rshape, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper)
+RenderData SwRenderer::prepare(const RenderShape& rshape, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper)
 {
     //prepare task
     auto task = static_cast<SwShapeTask*>(data);
diff --git a/src/renderer/sw_engine/tvgSwRenderer.h b/src/renderer/sw_engine/tvgSwRenderer.h
index 57be5589..d101527d 100644
--- a/src/renderer/sw_engine/tvgSwRenderer.h
+++ b/src/renderer/sw_engine/tvgSwRenderer.h
@@ -36,9 +36,9 @@ namespace tvg
 class SwRenderer : public RenderMethod
 {
 public:
-    RenderData prepare(const RenderShape& rshape, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
-    RenderData prepare(const Array<RenderData>& scene, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
-    RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(const RenderShape& rshape, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
+    RenderData prepare(const Array<RenderData>& scene, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
     bool preRender() override;
     bool renderShape(RenderData data) override;
     bool renderImage(RenderData data) override;
@@ -77,7 +77,7 @@ private:
     SwRenderer();
     ~SwRenderer();
 
-    RenderData prepareCommon(SwTask* task, const RenderTransform* transform, const Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags);
+    RenderData prepareCommon(SwTask* task, const Matrix* transform, const Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags);
 };
 
 }
diff --git a/src/renderer/tvgPaint.cpp b/src/renderer/tvgPaint.cpp
index 45f0d77c..8016c5e8 100644
--- a/src/renderer/tvgPaint.cpp
+++ b/src/renderer/tvgPaint.cpp
@@ -41,7 +41,7 @@
     }
 
 
-static Result _clipRect(RenderMethod* renderer, const Point* pts, const RenderTransform* pTransform, RenderTransform* rTransform, RenderRegion& before)
+static Result _clipRect(RenderMethod* renderer, const Point* pts, const Matrix* pm, const Matrix* rm, RenderRegion& before)
 {
     //sorting
     Point tmp[4];
@@ -50,8 +50,8 @@ static Result _clipRect(RenderMethod* renderer, const Point* pts, const RenderTr
 
     for (int i = 0; i < 4; ++i) {
         tmp[i] = pts[i];
-        if (rTransform) tmp[i] *= rTransform->m;
-        if (pTransform) tmp[i] *= pTransform->m;
+        if (rm) tmp[i] *= *rm;
+        if (pm) tmp[i] *= *pm;
         if (tmp[i].x < min.x) min.x = tmp[i].x;
         if (tmp[i].x > max.x) max.x = tmp[i].x;
         if (tmp[i].y < min.y) min.y = tmp[i].y;
@@ -73,7 +73,7 @@ static Result _clipRect(RenderMethod* renderer, const Point* pts, const RenderTr
 }
 
 
-static Result _compFastTrack(RenderMethod* renderer, Paint* cmpTarget, const RenderTransform* pTransform, RenderTransform* rTransform, RenderRegion& before)
+static Result _compFastTrack(RenderMethod* renderer, Paint* cmpTarget, const Matrix* pm, RenderRegion& before)
 {
     /* Access Shape class by Paint is bad... but it's ok still it's an internal usage. */
     auto shape = static_cast<Shape*>(cmpTarget);
@@ -84,18 +84,22 @@ static Result _compFastTrack(RenderMethod* renderer, Paint* cmpTarget, const Ren
 
     //nothing to clip
     if (ptsCnt == 0) return Result::InvalidArguments;
-
     if (ptsCnt != 4) return Result::InsufficientCondition;
 
-    if (rTransform && (cmpTarget->pImpl->renderFlag & RenderUpdateFlag::Transform)) rTransform->update();
+    Matrix* rm = nullptr;
+
+    if (P(cmpTarget)->rTransform && (P(cmpTarget)->renderFlag & RenderUpdateFlag::Transform)) {
+        P(cmpTarget)->rTransform->update();
+        rm = &P(cmpTarget)->rTransform->m;
+    }
 
     //No rotation and no skewing, still can try out clipping the rect region.
     auto tryClip = false;
 
-    if (pTransform && (!mathRightAngle(&pTransform->m) || mathSkewed(&pTransform->m))) tryClip = true;
-    if (rTransform && (!mathRightAngle(&rTransform->m) || mathSkewed(&rTransform->m))) tryClip = true;
+    if (pm && (!mathRightAngle(pm) || mathSkewed(pm))) tryClip = true;
+    if (rm && (!mathRightAngle(rm) || mathSkewed(rm))) tryClip = true;
 
-    if (tryClip) return _clipRect(renderer, pts, pTransform, rTransform, before);
+    if (tryClip) return _clipRect(renderer, pts, pm, rm, before);
 
     //Perpendicular Rectangle?
     auto pt1 = pts + 0;
@@ -111,14 +115,14 @@ static Result _compFastTrack(RenderMethod* renderer, Paint* cmpTarget, const Ren
         auto v1 = *pt1;
         auto v2 = *pt3;
 
-        if (rTransform) {
-            v1 *= rTransform->m;
-            v2 *= rTransform->m;
+        if (rm) {
+            v1 *= *rm;
+            v2 *= *rm;
         }
 
-        if (pTransform) {
-            v1 *= pTransform->m;
-            v2 *= pTransform->m;
+        if (pm) {
+            v1 *= *pm;
+            v2 *= *pm;
         }
 
         //sorting
@@ -266,7 +270,7 @@ bool Paint::Impl::render(RenderMethod* renderer)
 }
 
 
-RenderData Paint::Impl::update(RenderMethod* renderer, const RenderTransform* pTransform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
+RenderData Paint::Impl::update(RenderMethod* renderer, const Matrix* pm, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
 {
     if (this->renderer != renderer) {
         if (this->renderer) TVGERR("RENDERER", "paint's renderer has been changed!");
@@ -285,7 +289,7 @@ RenderData Paint::Impl::update(RenderMethod* renderer, const RenderTransform* pT
     if (compData) {
         auto target = compData->target;
         auto method = compData->method;
-        target->pImpl->ctxFlag &= ~ContextFlag::FastTrack;   //reset
+        P(target)->ctxFlag &= ~ContextFlag::FastTrack;   //reset
 
         /* If the transformation has no rotational factors and the ClipPath/Alpha(InvAlpha)Masking involves a simple rectangle,
            we can optimize by using the viewport instead of the regular ClipPath/AlphaMasking sequence for improved performance. */
@@ -304,14 +308,14 @@ RenderData Paint::Impl::update(RenderMethod* renderer, const RenderTransform* pT
             }
             if (tryFastTrack) {
                 viewport = renderer->viewport();
-                if ((compFastTrack = _compFastTrack(renderer, target, pTransform, target->pImpl->rTransform, viewport)) == Result::Success) {
-                    target->pImpl->ctxFlag |= ContextFlag::FastTrack;
+                if ((compFastTrack = _compFastTrack(renderer, target, pm, viewport)) == Result::Success) {
+                    P(target)->ctxFlag |= ContextFlag::FastTrack;
                 }
             }
         }
         if (compFastTrack == Result::InsufficientCondition) {
             childClipper = compData->method == CompositeMethod::ClipPath ? true : false;
-            trd = target->pImpl->update(renderer, pTransform, clips, 255, pFlag, childClipper);
+            trd = P(target)->update(renderer, pm, clips, 255, pFlag, childClipper);
             if (childClipper) clips.push(trd);
         }
     }
@@ -322,8 +326,8 @@ RenderData Paint::Impl::update(RenderMethod* renderer, const RenderTransform* pT
     opacity = MULTIPLY(opacity, this->opacity);
 
     RenderData rd = nullptr;
-    RenderTransform outTransform(pTransform, rTransform);
-    PAINT_METHOD(rd, update(renderer, &outTransform, clips, opacity, newFlag, clipper));
+    Matrix om = mathMultiply(pm, rTransform ? &rTransform->m : nullptr);
+    PAINT_METHOD(rd, update(renderer, &om, clips, opacity, newFlag, clipper));
 
     /* 3. Composition Post Processing */
     if (compFastTrack == Result::Success) renderer->viewport(viewport);
diff --git a/src/renderer/tvgPaint.h b/src/renderer/tvgPaint.h
index 67d1f81b..129743e7 100644
--- a/src/renderer/tvgPaint.h
+++ b/src/renderer/tvgPaint.h
@@ -136,7 +136,7 @@ namespace tvg
         bool scale(float factor);
         bool translate(float x, float y);
         bool bounds(float* x, float* y, float* w, float* h, bool transformed, bool stroking);
-        RenderData update(RenderMethod* renderer, const RenderTransform* pTransform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper = false);
+        RenderData update(RenderMethod* renderer, const Matrix* pm, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper = false);
         bool render(RenderMethod* renderer);
         Paint* duplicate(Paint* ret = nullptr);
     };
diff --git a/src/renderer/tvgPicture.cpp b/src/renderer/tvgPicture.cpp
index 5bd55a3f..c94c0727 100644
--- a/src/renderer/tvgPicture.cpp
+++ b/src/renderer/tvgPicture.cpp
@@ -104,18 +104,17 @@ RenderRegion Picture::Impl::bounds(RenderMethod* renderer)
 }
 
 
-RenderTransform Picture::Impl::resizeTransform(const RenderTransform* pTransform)
+Matrix Picture::Impl::resizeTransform(const Matrix* pm)
 {
     //Overriding Transformation by the desired image size
     auto sx = w / loader->w;
     auto sy = h / loader->h;
     auto scale = sx < sy ? sx : sy;
 
-    RenderTransform tmp;
-    tmp.m = {scale, 0, 0, 0, scale, 0, 0, 0, 1};
+    auto tmp = Matrix{scale, 0, 0, 0, scale, 0, 0, 0, 1};
 
-    if (!pTransform) return tmp;
-    else return RenderTransform(pTransform, &tmp);
+    if (!pm) return tmp;
+    return *pm * tmp;
 }
 
 
diff --git a/src/renderer/tvgPicture.h b/src/renderer/tvgPicture.h
index d751fcf2..bad508a0 100644
--- a/src/renderer/tvgPicture.h
+++ b/src/renderer/tvgPicture.h
@@ -68,7 +68,7 @@ struct Picture::Impl
     bool resizing = false;
     bool needComp = false;            //need composition
 
-    RenderTransform resizeTransform(const RenderTransform* pTransform);
+    Matrix resizeTransform(const Matrix* m);
     bool needComposition(uint8_t opacity);
     bool render(RenderMethod* renderer);
     bool size(float w, float h);
@@ -90,21 +90,21 @@ struct Picture::Impl
         delete(paint);
     }
 
-    RenderData update(RenderMethod* renderer, const RenderTransform* pTransform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
+    RenderData update(RenderMethod* renderer, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
     {
         auto flag = static_cast<RenderUpdateFlag>(pFlag | load());
 
         if (surface) {
             if (flag == RenderUpdateFlag::None) return rd;
-            auto transform = resizeTransform(pTransform);
-            rd = renderer->prepare(surface, &rm, rd, &transform, clips, opacity, flag);
+            auto om = resizeTransform(transform);
+            rd = renderer->prepare(surface, &rm, rd, &om, clips, opacity, flag);
         } else if (paint) {
             if (resizing) {
                 loader->resize(paint, w, h);
                 resizing = false;
             }
             needComp = needComposition(opacity) ? true : false;
-            rd = paint->pImpl->update(renderer, pTransform, clips, opacity, flag, clipper);
+            rd = paint->pImpl->update(renderer, transform, clips, opacity, flag, clipper);
         }
         return rd;
     }
diff --git a/src/renderer/tvgRender.cpp b/src/renderer/tvgRender.cpp
index 6ecaf77b..7283ed06 100644
--- a/src/renderer/tvgRender.cpp
+++ b/src/renderer/tvgRender.cpp
@@ -72,15 +72,6 @@ void RenderTransform::update()
 }
 
 
-RenderTransform::RenderTransform(const RenderTransform* lhs, const RenderTransform* rhs)
-{
-    if (lhs && rhs) m = lhs->m * rhs->m;
-    else if (lhs) m = lhs->m;
-    else if (rhs) m = rhs->m;
-    else mathIdentity(&m);
-}
-
-
 void RenderRegion::intersect(const RenderRegion& rhs)
 {
     auto x1 = x + w;
diff --git a/src/renderer/tvgRender.h b/src/renderer/tvgRender.h
index 0919d90e..08192dbf 100644
--- a/src/renderer/tvgRender.h
+++ b/src/renderer/tvgRender.h
@@ -124,8 +124,6 @@ struct RenderTransform
     {
         m.e13 = m.e23 = 0.0f;
     }
-
-    RenderTransform(const RenderTransform* lhs, const RenderTransform* rhs);
 };
 
 struct RenderStroke
@@ -277,9 +275,9 @@ public:
     uint32_t unref();
 
     virtual ~RenderMethod() {}
-    virtual RenderData prepare(const RenderShape& rshape, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) = 0;
-    virtual RenderData prepare(const Array<RenderData>& scene, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) = 0;
-    virtual RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) = 0;
+    virtual RenderData prepare(const RenderShape& rshape, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) = 0;
+    virtual RenderData prepare(const Array<RenderData>& scene, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) = 0;
+    virtual RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) = 0;
     virtual bool preRender() = 0;
     virtual bool renderShape(RenderData data) = 0;
     virtual bool renderImage(RenderData data) = 0;
diff --git a/src/renderer/tvgScene.h b/src/renderer/tvgScene.h
index 13924964..9e06c856 100644
--- a/src/renderer/tvgScene.h
+++ b/src/renderer/tvgScene.h
@@ -101,7 +101,7 @@ struct Scene::Impl
         return true;
     }
 
-    RenderData update(RenderMethod* renderer, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flag, bool clipper)
+    RenderData update(RenderMethod* renderer, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flag, bool clipper)
     {
         if ((needComp = needComposition(opacity))) {
             /* Overriding opacity value. If this scene is half-translucent,
diff --git a/src/renderer/tvgShape.h b/src/renderer/tvgShape.h
index fa2a186c..80b9399a 100644
--- a/src/renderer/tvgShape.h
+++ b/src/renderer/tvgShape.h
@@ -96,7 +96,7 @@ struct Shape::Impl
         return true;
     }
 
-    RenderData update(RenderMethod* renderer, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
+    RenderData update(RenderMethod* renderer, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
     {
         if (static_cast<RenderUpdateFlag>(pFlag | flag) == RenderUpdateFlag::None) return rd;
 
diff --git a/src/renderer/tvgText.h b/src/renderer/tvgText.h
index 04b038a1..c9864c7e 100644
--- a/src/renderer/tvgText.h
+++ b/src/renderer/tvgText.h
@@ -120,7 +120,7 @@ struct Text::Impl
         return false;
     }
 
-    RenderData update(RenderMethod* renderer, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
+    RenderData update(RenderMethod* renderer, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag pFlag, bool clipper)
     {
         if (!load()) return nullptr;
 
diff --git a/src/renderer/wg_engine/tvgWgRenderData.cpp b/src/renderer/wg_engine/tvgWgRenderData.cpp
index 2a1eee79..7aca1b45 100644
--- a/src/renderer/wg_engine/tvgWgRenderData.cpp
+++ b/src/renderer/wg_engine/tvgWgRenderData.cpp
@@ -277,7 +277,7 @@ void WgRenderDataShape::updateBBox(WgPoint pmin, WgPoint pmax)
 }
 
 
-void WgRenderDataShape::updateMeshes(WgContext &context, const RenderShape &rshape, const RenderTransform* rt)
+void WgRenderDataShape::updateMeshes(WgContext &context, const RenderShape &rshape, const Matrix* rt)
 {
     releaseMeshes(context);
     strokeFirst = rshape.stroke ? rshape.stroke->strokeFirst : false;
@@ -301,10 +301,10 @@ void WgRenderDataShape::updateMeshes(WgContext &context, const RenderShape &rsha
             polyline.close();
         } else if (cmd == PathCommand::CubicTo) {
             assert(polyline.pts.count > 0);
-            WgPoint pt0 = polyline.pts.last().trans(rt->m);
-            WgPoint pt1 = WgPoint(rshape.path.pts[pntIndex + 0]).trans(rt->m);
-            WgPoint pt2 = WgPoint(rshape.path.pts[pntIndex + 1]).trans(rt->m);
-            WgPoint pt3 = WgPoint(rshape.path.pts[pntIndex + 2]).trans(rt->m);
+            WgPoint pt0 = polyline.pts.last().trans(*rt);
+            WgPoint pt1 = WgPoint(rshape.path.pts[pntIndex + 0]).trans(*rt);
+            WgPoint pt2 = WgPoint(rshape.path.pts[pntIndex + 1]).trans(*rt);
+            WgPoint pt3 = WgPoint(rshape.path.pts[pntIndex + 2]).trans(*rt);
             uint32_t nsegs = (uint32_t)(pt0.dist(pt1) + pt1.dist(pt2) + pt2.dist(pt3));
             polyline.appendCubic(
                 rshape.path.pts[pntIndex + 0],
diff --git a/src/renderer/wg_engine/tvgWgRenderData.h b/src/renderer/wg_engine/tvgWgRenderData.h
index 4d509854..9efe3e17 100644
--- a/src/renderer/wg_engine/tvgWgRenderData.h
+++ b/src/renderer/wg_engine/tvgWgRenderData.h
@@ -108,7 +108,7 @@ struct WgRenderDataShape: public WgRenderDataPaint
     FillRule fillRule{};
 
     void updateBBox(WgPoint pmin, WgPoint pmax);
-    void updateMeshes(WgContext& context, const RenderShape& rshape, const RenderTransform* rt);
+    void updateMeshes(WgContext& context, const RenderShape& rshape, const Matrix* rt);
     void updateMeshes(WgContext& context, const WgPolyline* polyline, const RenderStroke* rstroke);
     void releaseMeshes(WgContext& context);
     void release(WgContext& context) override;
diff --git a/src/renderer/wg_engine/tvgWgRenderer.cpp b/src/renderer/wg_engine/tvgWgRenderer.cpp
index 2fa0ffa5..3c9a245e 100644
--- a/src/renderer/wg_engine/tvgWgRenderer.cpp
+++ b/src/renderer/wg_engine/tvgWgRenderer.cpp
@@ -68,7 +68,7 @@ void WgRenderer::release()
 }
 
 
-RenderData WgRenderer::prepare(const RenderShape& rshape, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper)
+RenderData WgRenderer::prepare(const RenderShape& rshape, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper)
 {
     // get or create render data shape
     auto renderDataShape = (WgRenderDataShape*)data;
@@ -98,13 +98,13 @@ RenderData WgRenderer::prepare(const RenderShape& rshape, RenderData data, const
 }
 
 
-RenderData WgRenderer::prepare(TVG_UNUSED const Array<RenderData>& scene, TVG_UNUSED RenderData data, TVG_UNUSED const RenderTransform* transform, TVG_UNUSED Array<RenderData>& clips, TVG_UNUSED uint8_t opacity, TVG_UNUSED RenderUpdateFlag flags)
+RenderData WgRenderer::prepare(TVG_UNUSED const Array<RenderData>& scene, TVG_UNUSED RenderData data, TVG_UNUSED const Matrix* transform, TVG_UNUSED Array<RenderData>& clips, TVG_UNUSED uint8_t opacity, TVG_UNUSED RenderUpdateFlag flags)
 {
     return nullptr;
 }
 
 
-RenderData WgRenderer::prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+RenderData WgRenderer::prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     // get or create render data shape
     auto renderDataPicture = (WgRenderDataPicture*)data;
diff --git a/src/renderer/wg_engine/tvgWgRenderer.h b/src/renderer/wg_engine/tvgWgRenderer.h
index 9757bbe7..38b98496 100644
--- a/src/renderer/wg_engine/tvgWgRenderer.h
+++ b/src/renderer/wg_engine/tvgWgRenderer.h
@@ -33,9 +33,9 @@ private:
     void initialize();
     void release();
 public:
-    RenderData prepare(const RenderShape& rshape, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
-    RenderData prepare(const Array<RenderData>& scene, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
-    RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const RenderTransform* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(const RenderShape& rshape, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
+    RenderData prepare(const Array<RenderData>& scene, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(Surface* surface, const RenderMesh* mesh, RenderData data, const Matrix* transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
     bool preRender() override;
     bool renderShape(RenderData data) override;
     bool renderImage(RenderData data) override;
diff --git a/src/renderer/wg_engine/tvgWgShaderTypes.cpp b/src/renderer/wg_engine/tvgWgShaderTypes.cpp
index 0a14f782..da7ba05a 100644
--- a/src/renderer/wg_engine/tvgWgShaderTypes.cpp
+++ b/src/renderer/wg_engine/tvgWgShaderTypes.cpp
@@ -32,7 +32,7 @@ WgShaderTypeMat4x4f::WgShaderTypeMat4x4f()
 }
 
 
-WgShaderTypeMat4x4f::WgShaderTypeMat4x4f(const RenderTransform* transform)
+WgShaderTypeMat4x4f::WgShaderTypeMat4x4f(const Matrix* transform)
 {
     update(transform);
 }
@@ -53,26 +53,26 @@ WgShaderTypeMat4x4f::WgShaderTypeMat4x4f(size_t w, size_t h)
 }
 
 
-void WgShaderTypeMat4x4f::update(const RenderTransform* transform)
+void WgShaderTypeMat4x4f::update(const Matrix* transform)
 {
     identity();
     if (transform) {
-        mat[0]  = transform->m.e11;
-        mat[1]  = transform->m.e21;
+        mat[0]  = transform->e11;
+        mat[1]  = transform->e21;
         mat[2]  = 0.0f;
-        mat[3]  = transform->m.e31;
-        mat[4]  = transform->m.e12;
-        mat[5]  = transform->m.e22;
+        mat[3]  = transform->e31;
+        mat[4]  = transform->e12;
+        mat[5]  = transform->e22;
         mat[6]  = 0.0f;
-        mat[7]  = transform->m.e32;
+        mat[7]  = transform->e32;
         mat[8]  = 0.0f;
         mat[9]  = 0.0f;
         mat[10] = 1.0f;
         mat[11] = 0.0f;
-        mat[12] = transform->m.e13;
-        mat[13] = transform->m.e23;
+        mat[12] = transform->e13;
+        mat[13] = transform->e23;
         mat[14] = 0.0f;
-        mat[15] = transform->m.e33;
+        mat[15] = transform->e33;
     };
 }
 
diff --git a/src/renderer/wg_engine/tvgWgShaderTypes.h b/src/renderer/wg_engine/tvgWgShaderTypes.h
index cf28861c..1b363439 100644
--- a/src/renderer/wg_engine/tvgWgShaderTypes.h
+++ b/src/renderer/wg_engine/tvgWgShaderTypes.h
@@ -35,10 +35,10 @@ struct WgShaderTypeMat4x4f
     float mat[16]{};
 
     WgShaderTypeMat4x4f();
-    WgShaderTypeMat4x4f(const RenderTransform* transform);
+    WgShaderTypeMat4x4f(const Matrix* transform);
     WgShaderTypeMat4x4f(size_t w, size_t h);
     void identity();
-    void update(const RenderTransform* transform);
+    void update(const Matrix* transform);
     void update(size_t w, size_t h);
 };