Add Dashing gpu effect for simple dashed lines

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
+#include "effects/GrDashingEffect.h"
 #include "effects/GrTextureDomain.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "GrContext.h"
 #include "GrBitmapTextContext.h"
 #include "GrDistanceFieldTextContext.h"
 #include "GrLayerCache.h"
 #include "GrPictureUtils.h"
 
 #include "SkGrTexturePixelRef.h"
@@ skipping 507 matching lines @@
 void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
                              size_t count, const SkPoint pts[], const SkPaint& paint) {
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw, false);
 
     SkScalar width = paint.getStrokeWidth();
     if (width < 0) {
         return;
     }
 
+    if (paint.getPathEffect() && 2 == count) {
+        if (this->drawDash(pts, paint, mode)) {
+            return;
+        }
+    }
+
     // we only handle hairlines and paints without path effects or mask filters,
     // else we let the SkDraw call our drawPath()
     if (width > 0 || paint.getPathEffect() || paint.getMaskFilter()) {
         draw.drawPoints(mode, count, pts, paint, true);
         return;
     }
 
     GrPaint grPaint;
     if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
         return;
     }
 
     fContext->drawVertices(grPaint,
                            gPointMode2PrimtiveType[mode],
                            SkToS32(count),
                            (SkPoint*)pts,
                            NULL,
                            NULL,
                            NULL,
                            0);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static void calcDashScaling(SkScalar* parallelScale, SkScalar* perpScale,

[bsalomon, 2014/05/09 15:02:37]

style nit: we've been tending towards
naming_static_non_class_functions_in_hacker_style().

[egdaniel, 2014/05/12 19:21:44]

fixed
On 2014/05/09 15:02:37, bsalomon wrote:

+                            const SkMatrix& viewMatrix, const SkPoint pts[2]) {
+    SkVector vecSrc = pts[1] - pts[0];
+    SkScalar magSrc = vecSrc.length();
+    SkScalar invSrc = magSrc ? SkScalarInvert(magSrc) : 0;
+    vecSrc.scale(invSrc);
+
+    SkVector vecSrcPerp;
+    vecSrc.rotateCW(&vecSrcPerp);
+    viewMatrix.mapVectors(&vecSrc, 1);
+    viewMatrix.mapVectors(&vecSrcPerp, 1);
+
+    // parallelScale tells how much to scale along the line parallel to the dash line
+    // perpScale tells how much to scale in the direction perpendicular to the dash line
+    *parallelScale = vecSrc.length();
+    *perpScale = vecSrcPerp.length();
+}
+
+// calculates the rotation needed to aligned pts to the x axis with pts[0] < pts[1]
+// Stores the rotation matrix in rotMatrix, and the mapped points in ptsRot
+static void alignToXAxis(const SkPoint pts[2], SkMatrix* rotMatrix, SkPoint ptsRot[2] = NULL) {
+    SkVector vec = pts[1] - pts[0];
+    SkScalar mag = vec.length();
+    SkScalar inv = mag ? SkScalarInvert(mag) : 0;
+
+    vec.scale(inv);
+    rotMatrix->setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
+    if (ptsRot) {
+        rotMatrix->mapPoints(ptsRot, pts, 2);
+        // correction for numerical issues if map doesn't make ptsRot exactly horizontal
+        ptsRot[1].fY = pts[0].fY;
+    }
+}
+
+// Assumes phase < sum of all intervals

[bsalomon, 2014/05/09 15:02:37]

is that a valid assumption? add an assert?

[egdaniel, 2014/05/12 19:21:44]

In the creation of SkDashEffect the phase is normalized to be between [0, len).
Since this helper function should only be called from within drawDash, which
itself gets the phase from an SkPaint then this assumption should be valid in
out current use cases. But I'll add an assert regardless.

On 2014/05/09 15:02:37, bsalomon wrote:

