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