mirror of
https://github.com/thorvg/thorvg.git
synced 2025-06-17 21:45:35 +00:00
af6969e15e
[issues 1479: Masking](#1479) Supported composition methods: AlphaMask InvAlphaMask LumaMask InvLumaMask AddMask SubtractMask IntersectMask DifferenceMask Usage example: //Solid Rectangle auto shape = tvg::Shape::gen(); shape->appendRect(0, 0, 400, 400); shape->fill(0, 0, 255); //Mask auto mask = tvg::Shape::gen(); mask->appendCircle(200, 200, 125, 125); mask->fill(255, 255, 255); //AlphaMask RGB channels are unused. //Nested Mask auto nMask = tvg::Shape::gen(); nMask->appendCircle(220, 220, 125, 125); nMask->fill(255, 255, 255); //AlphaMask RGB channels are unused. mask->composite(std::move(nMask), tvg::CompositeMethod::AlphaMask); shape->composite(std::move(mask), tvg::CompositeMethod::AlphaMask); canvas->push(std::move(shape)); //Star auto star = tvg::Shape::gen(); star->fill(80, 80, 80); star->moveTo(599, 34); star->lineTo(653, 143); star->lineTo(774, 160); star->lineTo(687, 244); star->lineTo(707, 365); star->lineTo(599, 309); star->lineTo(497, 365); star->lineTo(512, 245); star->lineTo(426, 161); star->lineTo(546, 143); star->close(); star->strokeWidth(30); star->strokeJoin(tvg::StrokeJoin::Miter); star->strokeFill(255, 255, 255); //Mask3 auto mask3 = tvg::Shape::gen(); mask3->appendCircle(600, 200, 125, 125); mask3->fill(255, 255, 255); //AlphaMask RGB channels are unused. mask3->opacity(200); star->composite(std::move(mask3), tvg::CompositeMethod::AlphaMask); if (canvas->push(std::move(star)) != tvg::Result::Success) return;
435 lines
16 KiB
C++
435 lines
16 KiB
C++
/*
|
|
* Copyright (c) 2023 - 2024 the 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 "tvgWgGeometry.h"
|
|
|
|
//***********************************************************************
|
|
// WgGeometryData
|
|
//***********************************************************************
|
|
|
|
void WgGeometryData::computeTriFansIndexes()
|
|
{
|
|
if (positions.count <= 2) return;
|
|
indexes.reserve((positions.count - 2) * 3);
|
|
for (size_t i = 0; i < positions.count - 2; i++) {
|
|
indexes.push(0);
|
|
indexes.push(i + 1);
|
|
indexes.push(i + 2);
|
|
}
|
|
};
|
|
|
|
|
|
void WgGeometryData::appendCubic(WgPoint p1, WgPoint p2, WgPoint p3)
|
|
{
|
|
WgPoint p0 = positions.count > 0 ? positions.last() : WgPoint(0.0f, 0.0f);
|
|
const size_t segs = 16;
|
|
for (size_t i = 1; i <= segs; i++) {
|
|
float t = i / (float)segs;
|
|
// get cubic spline interpolation coefficients
|
|
float t0 = 1 * (1.0f - t) * (1.0f - t) * (1.0f - t);
|
|
float t1 = 3 * (1.0f - t) * (1.0f - t) * t;
|
|
float t2 = 3 * (1.0f - t) * t * t;
|
|
float t3 = 1 * t * t * t;
|
|
positions.push(p0 * t0 + p1 * t1 + p2 * t2 + p3 * t3);
|
|
}
|
|
};
|
|
|
|
|
|
void WgGeometryData::appendBox(WgPoint pmin, WgPoint pmax)
|
|
{
|
|
appendRect(
|
|
{ pmin.x, pmin.y},
|
|
{ pmax.x, pmin.y},
|
|
{ pmin.x, pmax.y},
|
|
{ pmax.x, pmax.y});
|
|
};
|
|
|
|
|
|
void WgGeometryData::appendRect(WgPoint p0, WgPoint p1, WgPoint p2, WgPoint p3)
|
|
{
|
|
uint32_t index = positions.count;
|
|
positions.push(p0); // +0
|
|
positions.push(p1); // +1
|
|
positions.push(p2); // +2
|
|
positions.push(p3); // +3
|
|
indexes.push(index + 0);
|
|
indexes.push(index + 1);
|
|
indexes.push(index + 2);
|
|
indexes.push(index + 1);
|
|
indexes.push(index + 3);
|
|
indexes.push(index + 2);
|
|
};
|
|
|
|
|
|
// TODO: optimize vertex and index count
|
|
void WgGeometryData::appendCircle(WgPoint center, float radius)
|
|
{
|
|
uint32_t index = positions.count;
|
|
uint32_t nSegments = std::trunc(radius);
|
|
for (uint32_t i = 0; i < nSegments; i++) {
|
|
float angle0 = (float)(i + 0) / nSegments * (float)M_PI * 2.0f;
|
|
float angle1 = (float)(i + 1) / nSegments * (float)M_PI * 2.0f;
|
|
WgPoint p0 = center + WgPoint(sin(angle0) * radius, cos(angle0) * radius);
|
|
WgPoint p1 = center + WgPoint(sin(angle1) * radius, cos(angle1) * radius);
|
|
positions.push(center); // +0
|
|
positions.push(p0); // +1
|
|
positions.push(p1); // +2
|
|
indexes.push(index + 0);
|
|
indexes.push(index + 1);
|
|
indexes.push(index + 2);
|
|
index += 3;
|
|
}
|
|
};
|
|
|
|
|
|
void WgGeometryData::appendImageBox(float w, float h)
|
|
{
|
|
positions.push({ 0.0f, 0.0f });
|
|
positions.push({ w , 0.0f });
|
|
positions.push({ w , h });
|
|
positions.push({ 0.0f, h });
|
|
texCoords.push({ 0.0f, 0.0f });
|
|
texCoords.push({ 1.0f, 0.0f });
|
|
texCoords.push({ 1.0f, 1.0f });
|
|
texCoords.push({ 0.0f, 1.0f });
|
|
indexes.push(0);
|
|
indexes.push(1);
|
|
indexes.push(2);
|
|
indexes.push(0);
|
|
indexes.push(2);
|
|
indexes.push(3);
|
|
};
|
|
|
|
|
|
void WgGeometryData::appendBlitBox()
|
|
{
|
|
positions.push({ -1.0f, +1.0f });
|
|
positions.push({ +1.0f, +1.0f });
|
|
positions.push({ +1.0f, -1.0f });
|
|
positions.push({ -1.0f, -1.0f });
|
|
texCoords.push({ 0.0f, 0.0f });
|
|
texCoords.push({ 1.0f, 0.0f });
|
|
texCoords.push({ 1.0f, 1.0f });
|
|
texCoords.push({ 0.0f, 1.0f });
|
|
indexes.push(0);
|
|
indexes.push(1);
|
|
indexes.push(2);
|
|
indexes.push(0);
|
|
indexes.push(2);
|
|
indexes.push(3);
|
|
}
|
|
|
|
|
|
void WgGeometryData::appendMesh(const RenderMesh* rmesh)
|
|
{
|
|
assert(rmesh);
|
|
positions.reserve(rmesh->triangleCnt * 3);
|
|
texCoords.reserve(rmesh->triangleCnt * 3);
|
|
indexes.reserve(rmesh->triangleCnt * 3);
|
|
for (uint32_t i = 0; i < rmesh->triangleCnt; i++) {
|
|
positions.push(rmesh->triangles[i].vertex[0].pt);
|
|
positions.push(rmesh->triangles[i].vertex[1].pt);
|
|
positions.push(rmesh->triangles[i].vertex[2].pt);
|
|
texCoords.push(rmesh->triangles[i].vertex[0].uv);
|
|
texCoords.push(rmesh->triangles[i].vertex[1].uv);
|
|
texCoords.push(rmesh->triangles[i].vertex[2].uv);
|
|
indexes.push(i*3 + 0);
|
|
indexes.push(i*3 + 1);
|
|
indexes.push(i*3 + 2);
|
|
}
|
|
};
|
|
|
|
|
|
void WgGeometryData::close()
|
|
{
|
|
if (positions.count > 1) {
|
|
positions.push(positions[0]);
|
|
}
|
|
};
|
|
|
|
//***********************************************************************
|
|
// WgGeometryDataGroup
|
|
//***********************************************************************
|
|
|
|
void WgGeometryDataGroup::getBBox(WgPoint& pmin, WgPoint& pmax) {
|
|
assert(geometries.count > 0);
|
|
assert(geometries[0]->positions.count > 0);
|
|
pmin = geometries[0]->positions[0];
|
|
pmax = geometries[0]->positions[0];
|
|
for (uint32_t i = 0; i < geometries.count; i++) {
|
|
for (uint32_t j = 0; j < geometries[i]->positions.count; j++) {
|
|
pmin.x = std::min(pmin.x, geometries[i]->positions[j].x);
|
|
pmin.y = std::min(pmin.y, geometries[i]->positions[j].y);
|
|
pmax.x = std::max(pmax.x, geometries[i]->positions[j].x);
|
|
pmax.y = std::max(pmax.y, geometries[i]->positions[j].y);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void WgGeometryDataGroup::tesselate(const RenderShape& rshape)
|
|
{
|
|
decodePath(rshape, this);
|
|
for (uint32_t i = 0; i < geometries.count; i++)
|
|
geometries[i]->computeTriFansIndexes();
|
|
}
|
|
|
|
|
|
void WgGeometryDataGroup::stroke(const RenderShape& rshape)
|
|
{
|
|
assert(rshape.stroke);
|
|
if (rshape.stroke->dashPattern) {
|
|
// first step: decode path data
|
|
WgGeometryDataGroup segments{};
|
|
decodePath(rshape, &segments);
|
|
// second step: split path to segments using dash patterns
|
|
WgGeometryDataGroup outlines{};
|
|
strokeSegments(rshape, &segments, &outlines);
|
|
// third step: create geometry for strokes
|
|
auto strokeData = new WgGeometryData;
|
|
strokeSublines(rshape, &outlines, strokeData);
|
|
// append strokes geometry data
|
|
geometries.push(strokeData);
|
|
} else {
|
|
// first step: decode path data
|
|
WgGeometryDataGroup outlines{};
|
|
decodePath(rshape, &outlines);
|
|
// second step: create geometry for strokes
|
|
auto strokeData = new WgGeometryData;
|
|
strokeSublines(rshape, &outlines, strokeData);
|
|
// append strokes geometry data
|
|
geometries.push(strokeData);
|
|
}
|
|
}
|
|
|
|
|
|
void WgGeometryDataGroup::release()
|
|
{
|
|
for (uint32_t i = 0; i < geometries.count; i++)
|
|
delete geometries[i];
|
|
geometries.clear();
|
|
}
|
|
|
|
|
|
void WgGeometryDataGroup::decodePath(const RenderShape& rshape, WgGeometryDataGroup* outlines)
|
|
{
|
|
size_t pntIndex = 0;
|
|
for (uint32_t cmdIndex = 0; cmdIndex < rshape.path.cmds.count; cmdIndex++) {
|
|
PathCommand cmd = rshape.path.cmds[cmdIndex];
|
|
if (cmd == PathCommand::MoveTo) {
|
|
outlines->geometries.push(new WgGeometryData);
|
|
auto outline = outlines->geometries.last();
|
|
outline->positions.push(rshape.path.pts[pntIndex]);
|
|
pntIndex++;
|
|
} else if (cmd == PathCommand::LineTo) {
|
|
auto outline = outlines->geometries.last();
|
|
if (outline)
|
|
outline->positions.push(rshape.path.pts[pntIndex]);
|
|
pntIndex++;
|
|
} else if (cmd == PathCommand::Close) {
|
|
auto outline = outlines->geometries.last();
|
|
if ((outline) && (outline->positions.count > 0))
|
|
outline->positions.push(outline->positions[0]);
|
|
} else if (cmd == PathCommand::CubicTo) {
|
|
auto outline = outlines->geometries.last();
|
|
if ((outline) && (outline->positions.count > 0))
|
|
outline->appendCubic(
|
|
rshape.path.pts[pntIndex + 0],
|
|
rshape.path.pts[pntIndex + 1],
|
|
rshape.path.pts[pntIndex + 2]
|
|
);
|
|
pntIndex += 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void WgGeometryDataGroup::strokeSegments(const RenderShape& rshape, WgGeometryDataGroup* outlines, WgGeometryDataGroup* segments)
|
|
{
|
|
for (uint32_t i = 0; i < outlines->geometries.count; i++) {
|
|
auto& vlist = outlines->geometries[i]->positions;
|
|
|
|
// append single point segment
|
|
if (vlist.count == 1) {
|
|
auto segment = new WgGeometryData;
|
|
segment->positions.push(vlist.last());
|
|
segments->geometries.push(segment);
|
|
}
|
|
|
|
if (vlist.count >= 2) {
|
|
uint32_t icurr = 1;
|
|
uint32_t ipatt = 0;
|
|
WgPoint vcurr = vlist[0];
|
|
while (icurr < vlist.count) {
|
|
if (ipatt % 2 == 0) {
|
|
segments->geometries.push(new WgGeometryData);
|
|
segments->geometries.last()->positions.push(vcurr);
|
|
}
|
|
float lcurr = rshape.stroke->dashPattern[ipatt];
|
|
while ((icurr < vlist.count) && (vlist[icurr].dist(vcurr) < lcurr)) {
|
|
lcurr -= vlist[icurr].dist(vcurr);
|
|
vcurr = vlist[icurr];
|
|
icurr++;
|
|
if (ipatt % 2 == 0) segments->geometries.last()->positions.push(vcurr);
|
|
}
|
|
if (icurr < vlist.count) {
|
|
vcurr = vcurr + (vlist[icurr] - vlist[icurr-1]).normal() * lcurr;
|
|
if (ipatt % 2 == 0) segments->geometries.last()->positions.push(vcurr);
|
|
}
|
|
ipatt = (ipatt + 1) % rshape.stroke->dashCnt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void WgGeometryDataGroup::strokeSublines(const RenderShape& rshape, WgGeometryDataGroup* outlines, WgGeometryData* strokes)
|
|
{
|
|
float wdt = rshape.stroke->width / 2;
|
|
for (uint32_t i = 0; i < outlines->geometries.count; i++) {
|
|
auto outline = outlines->geometries[i];
|
|
|
|
// single point sub-path
|
|
if (outline->positions.count == 1) {
|
|
if (rshape.stroke->cap == StrokeCap::Round) {
|
|
strokes->appendCircle(outline->positions[0], wdt);
|
|
} else if (rshape.stroke->cap == StrokeCap::Butt) {
|
|
// for zero length sub-paths no stroke is rendered
|
|
} else if (rshape.stroke->cap == StrokeCap::Square) {
|
|
strokes->appendRect(
|
|
outline->positions[0] + WgPoint(+wdt, +wdt),
|
|
outline->positions[0] + WgPoint(+wdt, -wdt),
|
|
outline->positions[0] + WgPoint(-wdt, +wdt),
|
|
outline->positions[0] + WgPoint(-wdt, -wdt)
|
|
);
|
|
}
|
|
}
|
|
|
|
// single line sub-path
|
|
if (outline->positions.count == 2) {
|
|
WgPoint v0 = outline->positions[0];
|
|
WgPoint v1 = outline->positions[1];
|
|
WgPoint dir0 = (v1 - v0).normal();
|
|
WgPoint nrm0 = WgPoint{ -dir0.y, +dir0.x };
|
|
if (rshape.stroke->cap == StrokeCap::Round) {
|
|
strokes->appendRect(
|
|
v0 - nrm0 * wdt, v0 + nrm0 * wdt,
|
|
v1 - nrm0 * wdt, v1 + nrm0 * wdt);
|
|
strokes->appendCircle(outline->positions[0], wdt);
|
|
strokes->appendCircle(outline->positions[1], wdt);
|
|
} else if (rshape.stroke->cap == StrokeCap::Butt) {
|
|
strokes->appendRect(
|
|
v0 - nrm0 * wdt, v0 + nrm0 * wdt,
|
|
v1 - nrm0 * wdt, v1 + nrm0 * wdt
|
|
);
|
|
} else if (rshape.stroke->cap == StrokeCap::Square) {
|
|
strokes->appendRect(
|
|
v0 - nrm0 * wdt - dir0 * wdt, v0 + nrm0 * wdt - dir0 * wdt,
|
|
v1 - nrm0 * wdt + dir0 * wdt, v1 + nrm0 * wdt + dir0 * wdt
|
|
);
|
|
}
|
|
}
|
|
|
|
// multi-lined sub-path
|
|
if (outline->positions.count > 2) {
|
|
// append first cap
|
|
WgPoint v0 = outline->positions[0];
|
|
WgPoint v1 = outline->positions[1];
|
|
WgPoint dir0 = (v1 - v0).normal();
|
|
WgPoint nrm0 = WgPoint{ -dir0.y, +dir0.x };
|
|
if (rshape.stroke->cap == StrokeCap::Round) {
|
|
strokes->appendCircle(v0, wdt);
|
|
} else if (rshape.stroke->cap == StrokeCap::Butt) {
|
|
// no cap needed
|
|
} else if (rshape.stroke->cap == StrokeCap::Square) {
|
|
strokes->appendRect(
|
|
v0 - nrm0 * wdt - dir0 * wdt,
|
|
v0 + nrm0 * wdt - dir0 * wdt,
|
|
v0 - nrm0 * wdt,
|
|
v0 + nrm0 * wdt
|
|
);
|
|
}
|
|
|
|
// append last cap
|
|
v0 = outline->positions[outline->positions.count - 2];
|
|
v1 = outline->positions[outline->positions.count - 1];
|
|
dir0 = (v1 - v0).normal();
|
|
nrm0 = WgPoint{ -dir0.y, +dir0.x };
|
|
if (rshape.stroke->cap == StrokeCap::Round) {
|
|
strokes->appendCircle(v1, wdt);
|
|
} else if (rshape.stroke->cap == StrokeCap::Butt) {
|
|
// no cap needed
|
|
} else if (rshape.stroke->cap == StrokeCap::Square) {
|
|
strokes->appendRect(
|
|
v1 - nrm0 * wdt,
|
|
v1 + nrm0 * wdt,
|
|
v1 - nrm0 * wdt + dir0 * wdt,
|
|
v1 + nrm0 * wdt + dir0 * wdt
|
|
);
|
|
}
|
|
|
|
// append sub-lines
|
|
for (uint32_t j = 0; j < outline->positions.count - 1; j++) {
|
|
WgPoint v0 = outline->positions[j + 0];
|
|
WgPoint v1 = outline->positions[j + 1];
|
|
WgPoint dir = (v1 - v0).normal();
|
|
WgPoint nrm { -dir.y, +dir.x };
|
|
strokes->appendRect(
|
|
v0 - nrm * wdt,
|
|
v0 + nrm * wdt,
|
|
v1 - nrm * wdt,
|
|
v1 + nrm * wdt
|
|
);
|
|
}
|
|
|
|
// append joints (TODO: separate by joint types)
|
|
for (uint32_t j = 1; j < outline->positions.count - 1; j++) {
|
|
WgPoint v0 = outline->positions[j - 1];
|
|
WgPoint v1 = outline->positions[j + 0];
|
|
WgPoint v2 = outline->positions[j + 1];
|
|
WgPoint dir0 = (v1 - v0).normal();
|
|
WgPoint dir1 = (v1 - v2).normal();
|
|
WgPoint nrm0 { -dir0.y, +dir0.x };
|
|
WgPoint nrm1 { +dir1.y, -dir1.x };
|
|
if (rshape.stroke->join == StrokeJoin::Round) {
|
|
strokes->appendCircle(v1, wdt);
|
|
} else if (rshape.stroke->join == StrokeJoin::Bevel) {
|
|
strokes->appendRect(
|
|
v1 - nrm0 * wdt, v1 - nrm1 * wdt,
|
|
v1 + nrm1 * wdt, v1 + nrm0 * wdt
|
|
);
|
|
} else if (rshape.stroke->join == StrokeJoin::Miter) {
|
|
WgPoint nrm = (dir0 + dir1).normal();
|
|
float cosine = nrm.dot(nrm0);
|
|
if ((cosine != 0.0f) && (abs(wdt / cosine) <= rshape.stroke->miterlimit * 2)) {
|
|
strokes->appendRect(v1 + nrm * (wdt / cosine), v1 + nrm0 * wdt, v1 + nrm1 * wdt, v1);
|
|
strokes->appendRect(v1 - nrm * (wdt / cosine), v1 - nrm0 * wdt, v1 - nrm1 * wdt, v1);
|
|
} else {
|
|
strokes->appendRect(
|
|
v1 - nrm0 * wdt, v1 - nrm1 * wdt,
|
|
v1 + nrm1 * wdt, v1 + nrm0 * wdt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|