+static SkScalar calcStartAdjustment(const SkPathEffect::DashInfo& info) {
+    SkScalar srcIntervalLen = info.fIntervals[0] + info.fIntervals[1];

[bsalomon, 2014/05/09 15:02:37]

don't need this until inside both ifs, right?

[egdaniel, 2014/05/12 19:21:44]

yup
On 2014/05/09 15:02:37, bsalomon wrote:

+    if (info.fPhase >= info.fIntervals[0]) {
+        if (info.fIntervals[0] !=0 || info.fPhase != 0) {

[bsalomon, 2014/05/09 15:02:37]

if intervals[0] is != 0 then phase can't be either, right (since it is >=
intervals[0])? I guess I'm assuming intervals[0] is never negative.

[egdaniel, 2014/05/12 19:21:44]

Ahh you're right. I was just inverting the logic in my mind that I can't have
both 0.

On 2014/05/09 15:02:37, bsalomon wrote:

+            return srcIntervalLen - info.fPhase;
+        }
+    }
+    return 0;
+}
+
+static SkScalar calcEndAdjustment(const SkPathEffect::DashInfo& info, const SkPoint pts[2]) {
+    SkScalar srcIntervalLen = info.fIntervals[0] + info.fIntervals[1];
+    SkScalar totalLen = pts[1].fX - pts[0].fY;
+    SkScalar temp = SkScalarDiv(totalLen, srcIntervalLen);
+    SkScalar numFullIntervals = SkScalarFloorToScalar(temp);
+    SkScalar endingInt = totalLen - numFullIntervals * srcIntervalLen + info.fPhase;
+    temp = SkScalarDiv(endingInt, srcIntervalLen);
+    endingInt = endingInt - SkScalarFloorToScalar(temp) * srcIntervalLen;
+    if (0 == endingInt) {
+        endingInt = srcIntervalLen;
+    }
+    if (endingInt > info.fIntervals[0]) {
+        if (0 == info.fIntervals[0]) {
+            endingInt -= 0.01; // make sure we capture the last zero size pnt (used if has caps)
+        }
+        return endingInt - info.fIntervals[0];
+    }
+    return 0;
+}
+
+bool SkGpuDevice::drawDash(const SkPoint pts[2], const SkPaint& paint, SkCanvas::PointMode mode) {

[bsalomon, 2014/05/09 15:02:37]

maybe this should be called drawDashedLine()? It only allows two points as the
input geometry. Any reason to take the mode? Do you think it might be expanded
to support anything but kLines in the future?

[egdaniel, 2014/05/12 19:21:44]

Name changed. Moved the mode check to the caller.

On 2014/05/09 15:02:37, bsalomon wrote:

+    if (SkCanvas::kLines_PointMode != mode) {
+        return false;
+    }
+
+    const SkMatrix& viewMatrix = fContext->getMatrix();
+    if (!viewMatrix.preservesRightAngles()) {
+        return false;
+    }
+
+    const SkPathEffect* pe = paint.getPathEffect();
+    SkPathEffect::DashInfo info;
+    SkPathEffect::DashType dashType = pe->asADash(&info);
+    // Must be a dash effect with 2 intervals (1 on and 1 off)
+    if (SkPathEffect::kDash_DashType != dashType || 2 != info.fCount) {
+        return false;
+    }
+
+    GrPaint grPaint;

[bsalomon, 2014/05/09 15:02:37]

maybe hold off on this until after your cap check? It's non-trivial and wasted
work if we reject below.

[egdaniel, 2014/05/12 19:21:44]

done
On 2014/05/09 15:02:37, bsalomon wrote:

+    if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
+        return false;
+    }
+
+    SkPaint::Cap cap = paint.getStrokeCap();
+    // Current we do don't handle Round or Square cap dashes
+    if (SkPaint::kRound_Cap == cap) {
+        return false;
+    }
+
+    SkScalar srcStrokeWidth = paint.getStrokeWidth();
+
+    // Get all info about the dash effect
+    SkAutoTArray<SkScalar> intervals(info.fCount);
+    info.fIntervals = intervals.get();
+    pe->asADash(&info);
+
+    SkMatrix coordTrans;
+
+    // If the src pts are not axis aligned, rotate them so that they are horizontal
+    SkMatrix srcRotInv;
+    SkPoint ptsRot[2];
+    if (pts[0].fY != pts[1].fY || pts[0].fX > pts[1].fX) {
+        alignToXAxis(pts, &coordTrans, ptsRot);
+        if(!coordTrans.invert(&srcRotInv)) {
+            return false;
+        }
+    } else {
+        coordTrans.reset();
+        srcRotInv.reset();
+        ptsRot[0] = pts[0];
+        ptsRot[1] = pts[1];
+    }
+
+    // adjustments for start and end of bounding rect so we only draw dash intervals
+    // contained in the original line segment.
+    // TODO: what happens if adjustments make degenerate line?

[bsalomon, 2014/05/09 15:02:37]

Can these conditions cause us to draw incorrectly today? Are there test cases?

[egdaniel, 2014/05/12 19:21:44]

Changed so that if the first or last dashes in the line (and using AA), we will
draw those dashes separately using drawRects, and then using the shader for the
interior part of the line.

Also added checks to see if we ever end up in a case where the start point and
end point have been adjusted such that the end is to the left of the start. In
this case we just return since nothing is left to draw.

On 2014/05/09 15:02:37, bsalomon wrote:

+    // TODO: since we are using the bounding geometry to clip off bad parts, we now
+    // loss so AA that happens on end of dash segment. Better to draw first and last
+    // rects separately and use shader on middle?
+    SkScalar startAdj = calcStartAdjustment(info);
+    SkScalar endAdj = calcEndAdjustment(info, ptsRot);
+
+    coordTrans.postConcat(viewMatrix);
+
+    SkPoint devicePts[2];
+    viewMatrix.mapPoints(devicePts, ptsRot, 2);
+
+    // Scale corrections of intervals and stroke from view matrix
+    SkScalar parallelScale;
+    SkScalar perpScale;
+    calcDashScaling(&parallelScale, &perpScale, viewMatrix, ptsRot);
+    info.fIntervals[0] *= parallelScale;
+    info.fIntervals[1] *= parallelScale;
+    info.fPhase *= parallelScale;
+    SkScalar strokeWidth = srcStrokeWidth * perpScale;
+
+    bool useAA = paint.isAntiAlias();
+    if ((strokeWidth < 1.f && !useAA) || 0.f == strokeWidth) {
+        strokeWidth = 1.f;
+    }
+
+    // Set up coordTransform for device space transforms
+    // We rotate the dashed line such that it is horizontal with the start point at smaller x
+    // then we translate the start point to the origin
+    if (devicePts[0].fY != devicePts[1].fY || devicePts[0].fX > devicePts[1].fX) {
+        SkMatrix rot;
+        alignToXAxis(devicePts, &rot);
+        coordTrans.postConcat(rot);
+    }
+    coordTrans.postTranslate(-devicePts[0].fX, -devicePts[0].fY);
+    coordTrans.postTranslate(info.fIntervals[1] * 0.5f + info.fPhase, 0);
+
+    bool hasCap = false;
+    if (SkPaint::kSquare_Cap == cap && 0 != srcStrokeWidth) {
+        // add cap to on interveal and remove from off interval
+        info.fIntervals[0] += strokeWidth;
+        info.fIntervals[1] -= strokeWidth;
+        hasCap = true;
+    }
+
+    if (info.fIntervals[1] > 0.f) {
+        GrEffectEdgeType edgeType= useAA ? kFillAA_GrEffectEdgeType :
+            kFillBW_GrEffectEdgeType;
+        grPaint.addCoverageEffect(GrDashingEffect::Create(edgeType, info, coordTrans, strokeWidth));
+        grPaint.setAntiAlias(false);
+    }
+
+    // We always want to at least stroke out half a pixel on each side in device space
+    // so 0.5f / perpScale gives us this min in src space
+    SkScalar halfStroke = SkMaxScalar(srcStrokeWidth * 0.5f, 0.5f / perpScale);
+
+    SkRect rect;
+    bool bloat = useAA && info.fIntervals[1] > 0.f;
+    SkScalar bloatX = bloat ? 0.5f / parallelScale : 0.f;
+    SkScalar bloatY = bloat ? 0.5f / perpScale : 0.f;
+    SkScalar xStroke;
+    SkScalar yStroke;
+    if (!hasCap) {
+        bool horiz = ptsRot[0].fY == ptsRot[1].fY;
+        xStroke = horiz ? 0.f : halfStroke;
+        yStroke = horiz ? halfStroke : 0.f;
+    } else {
+        xStroke = halfStroke;
+        yStroke = halfStroke;
+    }
+    ptsRot[0].fX += startAdj;
+    ptsRot[1].fX -= endAdj;
+    rect.set(ptsRot, 2);
+    rect.outset(bloatX + xStroke, bloatY + yStroke);
+    fContext->drawRect(grPaint, rect, NULL, &srcRotInv);
+
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect,
                            const SkPaint& paint) {
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw, false);
 
     bool doStroke = paint.getStyle() != SkPaint::kFill_Style;
     SkScalar width = paint.getStrokeWidth();
 
     /*
         We have special code for hairline strokes, miter-strokes, bevel-stroke
@@ skipping 1548 matching lines @@
         GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture, i);
 
         if (NULL != layer->getTexture()) {
             fContext->unlockScratchTexture(layer->getTexture());
             layer->setTexture(NULL);
         }
     }
 
     return true;
 }