common: code refactoring

Properly renamed internal interfaces.
No logical changes.

- Compositor -> RenderCompositor
- Surface -> RenderSurface

src/loaders/external_webp/tvgWebpLoader.cpp

@@ -134,7 +134,7 @@ bool WebpLoader::read()
 }
 
 
-Surface* WebpLoader::bitmap()
+RenderSurface* WebpLoader::bitmap()
 {
     this->done();
 

src/loaders/external_webp/tvgWebpLoader.h

@@ -36,7 +36,7 @@ public:
     bool open(const char* data, uint32_t size, const string& rpath, bool copy) override;
     bool read() override;
 
-    Surface* bitmap() override;
+    RenderSurface* bitmap() override;
 
 private:
     void run(unsigned tid) override;

src/loaders/jpg/tvgJpgLoader.cpp

@@ -125,7 +125,7 @@ bool JpgLoader::close()
 }
 
 
-Surface* JpgLoader::bitmap()
+RenderSurface* JpgLoader::bitmap()
 {
     this->done();
     return ImageLoader::bitmap();

src/loaders/jpg/tvgJpgLoader.h

@@ -46,7 +46,7 @@ public:
     bool read() override;
     bool close() override;
 
-    Surface* bitmap() override;
+    RenderSurface* bitmap() override;
 };
 
 #endif //_TVG_JPG_LOADER_H_

src/loaders/png/tvgPngLoader.cpp

@@ -140,7 +140,7 @@ bool PngLoader::read()
 }
 
 
-Surface* PngLoader::bitmap()
+RenderSurface* PngLoader::bitmap()
 {
     this->done();
     return ImageLoader::bitmap();

src/loaders/png/tvgPngLoader.h

@@ -45,7 +45,7 @@ public:
     bool open(const char* data, uint32_t size, const string& rpath, bool copy) override;
     bool read() override;
 
-    Surface* bitmap() override;
+    RenderSurface* bitmap() override;
 };
 
 #endif //_TVG_PNG_LOADER_H_

src/loaders/webp/tvgWebpLoader.cpp

@@ -149,7 +149,7 @@ bool WebpLoader::close()
 }
 
 
-Surface* WebpLoader::bitmap()
+RenderSurface* WebpLoader::bitmap()
 {
     this->done();
 

src/loaders/webp/tvgWebpLoader.h

@@ -42,7 +42,7 @@ public:
     bool read() override;
     bool close() override;
 
-    Surface* bitmap() override;
+    RenderSurface* bitmap() override;
 };
 
 #endif //_TVG_WEBP_LOADER_H_

src/renderer/gl_engine/tvgGlCommon.h

@@ -95,7 +95,7 @@ struct GlRadialGradientBlock
     alignas(16) float stopColors[4 * MAX_GRADIENT_STOPS] = {};
 };
 
-struct GlCompositor : public Compositor
+struct GlCompositor : RenderCompositor
 {
     RenderRegion bbox = {};
 

src/renderer/gl_engine/tvgGlGeometry.cpp

@@ -58,7 +58,7 @@ bool GlGeometry::tesselate(const RenderShape& rshape, RenderUpdateFlag flag)
     return true;
 }
 
