The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/core/SkStrokerPriv.cpp

gfx/skia/trunk/src/core/SkStrokerPriv.cpp

branch
TOR_BUG_3246
changeset 6
8bccb770b82d
equal deleted inserted replaced
-1:000000000000 0:c92737859de2
1
2 /*
3 * Copyright 2006 The Android Open Source Project
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10 #include "SkStrokerPriv.h"
11 #include "SkGeometry.h"
12 #include "SkPath.h"
13
14 static void ButtCapper(SkPath* path, const SkPoint& pivot,
15 const SkVector& normal, const SkPoint& stop,
16 SkPath*)
17 {
18 path->lineTo(stop.fX, stop.fY);
19 }
20
21 static void RoundCapper(SkPath* path, const SkPoint& pivot,
22 const SkVector& normal, const SkPoint& stop,
23 SkPath*)
24 {
25 SkScalar px = pivot.fX;
26 SkScalar py = pivot.fY;
27 SkScalar nx = normal.fX;
28 SkScalar ny = normal.fY;
29 SkScalar sx = SkScalarMul(nx, CUBIC_ARC_FACTOR);
30 SkScalar sy = SkScalarMul(ny, CUBIC_ARC_FACTOR);
31
32 path->cubicTo(px + nx + CWX(sx, sy), py + ny + CWY(sx, sy),
33 px + CWX(nx, ny) + sx, py + CWY(nx, ny) + sy,
34 px + CWX(nx, ny), py + CWY(nx, ny));
35 path->cubicTo(px + CWX(nx, ny) - sx, py + CWY(nx, ny) - sy,
36 px - nx + CWX(sx, sy), py - ny + CWY(sx, sy),
37 stop.fX, stop.fY);
38 }
39
40 static void SquareCapper(SkPath* path, const SkPoint& pivot,
41 const SkVector& normal, const SkPoint& stop,
42 SkPath* otherPath)
43 {
44 SkVector parallel;
45 normal.rotateCW(&parallel);
46
47 if (otherPath)
48 {
49 path->setLastPt(pivot.fX + normal.fX + parallel.fX, pivot.fY + normal.fY + parallel.fY);
50 path->lineTo(pivot.fX - normal.fX + parallel.fX, pivot.fY - normal.fY + parallel.fY);
51 }
52 else
53 {
54 path->lineTo(pivot.fX + normal.fX + parallel.fX, pivot.fY + normal.fY + parallel.fY);
55 path->lineTo(pivot.fX - normal.fX + parallel.fX, pivot.fY - normal.fY + parallel.fY);
56 path->lineTo(stop.fX, stop.fY);
57 }
58 }
59
60 /////////////////////////////////////////////////////////////////////////////
61
62 static bool is_clockwise(const SkVector& before, const SkVector& after)
63 {
64 return SkScalarMul(before.fX, after.fY) - SkScalarMul(before.fY, after.fX) > 0;
65 }
66
67 enum AngleType {
68 kNearly180_AngleType,
69 kSharp_AngleType,
70 kShallow_AngleType,
71 kNearlyLine_AngleType
72 };
73
74 static AngleType Dot2AngleType(SkScalar dot)
75 {
76 // need more precise fixed normalization
77 // SkASSERT(SkScalarAbs(dot) <= SK_Scalar1 + SK_ScalarNearlyZero);
78
79 if (dot >= 0) // shallow or line
80 return SkScalarNearlyZero(SK_Scalar1 - dot) ? kNearlyLine_AngleType : kShallow_AngleType;
81 else // sharp or 180
82 return SkScalarNearlyZero(SK_Scalar1 + dot) ? kNearly180_AngleType : kSharp_AngleType;
83 }
84
85 static void HandleInnerJoin(SkPath* inner, const SkPoint& pivot, const SkVector& after)
86 {
87 #if 1
88 /* In the degenerate case that the stroke radius is larger than our segments
89 just connecting the two inner segments may "show through" as a funny
90 diagonal. To pseudo-fix this, we go through the pivot point. This adds
91 an extra point/edge, but I can't see a cheap way to know when this is
92 not needed :(
93 */
94 inner->lineTo(pivot.fX, pivot.fY);
95 #endif
96
97 inner->lineTo(pivot.fX - after.fX, pivot.fY - after.fY);
98 }
99
100 static void BluntJoiner(SkPath* outer, SkPath* inner, const SkVector& beforeUnitNormal,
101 const SkPoint& pivot, const SkVector& afterUnitNormal,
102 SkScalar radius, SkScalar invMiterLimit, bool, bool)
103 {
104 SkVector after;
105 afterUnitNormal.scale(radius, &after);
106
107 if (!is_clockwise(beforeUnitNormal, afterUnitNormal))
108 {
109 SkTSwap<SkPath*>(outer, inner);
110 after.negate();
111 }
112
113 outer->lineTo(pivot.fX + after.fX, pivot.fY + after.fY);
114 HandleInnerJoin(inner, pivot, after);
115 }
116
117 static void RoundJoiner(SkPath* outer, SkPath* inner, const SkVector& beforeUnitNormal,
118 const SkPoint& pivot, const SkVector& afterUnitNormal,
119 SkScalar radius, SkScalar invMiterLimit, bool, bool)
120 {
121 SkScalar dotProd = SkPoint::DotProduct(beforeUnitNormal, afterUnitNormal);
122 AngleType angleType = Dot2AngleType(dotProd);
123
124 if (angleType == kNearlyLine_AngleType)
125 return;
126
127 SkVector before = beforeUnitNormal;
128 SkVector after = afterUnitNormal;
129 SkRotationDirection dir = kCW_SkRotationDirection;
130
131 if (!is_clockwise(before, after))
132 {
133 SkTSwap<SkPath*>(outer, inner);
134 before.negate();
135 after.negate();
136 dir = kCCW_SkRotationDirection;
137 }
138
139 SkPoint pts[kSkBuildQuadArcStorage];
140 SkMatrix matrix;
141 matrix.setScale(radius, radius);
142 matrix.postTranslate(pivot.fX, pivot.fY);
143 int count = SkBuildQuadArc(before, after, dir, &matrix, pts);
144 SkASSERT((count & 1) == 1);
145
146 if (count > 1)
147 {
148 for (int i = 1; i < count; i += 2)
149 outer->quadTo(pts[i].fX, pts[i].fY, pts[i+1].fX, pts[i+1].fY);
150
151 after.scale(radius);
152 HandleInnerJoin(inner, pivot, after);
153 }
154 }
155
156 #define kOneOverSqrt2 (0.707106781f)
157
158 static void MiterJoiner(SkPath* outer, SkPath* inner, const SkVector& beforeUnitNormal,
159 const SkPoint& pivot, const SkVector& afterUnitNormal,
160 SkScalar radius, SkScalar invMiterLimit,
161 bool prevIsLine, bool currIsLine)
162 {
163 // negate the dot since we're using normals instead of tangents
164 SkScalar dotProd = SkPoint::DotProduct(beforeUnitNormal, afterUnitNormal);
165 AngleType angleType = Dot2AngleType(dotProd);
166 SkVector before = beforeUnitNormal;
167 SkVector after = afterUnitNormal;
168 SkVector mid;
169 SkScalar sinHalfAngle;
170 bool ccw;
171
172 if (angleType == kNearlyLine_AngleType)
173 return;
174 if (angleType == kNearly180_AngleType)
175 {
176 currIsLine = false;
177 goto DO_BLUNT;
178 }
179
180 ccw = !is_clockwise(before, after);
181 if (ccw)
182 {
183 SkTSwap<SkPath*>(outer, inner);
184 before.negate();
185 after.negate();
186 }
187
188 /* Before we enter the world of square-roots and divides,
189 check if we're trying to join an upright right angle
190 (common case for stroking rectangles). If so, special case
191 that (for speed an accuracy).
192 Note: we only need to check one normal if dot==0
193 */
194 if (0 == dotProd && invMiterLimit <= kOneOverSqrt2)
195 {
196 mid.set(SkScalarMul(before.fX + after.fX, radius),
197 SkScalarMul(before.fY + after.fY, radius));
198 goto DO_MITER;
199 }
200
201 /* midLength = radius / sinHalfAngle
202 if (midLength > miterLimit * radius) abort
203 if (radius / sinHalf > miterLimit * radius) abort
204 if (1 / sinHalf > miterLimit) abort
205 if (1 / miterLimit > sinHalf) abort
206 My dotProd is opposite sign, since it is built from normals and not tangents
207 hence 1 + dot instead of 1 - dot in the formula
208 */
209 sinHalfAngle = SkScalarSqrt(SkScalarHalf(SK_Scalar1 + dotProd));
210 if (sinHalfAngle < invMiterLimit)
211 {
212 currIsLine = false;
213 goto DO_BLUNT;
214 }
215
216 // choose the most accurate way to form the initial mid-vector
217 if (angleType == kSharp_AngleType)
218 {
219 mid.set(after.fY - before.fY, before.fX - after.fX);
220 if (ccw)
221 mid.negate();
222 }
223 else
224 mid.set(before.fX + after.fX, before.fY + after.fY);
225
226 mid.setLength(SkScalarDiv(radius, sinHalfAngle));
227 DO_MITER:
228 if (prevIsLine)
229 outer->setLastPt(pivot.fX + mid.fX, pivot.fY + mid.fY);
230 else
231 outer->lineTo(pivot.fX + mid.fX, pivot.fY + mid.fY);
232
233 DO_BLUNT:
234 after.scale(radius);
235 if (!currIsLine)
236 outer->lineTo(pivot.fX + after.fX, pivot.fY + after.fY);
237 HandleInnerJoin(inner, pivot, after);
238 }
239
240 /////////////////////////////////////////////////////////////////////////////
241
242 SkStrokerPriv::CapProc SkStrokerPriv::CapFactory(SkPaint::Cap cap)
243 {
244 static const SkStrokerPriv::CapProc gCappers[] = {
245 ButtCapper, RoundCapper, SquareCapper
246 };
247
248 SkASSERT((unsigned)cap < SkPaint::kCapCount);
249 return gCappers[cap];
250 }
251
252 SkStrokerPriv::JoinProc SkStrokerPriv::JoinFactory(SkPaint::Join join)
253 {
254 static const SkStrokerPriv::JoinProc gJoiners[] = {
255 MiterJoiner, RoundJoiner, BluntJoiner
256 };
257
258 SkASSERT((unsigned)join < SkPaint::kJoinCount);
259 return gJoiners[join];
260 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial