Paint* Paint::Impl::duplicate()
{
auto ret = smethod->duplicate();
- if (!ret) return nullptr;
//duplicate Transform
if (rTransform) {
ret->pImpl->opacity = opacity;
- if (cmpTarget) ret->pImpl->cmpTarget = cmpTarget->duplicate();
-
- ret->pImpl->cmpMethod = cmpMethod;
+ if (compData) ret->pImpl->composite(ret, compData->target->duplicate(), compData->method);
return ret;
}
/* Note: only ClipPath is processed in update() step.
Create a composition image. */
- if (cmpTarget && cmpMethod != CompositeMethod::ClipPath && !(cmpTarget->pImpl->ctxFlag & ContextFlag::FastTrack)) {
+ if (compData && compData->method != CompositeMethod::ClipPath && !(compData->target->pImpl->ctxFlag & ContextFlag::FastTrack)) {
auto region = smethod->bounds(renderer);
if (region.w == 0 || region.h == 0) return true;
cmp = renderer.target(region);
renderer.beginComposite(cmp, CompositeMethod::None, 255);
- cmpTarget->pImpl->render(renderer);
+ compData->target->pImpl->render(renderer);
}
- if (cmp) renderer.beginComposite(cmp, cmpMethod, cmpTarget->pImpl->opacity);
+ if (cmp) renderer.beginComposite(cmp, compData->method, compData->target->pImpl->opacity);
auto ret = smethod->render(renderer);
}
/* 1. Composition Pre Processing */
- void *cmpData = nullptr;
+ void *tdata = nullptr;
RenderRegion viewport;
- bool cmpFastTrack = false;
+ bool compFastTrack = false;
- if (cmpTarget) {
- cmpTarget->pImpl->ctxFlag = ContextFlag::Invalid; //reset
+ if (compData) {
+ auto target = compData->target;
+ auto method = compData->method;
+ target->pImpl->ctxFlag = ContextFlag::Invalid; //reset
/* If transform has no rotation factors && ClipPath / AlphaMasking is a simple rectangle,
we can avoid regular ClipPath / AlphaMasking sequence but use viewport for performance */
auto tryFastTrack = false;
- if (cmpMethod == CompositeMethod::ClipPath) tryFastTrack = true;
- else if (cmpMethod == CompositeMethod::AlphaMask && cmpTarget->identifier() == TVG_CLASS_ID_SHAPE) {
- auto shape = static_cast<Shape*>(cmpTarget);
+ if (method == CompositeMethod::ClipPath) tryFastTrack = true;
+ else if (method == CompositeMethod::AlphaMask && target->identifier() == TVG_CLASS_ID_SHAPE) {
+ auto shape = static_cast<Shape*>(target);
uint8_t a;
shape->fillColor(nullptr, nullptr, nullptr, &a);
if (a == 255 && shape->opacity() == 255 && !shape->fill()) tryFastTrack = true;
}
if (tryFastTrack) {
RenderRegion viewport2;
- if ((cmpFastTrack = _compFastTrack(cmpTarget, pTransform, cmpTarget->pImpl->rTransform, viewport2))) {
+ if ((compFastTrack = _compFastTrack(target, pTransform, target->pImpl->rTransform, viewport2))) {
viewport = renderer.viewport();
viewport2.intersect(viewport);
renderer.viewport(viewport2);
- cmpTarget->pImpl->ctxFlag |= ContextFlag::FastTrack;
+ target->pImpl->ctxFlag |= ContextFlag::FastTrack;
}
}
- if (!cmpFastTrack) {
- cmpData = cmpTarget->pImpl->update(renderer, pTransform, 255, clips, pFlag);
- if (cmpMethod == CompositeMethod::ClipPath) clips.push(cmpData);
+ if (!compFastTrack) {
+ tdata = target->pImpl->update(renderer, pTransform, 255, clips, pFlag);
+ if (method == CompositeMethod::ClipPath) clips.push(tdata);
}
}
}
/* 3. Composition Post Processing */
- if (cmpFastTrack) renderer.viewport(viewport);
- else if (cmpData && cmpMethod == CompositeMethod::ClipPath) clips.pop();
+ if (compFastTrack) renderer.viewport(viewport);
+ else if (tdata && compData->method == CompositeMethod::ClipPath) clips.pop();
return edata;
}
Result Paint::composite(std::unique_ptr<Paint> target, CompositeMethod method) noexcept
{
auto p = target.release();
- if (pImpl->composite(p, method)) return Result::Success;
+ if (pImpl->composite(this, p, method)) return Result::Success;
if (p) delete(p);
return Result::InvalidArguments;
}
CompositeMethod Paint::composite(const Paint** target) const noexcept
{
- if (target) *target = pImpl->cmpTarget;
-
- return pImpl->cmpMethod;
+ if (pImpl->compData) {
+ if (target) *target = pImpl->compData->target;
+ return pImpl->compData->method;
+ } else {
+ if (target) *target = nullptr;
+ return CompositeMethod::None;
+ }
}
virtual Iterator* iterator() = 0;
};
+ struct Composite
+ {
+ Paint* target;
+ Paint* source;
+ CompositeMethod method;
+ };
+
struct Paint::Impl
{
StrategyMethod* smethod = nullptr;
RenderTransform* rTransform = nullptr;
+ Composite* compData = nullptr;
uint32_t renderFlag = RenderUpdateFlag::None;
- Paint* cmpTarget = nullptr;
- CompositeMethod cmpMethod = CompositeMethod::None;
uint32_t ctxFlag = ContextFlag::Invalid;
uint32_t id;
uint8_t opacity = 255;
~Impl() {
- if (cmpTarget) delete(cmpTarget);
+ if (compData) {
+ delete(compData->target);
+ free(compData);
+ }
if (smethod) delete(smethod);
if (rTransform) delete(rTransform);
}
bool dispose(RenderMethod& renderer)
{
- if (cmpTarget) cmpTarget->pImpl->dispose(renderer);
+ if (compData) compData->target->pImpl->dispose(renderer);
return smethod->dispose(renderer);
}
return smethod->iterator();
}
- bool composite(Paint* target, CompositeMethod method)
+ bool composite(Paint* source, Paint* target, CompositeMethod method)
{
+ //Invalid case
if ((!target && method != CompositeMethod::None) || (target && method == CompositeMethod::None)) return false;
- if (cmpTarget) delete(cmpTarget);
- cmpTarget = target;
- cmpMethod = method;
+
+ if (compData) {
+ delete(compData->target);
+ //Reset scenario
+ if (!target && method == CompositeMethod::None) {
+ free(compData);
+ compData = nullptr;
+ return true;
+ }
+ } else {
+ if (!target && method == CompositeMethod::None) return true;
+ compData = static_cast<Composite*>(calloc(1, sizeof(Composite)));
+ }
+ compData->target = target;
+ compData->source = source;
+ compData->method = method;
return true;
}