/* * Copyright (c) 2020 - 2026 ThorVG project. All rights reserved. * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "tvgMath.h" #include "tvgPaint.h" #include "tvgShape.h" #include "tvgPicture.h" #include "tvgScene.h" #include "tvgText.h" /************************************************************************/ /* Internal Class Implementation */ /************************************************************************/ #define PAINT_METHOD(ret, METHOD) \ switch (paint->type()) { \ case Type::Shape: ret = to(paint)->METHOD; break; \ case Type::Scene: ret = to(paint)->METHOD; break; \ case Type::Picture: ret = to(paint)->METHOD; break; \ case Type::Text: ret = to(paint)->METHOD; break; \ default: ret = {}; \ } static bool _clipRect(RenderMethod* renderer, const Point* pts, const Matrix& m, RenderRegion& before) { Point c[4]; //corners for (int i = 0; i < 4; ++i) { c[i] = pts[i] * m; } //figure out if the clipper is a superset of the current viewport(before) region auto pointInConvexQuad = [](const Point& p, const Point* quad) { auto sign = [](const Point& p1, const Point& p2, const Point& p3) { return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y); }; auto b1 = sign(p, quad[0], quad[1]) < 0.0f; auto b2 = sign(p, quad[1], quad[2]) < 0.0f; auto b3 = sign(p, quad[2], quad[3]) < 0.0f; auto b4 = sign(p, quad[3], quad[0]) < 0.0f; return ((b1 == b2) && (b2 == b3) && (b3 == b4)); }; if (!pointInConvexQuad({float(before.min.x), float(before.min.y)}, c)) return false; if (!pointInConvexQuad({float(before.max.x), float(before.min.y)}, c)) return false; if (!pointInConvexQuad({float(before.max.x), float(before.max.y)}, c)) return false; if (!pointInConvexQuad({float(before.min.x), float(before.max.y)}, c)) return false; //same viewport return true; } static bool _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(cmpTarget); //Trimming likely makes the shape non-rectangular if (to(shape)->rs.trimpath()) return false; //Rectangle Candidates? const Point* pts; uint32_t ptsCnt; shape->path(nullptr, nullptr, &pts, &ptsCnt); //No rectangle format if (ptsCnt != 4) return false; //No rotation and no skewing, still can try out clipping the rect region. auto tm = pm * cmpTarget->transform(); //Perpendicular Rectangle? if (rightAngle(tm) && !skewed(tm)) { auto pt1 = pts + 0; auto pt2 = pts + 1; auto pt3 = pts + 2; auto pt4 = pts + 3; if ((tvg::equal(pt1->x, pt2->x) && tvg::equal(pt2->y, pt3->y) && tvg::equal(pt3->x, pt4->x) && tvg::equal(pt1->y, pt4->y)) || (tvg::equal(pt2->x, pt3->x) && tvg::equal(pt1->y, pt2->y) && tvg::equal(pt1->x, pt4->x) && tvg::equal(pt3->y, pt4->y))) { RenderRegion after; auto v1 = *pt1; auto v2 = *pt3; v1 *= tm; v2 *= tm; //sorting if (v1.x > v2.x) std::swap(v1.x, v2.x); if (v1.y > v2.y) std::swap(v1.y, v2.y); after.min.x = static_cast(nearbyint(v1.x)); after.min.y = static_cast(nearbyint(v1.y)); after.max.x = static_cast(nearbyint(v2.x)); after.max.y = static_cast(nearbyint(v2.y)); if (after.max.x < after.min.x) after.max.x = after.min.x; if (after.max.y < after.min.y) after.max.y = after.min.y; after.intersect(before); renderer->viewport(after); return true; } } return _clipRect(renderer, pts, tm, before); } RenderRegion Paint::Impl::bounds() { RenderRegion ret; PAINT_METHOD(ret, bounds()); return ret; } Iterator* Paint::Impl::iterator() { Iterator* ret; PAINT_METHOD(ret, iterator()); return ret; } Paint* Paint::Impl::duplicate(Paint* ret) { if (ret) ret->mask(nullptr, MaskMethod::None); PAINT_METHOD(ret, duplicate(ret)); if (maskData) ret->mask(maskData->target->duplicate(), maskData->method); if (clipper) ret->clip(static_cast(clipper->duplicate())); ret->pImpl->tr = tr; ret->pImpl->blendMethod = blendMethod; ret->pImpl->opacity = opacity; ret->pImpl->hidden = hidden; ret->pImpl->mark(RenderUpdateFlag::All); return ret; } bool Paint::Impl::render(RenderMethod* renderer, CompositionFlag flag) { if (hidden || opacity == 0) return true; RenderCompositor* cmp = nullptr; //OPTIMIZE: bounds(renderer) calls could dismiss the parallelization if (maskData && !(maskData->target->pImpl->ctxFlag & ContextFlag::FastTrack)) { RenderRegion region; PAINT_METHOD(region, bounds()); auto mData = maskData; while (mData) { if (MASK_REGION_MERGING(mData->method)) region.add(PAINT(mData->target)->bounds()); if (region.invalid()) return true; mData = PAINT(mData->target)->maskData; } cmp = renderer->target(region, MASK_TO_COLORSPACE(renderer, maskData->method), CompositionFlag::Masking); if (renderer->beginComposite(cmp, MaskMethod::None, 255)) { maskData->target->pImpl->render(renderer); } } if (cmp) renderer->beginComposite(cmp, maskData->method, maskData->target->pImpl->opacity); bool ret; PAINT_METHOD(ret, render(renderer, flag)); if (cmp) renderer->endComposite(cmp); return ret; } RenderData Paint::Impl::update(RenderMethod* renderer, const Matrix& pm, Array& clips, uint8_t opacity, RenderUpdateFlag flag, bool clipper) { bool ret; PAINT_METHOD(ret, skip((flag | renderFlag))); if (ret) return rd; cmpFlag = CompositionFlag::Invalid; //must clear after the rendering if (this->renderer != renderer) { if (this->renderer) TVGERR("RENDERER", "paint's renderer has been changed!"); renderer->ref(); this->renderer = renderer; } if (renderFlag & RenderUpdateFlag::Transform) tr.update(); /* 1. Composition Pre Processing */ RenderData trd = nullptr; //composite target render data RenderRegion viewport; auto compFastTrack = false; if (maskData) { auto target = maskData->target; auto method = maskData->method; PAINT(target)->ctxFlag &= ~ContextFlag::FastTrack; //reset /* If the transformation has no rotational factors and the Alpha(InvAlpha) Masking involves a simple rectangle, we can optimize by using the viewport instead of the regular Alphaing sequence for improved performance. */ if (target->type() == Type::Shape) { auto shape = static_cast(target); uint8_t a; shape->fill(nullptr, nullptr, nullptr, &a); //no gradient fill & no maskings of the masking target. if (!shape->fill() && !(PAINT(shape)->maskData)) { if ((method == MaskMethod::Alpha && a == 255 && PAINT(shape)->opacity == 255) || (method == MaskMethod::InvAlpha && (a == 0 || PAINT(shape)->opacity == 0))) { viewport = renderer->viewport(); if ((compFastTrack = _compFastTrack(renderer, target, pm, viewport))) { PAINT(target)->ctxFlag |= ContextFlag::FastTrack; } } } } if (!compFastTrack) { trd = PAINT(target)->update(renderer, pm, clips, 255, flag, false); } } /* 2. Clipping */ if (this->clipper) { auto pclip = PAINT(this->clipper); pclip->ctxFlag &= ~ContextFlag::FastTrack; //reset viewport = renderer->viewport(); if (!pclip->clipper && to(this->clipper)->rs.strokeWidth() == 0.0f && _compFastTrack(renderer, this->clipper, pm, viewport)) { pclip->ctxFlag |= ContextFlag::FastTrack; compFastTrack = true; } else { mark(RenderUpdateFlag::Clip); trd = pclip->update(renderer, pm, clips, 255, flag, true); clips.push(trd); } } /* 3. Main Update */ opacity = MULTIPLY(opacity, this->opacity); PAINT_METHOD(ret, update(renderer, pm * tr.m, clips, opacity, (flag | renderFlag), clipper)); /* 4. Composition Post Processing */ if (compFastTrack) renderer->viewport(viewport); else if (this->clipper) clips.pop(); renderFlag = RenderUpdateFlag::None; return rd; } bool Paint::Impl::bounds(Point* pt4, const Matrix* pm, bool obb) { bool ret; PAINT_METHOD(ret, bounds(pt4, pm * transform(), obb)); return ret; } bool Paint::Impl::intersects(const RenderRegion& region) { if (renderer) { bool ret; PAINT_METHOD(ret, intersects(region)); return ret; } return false; } /************************************************************************/ /* External Class Implementation */ /************************************************************************/ Paint :: Paint() = default; Paint :: ~Paint() = default; void Paint::rel(Paint* paint) noexcept { if (paint && paint->refCnt() <= 0) delete(paint); } Result Paint::rotate(float degree) noexcept { if (pImpl->rotate(degree)) return Result::Success; return Result::InsufficientCondition; } Result Paint::scale(float factor) noexcept { if (pImpl->scale(factor)) return Result::Success; return Result::InsufficientCondition; } Result Paint::translate(float x, float y) noexcept { if (pImpl->translate(x, y)) return Result::Success; return Result::InsufficientCondition; } Result Paint::transform(const Matrix& m) noexcept { if (pImpl->transform(m)) return Result::Success; return Result::InsufficientCondition; } Matrix& Paint::transform() noexcept { return pImpl->transform(); } Result Paint::bounds(float* x, float* y, float* w, float* h) noexcept { Point pt4[4] = {}; const auto pm = pImpl->ptransform(); if (pImpl->bounds(pt4, &pm, false)) { BBox box = {{FLT_MAX, FLT_MAX}, {-FLT_MAX, -FLT_MAX}}; for (int i = 0; i < 4; ++i) { if (pt4[i].x < box.min.x) box.min.x = pt4[i].x; if (pt4[i].x > box.max.x) box.max.x = pt4[i].x; if (pt4[i].y < box.min.y) box.min.y = pt4[i].y; if (pt4[i].y > box.max.y) box.max.y = pt4[i].y; } if (x) *x = box.min.x; if (y) *y = box.min.y; if (w) *w = box.max.x - box.min.x; if (h) *h = box.max.y - box.min.y; return Result::Success; } return Result::InsufficientCondition; } Result Paint::bounds(Point* pt4) noexcept { if (!pt4) return Result::InvalidArguments; auto pm = pImpl->ptransform(); if (pImpl->bounds(pt4, &pm, true)) return Result::Success; return Result::InsufficientCondition; } bool Paint::intersects(int32_t x, int32_t y, int32_t w, int32_t h) noexcept { if (w <= 0 || h <= 0) return false; return pImpl->intersects({{x, y}, {x + w, y + h}}); } Paint* Paint::duplicate() const noexcept { return pImpl->duplicate(); } Result Paint::clip(Shape* clipper) noexcept { return pImpl->clip(clipper); } Shape* Paint::clip() const noexcept { return pImpl->clipper; } Result Paint::mask(Paint* target, MaskMethod method) noexcept { if (method > MaskMethod::Darken) return Result::InvalidArguments; return pImpl->mask(target, method); } MaskMethod Paint::mask(const Paint** target) const noexcept { return pImpl->mask(target); } Result Paint::opacity(uint8_t o) noexcept { if (pImpl->opacity != o) { pImpl->opacity = o; pImpl->mark(RenderUpdateFlag::Color); } return Result::Success; } uint8_t Paint::opacity() const noexcept { return pImpl->opacity; } Result Paint::blend(BlendMethod method) noexcept { if (method <= BlendMethod::Add || method == BlendMethod::Composition) { pImpl->blend(method); return Result::Success; } return Result::InvalidArguments; } uint16_t Paint::ref() noexcept { return pImpl->ref(); } uint16_t Paint::unref(bool free) noexcept { return pImpl->unrefx(free); } uint16_t Paint::refCnt() const noexcept { return pImpl->refCnt; } const Paint* Paint::parent() const noexcept { return pImpl->parent; } Result Paint::visible(bool on) noexcept { return pImpl->visible(!on); } bool Paint::visible() const noexcept { return !pImpl->hidden; }