/*
- * Copyright (c) 2020-2021 Samsung Electronics Co., Ltd. All rights reserved.
+ * Copyright (c) 2020 - 2023 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
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
+
#include "tvgSwCommon.h"
#include "tvgBezier.h"
+#include <float.h>
+#include <math.h>
/************************************************************************/
/* Internal Class Implementation */
}
-static void _growOutlineContour(SwOutline& outline, uint32_t n)
+static bool _growOutlineContour(SwOutline& outline, uint32_t n)
{
- if (outline.reservedCntrsCnt >= outline.cntrsCnt + n) return;
+ if (outline.reservedCntrsCnt >= outline.cntrsCnt + n) return false;
outline.reservedCntrsCnt = outline.cntrsCnt + n;
outline.cntrs = static_cast<uint32_t*>(realloc(outline.cntrs, outline.reservedCntrsCnt * sizeof(uint32_t)));
+ return true;
+}
+
+
+static void _reserveOutlineClose(SwOutline& outline)
+{
+ //Dash outlines are always opened.
+ //Only normal outlines use this information, it sholud be same to their contour counts.
+ if (outline.closed) free(outline.closed);
+ outline.closed = static_cast<bool*>(calloc(outline.reservedCntrsCnt, sizeof(bool)));
+}
+
+
+static void _resetOutlineClose(SwOutline& outline)
+{
+ memset(outline.closed, 0x0, outline.reservedCntrsCnt * sizeof(bool));
}
static void _outlineEnd(SwOutline& outline)
{
+ if (outline.ptsCnt == 0) return;
+
_growOutlineContour(outline, 1);
- if (outline.ptsCnt > 0) {
- outline.cntrs[outline.cntrsCnt] = outline.ptsCnt - 1;
- ++outline.cntrsCnt;
- }
+ outline.cntrs[outline.cntrsCnt] = outline.ptsCnt - 1;
+ ++outline.cntrsCnt;
}
}
//Make sure there is at least one point in the current path
- if (outline.ptsCnt == i) {
- outline.opened = true;
- return;
- }
+ if (outline.ptsCnt == i) return;
//Close the path
_growOutlinePoint(outline, 1);
outline.pts[outline.ptsCnt] = outline.pts[i];
outline.types[outline.ptsCnt] = SW_CURVE_TYPE_POINT;
++outline.ptsCnt;
-
- outline.opened = false;
+ outline.closed[outline.cntrsCnt] = true;
}
Bezier left, right;
len -= dash.curLen;
bezSplitAt(cur, dash.curLen, left, right);
- dash.curIdx = (dash.curIdx + 1) % dash.cnt;
if (!dash.curOpGap) {
- _outlineMoveTo(*dash.outline, &left.start, transform);
+ // leftovers from a previous command don't require moveTo
+ if (dash.pattern[dash.curIdx] - dash.curLen < FLT_EPSILON) {
+ _outlineMoveTo(*dash.outline, &left.start, transform);
+ }
_outlineCubicTo(*dash.outline, &left.ctrl1, &left.ctrl2, &left.end, transform);
}
+ dash.curIdx = (dash.curIdx + 1) % dash.cnt;
dash.curLen = dash.pattern[dash.curIdx];
dash.curOpGap = !dash.curOpGap;
cur = right;
//OPTMIZE ME: Use mempool???
dash.pattern = const_cast<float*>(pattern);
dash.outline = static_cast<SwOutline*>(calloc(1, sizeof(SwOutline)));
- dash.outline->opened = true;
//smart reservation
auto outlinePtsCnt = 0;
auto outlineCntrsCnt = 0;
for (uint32_t i = 0; i < cmdCnt; ++i) {
- switch(*(cmds + i)) {
+ switch (*(cmds + i)) {
case PathCommand::Close: {
++outlinePtsCnt;
break;
++outlinePtsCnt; //for close
++outlineCntrsCnt; //for end
- //Reserve Approximitely 20x...
+ //No idea exact count.... Reserve Approximitely 20x...
_growOutlinePoint(*dash.outline, outlinePtsCnt * 20);
_growOutlineContour(*dash.outline, outlineCntrsCnt * 20);
while (cmdCnt-- > 0) {
- switch(*cmds) {
+ switch (*cmds) {
case PathCommand::Close: {
_dashLineTo(dash, &dash.ptStart, transform);
break;
}
-static bool _fastTrack(const SwOutline* outline)
+static bool _axisAlignedRect(const SwOutline* outline)
{
- //Fast Track: Othogonal rectangle?
+ //Fast Track: axis-aligned rectangle?
if (outline->ptsCnt != 5) return false;
auto pt1 = outline->pts + 0;
-static bool _genOutline(SwShape* shape, const Shape* sdata, const Matrix* transform, SwMpool* mpool, unsigned tid)
+static bool _genOutline(SwShape* shape, const Shape* sdata, const Matrix* transform, SwMpool* mpool, unsigned tid, bool hasComposite)
{
const PathCommand* cmds = nullptr;
auto cmdCnt = sdata->pathCommands(&cmds);
//smart reservation
auto outlinePtsCnt = 0;
auto outlineCntrsCnt = 0;
+ auto closeCnt = 0;
for (uint32_t i = 0; i < cmdCnt; ++i) {
- switch(*(cmds + i)) {
+ switch (*(cmds + i)) {
case PathCommand::Close: {
++outlinePtsCnt;
+ ++closeCnt;
break;
}
case PathCommand::MoveTo: {
}
}
+ if (static_cast<uint32_t>(outlinePtsCnt - closeCnt) > ptsCnt) {
+ TVGERR("SW_ENGINE", "Wrong a pair of the commands & points - required(%d), current(%d)", outlinePtsCnt - closeCnt, ptsCnt);
+ return false;
+ }
+
++outlinePtsCnt; //for close
++outlineCntrsCnt; //for end
shape->outline = mpoolReqOutline(mpool, tid);
auto outline = shape->outline;
- outline->opened = true;
_growOutlinePoint(*outline, outlinePtsCnt);
- _growOutlineContour(*outline, outlineCntrsCnt);
- auto closed = false;
+ if (_growOutlineContour(*outline, outlineCntrsCnt)) {
+ _reserveOutlineClose(*outline);
+ } else {
+ _resetOutlineClose(*outline);
+ }
//Generate Outlines
while (cmdCnt-- > 0) {
- switch(*cmds) {
+ switch (*cmds) {
case PathCommand::Close: {
_outlineClose(*outline);
- closed = true;
break;
}
case PathCommand::MoveTo: {
_outlineEnd(*outline);
- if (closed) outline->opened = false;
-
outline->fillRule = sdata->fillRule();
shape->outline = outline;
+ shape->fastTrack = (!hasComposite && _axisAlignedRect(shape->outline));
return true;
}
/* External Class Implementation */
/************************************************************************/
-bool shapePrepare(SwShape* shape, const Shape* sdata, const Matrix* transform, const SwBBox& clipRegion, SwBBox& renderRegion, SwMpool* mpool, unsigned tid)
+bool shapePrepare(SwShape* shape, const Shape* sdata, const Matrix* transform, const SwBBox& clipRegion, SwBBox& renderRegion, SwMpool* mpool, unsigned tid, bool hasComposite)
{
- if (!_genOutline(shape, sdata, transform, mpool, tid)) return false;
- if (!mathUpdateOutlineBBox(shape->outline, clipRegion, renderRegion)) return false;
+ if (!_genOutline(shape, sdata, transform, mpool, tid, hasComposite)) return false;
+ if (!mathUpdateOutlineBBox(shape->outline, clipRegion, renderRegion, shape->fastTrack)) return false;
//Keep it for Rasterization Region
shape->bbox = renderRegion;
}
-bool shapeGenRle(SwShape* shape, TVG_UNUSED const Shape* sdata, bool antiAlias, bool hasComposite)
+bool shapeGenRle(SwShape* shape, TVG_UNUSED const Shape* sdata, bool antiAlias)
{
//FIXME: Should we draw it?
//Case: Stroke Line
//if (shape.outline->opened) return true;
//Case A: Fast Track Rectangle Drawing
- if (!hasComposite && (shape->rect = _fastTrack(shape->outline))) return true;
- //Case B: Normale Shape RLE Drawing
+ if (shape->fastTrack) return true;
+
+ //Case B: Normal Shape RLE Drawing
if ((shape->rle = rleRender(shape->rle, shape->outline, shape->bbox, antiAlias))) return true;
return false;
{
rleReset(shape->rle);
rleReset(shape->strokeRle);
- shape->rect = false;
+ shape->fastTrack = false;
shape->bbox.reset();
}
//Normal Style stroke
} else {
if (!shape->outline) {
- if (!_genOutline(shape, sdata, transform, mpool, tid)) return false;
+ if (!_genOutline(shape, sdata, transform, mpool, tid, false)) return false;
}
shapeOutline = shape->outline;
}
}
strokeOutline = strokeExportOutline(shape->stroke, mpool, tid);
- if (!strokeOutline) {
- ret = false;
- goto fail;
- }
- if (!mathUpdateOutlineBBox(strokeOutline, clipRegion, renderRegion)) {
+ if (!mathUpdateOutlineBBox(strokeOutline, clipRegion, renderRegion, false)) {
ret = false;
goto fail;
}
if (shapeOutline->cntrs) free(shapeOutline->cntrs);
if (shapeOutline->pts) free(shapeOutline->pts);
if (shapeOutline->types) free(shapeOutline->types);
+ if (shapeOutline->closed) free(shapeOutline->closed);
free(shapeOutline);
}
mpoolRetStrokeOutline(mpool, tid);
if (!shape->stroke->fill) return;
fillFree(shape->stroke->fill);
shape->stroke->fill = nullptr;
-}
\ No newline at end of file
+}