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