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 "Sk1DPathEffect.h"
11#include "SkReadBuffer.h"
12#include "SkWriteBuffer.h"
13#include "SkPathMeasure.h"
14
15bool Sk1DPathEffect::filterPath(SkPath* dst, const SkPath& src,
16                                SkStrokeRec*, const SkRect*) const {
17    SkPathMeasure   meas(src, false);
18    do {
19        SkScalar    length = meas.getLength();
20        SkScalar    distance = this->begin(length);
21        while (distance < length) {
22            SkScalar delta = this->next(dst, distance, meas);
23            if (delta <= 0) {
24                break;
25            }
26            distance += delta;
27        }
28    } while (meas.nextContour());
29    return true;
30}
31
32///////////////////////////////////////////////////////////////////////////////
33
34SkPath1DPathEffect::SkPath1DPathEffect(const SkPath& path, SkScalar advance,
35    SkScalar phase, Style style) : fPath(path)
36{
37    if (advance <= 0 || path.isEmpty()) {
38        SkDEBUGF(("SkPath1DPathEffect can't use advance <= 0\n"));
39        fAdvance = 0;   // signals we can't draw anything
40        fInitialOffset = 0;
41        fStyle = kStyleCount;
42    } else {
43        // cleanup their phase parameter, inverting it so that it becomes an
44        // offset along the path (to match the interpretation in PostScript)
45        if (phase < 0) {
46            phase = -phase;
47            if (phase > advance) {
48                phase = SkScalarMod(phase, advance);
49            }
50        } else {
51            if (phase > advance) {
52                phase = SkScalarMod(phase, advance);
53            }
54            phase = advance - phase;
55        }
56        // now catch the edge case where phase == advance (within epsilon)
57        if (phase >= advance) {
58            phase = 0;
59        }
60        SkASSERT(phase >= 0);
61
62        fAdvance = advance;
63        fInitialOffset = phase;
64
65        if ((unsigned)style >= kStyleCount) {
66            SkDEBUGF(("SkPath1DPathEffect style enum out of range %d\n", style));
67        }
68        fStyle = style;
69    }
70}
71
72bool SkPath1DPathEffect::filterPath(SkPath* dst, const SkPath& src,
73                            SkStrokeRec* rec, const SkRect* cullRect) const {
74    if (fAdvance > 0) {
75        rec->setFillStyle();
76        return this->INHERITED::filterPath(dst, src, rec, cullRect);
77    }
78    return false;
79}
80
81static bool morphpoints(SkPoint dst[], const SkPoint src[], int count,
82                        SkPathMeasure& meas, SkScalar dist) {
83    for (int i = 0; i < count; i++) {
84        SkPoint pos;
85        SkVector tangent;
86
87        SkScalar sx = src[i].fX;
88        SkScalar sy = src[i].fY;
89
90        if (!meas.getPosTan(dist + sx, &pos, &tangent)) {
91            return false;
92        }
93
94        SkMatrix    matrix;
95        SkPoint     pt;
96
97        pt.set(sx, sy);
98        matrix.setSinCos(tangent.fY, tangent.fX, 0, 0);
99        matrix.preTranslate(-sx, 0);
100        matrix.postTranslate(pos.fX, pos.fY);
101        matrix.mapPoints(&dst[i], &pt, 1);
102    }
103    return true;
104}
105
106/*  TODO
107
108Need differentially more subdivisions when the follow-path is curvy. Not sure how to
109determine that, but we need it. I guess a cheap answer is let the caller tell us,
110but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out.
111*/
112static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas,
113                      SkScalar dist) {
114    SkPath::Iter    iter(src, false);
115    SkPoint         srcP[4], dstP[3];
116    SkPath::Verb    verb;
117
118    while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) {
119        switch (verb) {
120            case SkPath::kMove_Verb:
121                if (morphpoints(dstP, srcP, 1, meas, dist)) {
122                    dst->moveTo(dstP[0]);
123                }
124                break;
125            case SkPath::kLine_Verb:
126                srcP[2] = srcP[1];
127                srcP[1].set(SkScalarAve(srcP[0].fX, srcP[2].fX),
128                            SkScalarAve(srcP[0].fY, srcP[2].fY));
129                // fall through to quad
130            case SkPath::kQuad_Verb:
131                if (morphpoints(dstP, &srcP[1], 2, meas, dist)) {
132                    dst->quadTo(dstP[0], dstP[1]);
133                }
134                break;
135            case SkPath::kCubic_Verb:
136                if (morphpoints(dstP, &srcP[1], 3, meas, dist)) {
137                    dst->cubicTo(dstP[0], dstP[1], dstP[2]);
138                }
139                break;
140            case SkPath::kClose_Verb:
141                dst->close();
142                break;
143            default:
144                SkDEBUGFAIL("unknown verb");
145                break;
146        }
147    }
148}
149
150SkPath1DPathEffect::SkPath1DPathEffect(SkReadBuffer& buffer) {
151    fAdvance = buffer.readScalar();
152    if (fAdvance > 0) {
153        buffer.readPath(&fPath);
154        fInitialOffset = buffer.readScalar();
155        fStyle = (Style) buffer.readUInt();
156    } else {
157        SkDEBUGF(("SkPath1DPathEffect can't use advance <= 0\n"));
158        // Make Coverity happy.
159        fInitialOffset = 0;
160        fStyle = kStyleCount;
161    }
162}
163
164SkScalar SkPath1DPathEffect::begin(SkScalar contourLength) const {
165    return fInitialOffset;
166}
167
168void SkPath1DPathEffect::flatten(SkWriteBuffer& buffer) const {
169    this->INHERITED::flatten(buffer);
170    buffer.writeScalar(fAdvance);
171    if (fAdvance > 0) {
172        buffer.writePath(fPath);
173        buffer.writeScalar(fInitialOffset);
174        buffer.writeUInt(fStyle);
175    }
176}
177
178SkScalar SkPath1DPathEffect::next(SkPath* dst, SkScalar distance,
179                                  SkPathMeasure& meas) const {
180    switch (fStyle) {
181        case kTranslate_Style: {
182            SkPoint pos;
183            if (meas.getPosTan(distance, &pos, NULL)) {
184                dst->addPath(fPath, pos.fX, pos.fY);
185            }
186        } break;
187        case kRotate_Style: {
188            SkMatrix matrix;
189            if (meas.getMatrix(distance, &matrix)) {
190                dst->addPath(fPath, matrix);
191            }
192        } break;
193        case kMorph_Style:
194            morphpath(dst, fPath, meas, distance);
195            break;
196        default:
197            SkDEBUGFAIL("unknown Style enum");
198            break;
199    }
200    return fAdvance;
201}
202