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 /************************************************************************/
205 /* External Class Implementation */
206 /************************************************************************/
208 bool shapeTransformOutline(const ShapeNode& shape, SwShape& sdata)
215 void shapeDelRle(const ShapeNode& shape, SwShape& sdata)
217 if (sdata.rle.spans) free(sdata.rle.spans);
218 sdata.rle.spans = nullptr;
222 bool shapeGenRle(const ShapeNode& shape, SwShape& sdata)
224 shapeDelRle(shape, sdata);
225 if (!updateBBox(sdata)) return false;
226 return rleRender(sdata);
230 void shapeDelOutline(const ShapeNode& shape, SwShape& sdata)
232 if (!sdata.outline) return;
234 SwOutline* outline = sdata.outline;
235 if (outline->cntrs) free(outline->cntrs);
236 if (outline->pts) free(outline->pts);
237 if (outline->tags) free(outline->tags);
240 sdata.outline = nullptr;
244 bool shapeGenOutline(const ShapeNode& shape, SwShape& sdata)
248 const PathCommand* cmds = nullptr;
249 auto cmdCnt = shape.pathCommands(&cmds);
251 const Point* pts = nullptr;
252 auto ptsCnt = shape.pathCoords(&pts);
254 //No actual shape data
255 if (cmdCnt == 0 || ptsCnt == 0) return false;
258 auto outlinePtsCnt = 0;
259 auto outlineCntrsCnt = 0;
260 // auto closed = false;
262 for (auto i = 0; i < cmdCnt; ++i) {
263 switch(*(cmds + i)) {
264 case PathCommand::Close: {
268 case PathCommand::MoveTo: {
273 case PathCommand::LineTo: {
277 case PathCommand::CubicTo: {
284 ++outlinePtsCnt; //for close
285 ++outlineCntrsCnt; //for end
287 SwOutline* outline = sdata.outline;
290 outline = static_cast<SwOutline*>(calloc(1, sizeof(SwOutline)));
293 cout << "Outline was already allocated? How?" << endl;
296 //TODO: Probabry we can copy pts from shape directly.
297 growOutlinePoint(*outline, outlinePtsCnt);
298 growOutlineContour(*outline, outlineCntrsCnt);
301 while (cmdCnt-- > 0) {
303 case PathCommand::Close: {
304 outlineClose(*outline);
307 case PathCommand::MoveTo: {
308 outlineMoveTo(*outline, pts);
312 case PathCommand::LineTo: {
313 outlineLineTo(*outline, pts);
317 case PathCommand::CubicTo: {
318 outlineCubicTo(*outline, pts, pts + 1, pts + 2);
326 outlineEnd(*outline);
329 //outline->flags = SwOutline::FillRule::Winding;
331 sdata.outline = outline;
337 #endif /* _TVG_SW_SHAPE_H_ */