Make AALinearizingConvexPathRenderer able to handle stroke and fill

src/gpu/batches/GrAAConvexTessellator.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexTessellator.h"
 #include "SkCanvas.h"
 #include "SkPath.h"
@@ skipping 14 matching lines @@
 static const SkScalar kQuadTolerance = 0.2f;
 static const SkScalar kCubicTolerance = 0.2f;
 static const SkScalar kConicTolerance = 0.5f;
 
 // dot product below which we use a round cap between curve segments
 static const SkScalar kRoundCapThreshold = 0.8f;
 
 // dot product above which we consider two adjacent curves to be part of the "same" curve
 static const SkScalar kCurveConnectionThreshold = 0.8f;
 
-static SkScalar intersect(const SkPoint& p0, const SkPoint& n0,
-                          const SkPoint& p1, const SkPoint& n1) {
+static bool intersect(const SkPoint& p0, const SkPoint& n0,
+                      const SkPoint& p1, const SkPoint& n1,
+                      SkScalar* t) {
     const SkPoint v = p1 - p0;
     SkScalar perpDot = n0.fX * n1.fY - n0.fY * n1.fX;
-    return (v.fX * n1.fY - v.fY * n1.fX) / perpDot;
+    if (SkScalarNearlyZero(perpDot)) {
+        return true;

[ethannicholas, 2016/09/06 20:34:05]

The return value of this function seems backward to me -- intersect() returns
true if the function fails because the lines don't intersect?

[robertphillips, 2016/09/06 20:47:06]

Haha - good point. Fixed.

+    }
+    *t = (v.fX * n1.fY - v.fY * n1.fX) / perpDot;
+    SkASSERT(SkScalarIsFinite(*t));
+    return false;
 }
 
 // This is a special case version of intersect where we have the vector
 // perpendicular to the second line rather than the vector parallel to it.
 static SkScalar perp_intersect(const SkPoint& p0, const SkPoint& n0,
                                const SkPoint& p1, const SkPoint& perp) {
     const SkPoint v = p1 - p0;
     SkScalar perpDot = n0.dot(perp);
     return v.dot(perp) / perpDot;
 }
@@ skipping 161 matching lines @@
 // The polygon state is captured in the Ring class while the GrAAConvexTessellator
 // controls the iteration. The CandidateVerts holds the formative points for the
 // next ring.
 bool GrAAConvexTessellator::tessellate(const SkMatrix& m, const SkPath& path) {
     if (!this->extractFromPath(m, path)) {
         return false;
     }
 
     SkScalar coverage = 1.0f;
     SkScalar scaleFactor = 0.0f;
-    if (fStrokeWidth >= 0.0f) {
+
+    if (SkStrokeRec::kStrokeAndFill_Style == fStyle) {
         SkASSERT(m.isSimilarity());
         scaleFactor = m.getMaxScale(); // x and y scale are the same
         SkScalar effectiveStrokeWidth = scaleFactor * fStrokeWidth;
+        Ring outerStrokeAndAARing;
+        this->createOuterRing(fInitialRing,
+                              effectiveStrokeWidth / 2 + kAntialiasingRadius, 0.0,
+                              &outerStrokeAndAARing);
+
+        // discard all the triangles added between the originating ring and the new outer ring
+        fIndices.rewind();
+
+        outerStrokeAndAARing.init(*this);
+
+        outerStrokeAndAARing.makeOriginalRing();
+
+        // Add the outer stroke ring's normals to the originating ring's normals
+        // so it can also act as an originating ring
+        fNorms.setReserve(fNorms.count() + outerStrokeAndAARing.numPts());
+        for (int i = 0; i < outerStrokeAndAARing.numPts(); ++i) {
+            fNorms.push(outerStrokeAndAARing.norm(i));
+        }
+
+        // the bisectors are only needed for the computation of the outer ring
+        fBisectors.rewind();
+
+        Ring* insetAARing;
+        this->createInsetRings(outerStrokeAndAARing,
+                               0.0f, 0.0f, 2*kAntialiasingRadius, 1.0f,
+                               &insetAARing);
+
+        SkDEBUGCODE(this->validate();)
+        return true;
+    }
+
+    if (SkStrokeRec::kStroke_Style == fStyle) {
+        SkASSERT(fStrokeWidth >= 0.0f);
+        SkASSERT(m.isSimilarity());
+        scaleFactor = m.getMaxScale(); // x and y scale are the same
+        SkScalar effectiveStrokeWidth = scaleFactor * fStrokeWidth;
         Ring outerStrokeRing;
         this->createOuterRing(fInitialRing, effectiveStrokeWidth / 2 - kAntialiasingRadius,
                               coverage, &outerStrokeRing);
         outerStrokeRing.init(*this);
         Ring outerAARing;
         this->createOuterRing(outerStrokeRing, kAntialiasingRadius * 2, 0.0f, &outerAARing);
     } else {
         Ring outerAARing;
         this->createOuterRing(fInitialRing, kAntialiasingRadius, 0.0f, &outerAARing);
     }
 
     // the bisectors are only needed for the computation of the outer ring
     fBisectors.rewind();
-    if (fStrokeWidth >= 0.0f && fInitialRing.numPts() > 2) {
+    if (SkStrokeRec::kStroke_Style == fStyle && fInitialRing.numPts() > 2) {
+        SkASSERT(fStrokeWidth >= 0.0f);
         SkScalar effectiveStrokeWidth = scaleFactor * fStrokeWidth;
         Ring* insetStrokeRing;
         SkScalar strokeDepth = effectiveStrokeWidth / 2 - kAntialiasingRadius;
         if (this->createInsetRings(fInitialRing, 0.0f, coverage, strokeDepth, coverage,
-                             &insetStrokeRing)) {
+                                   &insetStrokeRing)) {
             Ring* insetAARing;
             this->createInsetRings(*insetStrokeRing, strokeDepth, coverage, strokeDepth +
-                             kAntialiasingRadius * 2, 0.0f, &insetAARing);
+                                   kAntialiasingRadius * 2, 0.0f, &insetAARing);
         }
     } else {
         Ring* insetAARing;
         this->createInsetRings(fInitialRing, 0.0f, 0.5f, kAntialiasingRadius, 1.0f, &insetAARing);
     }
 
     SkDEBUGCODE(this->validate();)
     return true;
 }
 
@@ skipping 126 matching lines @@
 
         // Make all the normals face outwards rather than along the edge
         for (int cur = 0; cur < fNorms.count(); ++cur) {
             fNorms[cur].setOrthog(fNorms[cur], fSide);
             SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
         }
 
         this->computeBisectors();
     } else if (this->numPts() == 2) {
         // We've got two points, so we're degenerate.
-        if (fStrokeWidth < 0.0f) {
+        if (fStyle == SkStrokeRec::kFill_Style) {
             // it's a fill, so we don't need to worry about degenerate paths
             return false;
         }
         // For stroking, we still need to process the degenerate path, so fix it up
         fSide = SkPoint::kLeft_Side;
 
         // Make all the normals face outwards rather than along the edge
         for (int cur = 0; cur < fNorms.count(); ++cur) {
             fNorms[cur].setOrthog(fNorms[cur], fSide);
             SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
@@ skipping 175 matching lines @@
     int lastIdx = previousRing.index(numPts - 1);
     this->addTri(lastIdx, firstPerpIdx, previousRing.index(0));
     this->addTri(lastIdx, lastPerpIdx, firstPerpIdx);
 
     this->validate();
 }
 
 // Something went wrong in the creation of the next ring. If we're filling the shape, just go ahead
 // and fan it.
 void GrAAConvexTessellator::terminate(const Ring& ring) {
-    if (fStrokeWidth < 0.0f) {
+    if (fStyle != SkStrokeRec::kStroke_Style) {
         this->fanRing(ring);
     }
 }
 
 static SkScalar compute_coverage(SkScalar depth, SkScalar initialDepth, SkScalar initialCoverage,
                                 SkScalar targetDepth, SkScalar targetCoverage) {
     if (SkScalarNearlyEqual(initialDepth, targetDepth)) {
         return targetCoverage;
     }
     SkScalar result = (depth - initialDepth) / (targetDepth - initialDepth) *
             (targetCoverage - initialCoverage) + initialCoverage;
     return SkScalarClampMax(result, 1.0f);
 }
 
 // return true when processing is complete
 bool GrAAConvexTessellator::createInsetRing(const Ring& lastRing, Ring* nextRing,
                                             SkScalar initialDepth, SkScalar initialCoverage,
                                             SkScalar targetDepth, SkScalar targetCoverage,
                                             bool forceNew) {
     bool done = false;
 
     fCandidateVerts.rewind();
 
     // Loop through all the points in the ring and find the intersection with the smallest depth
     SkScalar minDist = SK_ScalarMax, minT = 0.0f;
     int minEdgeIdx = -1;
 
     for (int cur = 0; cur < lastRing.numPts(); ++cur) {
         int next = (cur + 1) % lastRing.numPts();
-        SkScalar t = intersect(this->point(lastRing.index(cur)),  lastRing.bisector(cur),
-                               this->point(lastRing.index(next)), lastRing.bisector(next));
+
+        SkScalar t;
+        bool parallel = intersect(this->point(lastRing.index(cur)),  lastRing.bisector(cur),
+                                  this->point(lastRing.index(next)), lastRing.bisector(next),
+                                  &t);
+        if (parallel) {
+            continue;
+        }
         SkScalar dist = -t * lastRing.norm(cur).dot(lastRing.bisector(cur));
 
         if (minDist > dist) {
             minDist = dist;
             minT = t;
             minEdgeIdx = cur;
         }
     }
 
     if (minEdgeIdx == -1) {
@@ skipping 107 matching lines @@
         dst[i] = nextRing->index(dst[i]);
     }
 
     for (int i = 0; i < lastRing.numPts(); ++i) {
         int next = (i + 1) % lastRing.numPts();
 
         this->addTri(lastRing.index(i), lastRing.index(next), dst[next]);
         this->addTri(lastRing.index(i), dst[next], dst[i]);
     }
 
-    if (done && fStrokeWidth < 0.0f) {
-        // fill
+    if (done && fStyle != SkStrokeRec::kStroke_Style) {
+        // fill or stroke-and-fill
         this->fanRing(*nextRing);
     }
 
     if (nextRing->numPts() < 3) {
         done = true;
     }
     return done;
 }
 
 void GrAAConvexTessellator::validate() const {
@@ skipping 93 matching lines @@
         fNorms.pop();
         fCurveState.pop();
         // double-check that the new last point is not a duplicate of the new point. In an ideal
         // world this wouldn't be necessary (since it's only possible for non-convex paths), but
         // floating point precision issues mean it can actually happen on paths that were determined
         // to be convex.
         if (duplicate_pt(p, this->lastPoint())) {
             return;
         }
     }
-    SkScalar initialRingCoverage = fStrokeWidth < 0.0f ? 0.5f : 1.0f;
+    SkScalar initialRingCoverage = (SkStrokeRec::kFill_Style == fStyle) ? 0.5f : 1.0f;
     this->addPt(p, 0.0f, initialRingCoverage, false, curve);
     if (this->numPts() > 1) {
         *fNorms.push() = fPts.top() - fPts[fPts.count()-2];
         SkDEBUGCODE(SkScalar len =) SkPoint::Normalize(&fNorms.top());
         SkASSERT(len > 0.0f);
         SkASSERT(SkScalarNearlyEqual(1.0f, fNorms.top().length()));
     }
 }
 
 void GrAAConvexTessellator::lineTo(const SkMatrix& m, SkPoint p, CurveState curve) {
@@ skipping 169 matching lines @@
 
         SkString num;
         num.printf("%d", i);
         canvas->drawText(num.c_str(), num.size(),
                          this->point(i).fX, this->point(i).fY+(kPointRadius/2.0f),
                          paint);
     }
 }
 
 #endif