-bool GlGeometry::tesselate(const Surface* image, RenderUpdateFlag flag)
+bool GlGeometry::tesselate(const RenderSurface* image, RenderUpdateFlag flag)
 {
     if (flag & RenderUpdateFlag::Image) {
         fillVertex.clear();

src/renderer/gl_engine/tvgGlGeometry.h

@@ -190,7 +190,7 @@ public:
     ~GlGeometry();
 
     bool tesselate(const RenderShape& rshape, RenderUpdateFlag flag);
-    bool tesselate(const Surface* image, RenderUpdateFlag flag);
+    bool tesselate(const RenderSurface* image, RenderUpdateFlag flag);
     void disableVertex(uint32_t location);
     bool draw(GlRenderTask* task, GlStageBuffer* gpuBuffer, RenderUpdateFlag flag);
     void updateTransform(const Matrix& m);

src/renderer/gl_engine/tvgGlRenderer.cpp

@@ -758,7 +758,7 @@ void GlRenderer::prepareCmpTask(GlRenderTask* task, const RenderRegion& vp, uint
 }
 
 
-void GlRenderer::endRenderPass(Compositor* cmp)
+void GlRenderer::endRenderPass(RenderCompositor* cmp)
 {
     auto gl_cmp = static_cast<GlCompositor*>(cmp);
     if (cmp->method != CompositeMethod::None) {
@@ -1000,7 +1000,7 @@ bool GlRenderer::postRender()
 }
 
 
-Compositor* GlRenderer::target(const RenderRegion& region, TVG_UNUSED ColorSpace cs)
+RenderCompositor* GlRenderer::target(const RenderRegion& region, TVG_UNUSED ColorSpace cs)
 {
     auto vp = region;
     if (currentPass()->isEmpty()) return nullptr;
@@ -1012,7 +1012,7 @@ Compositor* GlRenderer::target(const RenderRegion& region, TVG_UNUSED ColorSpace
 }
 
 
-bool GlRenderer::beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity)
+bool GlRenderer::beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity)
 {
     if (!cmp) return false;
 
@@ -1039,7 +1039,7 @@ bool GlRenderer::beginComposite(Compositor* cmp, CompositeMethod method, uint8_t
 }
 
 
-bool GlRenderer::endComposite(Compositor* cmp)
+bool GlRenderer::endComposite(RenderCompositor* cmp)
 {
     if (mComposeStack.empty()) return false;
     if (mComposeStack.back().get() != cmp) return false;
@@ -1062,7 +1062,7 @@ ColorSpace GlRenderer::colorSpace()
 }
 
 
-const Surface* GlRenderer::mainSurface()
+const RenderSurface* GlRenderer::mainSurface()
 {
     return &surface;
 }
@@ -1245,7 +1245,7 @@ void GlRenderer::dispose(RenderData data)
     delete sdata;
 }
 
-static GLuint _genTexture(Surface* image)
+static GLuint _genTexture(RenderSurface* image)
 {
     GLuint tex = 0;
 
@@ -1265,7 +1265,7 @@ static GLuint _genTexture(Surface* image)
 }
 
 
-RenderData GlRenderer::prepare(Surface* image, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+RenderData GlRenderer::prepare(RenderSurface* image, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     if (flags == RenderUpdateFlag::None) return data;
 

src/renderer/gl_engine/tvgGlRenderer.h

@@ -63,7 +63,7 @@ public:
     };
 
     RenderData prepare(const RenderShape& rshape, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
-    RenderData prepare(Surface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(RenderSurface* surface, 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;
@@ -74,15 +74,15 @@ public:
     bool viewport(const RenderRegion& vp) override;
     bool blend(BlendMethod method) override;
     ColorSpace colorSpace() override;
-    const Surface* mainSurface() override;
+    const RenderSurface* mainSurface() override;
 
     bool target(int32_t id, uint32_t w, uint32_t h);
     bool sync() override;
     bool clear() override;
 
-    Compositor* target(const RenderRegion& region, ColorSpace cs) override;
+    RenderCompositor* target(const RenderRegion& region, ColorSpace cs) override;
-    bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) override;
+    bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) override;
-    bool endComposite(Compositor* cmp) override;
+    bool endComposite(RenderCompositor* cmp) override;
 
     static GlRenderer* gen();
     static int init(TVG_UNUSED uint32_t threads);
@@ -106,11 +106,11 @@ private:
 
     void prepareBlitTask(GlBlitTask* task);
     void prepareCmpTask(GlRenderTask* task, const RenderRegion& vp, uint32_t cmpWidth, uint32_t cmpHeight);
-    void endRenderPass(Compositor* cmp);
+    void endRenderPass(RenderCompositor* cmp);
 
     void clearDisposes();
 
-    Surface surface;
+    RenderSurface surface;
     GLint mTargetFboId = 0;
     RenderRegion mViewport;
     //TODO: remove all unique_ptr / replace the vector with tvg::Array

src/renderer/sw_engine/tvgSwCommon.h

@@ -240,7 +240,7 @@ typedef uint8_t(*SwAlpha)(uint8_t*);                                        //bl
 
 struct SwCompositor;
 
-struct SwSurface : Surface
+struct SwSurface : RenderSurface
 {
     SwJoin  join;
     SwAlpha alphas[4];                    //Alpha:2, InvAlpha:3, Luma:4, InvLuma:5
@@ -258,7 +258,7 @@ struct SwSurface : Surface
     {
     }
 
-    SwSurface(const SwSurface* rhs) : Surface(rhs)
+    SwSurface(const SwSurface* rhs) : RenderSurface(rhs)
     {
         join = rhs->join;
         memcpy(alphas, rhs->alphas, sizeof(alphas));
@@ -268,7 +268,7 @@ struct SwSurface : Surface
      }
 };
 
-struct SwCompositor : Compositor
+struct SwCompositor : RenderCompositor
 {
     SwSurface* recoverSfc;                  //Recover surface when composition is started
     SwCompositor* recoverCmp;               //Recover compositor when composition is done
@@ -564,8 +564,8 @@ bool rasterGradientStroke(SwSurface* surface, SwShape* shape, const Fill* fdata,
 bool rasterClear(SwSurface* surface, uint32_t x, uint32_t y, uint32_t w, uint32_t h, pixel_t val = 0);
 void rasterPixel32(uint32_t *dst, uint32_t val, uint32_t offset, int32_t len);
 void rasterGrayscale8(uint8_t *dst, uint8_t val, uint32_t offset, int32_t len);
-void rasterUnpremultiply(Surface* surface);
+void rasterUnpremultiply(RenderSurface* surface);
-void rasterPremultiply(Surface* surface);
+void rasterPremultiply(RenderSurface* surface);
-bool rasterConvertCS(Surface* surface, ColorSpace to);
+bool rasterConvertCS(RenderSurface* surface, ColorSpace to);
 
 #endif /* _TVG_SW_COMMON_H_ */

src/renderer/sw_engine/tvgSwRaster.cpp

@@ -1655,7 +1655,7 @@ bool rasterClear(SwSurface* surface, uint32_t x, uint32_t y, uint32_t w, uint32_
 }
 
 
-void rasterUnpremultiply(Surface* surface)
+void rasterUnpremultiply(RenderSurface* surface)
 {
     if (surface->channelSize != sizeof(uint32_t)) return;
 
@@ -1685,7 +1685,7 @@ void rasterUnpremultiply(Surface* surface)
 }
 
 
-void rasterPremultiply(Surface* surface)
+void rasterPremultiply(RenderSurface* surface)
 {
     ScopedLock lock(surface->key);
     if (surface->premultiplied || (surface->channelSize != sizeof(uint32_t))) return;
@@ -1777,7 +1777,7 @@ bool rasterImage(SwSurface* surface, SwImage* image, const Matrix& transform, co
 }
 
 
-bool rasterConvertCS(Surface* surface, ColorSpace to)
+bool rasterConvertCS(RenderSurface* surface, ColorSpace to)
 {
     ScopedLock lock(surface->key);
     if (surface->cs == to) return true;

src/renderer/sw_engine/tvgSwRasterC.h

@@ -125,7 +125,7 @@ static bool inline cRasterTranslucentRect(SwSurface* surface, const SwBBox& regi
 }
 
 
-static bool inline cRasterABGRtoARGB(Surface* surface)
+static bool inline cRasterABGRtoARGB(RenderSurface* surface)
 {
     TVGLOG("SW_ENGINE", "Convert ColorSpace ABGR - ARGB [Size: %d x %d]", surface->w, surface->h);
 
@@ -156,7 +156,7 @@ static bool inline cRasterABGRtoARGB(Surface* surface)
 }
 
 
-static bool inline cRasterARGBtoABGR(Surface* surface)
+static bool inline cRasterARGBtoABGR(RenderSurface* surface)
 {
     //exactly same with ABGRtoARGB
     return cRasterABGRtoARGB(surface);

src/renderer/sw_engine/tvgSwRasterTexmap.h

@@ -20,6 +20,17 @@
  * SOFTWARE.
  */
 
+struct Vertex
+{
+   Point pt;
+   Point uv;
+};
+
+struct Polygon
+{
+   Vertex vertex[3];
+};
+
 struct AALine
 {
    int32_t x[2];

src/renderer/sw_engine/tvgSwRenderer.cpp

@@ -191,7 +191,7 @@ struct SwShapeTask : SwTask
 struct SwImageTask : SwTask
 {
     SwImage image;
-    Surface* source;                            //Image source
+    RenderSurface* source;                //Image source
 
     bool clip(SwRle* target) override
     {
@@ -485,7 +485,7 @@ RenderRegion SwRenderer::region(RenderData data)
 }
 
 
-bool SwRenderer::beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity)
+bool SwRenderer::beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity)
 {
     if (!cmp) return false;
     auto p = static_cast<SwCompositor*>(cmp);
@@ -523,13 +523,13 @@ bool SwRenderer::mempool(bool shared)
 }
 
 
-const Surface* SwRenderer::mainSurface()
+const RenderSurface* SwRenderer::mainSurface()
 {
     return surface;
 }
 
 
-Compositor* SwRenderer::target(const RenderRegion& region, ColorSpace cs)
+RenderCompositor* SwRenderer::target(const RenderRegion& region, ColorSpace cs)
 {
     auto x = region.x;
     auto y = region.y;
@@ -598,7 +598,7 @@ Compositor* SwRenderer::target(const RenderRegion& region, ColorSpace cs)
 }
 
 
-bool SwRenderer::endComposite(Compositor* cmp)
+bool SwRenderer::endComposite(RenderCompositor* cmp)
 {
     if (!cmp) return false;
 
@@ -677,7 +677,7 @@ void* SwRenderer::prepareCommon(SwTask* task, const Matrix& transform, const Arr
 }
 
 
-RenderData SwRenderer::prepare(Surface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+RenderData SwRenderer::prepare(RenderSurface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     //prepare task
     auto task = static_cast<SwImageTask*>(data);

src/renderer/sw_engine/tvgSwRenderer.h

@@ -37,7 +37,7 @@ class SwRenderer : public RenderMethod
 {
 public:
     RenderData prepare(const RenderShape& rshape, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
-    RenderData prepare(Surface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(RenderSurface* surface, 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;
@@ -48,16 +48,16 @@ public:
     bool viewport(const RenderRegion& vp) override;
     bool blend(BlendMethod method) override;
     ColorSpace colorSpace() override;
-    const Surface* mainSurface() override;
+    const RenderSurface* mainSurface() override;
 
     bool clear() override;
     bool sync() override;
     bool target(pixel_t* data, uint32_t stride, uint32_t w, uint32_t h, ColorSpace cs);
     bool mempool(bool shared);
 
-    Compositor* target(const RenderRegion& region, ColorSpace cs) override;
+    RenderCompositor* target(const RenderRegion& region, ColorSpace cs) override;
-    bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) override;
+    bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) override;
-    bool endComposite(Compositor* cmp) override;
+    bool endComposite(RenderCompositor* cmp) override;
     void clearCompositors();
 
     static SwRenderer* gen();

src/renderer/tvgLoadModule.h

@@ -80,14 +80,14 @@ struct ImageLoader : LoadModule
     static ColorSpace cs;                           //desired value
 
     float w = 0, h = 0;                             //default image size
-    Surface surface;
+    RenderSurface surface;
 
     ImageLoader(FileType type) : LoadModule(type) {}
 
     virtual bool animatable() { return false; }  //true if this loader supports animation.
     virtual Paint* paint() { return nullptr; }
 
-    virtual Surface* bitmap()
+    virtual RenderSurface* bitmap()
     {
         if (surface.data) return &surface;
         return nullptr;

src/renderer/tvgPaint.cpp

@@ -208,7 +208,7 @@ bool Paint::Impl::render(RenderMethod* renderer)
 {
     if (opacity == 0) return true;
 
-    Compositor* cmp = nullptr;
+    RenderCompositor* cmp = nullptr;
 
     if (compData && !(compData->target->pImpl->ctxFlag & ContextFlag::FastTrack)) {
         RenderRegion region;

src/renderer/tvgPicture.cpp

@@ -77,7 +77,7 @@ bool Picture::Impl::render(RenderMethod* renderer)
 
     if (surface) return renderer->renderImage(rd);
     else if (paint) {
-        Compositor* cmp = nullptr;
+        RenderCompositor* cmp = nullptr;
         if (needComp) {
             cmp = renderer->target(bounds(renderer), renderer->colorSpace());
             renderer->beginComposite(cmp, CompositeMethod::None, 255);

src/renderer/tvgPicture.h

@@ -60,7 +60,7 @@ struct Picture::Impl
     ImageLoader* loader = nullptr;
 
     Paint* paint = nullptr;           //vector picture uses
-    Surface* surface = nullptr;       //bitmap picture uses
+    RenderSurface* surface = nullptr; //bitmap picture uses
     RenderData rd = nullptr;          //engine data
     float w = 0, h = 0;
     Picture* picture = nullptr;

src/renderer/tvgRender.h

@@ -36,8 +36,7 @@ using pixel_t = uint32_t;
 
 enum RenderUpdateFlag : uint8_t {None = 0, Path = 1, Color = 2, Gradient = 4, Stroke = 8, Transform = 16, Image = 32, GradientStroke = 64, Blend = 128, All = 255};
 
-struct Surface;
+//TODO: Move this in public header unifying with SwCanvas::Colorspace
-
 enum ColorSpace : uint8_t
 {
     ABGR8888 = 0,      //The channels are joined in the order: alpha, blue, green, red. Colors are alpha-premultiplied.
@@ -48,7 +47,7 @@ enum ColorSpace : uint8_t
     Unsupported        //TODO: Change to the default, At the moment, we put it in the last to align with SwCanvas::Colorspace.
 };
 
-struct Surface
+struct RenderSurface
 {
     union {
         pixel_t* data = nullptr;    //system based data pointer
@@ -62,11 +61,11 @@ struct Surface
     uint8_t channelSize = 0;
     bool premultiplied = false;         //Alpha-premultiplied
 
-    Surface()
+    RenderSurface()
     {
     }
 
-    Surface(const Surface* rhs)
+    RenderSurface(const RenderSurface* rhs)
     {
         data = rhs->data;
         stride = rhs->stride;
@@ -78,21 +77,10 @@ struct Surface
     }
 };
 
-struct Compositor
+struct RenderCompositor
 {
     CompositeMethod method;
-    uint8_t        opacity;
+    uint8_t opacity;
-};
-
-struct Vertex
-{
-   Point pt;
-   Point uv;
-};
-
-struct Polygon
-{
-   Vertex vertex[3];
 };
 
 struct RenderRegion
@@ -285,7 +273,7 @@ public:
 
     virtual ~RenderMethod() {}
     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(Surface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) = 0;
+    virtual RenderData prepare(RenderSurface* surface, 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;
@@ -296,14 +284,14 @@ public:
     virtual bool viewport(const RenderRegion& vp) = 0;
     virtual bool blend(BlendMethod method) = 0;
     virtual ColorSpace colorSpace() = 0;
-    virtual const Surface* mainSurface() = 0;
+    virtual const RenderSurface* mainSurface() = 0;
 
     virtual bool clear() = 0;
     virtual bool sync() = 0;
 
-    virtual Compositor* target(const RenderRegion& region, ColorSpace cs) = 0;
+    virtual RenderCompositor* target(const RenderRegion& region, ColorSpace cs) = 0;
-    virtual bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) = 0;
+    virtual bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) = 0;
-    virtual bool endComposite(Compositor* cmp) = 0;
+    virtual bool endComposite(RenderCompositor* cmp) = 0;
 };
 
 static inline bool MASK_REGION_MERGING(CompositeMethod method)

src/renderer/tvgScene.h

@@ -117,7 +117,7 @@ struct Scene::Impl
 
     bool render(RenderMethod* renderer)
     {
-        Compositor* cmp = nullptr;
+        RenderCompositor* cmp = nullptr;
         auto ret = true;
 
         renderer->blend(scene->blend());

src/renderer/tvgShape.h

@@ -53,7 +53,7 @@ struct Shape::Impl
     {
         if (!rd) return false;
 
-        Compositor* cmp = nullptr;
+        RenderCompositor* cmp = nullptr;
 
         renderer->blend(shape->blend());
 

src/renderer/wg_engine/tvgWgCompositor.h

@@ -26,12 +26,14 @@
 #include "tvgWgRenderTarget.h"
 #include "tvgWgRenderData.h"
 
-struct WgCompose: public Compositor {
+struct WgCompose: RenderCompositor
+{
     BlendMethod blend{};
     RenderRegion aabb{};
 };
 
-class WgCompositor {
+class WgCompositor
+{
 private:
     // pipelines (external handle, do not release)
     WgPipelines* pipelines{};

src/renderer/wg_engine/tvgWgRenderData.cpp

@@ -181,7 +181,7 @@ void WgMeshDataGroup::release(WgContext& context)
 // WgImageData
 //***********************************************************************
 
-void WgImageData::update(WgContext& context, Surface* surface)
+void WgImageData::update(WgContext& context, RenderSurface* surface)
 {
     release(context);
     assert(surface);

src/renderer/wg_engine/tvgWgRenderData.h

@@ -68,7 +68,7 @@ struct WgImageData {
     WGPUTexture texture{};
     WGPUTextureView textureView{};
 
-    void update(WgContext& context, Surface* surface);
+    void update(WgContext& context, RenderSurface* surface);
     void release(WgContext& context);
 };
 

src/renderer/wg_engine/tvgWgRenderer.cpp

@@ -114,7 +114,7 @@ RenderData WgRenderer::prepare(const RenderShape& rshape, RenderData data, const
 }
 
 
-RenderData WgRenderer::prepare(Surface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
+RenderData WgRenderer::prepare(RenderSurface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags)
 {
     // get or create render data shape
     auto renderDataPicture = (WgRenderDataPicture*)data;
@@ -238,7 +238,7 @@ ColorSpace WgRenderer::colorSpace()
 }
 
 
-const Surface* WgRenderer::mainSurface()
+const RenderSurface* WgRenderer::mainSurface()
 {
     return &mTargetSurface;
 }
@@ -338,7 +338,7 @@ bool WgRenderer::target(WGPUSurface surface, uint32_t w, uint32_t h) {
 }
 
 
-Compositor* WgRenderer::target(TVG_UNUSED const RenderRegion& region, TVG_UNUSED ColorSpace cs)
+RenderCompositor* WgRenderer::target(TVG_UNUSED const RenderRegion& region, TVG_UNUSED ColorSpace cs)
 {
     mCompositorStack.push(new WgCompose);
     mCompositorStack.last()->aabb = region;
@@ -346,7 +346,7 @@ Compositor* WgRenderer::target(TVG_UNUSED const RenderRegion& region, TVG_UNUSED
 }
 
 
-bool WgRenderer::beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity)
+bool WgRenderer::beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity)
 {
     // save current composition settings
     WgCompose* compose = (WgCompose *)cmp;
@@ -364,7 +364,7 @@ bool WgRenderer::beginComposite(Compositor* cmp, CompositeMethod method, uint8_t
 }
 
 
-bool WgRenderer::endComposite(Compositor* cmp)
+bool WgRenderer::endComposite(RenderCompositor* cmp)
 {
     // get current composition settings
     WgCompose* comp = (WgCompose *)cmp;

src/renderer/wg_engine/tvgWgRenderer.h

@@ -29,7 +29,7 @@ class WgRenderer : public RenderMethod
 {
 public:
     RenderData prepare(const RenderShape& rshape, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags, bool clipper) override;
-    RenderData prepare(Surface* surface, RenderData data, const Matrix& transform, Array<RenderData>& clips, uint8_t opacity, RenderUpdateFlag flags) override;
+    RenderData prepare(RenderSurface* surface, 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;
@@ -40,7 +40,7 @@ public:
     bool viewport(const RenderRegion& vp) override;
     bool blend(BlendMethod method) override;
     ColorSpace colorSpace() override;
-    const Surface* mainSurface() override;
+    const RenderSurface* mainSurface() override;
 
     bool clear() override;
     bool sync() override;
@@ -48,9 +48,9 @@ public:
     bool target(WGPUInstance instance, WGPUSurface surface, uint32_t w, uint32_t h, WGPUDevice device);
     bool target(WGPUSurface surface, uint32_t w, uint32_t h);
 
-    Compositor* target(const RenderRegion& region, ColorSpace cs) override;
+    RenderCompositor* target(const RenderRegion& region, ColorSpace cs) override;
-    bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) override;
+    bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) override;
-    bool endComposite(Compositor* cmp) override;
+    bool endComposite(RenderCompositor* cmp) override;
 
     static WgRenderer* gen();
     static bool init(uint32_t threads);
@@ -78,7 +78,7 @@ private:
     WgPipelines mPipelines;
     WgCompositor mCompositor;
 
-    Surface mTargetSurface;
+    RenderSurface mTargetSurface;
     BlendMethod mBlendMethod{};
     RenderRegion mViewport{};