2 * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #ifndef _TVG_SW_SHAPE_H_
18 #define _TVG_SW_SHAPE_H_
20 #include "tvgSwCommon.h"
22 /************************************************************************/
23 /* Internal Class Implementation */
24 /************************************************************************/
26 static inline SwPoint TO_SWPOINT(const Point* pt)
28 return {SwCoord(pt->x * 64), SwCoord(pt->y * 64)};
32 static void _growOutlineContour(SwOutline& outline, size_t n)
36 outline.cntrs = nullptr;
38 outline.reservedCntrsCnt = 0;
41 if (outline.reservedCntrsCnt >= outline.cntrsCnt + n) return;
43 //cout << "Grow Cntrs: " << outline.reservedCntrsCnt << " -> " << outline.cntrsCnt + n << endl;;
44 outline.reservedCntrsCnt = n;
45 outline.cntrs = static_cast<size_t*>(realloc(outline.cntrs, n * sizeof(size_t)));
46 assert(outline.cntrs);
50 static void _growOutlinePoint(SwOutline& outline, size_t n)
54 outline.pts = nullptr;
56 outline.tags = nullptr;
57 outline.reservedPtsCnt = 0;
62 if (outline.reservedPtsCnt >= outline.ptsCnt + n) return;
64 //cout << "Grow Pts: " << outline.reservedPtsCnt << " -> " << outline.ptsCnt + n << endl;
65 outline.reservedPtsCnt = n;
66 outline.pts = static_cast<SwPoint*>(realloc(outline.pts, n * sizeof(SwPoint)));
68 outline.tags = static_cast<char*>(realloc(outline.tags, n * sizeof(char)));
73 static void _outlineEnd(SwOutline& outline)
75 _growOutlineContour(outline, 1);
76 if (outline.ptsCnt > 0) {
77 outline.cntrs[outline.cntrsCnt] = outline.ptsCnt - 1;
83 static void _outlineMoveTo(SwOutline& outline, const Point* to)
87 _growOutlinePoint(outline, 1);
89 outline.pts[outline.ptsCnt] = TO_SWPOINT(to);
90 outline.tags[outline.ptsCnt] = SW_CURVE_TAG_ON;
92 if (outline.ptsCnt > 0) {
93 _growOutlineContour(outline, 1);
94 outline.cntrs[outline.cntrsCnt] = outline.ptsCnt - 1;
102 static void _outlineLineTo(SwOutline& outline, const Point* to)
106 _growOutlinePoint(outline, 1);
108 outline.pts[outline.ptsCnt] = TO_SWPOINT(to);
109 outline.tags[outline.ptsCnt] = SW_CURVE_TAG_ON;
115 static void _outlineCubicTo(SwOutline& outline, const Point* ctrl1, const Point* ctrl2, const Point* to)
117 assert(ctrl1 && ctrl2 && to);
119 _growOutlinePoint(outline, 3);
121 outline.pts[outline.ptsCnt] = TO_SWPOINT(ctrl1);
122 outline.tags[outline.ptsCnt] = SW_CURVE_TAG_CUBIC;
125 outline.pts[outline.ptsCnt] = TO_SWPOINT(ctrl2);
126 outline.tags[outline.ptsCnt] = SW_CURVE_TAG_CUBIC;
129 outline.pts[outline.ptsCnt] = TO_SWPOINT(to);
130 outline.tags[outline.ptsCnt] = SW_CURVE_TAG_ON;
135 static bool _outlineClose(SwOutline& outline)
139 if (outline.cntrsCnt > 0) {
140 i = outline.cntrs[outline.cntrsCnt - 1] + 1;
145 //Make sure there is at least one point in the current path
146 if (outline.ptsCnt == i) return false;
149 _growOutlinePoint(outline, 1);
151 outline.pts[outline.ptsCnt] = outline.pts[i];
152 outline.tags[outline.ptsCnt] = SW_CURVE_TAG_ON;
159 static void _initBBox(SwShape& sdata)
161 sdata.bbox.min.x = sdata.bbox.min.y = 0;
162 sdata.bbox.max.x = sdata.bbox.max.y = 0;
166 static bool _updateBBox(SwShape& sdata)
168 auto outline = sdata.outline;
171 auto pt = outline->pts;
174 if (outline->ptsCnt <= 0) {
186 for(size_t i = 1; i < outline->ptsCnt; ++i, ++pt) {
188 if (xMin > pt->x) xMin = pt->x;
189 if (xMax < pt->x) xMax = pt->x;
190 if (yMin > pt->y) yMin = pt->y;
191 if (yMax < pt->y) yMax = pt->y;
193 sdata.bbox.min.x = xMin >> 6;
194 sdata.bbox.max.x = (xMax + 63) >> 6;
195 sdata.bbox.min.y = yMin >> 6;
196 sdata.bbox.max.y = (yMax + 63) >> 6;
198 if (xMax - xMin < 1 || yMax - yMin < 1) return false;
204 void _deleteRle(SwShape& sdata)
207 if (sdata.rle->spans) free(sdata.rle->spans);
214 void _deleteOutline(SwShape& sdata)
216 if (!sdata.outline) return;
218 SwOutline* outline = sdata.outline;
219 if (outline->cntrs) free(outline->cntrs);
220 if (outline->pts) free(outline->pts);
221 if (outline->tags) free(outline->tags);
224 sdata.outline = nullptr;
227 /************************************************************************/
228 /* External Class Implementation */
229 /************************************************************************/
231 bool shapeTransformOutline(const ShapeNode& shape, SwShape& sdata)
238 bool shapeGenRle(const ShapeNode& shape, SwShape& sdata)
240 if (!_updateBBox(sdata)) goto end;
241 sdata.rle = rleRender(sdata);
242 _deleteOutline(sdata);
244 if (sdata.rle) return true;
249 void shapeReset(SwShape& sdata)
251 _deleteOutline(sdata);
257 bool shapeGenOutline(const ShapeNode& shape, SwShape& sdata)
259 const PathCommand* cmds = nullptr;
260 auto cmdCnt = shape.pathCommands(&cmds);
262 const Point* pts = nullptr;
263 auto ptsCnt = shape.pathCoords(&pts);
265 //No actual shape data
266 if (cmdCnt == 0 || ptsCnt == 0) return false;
269 auto outlinePtsCnt = 0;
270 auto outlineCntrsCnt = 0;
272 for (auto i = 0; i < cmdCnt; ++i) {
273 switch(*(cmds + i)) {
274 case PathCommand::Close: {
278 case PathCommand::MoveTo: {
283 case PathCommand::LineTo: {
287 case PathCommand::CubicTo: {
294 ++outlinePtsCnt; //for close
295 ++outlineCntrsCnt; //for end
297 SwOutline* outline = sdata.outline;
300 outline = static_cast<SwOutline*>(calloc(1, sizeof(SwOutline)));
303 cout << "Outline was already allocated? How?" << endl;
306 //TODO: Probabry we can copy pts from shape directly.
307 _growOutlinePoint(*outline, outlinePtsCnt);
308 _growOutlineContour(*outline, outlineCntrsCnt);
311 while (cmdCnt-- > 0) {
313 case PathCommand::Close: {
314 _outlineClose(*outline);
317 case PathCommand::MoveTo: {
318 _outlineMoveTo(*outline, pts);
322 case PathCommand::LineTo: {
323 _outlineLineTo(*outline, pts);
327 case PathCommand::CubicTo: {
328 _outlineCubicTo(*outline, pts, pts + 1, pts + 2);
336 _outlineEnd(*outline);
339 //outline->flags = SwOutline::FillRule::Winding;
341 sdata.outline = outline;
347 #endif /* _TVG_SW_SHAPE_H_ */