Handle stroked single line special case in Ganesh

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 "GrBlurUtils.h"
@@ skipping 674 matching lines @@
                           this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
     fDrawContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, GrStyle(paint));
 }
 
 #include "SkMaskFilter.h"
 
 ///////////////////////////////////////////////////////////////////////////////
+void SkGpuDevice::drawStrokedLine(const SkPoint points[2],
+                                  const SkDraw& draw,
+                                  const SkPaint& origPaint) {
+    ASSERT_SINGLE_OWNER
+    GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawStrokedLine", fContext);
+    CHECK_SHOULD_DRAW(draw);
+
+    SkASSERT(SkPaint::kStroke_Style == origPaint.getStyle());
+    SkASSERT(!origPaint.getPathEffect());
+    SkASSERT(!origPaint.getMaskFilter());
+
+    const SkScalar halfWidth = origPaint.getStrokeWidth()/2.0f;

[reed1, 2016/05/31 12:54:48]

Does this version devolve into multiply-by-0.5 ?

[robertphillips, 2016/05/31 19:06:54]

Done.

+    SkASSERT(halfWidth > 0);

[reed1, 2016/05/31 12:54:48]

Do you not try to trigger your hairline code for thin lines?

[robertphillips, 2016/05/31 19:06:54]

To the best of my knowledge we only kick into hairline mode when strokeWidth is
exactly 0.

+
+    SkVector v = points[1] - points[0];
+
+    SkScalar length = SkPoint::Normalize(&v);
+
+    SkPaint newPaint(origPaint);
+    newPaint.setStyle(SkPaint::kFill_Style);
+
+    SkScalar xtraLength = 0.0f;
+    if (SkPaint::kButt_Cap != origPaint.getStrokeCap()) {
+        xtraLength = halfWidth;
+    }
+
+    SkPoint mid = points[0] + points[1];
+    mid.scale(0.5f);
+
+    SkRect rect = SkRect::MakeLTRB(mid.fX-halfWidth, mid.fY - 0.5f*length - xtraLength,
+                                   mid.fX+halfWidth, mid.fY + 0.5f*length + xtraLength);
+    SkMatrix m;
+    m.setSinCos(v.fX, -v.fY, mid.fX, mid.fY);

[reed1, 2016/05/31 12:54:48]

Is this really faster than just drawing a quad? I have a working CL that also
tries to catch stroked lines, but I was adding a helper to SkStroker that would
return a quad (at least for non-round-caps). Was hoping we might share code, but
not if that is a lot slower than your rotated rect trick.

[robertphillips, 2016/05/31 19:06:54]

Doing it this way allows greater batching. A more extensive change could add a
GrDrawContext::drawQuad entry point but we would have to ensure the axis-aligned
rect draws would also batch with them. So ... for right now, yes, this is
faster.

+
+    SkMatrix local = m;
+
+    m.postConcat(*draw.fMatrix);
+
+    GrPaint grPaint;
+    if (!SkPaintToGrPaint(this->context(), newPaint, m,
+                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+        return;
+    }
+
+    if (SkPaint::kRound_Cap != origPaint.getStrokeCap()) {
+        fDrawContext->fillRectWithLocalMatrix(fClip, grPaint, m, rect, local);
+    } else {
+        // TODO: add a GrDrawContext::fillRRectWithLocalMatrix entry point
+        SkASSERT(0);
+        const SkRRect rrect = SkRRect::MakeRectXY(rect, halfWidth, halfWidth);
+
+        GrStyle style(newPaint);
+        fDrawContext->drawRRect(fClip, grPaint, m, rrect, style);
+    }
+}
 
 void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
                            const SkPaint& paint, const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     ASSERT_SINGLE_OWNER
     if (!origSrcPath.isInverseFillType() && !paint.getPathEffect() && !prePathMatrix) {
+        SkPoint points[2];
+        if (SkPaint::kStroke_Style == paint.getStyle() && paint.getStrokeWidth() > 0 &&
+            !paint.getMaskFilter() && SkPaint::kRound_Cap != paint.getStrokeCap() &&
+            draw.fMatrix->preservesRightAngles() && origSrcPath.isLine(points)) {

[reed1, 2016/05/31 12:54:48]

May not come up much, but if we just create quads, we don't need to check the
matrix for this attribute...

[robertphillips, 2016/05/31 19:06:54]

Right. The skew and perspective cases don't seem to come up much in practice
though.

+            // TODO: to support round capped stroked lines we need RRect batches

[bsalomon, 2016/05/31 16:47:27]

Re to TODO. Unless we really have to, I strongly prefer to not add more
complexity here. Adding another drawing path now for this case is, to me, only
justified by the big perf win. drawStrokedLine already destined to get
rewritten/removed in the near future, I don't want to pile on more technical
debt.

[robertphillips, 2016/05/31 19:06:54]

Done. Switched the TODO over to an informational comment.

+            // that take a localMatrix
+            this->drawStrokedLine(points, draw, paint);
+            return;
+        }
         bool isClosed;
         SkRect rect;
         if (origSrcPath.isRect(&rect, &isClosed) && isClosed) {
             this->drawRect(draw, rect, paint);
             return;
         }
         if (origSrcPath.isOval(&rect)) {
             this->drawOval(draw, rect, paint);
             return;
         }
@@ skipping 1146 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif