Crop the fast path dashed lines to the cull rect

src/effects/SkDashPathEffect.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDashPathEffect.h"
 
 #include "SkDashPathPriv.h"
@@ skipping 23 matching lines @@
 SkDashPathEffect::~SkDashPathEffect() {
     sk_free(fIntervals);
 }
 
 bool SkDashPathEffect::filterPath(SkPath* dst, const SkPath& src,
                               SkStrokeRec* rec, const SkRect* cullRect) const {
     return SkDashPath::FilterDashPath(dst, src, rec, cullRect, fIntervals, fCount,
                                       fInitialDashLength, fInitialDashIndex, fIntervalLength);
 }
 
+static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) {
+    SkScalar radius = SkScalarHalf(rec.getWidth());
+    if (0 == radius) {
+        radius = SK_Scalar1;    // hairlines
+    }
+    if (SkPaint::kMiter_Join == rec.getJoin()) {
+        radius = SkScalarMul(radius, rec.getMiter());
+    }
+    rect->outset(radius, radius);
+}
+
+// Attempt to trim the line to minimally cover the cull rect (currently 
+// only works for horizontal and vertical lines).
+static void crop_line(SkPoint* pts, const SkStrokeRec& rec,
+                      const SkRect* cullRect,
+                      const SkScalar phase, const SkScalar intervalLength) {
+    SkASSERT(phase >= 0);   // < 0 is used as a signal that the dash is invalid
+    SkASSERT(phase <= intervalLength);
+
+    if (NULL == cullRect) {
+        return;
+    }
+
+    SkRect bounds = *cullRect;
+    outset_for_stroke(&bounds, rec);
+
+    // By outsetting the cull rect by the phase we can ignore its effect in the
+    // followingr computations
+    bounds.outset(phase, phase);
+
+    SkScalar dx = pts[1].x() - pts[0].x();
+    SkScalar dy = pts[1].y() - pts[0].y();
+
+    if (dx && dy) {

[reed1, 2014/11/04 18:24:58]

can/should we move this check earlier? seems like we don't need to perform the
outset to check this.

[robertphillips, 2014/11/04 18:51:16]

Done.

+        return;
+    }
+
+    if (dx) {
+        SkASSERT(dx && !dy);
+        SkScalar minX = pts[0].fX;
+        SkScalar maxX = pts[1].fX;
+
+        if (dx < 0) {
+            SkTSwap(minX, maxX);
+        }
+
+        SkASSERT(minX < maxX);
+        if (maxX < bounds.fLeft || minX > bounds.fRight) {

[danakj, 2014/11/04 18:30:04]

This early out is causing us to miss the last tile and not cull anything for it.

minX is 227
maxX is 10000224

bounds.fLeft is -2
bounds.fRight is 208

It appears that bounds.fRight is not correct?

[robertphillips, 2014/11/04 18:51:16]

Done.

+            return;

[reed1, 2014/11/04 18:24:58]

If we're returning here, does that mean we're culled-out? should we return a
flag that says don't draw?

[robertphillips, 2014/11/04 18:51:16]

Done.

+        }
+
+        // Now we actually perform the chop, removing the excess to the left and
+        // right of the bounds (keeping our new line "in phase" with the dash,
+        // hence the (mod intervalLength).
+
+        if (minX < bounds.fLeft) {
+            minX = bounds.fLeft - SkScalarMod(bounds.fLeft - minX, intervalLength);
+        }
+        if (maxX > bounds.fRight) {
+            maxX = bounds.fRight + SkScalarMod(maxX - bounds.fRight, intervalLength);
+        }
+
+        SkASSERT(maxX > minX);
+        if (dx < 0) {
+            SkTSwap(minX, maxX);
+        }
+        pts[0].fX = minX;
+        pts[1].fX = maxX;
+    } else {
+        SkASSERT(dy && !dx);
+        SkScalar minY = pts[0].fY;
+        SkScalar maxY = pts[1].fY;
+
+        if (dy < 0) {
+            SkTSwap(minY, maxY);
+        }
+
+        SkASSERT(minY < maxY);
+        if (maxY < bounds.fTop || minY > bounds.fBottom) {
+            return;
+        }
+
+        // Now we actually perform the chop, removing the excess to the top and
+        // bottom of the bounds (keeping our new line "in phase" with the dash,
+        // hence the (mod intervalLength).
+
+        if (minY < bounds.fTop) {
+            minY = bounds.fTop - SkScalarMod(bounds.fTop - minY, intervalLength);
+        }
+        if (maxY > bounds.fBottom) {
+            maxY = bounds.fBottom + SkScalarMod(maxY - bounds.fBottom, intervalLength);
+        }
+
+        SkASSERT(maxY > minY);
+        if (dy < 0) {
+            SkTSwap(minY, maxY);
+        }
+        pts[0].fY = minY;
+        pts[1].fY = maxY;
+    }
+}
+
 // Currently asPoints is more restrictive then it needs to be. In the future
 // we need to:
 //      allow kRound_Cap capping (could allow rotations in the matrix with this)
 //      allow paths to be returned
 bool SkDashPathEffect::asPoints(PointData* results,
                                 const SkPath& src,
                                 const SkStrokeRec& rec,
                                 const SkMatrix& matrix,
                                 const SkRect* cullRect) const {
     // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out
@@ skipping 22 matching lines @@
     // TODO: this test could be eased up to allow circles
     if (SkPaint::kButt_Cap != rec.getCap()) {
         return false;
     }
 
     // TODO: this test could be eased up for circles. Rotations could be allowed.
     if (!matrix.rectStaysRect()) {
         return false;
     }
 
-    SkScalar        length = SkPoint::Distance(pts[1], pts[0]);
+    // crop the line to the cull rect
+    crop_line(pts, rec, cullRect, fPhase, fIntervalLength);
+
+    SkScalar length = SkPoint::Distance(pts[1], pts[0]);
 
     SkVector tangent = pts[1] - pts[0];
     if (tangent.isZero()) {
         return false;
     }
 
     tangent.scale(SkScalarInvert(length));
 
     // TODO: make this test for horizontal & vertical lines more robust
     bool isXAxis = true;
-    if (SK_Scalar1 == tangent.fX || -SK_Scalar1 == tangent.fX) {
+    if (SkScalarNearlyEqual(SK_Scalar1, tangent.fX) ||
+        SkScalarNearlyEqual(-SK_Scalar1, tangent.fX)) {
         results->fSize.set(SkScalarHalf(fIntervals[0]), SkScalarHalf(rec.getWidth()));
-    } else if (SK_Scalar1 == tangent.fY || -SK_Scalar1 == tangent.fY) {
+    } else if (SkScalarNearlyEqual(SK_Scalar1, tangent.fY) ||
+               SkScalarNearlyEqual(-SK_Scalar1, tangent.fY)) {
         results->fSize.set(SkScalarHalf(rec.getWidth()), SkScalarHalf(fIntervals[0]));
         isXAxis = false;
     } else if (SkPaint::kRound_Cap != rec.getCap()) {
         // Angled lines don't have axis-aligned boxes.
         return false;
     }
 
     if (results) {
         results->fFlags = 0;
         SkScalar clampedInitialDashLength = SkMinScalar(length, fInitialDashLength);
@@ skipping 179 matching lines @@
         }
     } else {
         // set the internal data members, fPhase should have been between 0 and intervalLength
         // when written to buffer so no need to adjust it
         SkDashPath::CalcDashParameters(fPhase, fIntervals, fCount,
                 &fInitialDashLength, &fInitialDashIndex, &fIntervalLength);
     }
 }
 #endif