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 #include "SkDashPathEffect.h"
      9 
     10 #include "SkDashPathPriv.h"
     11 #include "SkReadBuffer.h"
     12 #include "SkWriteBuffer.h"
     13 
     14 SkDashPathEffect::SkDashPathEffect(const SkScalar intervals[], int count, SkScalar phase)
     15         : fPhase(0)
     16         , fInitialDashLength(0)
     17         , fInitialDashIndex(0)
     18         , fIntervalLength(0) {
     19     SkASSERT(intervals);
     20     SkASSERT(count > 1 && SkAlign2(count) == count);
     21 
     22     fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count);
     23     fCount = count;
     24     for (int i = 0; i < count; i++) {
     25         SkASSERT(intervals[i] >= 0);
     26         fIntervals[i] = intervals[i];
     27     }
     28 
     29     // set the internal data members
     30     SkDashPath::CalcDashParameters(phase, fIntervals, fCount,
     31             &fInitialDashLength, &fInitialDashIndex, &fIntervalLength, &fPhase);
     32 }
     33 
     34 SkDashPathEffect::~SkDashPathEffect() {
     35     sk_free(fIntervals);
     36 }
     37 
     38 bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src,
     39                               SkStrokeRec* rec, const SkRect* cullRect) const {
     40     return SkDashPath::FilterDashPath(dst, src, rec, cullRect, fIntervals, fCount,
     41                                       fInitialDashLength, fInitialDashIndex, fIntervalLength);
     42 }
     43 
     44 static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) {
     45     SkScalar radius = SkScalarHalf(rec.getWidth());
     46     if (0 == radius) {
     47         radius = SK_Scalar1;    // hairlines
     48     }
     49     if (SkPaint::kMiter_Join == rec.getJoin()) {
     50         radius = SkScalarMul(radius, rec.getMiter());
     51     }
     52     rect->outset(radius, radius);
     53 }
     54 
     55 // Attempt to trim the line to minimally cover the cull rect (currently
     56 // only works for horizontal and vertical lines).
     57 // Return true if processing should continue; false otherwise.
     58 static bool cull_line(SkPoint* pts, const SkStrokeRec& rec,
     59                       const SkMatrix& ctm, const SkRect* cullRect,
     60                       const SkScalar intervalLength) {
     61     if (NULL == cullRect) {
     62         SkASSERT(false); // Shouldn't ever occur in practice
     63         return false;
     64     }
     65 
     66     SkScalar dx = pts[1].x() - pts[0].x();
     67     SkScalar dy = pts[1].y() - pts[0].y();
     68 
     69     if ((dx && dy) || (!dx && !dy)) {
     70         return false;
     71     }
     72 
     73     SkRect bounds = *cullRect;
     74     outset_for_stroke(&bounds, rec);
     75 
     76     // cullRect is in device space while pts are in the local coordinate system
     77     // defined by the ctm. We want our answer in the local coordinate system.
     78 
     79     SkASSERT(ctm.rectStaysRect());
     80     SkMatrix inv;
     81     if (!ctm.invert(&inv)) {
     82         return false;
     83     }
     84 
     85     inv.mapRect(&bounds);
     86 
     87     if (dx) {
     88         SkASSERT(dx && !dy);
     89         SkScalar minX = pts[0].fX;
     90         SkScalar maxX = pts[1].fX;
     91 
     92         if (dx < 0) {
     93             SkTSwap(minX, maxX);
     94         }
     95 
     96         SkASSERT(minX < maxX);
     97         if (maxX < bounds.fLeft || minX > bounds.fRight) {
     98             return false;
     99         }
    100 
    101         // Now we actually perform the chop, removing the excess to the left and
    102         // right of the bounds (keeping our new line "in phase" with the dash,
    103         // hence the (mod intervalLength).
    104 
    105         if (minX < bounds.fLeft) {
    106             minX = bounds.fLeft - SkScalarMod(bounds.fLeft - minX, intervalLength);
    107         }
    108         if (maxX > bounds.fRight) {
    109             maxX = bounds.fRight + SkScalarMod(maxX - bounds.fRight, intervalLength);
    110         }
    111 
    112         SkASSERT(maxX > minX);
    113         if (dx < 0) {
    114             SkTSwap(minX, maxX);
    115         }
    116         pts[0].fX = minX;
    117         pts[1].fX = maxX;
    118     } else {
    119         SkASSERT(dy && !dx);
    120         SkScalar minY = pts[0].fY;
    121         SkScalar maxY = pts[1].fY;
    122 
    123         if (dy < 0) {
    124             SkTSwap(minY, maxY);
    125         }
    126 
    127         SkASSERT(minY < maxY);
    128         if (maxY < bounds.fTop || minY > bounds.fBottom) {
    129             return false;
    130         }
    131 
    132         // Now we actually perform the chop, removing the excess to the top and
    133         // bottom of the bounds (keeping our new line "in phase" with the dash,
    134         // hence the (mod intervalLength).
    135 
    136         if (minY < bounds.fTop) {
    137             minY = bounds.fTop - SkScalarMod(bounds.fTop - minY, intervalLength);
    138         }
    139         if (maxY > bounds.fBottom) {
    140             maxY = bounds.fBottom + SkScalarMod(maxY - bounds.fBottom, intervalLength);
    141         }
    142 
    143         SkASSERT(maxY > minY);
    144         if (dy < 0) {
    145             SkTSwap(minY, maxY);
    146         }
    147         pts[0].fY = minY;
    148         pts[1].fY = maxY;
    149     }
    150 
    151     return true;
    152 }
    153 
    154 // Currently asPoints is more restrictive then it needs to be. In the future
    155 // we need to:
    156 //      allow kRound_Cap capping (could allow rotations in the matrix with this)
    157 //      allow paths to be returned
    158 bool SkDashPathEffect::asPoints(PointData* results,
    159                                 const SkPath& src,
    160                                 const SkStrokeRec& rec,
    161                                 const SkMatrix& matrix,
    162                                 const SkRect* cullRect) const {
    163     // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out
    164     if (fInitialDashLength < 0 || 0 >= rec.getWidth()) {
    165         return false;
    166     }
    167 
    168     // TODO: this next test could be eased up. We could allow any number of
    169     // intervals as long as all the ons match and all the offs match.
    170     // Additionally, they do not necessarily need to be integers.
    171     // We cannot allow arbitrary intervals since we want the returned points
    172     // to be uniformly sized.
    173     if (fCount != 2 ||
    174         !SkScalarNearlyEqual(fIntervals[0], fIntervals[1]) ||
    175         !SkScalarIsInt(fIntervals[0]) ||
    176         !SkScalarIsInt(fIntervals[1])) {
    177         return false;
    178     }
    179 
    180     SkPoint pts[2];
    181 
    182     if (!src.isLine(pts)) {
    183         return false;
    184     }
    185 
    186     // TODO: this test could be eased up to allow circles
    187     if (SkPaint::kButt_Cap != rec.getCap()) {
    188         return false;
    189     }
    190 
    191     // TODO: this test could be eased up for circles. Rotations could be allowed.
    192     if (!matrix.rectStaysRect()) {
    193         return false;
    194     }
    195 
    196     // See if the line can be limited to something plausible.
    197     if (!cull_line(pts, rec, matrix, cullRect, fIntervalLength)) {
    198         return false;
    199     }
    200 
    201     SkScalar length = SkPoint::Distance(pts[1], pts[0]);
    202 
    203     SkVector tangent = pts[1] - pts[0];
    204     if (tangent.isZero()) {
    205         return false;
    206     }
    207 
    208     tangent.scale(SkScalarInvert(length));
    209 
    210     // TODO: make this test for horizontal & vertical lines more robust
    211     bool isXAxis = true;
    212     if (SkScalarNearlyEqual(SK_Scalar1, tangent.fX) ||
    213         SkScalarNearlyEqual(-SK_Scalar1, tangent.fX)) {
    214         results->fSize.set(SkScalarHalf(fIntervals[0]), SkScalarHalf(rec.getWidth()));
    215     } else if (SkScalarNearlyEqual(SK_Scalar1, tangent.fY) ||
    216                SkScalarNearlyEqual(-SK_Scalar1, tangent.fY)) {
    217         results->fSize.set(SkScalarHalf(rec.getWidth()), SkScalarHalf(fIntervals[0]));
    218         isXAxis = false;
    219     } else if (SkPaint::kRound_Cap != rec.getCap()) {
    220         // Angled lines don't have axis-aligned boxes.
    221         return false;
    222     }
    223 
    224     if (results) {
    225         results->fFlags = 0;
    226         SkScalar clampedInitialDashLength = SkMinScalar(length, fInitialDashLength);
    227 
    228         if (SkPaint::kRound_Cap == rec.getCap()) {
    229             results->fFlags |= PointData::kCircles_PointFlag;
    230         }
    231 
    232         results->fNumPoints = 0;
    233         SkScalar len2 = length;
    234         if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
    235             SkASSERT(len2 >= clampedInitialDashLength);
    236             if (0 == fInitialDashIndex) {
    237                 if (clampedInitialDashLength > 0) {
    238                     if (clampedInitialDashLength >= fIntervals[0]) {
    239                         ++results->fNumPoints;  // partial first dash
    240                     }
    241                     len2 -= clampedInitialDashLength;
    242                 }
    243                 len2 -= fIntervals[1];  // also skip first space
    244                 if (len2 < 0) {
    245                     len2 = 0;
    246                 }
    247             } else {
    248                 len2 -= clampedInitialDashLength; // skip initial partial empty
    249             }
    250         }
    251         int numMidPoints = SkScalarFloorToInt(SkScalarDiv(len2, fIntervalLength));
    252         results->fNumPoints += numMidPoints;
    253         len2 -= numMidPoints * fIntervalLength;
    254         bool partialLast = false;
    255         if (len2 > 0) {
    256             if (len2 < fIntervals[0]) {
    257                 partialLast = true;
    258             } else {
    259                 ++numMidPoints;
    260                 ++results->fNumPoints;
    261             }
    262         }
    263 
    264         results->fPoints = new SkPoint[results->fNumPoints];
    265 
    266         SkScalar    distance = 0;
    267         int         curPt = 0;
    268 
    269         if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
    270             SkASSERT(clampedInitialDashLength <= length);
    271 
    272             if (0 == fInitialDashIndex) {
    273                 if (clampedInitialDashLength > 0) {
    274                     // partial first block
    275                     SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
    276                     SkScalar x = pts[0].fX + SkScalarMul(tangent.fX, SkScalarHalf(clampedInitialDashLength));
    277                     SkScalar y = pts[0].fY + SkScalarMul(tangent.fY, SkScalarHalf(clampedInitialDashLength));
    278                     SkScalar halfWidth, halfHeight;
    279                     if (isXAxis) {
    280                         halfWidth = SkScalarHalf(clampedInitialDashLength);
    281                         halfHeight = SkScalarHalf(rec.getWidth());
    282                     } else {
    283                         halfWidth = SkScalarHalf(rec.getWidth());
    284                         halfHeight = SkScalarHalf(clampedInitialDashLength);
    285                     }
    286                     if (clampedInitialDashLength < fIntervals[0]) {
    287                         // This one will not be like the others
    288                         results->fFirst.addRect(x - halfWidth, y - halfHeight,
    289                                                 x + halfWidth, y + halfHeight);
    290                     } else {
    291                         SkASSERT(curPt < results->fNumPoints);
    292                         results->fPoints[curPt].set(x, y);
    293                         ++curPt;
    294                     }
    295 
    296                     distance += clampedInitialDashLength;
    297                 }
    298 
    299                 distance += fIntervals[1];  // skip over the next blank block too
    300             } else {
    301                 distance += clampedInitialDashLength;
    302             }
    303         }
    304 
    305         if (0 != numMidPoints) {
    306             distance += SkScalarHalf(fIntervals[0]);
    307 
    308             for (int i = 0; i < numMidPoints; ++i) {
    309                 SkScalar x = pts[0].fX + SkScalarMul(tangent.fX, distance);
    310                 SkScalar y = pts[0].fY + SkScalarMul(tangent.fY, distance);
    311 
    312                 SkASSERT(curPt < results->fNumPoints);
    313                 results->fPoints[curPt].set(x, y);
    314                 ++curPt;
    315 
    316                 distance += fIntervalLength;
    317             }
    318 
    319             distance -= SkScalarHalf(fIntervals[0]);
    320         }
    321 
    322         if (partialLast) {
    323             // partial final block
    324             SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
    325             SkScalar temp = length - distance;
    326             SkASSERT(temp < fIntervals[0]);
    327             SkScalar x = pts[0].fX + SkScalarMul(tangent.fX, distance + SkScalarHalf(temp));
    328             SkScalar y = pts[0].fY + SkScalarMul(tangent.fY, distance + SkScalarHalf(temp));
    329             SkScalar halfWidth, halfHeight;
    330             if (isXAxis) {
    331                 halfWidth = SkScalarHalf(temp);
    332                 halfHeight = SkScalarHalf(rec.getWidth());
    333             } else {
    334                 halfWidth = SkScalarHalf(rec.getWidth());
    335                 halfHeight = SkScalarHalf(temp);
    336             }
    337             results->fLast.addRect(x - halfWidth, y - halfHeight,
    338                                    x + halfWidth, y + halfHeight);
    339         }
    340 
    341         SkASSERT(curPt == results->fNumPoints);
    342     }
    343 
    344     return true;
    345 }
    346 
    347 SkPathEffect::DashType SkDashPathEffect::asADash(DashInfo* info) const {
    348     if (info) {
    349         if (info->fCount >= fCount && info->fIntervals) {
    350             memcpy(info->fIntervals, fIntervals, fCount * sizeof(SkScalar));
    351         }
    352         info->fCount = fCount;
    353         info->fPhase = fPhase;
    354     }
    355     return kDash_DashType;
    356 }
    357 
    358 void SkDashPathEffect::flatten(SkWriteBuffer& buffer) const {
    359     buffer.writeScalar(fPhase);
    360     buffer.writeScalarArray(fIntervals, fCount);
    361 }
    362 
    363 SkFlattenable* SkDashPathEffect::CreateProc(SkReadBuffer& buffer) {
    364     const SkScalar phase = buffer.readScalar();
    365     uint32_t count = buffer.getArrayCount();
    366     SkAutoSTArray<32, SkScalar> intervals(count);
    367     if (buffer.readScalarArray(intervals.get(), count)) {
    368         return Create(intervals.get(), SkToInt(count), phase);
    369     }
    370     return NULL;
    371 }
    372 
    373 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
    374 SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer)
    375         : INHERITED(buffer)
    376         , fPhase(0)
    377         , fInitialDashLength(0)
    378         , fInitialDashIndex(0)
    379         , fIntervalLength(0) {
    380     bool useOldPic = buffer.isVersionLT(SkReadBuffer::kDashWritesPhaseIntervals_Version);
    381     if (useOldPic) {
    382         fInitialDashIndex = buffer.readInt();
    383         fInitialDashLength = buffer.readScalar();
    384         fIntervalLength = buffer.readScalar();
    385         buffer.readBool(); // Dummy for old ScalarToFit field
    386     } else {
    387         fPhase = buffer.readScalar();
    388     }
    389 
    390     fCount = buffer.getArrayCount();
    391     size_t allocSize = sizeof(SkScalar) * fCount;
    392     if (buffer.validateAvailable(allocSize)) {
    393         fIntervals = (SkScalar*)sk_malloc_throw(allocSize);
    394         buffer.readScalarArray(fIntervals, fCount);
    395     } else {
    396         fIntervals = NULL;
    397     }
    398 
    399     if (useOldPic) {
    400         fPhase = 0;
    401         if (fInitialDashLength != -1) { // Signal for bad dash interval
    402             for (int i = 0; i < fInitialDashIndex; ++i) {
    403                 fPhase += fIntervals[i];
    404             }
    405             fPhase += fIntervals[fInitialDashIndex] - fInitialDashLength;
    406         }
    407     } else {
    408         // set the internal data members, fPhase should have been between 0 and intervalLength
    409         // when written to buffer so no need to adjust it
    410         SkDashPath::CalcDashParameters(fPhase, fIntervals, fCount,
    411                 &fInitialDashLength, &fInitialDashIndex, &fIntervalLength);
    412     }
    413 }
    414 #endif
    415 
    416