/*
- * 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 _growOutlineClose(SwOutline& outline)
+static void _reserveOutlineClose(SwOutline& outline)
{
//Dash outlines are always opened.
//Only normal outlines use this information, it sholud be same to their contour counts.
- outline.closed = static_cast<bool*>(realloc(outline.closed, outline.reservedCntrsCnt * sizeof(bool)));
+ 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)
{
- _growOutlineContour(outline, 1);
+ if (outline.ptsCnt == 0) return;
- if (outline.closed) {
- outline.closed[outline.cntrsCnt] = false;
- }
-
- if (outline.ptsCnt > 0) {
- outline.cntrs[outline.cntrsCnt] = outline.ptsCnt - 1;
- ++outline.cntrsCnt;
- }
+ _growOutlineContour(outline, 1);
+ 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.closed[outline.cntrsCnt] = false;
- 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.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;
auto outlineCntrsCnt = 0;
for (uint32_t i = 0; i < cmdCnt; ++i) {
- switch(*(cmds + i)) {
+ switch (*(cmds + i)) {
case PathCommand::Close: {
++outlinePtsCnt;
break;
_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
_growOutlinePoint(*outline, outlinePtsCnt);
if (_growOutlineContour(*outline, outlineCntrsCnt)) {
- _growOutlineClose(*outline);
+ _reserveOutlineClose(*outline);
+ } else {
+ _resetOutlineClose(*outline);
}
//Generate Outlines
while (cmdCnt-- > 0) {
- switch(*cmds) {
+ switch (*cmds) {
case PathCommand::Close: {
_outlineClose(*outline);
break;
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;
}