1/*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "SkDashPathEffect.h"
9
10#include "SkDashPathPriv.h"
11#include "SkReadBuffer.h"
12#include "SkWriteBuffer.h"
13#include "SkStrokeRec.h"
14
15SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count, SkScalar phase)
16        : fPhase(0)
17        , fInitialDashLength(0)
18        , fInitialDashIndex(0)
19        , fIntervalLength(0) {
20    SkASSERT(intervals);
21    SkASSERT(count > 1 && SkAlign2(count) == count);
22
23    fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count);
24    fCount = count;
25    for (int i = 0; i < count; i++) {
26        SkASSERT(intervals[i] >= 0);
27        fIntervals[i] = intervals[i];
28    }
29
30    // set the internal data members
31    SkDashPath::CalcDashParameters(phase, fIntervals, fCount,
32            &fInitialDashLength, &fInitialDashIndex, &fIntervalLength, &fPhase);
33}
34
35SkDashPathEffect::~SkDashPathEffect() {
36    sk_free(fIntervals);
37}
38
39bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src,
40                              SkStrokeRec* rec, const SkRect* cullRect) const {
41    return SkDashPath::FilterDashPath(dst, src, rec, cullRect, fIntervals, fCount,
42                                      fInitialDashLength, fInitialDashIndex, fIntervalLength);
43}
44
45static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) {
46    SkScalar radius = SkScalarHalf(rec.getWidth());
47    if (0 == radius) {
48        radius = SK_Scalar1;    // hairlines
49    }
50    if (SkPaint::kMiter_Join == rec.getJoin()) {
51        radius = SkScalarMul(radius, rec.getMiter());
52    }
53    rect->outset(radius, radius);
54}
55
56// Attempt to trim the line to minimally cover the cull rect (currently
57// only works for horizontal and vertical lines).
58// Return true if processing should continue; false otherwise.
59static bool cull_line(SkPoint* pts, const SkStrokeRec& rec,
60                      const SkMatrix& ctm, const SkRect* cullRect,
61                      const SkScalar intervalLength) {
62    if (nullptr == cullRect) {
63        SkASSERT(false); // Shouldn't ever occur in practice
64        return false;
65    }
66
67    SkScalar dx = pts[1].x() - pts[0].x();
68    SkScalar dy = pts[1].y() - pts[0].y();
69
70    if ((dx && dy) || (!dx && !dy)) {
71        return false;
72    }
73
74    SkRect bounds = *cullRect;
75    outset_for_stroke(&bounds, rec);
76
77    // cullRect is in device space while pts are in the local coordinate system
78    // defined by the ctm. We want our answer in the local coordinate system.
79
80    SkASSERT(ctm.rectStaysRect());
81    SkMatrix inv;
82    if (!ctm.invert(&inv)) {
83        return false;
84    }
85
86    inv.mapRect(&bounds);
87
88    if (dx) {
89        SkASSERT(dx && !dy);
90        SkScalar minX = pts[0].fX;
91        SkScalar maxX = pts[1].fX;
92
93        if (dx < 0) {
94            SkTSwap(minX, maxX);
95        }
96
97        SkASSERT(minX < maxX);
98        if (maxX <= bounds.fLeft || minX >= bounds.fRight) {
99            return false;
100        }
101
102        // Now we actually perform the chop, removing the excess to the left and
103        // right of the bounds (keeping our new line "in phase" with the dash,
104        // hence the (mod intervalLength).
105
106        if (minX < bounds.fLeft) {
107            minX = bounds.fLeft - SkScalarMod(bounds.fLeft - minX, intervalLength);
108        }
109        if (maxX > bounds.fRight) {
110            maxX = bounds.fRight + SkScalarMod(maxX - bounds.fRight, intervalLength);
111        }
112
113        SkASSERT(maxX > minX);
114        if (dx < 0) {
115            SkTSwap(minX, maxX);
116        }
117        pts[0].fX = minX;
118        pts[1].fX = maxX;
119    } else {
120        SkASSERT(dy && !dx);
121        SkScalar minY = pts[0].fY;
122        SkScalar maxY = pts[1].fY;
123
124        if (dy < 0) {
125            SkTSwap(minY, maxY);
126        }
127
128        SkASSERT(minY < maxY);
129        if (maxY <= bounds.fTop || minY >= bounds.fBottom) {
130            return false;
131        }
132
133        // Now we actually perform the chop, removing the excess to the top and
134        // bottom of the bounds (keeping our new line "in phase" with the dash,
135        // hence the (mod intervalLength).
136
137        if (minY < bounds.fTop) {
138            minY = bounds.fTop - SkScalarMod(bounds.fTop - minY, intervalLength);
139        }
140        if (maxY > bounds.fBottom) {
141            maxY = bounds.fBottom + SkScalarMod(maxY - bounds.fBottom, intervalLength);
142        }
143
144        SkASSERT(maxY > minY);
145        if (dy < 0) {
146            SkTSwap(minY, maxY);
147        }
148        pts[0].fY = minY;
149        pts[1].fY = maxY;
150    }
151
152    return true;
153}
154
155// Currently asPoints is more restrictive then it needs to be. In the future
156// we need to:
157//      allow kRound_Cap capping (could allow rotations in the matrix with this)
158//      allow paths to be returned
159bool SkDashPathEffect::asPoints(PointData* results,
160                                const SkPath& src,
161                                const SkStrokeRec& rec,
162                                const SkMatrix& matrix,
163                                const SkRect* cullRect) const {
164    // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out
165    if (fInitialDashLength < 0 || 0 >= rec.getWidth()) {
166        return false;
167    }
168
169    // TODO: this next test could be eased up. We could allow any number of
170    // intervals as long as all the ons match and all the offs match.
171    // Additionally, they do not necessarily need to be integers.
172    // We cannot allow arbitrary intervals since we want the returned points
173    // to be uniformly sized.
174    if (fCount != 2 ||
175        !SkScalarNearlyEqual(fIntervals[0], fIntervals[1]) ||
176        !SkScalarIsInt(fIntervals[0]) ||
177        !SkScalarIsInt(fIntervals[1])) {
178        return false;
179    }
180
181    SkPoint pts[2];
182
183    if (!src.isLine(pts)) {
184        return false;
185    }
186
187    // TODO: this test could be eased up to allow circles
188    if (SkPaint::kButt_Cap != rec.getCap()) {
189        return false;
190    }
191
192    // TODO: this test could be eased up for circles. Rotations could be allowed.
193    if (!matrix.rectStaysRect()) {
194        return false;
195    }
196
197    // See if the line can be limited to something plausible.
198    if (!cull_line(pts, rec, matrix, cullRect, fIntervalLength)) {
199        return false;
200    }
201
202    SkScalar length = SkPoint::Distance(pts[1], pts[0]);
203
204    SkVector tangent = pts[1] - pts[0];
205    if (tangent.isZero()) {
206        return false;
207    }
208
209    tangent.scale(SkScalarInvert(length));
210
211    // TODO: make this test for horizontal & vertical lines more robust
212    bool isXAxis = true;
213    if (SkScalarNearlyEqual(SK_Scalar1, tangent.fX) ||
214        SkScalarNearlyEqual(-SK_Scalar1, tangent.fX)) {
215        results->fSize.set(SkScalarHalf(fIntervals[0]), SkScalarHalf(rec.getWidth()));
216    } else if (SkScalarNearlyEqual(SK_Scalar1, tangent.fY) ||
217               SkScalarNearlyEqual(-SK_Scalar1, tangent.fY)) {
218        results->fSize.set(SkScalarHalf(rec.getWidth()), SkScalarHalf(fIntervals[0]));
219        isXAxis = false;
220    } else if (SkPaint::kRound_Cap != rec.getCap()) {
221        // Angled lines don't have axis-aligned boxes.
222        return false;
223    }
224
225    if (results) {
226        results->fFlags = 0;
227        SkScalar clampedInitialDashLength = SkMinScalar(length, fInitialDashLength);
228
229        if (SkPaint::kRound_Cap == rec.getCap()) {
230            results->fFlags |= PointData::kCircles_PointFlag;
231        }
232
233        results->fNumPoints = 0;
234        SkScalar len2 = length;
235        if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
236            SkASSERT(len2 >= clampedInitialDashLength);
237            if (0 == fInitialDashIndex) {
238                if (clampedInitialDashLength > 0) {
239                    if (clampedInitialDashLength >= fIntervals[0]) {
240                        ++results->fNumPoints;  // partial first dash
241                    }
242                    len2 -= clampedInitialDashLength;
243                }
244                len2 -= fIntervals[1];  // also skip first space
245                if (len2 < 0) {
246                    len2 = 0;
247                }
248            } else {
249                len2 -= clampedInitialDashLength; // skip initial partial empty
250            }
251        }
252        int numMidPoints = SkScalarFloorToInt(len2 / fIntervalLength);
253        results->fNumPoints += numMidPoints;
254        len2 -= numMidPoints * fIntervalLength;
255        bool partialLast = false;
256        if (len2 > 0) {
257            if (len2 < fIntervals[0]) {
258                partialLast = true;
259            } else {
260                ++numMidPoints;
261                ++results->fNumPoints;
262            }
263        }
264
265        results->fPoints = new SkPoint[results->fNumPoints];
266
267        SkScalar    distance = 0;
268        int         curPt = 0;
269
270        if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
271            SkASSERT(clampedInitialDashLength <= length);
272
273            if (0 == fInitialDashIndex) {
274                if (clampedInitialDashLength > 0) {
275                    // partial first block
276                    SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
277                    SkScalar x = pts[0].fX + SkScalarMul(tangent.fX, SkScalarHalf(clampedInitialDashLength));
278                    SkScalar y = pts[0].fY + SkScalarMul(tangent.fY, SkScalarHalf(clampedInitialDashLength));
279                    SkScalar halfWidth, halfHeight;
280                    if (isXAxis) {
281                        halfWidth = SkScalarHalf(clampedInitialDashLength);
282                        halfHeight = SkScalarHalf(rec.getWidth());
283                    } else {
284                        halfWidth = SkScalarHalf(rec.getWidth());
285                        halfHeight = SkScalarHalf(clampedInitialDashLength);
286                    }
287                    if (clampedInitialDashLength < fIntervals[0]) {
288                        // This one will not be like the others
289                        results->fFirst.addRect(x - halfWidth, y - halfHeight,
290                                                x + halfWidth, y + halfHeight);
291                    } else {
292                        SkASSERT(curPt < results->fNumPoints);
293                        results->fPoints[curPt].set(x, y);
294                        ++curPt;
295                    }
296
297                    distance += clampedInitialDashLength;
298                }
299
300                distance += fIntervals[1];  // skip over the next blank block too
301            } else {
302                distance += clampedInitialDashLength;
303            }
304        }
305
306        if (0 != numMidPoints) {
307            distance += SkScalarHalf(fIntervals[0]);
308
309            for (int i = 0; i < numMidPoints; ++i) {
310                SkScalar x = pts[0].fX + SkScalarMul(tangent.fX, distance);
311                SkScalar y = pts[0].fY + SkScalarMul(tangent.fY, distance);
312
313                SkASSERT(curPt < results->fNumPoints);
314                results->fPoints[curPt].set(x, y);
315                ++curPt;
316
317                distance += fIntervalLength;
318            }
319
320            distance -= SkScalarHalf(fIntervals[0]);
321        }
322
323        if (partialLast) {
324            // partial final block
325            SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
326            SkScalar temp = length - distance;
327            SkASSERT(temp < fIntervals[0]);
328            SkScalar x = pts[0].fX + SkScalarMul(tangent.fX, distance + SkScalarHalf(temp));
329            SkScalar y = pts[0].fY + SkScalarMul(tangent.fY, distance + SkScalarHalf(temp));
330            SkScalar halfWidth, halfHeight;
331            if (isXAxis) {
332                halfWidth = SkScalarHalf(temp);
333                halfHeight = SkScalarHalf(rec.getWidth());
334            } else {
335                halfWidth = SkScalarHalf(rec.getWidth());
336                halfHeight = SkScalarHalf(temp);
337            }
338            results->fLast.addRect(x - halfWidth, y - halfHeight,
339                                   x + halfWidth, y + halfHeight);
340        }
341
342        SkASSERT(curPt == results->fNumPoints);
343    }
344
345    return true;
346}
347
348SkPathEffect::DashType SkDashPathEffect::asADash(DashInfo* info) const {
349    if (info) {
350        if (info->fCount >= fCount && info->fIntervals) {
351            memcpy(info->fIntervals, fIntervals, fCount * sizeof(SkScalar));
352        }
353        info->fCount = fCount;
354        info->fPhase = fPhase;
355    }
356    return kDash_DashType;
357}
358
359void SkDashPathEffect::flatten(SkWriteBuffer& buffer) const {
360    buffer.writeScalar(fPhase);
361    buffer.writeScalarArray(fIntervals, fCount);
362}
363
364SkFlattenable* SkDashPathEffect::CreateProc(SkReadBuffer& buffer) {
365    const SkScalar phase = buffer.readScalar();
366    uint32_t count = buffer.getArrayCount();
367    SkAutoSTArray<32, SkScalar> intervals(count);
368    if (buffer.readScalarArray(intervals.get(), count)) {
369        return Create(intervals.get(), SkToInt(count), phase);
370    }
371    return nullptr;
372}
373
374#ifndef SK_IGNORE_TO_STRING
375void SkDashPathEffect::toString(SkString* str) const {
376    str->appendf("SkDashPathEffect: (");
377    str->appendf("count: %d phase %.2f intervals: (", fCount, fPhase);
378    for (int i = 0; i < fCount; ++i) {
379        str->appendf("%.2f", fIntervals[i]);
380        if (i < fCount-1) {
381            str->appendf(", ");
382        }
383    }
384    str->appendf("))");
385}
386#endif
387
388//////////////////////////////////////////////////////////////////////////////////////////////////
389
390SkPathEffect* SkDashPathEffect::Create(const SkScalar intervals[], int count, SkScalar phase) {
391    if ((count < 2) || !SkIsAlign2(count)) {
392        return nullptr;
393    }
394    for (int i = 0; i < count; i++) {
395        if (intervals[i] < 0) {
396            return nullptr;
397        }
398    }
399    return new SkDashPathEffect(intervals, count, phase);
400}
401