submodule/skia/src/effects/Sk1DPathEffect.cpp

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