git_clone/thorvg
1
0
Fork 0
mirror of https://github.com/thorvg/thorvg.git synced 2025-06-08 05:33:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

common: code refactoring

Browse source 
Properly renamed internal interfaces.
No logical changes.

- Compositor -> RenderCompositor
- Surface -> RenderSurface
This commit is contained in:
Hermet Park 2024-09-21 16:18:00 +09:00 • committed by Hermet Park
parent 853d701d27
commit 0e2d1dfcfa
31 changed files with 93 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/loaders/external_webp/tvgWebpLoader.cpp
View file

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

2
src/loaders/external_webp/tvgWebpLoader.h
View file

@ -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;

2
src/loaders/jpg/tvgJpgLoader.cpp
View file

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

2
src/loaders/jpg/tvgJpgLoader.h
View file

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

2
src/loaders/png/tvgPngLoader.cpp
View file

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

2
src/loaders/png/tvgPngLoader.h
View file

@ -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_

2
src/loaders/webp/tvgWebpLoader.cpp
View file

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

2
src/loaders/webp/tvgWebpLoader.h
View file

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

2
src/renderer/gl_engine/tvgGlCommon.h
View file

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

2
src/renderer/gl_engine/tvgGlGeometry.cpp
View file

@ -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();

2
src/renderer/gl_engine/tvgGlGeometry.h
View file

@ -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);

14
src/renderer/gl_engine/tvgGlRenderer.cpp
View file

@ -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;

14
src/renderer/gl_engine/tvgGlRenderer.h
View file

@ -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;
bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) override;
bool endComposite(Compositor* cmp) override;
RenderCompositor* target(const RenderRegion& region, ColorSpace cs) override;
bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) 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

12
src/renderer/sw_engine/tvgSwCommon.h
View file

@ -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 rasterPremultiply(Surface* surface);
bool rasterConvertCS(Surface* surface, ColorSpace to);
void rasterUnpremultiply(RenderSurface* surface);
void rasterPremultiply(RenderSurface* surface);
bool rasterConvertCS(RenderSurface* surface, ColorSpace to);
#endif /* _TVG_SW_COMMON_H_ */

6
src/renderer/sw_engine/tvgSwRaster.cpp
View file

@ -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;

4
src/renderer/sw_engine/tvgSwRasterC.h
View file

@ -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);

11
src/renderer/sw_engine/tvgSwRasterTexmap.h
View file

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

12
src/renderer/sw_engine/tvgSwRenderer.cpp
View file

@ -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);

10
src/renderer/sw_engine/tvgSwRenderer.h
View file

@ -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;
bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) override;
bool endComposite(Compositor* cmp) override;
RenderCompositor* target(const RenderRegion& region, ColorSpace cs) override;
bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) override;
bool endComposite(RenderCompositor* cmp) override;
void clearCompositors();
static SwRenderer* gen();

4
src/renderer/tvgLoadModule.h
View file

@ -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;

2
src/renderer/tvgPaint.cpp
View file

@ -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;

2
src/renderer/tvgPicture.cpp
View file

@ -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);

2
src/renderer/tvgPicture.h
View file

@ -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;

32
src/renderer/tvgRender.h
View file

@ -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,23 +77,12 @@ struct Surface
}
};
struct Compositor
struct RenderCompositor
{
CompositeMethod method;
uint8_t opacity;
};
struct Vertex
{
Point pt;
Point uv;
};
struct Polygon
{
Vertex vertex[3];
};
struct RenderRegion
{
int32_t x, y, w, h;
@ -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 bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) = 0;
virtual bool endComposite(Compositor* cmp) = 0;
virtual RenderCompositor* target(const RenderRegion& region, ColorSpace cs) = 0;
virtual bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) = 0;
virtual bool endComposite(RenderCompositor* cmp) = 0;
};
static inline bool MASK_REGION_MERGING(CompositeMethod method)

2
src/renderer/tvgScene.h
View file

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

2
src/renderer/tvgShape.h
View file

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

6
src/renderer/wg_engine/tvgWgCompositor.h
View file

@ -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{};

2
src/renderer/wg_engine/tvgWgRenderData.cpp
View file

@ -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);

2
src/renderer/wg_engine/tvgWgRenderData.h
View file

@ -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);
};

10
src/renderer/wg_engine/tvgWgRenderer.cpp
View file

@ -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;

12
src/renderer/wg_engine/tvgWgRenderer.h
View file

@ -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;
bool beginComposite(Compositor* cmp, CompositeMethod method, uint8_t opacity) override;
bool endComposite(Compositor* cmp) override;
RenderCompositor* target(const RenderRegion& region, ColorSpace cs) override;
bool beginComposite(RenderCompositor* cmp, CompositeMethod method, uint8_t opacity) 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{};