src/third_party/skia/src/effects/Sk1DPathEffect.cpp

   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
  15 bool 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
  34 SkPath1DPathEffect::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
  72 bool 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
  81 static 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
 108 Need differentially more subdivisions when the follow-path is curvy. Not sure how to
 109 determine that, but we need it. I guess a cheap answer is let the caller tell us,
 110 but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out.
 111 */
 112 static 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
 150 SkPath1DPathEffect::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
 164 SkScalar SkPath1DPathEffect::begin(SkScalar contourLength) const {
 165     return fInitialOffset;
 166 }
 167
 168 void 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
 178 SkScalar 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 }