fixed 'corners' of paths in GrAAConvexTessellator

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 11 matching lines @@
 static const SkScalar kCloseSqd = SkScalarMul(kClose, kClose);
 
 // tesselation tolerance values, in device space pixels
 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.95f;
+
 static SkScalar intersect(const SkPoint& p0, const SkPoint& n0,
                           const SkPoint& p1, const SkPoint& n1) {
     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;
 }
 
 // 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,
@@ skipping 11 matching lines @@
 static SkScalar abs_dist_from_line(const SkPoint& p0, const SkVector& v, const SkPoint& test) {
     SkPoint testV = test - p0;
     SkScalar dist = testV.fX * v.fY - testV.fY * v.fX;
     return SkScalarAbs(dist);
 }
 
 int GrAAConvexTessellator::addPt(const SkPoint& pt,
                                  SkScalar depth,
                                  SkScalar coverage,
                                  bool movable,
-                                 bool isCurve) {
+                                 CurveState curve) {
     this->validate();
 
     int index = fPts.count();
     *fPts.push() = pt;
     *fCoverages.push() = coverage;
     *fMovable.push() = movable;
-    *fIsCurve.push() = isCurve;
+    *fCurveState.push() = curve;
 
     this->validate();
     return index;
 }
 
 void GrAAConvexTessellator::popLastPt() {
     this->validate();
 
     fPts.pop();
     fCoverages.pop();
@@ skipping 58 matching lines @@
         if (!fBisectors[cur].normalize()) {
             SkASSERT(SkPoint::kLeft_Side == fSide || SkPoint::kRight_Side == fSide);
             fBisectors[cur].setOrthog(fNorms[cur], (SkPoint::Side)-fSide);
             SkVector other;
             other.setOrthog(fNorms[prev], fSide);
             fBisectors[cur] += other;
             SkAssertResult(fBisectors[cur].normalize());
         } else {
             fBisectors[cur].negate();      // make the bisector face in
         }
+        if (fCurveState[prev] == kIndeterminate_CurveState) {
+            if (fCurveState[cur] == kSharp_CurveState) {
+                fCurveState[prev] = kSharp_CurveState;
+            } else {
+                if (SkScalarAbs(fNorms[cur].dot(fNorms[prev])) > kCurveConnectionThreshold) {
+                    fCurveState[prev] = kCurve_CurveState;
+                    fCurveState[cur]  = kCurve_CurveState;
+                } else {
+                    fCurveState[prev] = kSharp_CurveState;
+                    fCurveState[cur]  = kSharp_CurveState;
+                }
+            }
+        }
 
         SkASSERT(SkScalarNearlyEqual(1.0f, fBisectors[cur].length()));
     }
 }
 
 // Create as many rings as we need to (up to a predefined limit) to reach the specified target
 // depth. If we are in fill mode, the final ring will automatically be fanned.
 bool GrAAConvexTessellator::createInsetRings(Ring& previousRing, SkScalar initialDepth,
                                              SkScalar initialCoverage, SkScalar targetDepth,
                                              SkScalar targetCoverage, Ring** finalRing) {
@@ skipping 138 matching lines @@
 
     // TODO: is there a faster way to extract the points from the path? Perhaps
     // get all the points via a new entry point, transform them all in bulk
     // and then walk them to find duplicates?
     SkPath::Iter iter(path, true);
     SkPoint pts[4];
     SkPath::Verb verb;
     while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
         switch (verb) {
             case SkPath::kLine_Verb:
-                this->lineTo(m, pts[1], false);
+                this->lineTo(m, pts[1], kSharp_CurveState);
                 break;
             case SkPath::kQuad_Verb:
                 this->quadTo(m, pts);
                 break;
             case SkPath::kCubic_Verb:
                 this->cubicTo(m, pts);
                 break;
             case SkPath::kConic_Verb:
                 this->conicTo(m, pts, iter.conicWeight());
                 break;
@@ skipping 136 matching lines @@
         SkPoint perp1 = normal1;
         perp1.scale(outset);
         perp1 += this->point(originalIdx);
 
         // The perpendicular point for the next edge.
         SkPoint normal2 = previousRing.norm(cur);
         SkPoint perp2 = normal2;
         perp2.scale(outset);
         perp2 += fPts[originalIdx];
 
-        bool isCurve = fIsCurve[originalIdx];
+        CurveState curve = fCurveState[originalIdx];
 
         // We know it isn't a duplicate of the prior point (since it and this
         // one are just perpendicular offsets from the non-merged polygon points)
-        int perp1Idx = this->addPt(perp1, -outset, coverage, false, isCurve);
+        int perp1Idx = this->addPt(perp1, -outset, coverage, false, curve);
         nextRing->addIdx(perp1Idx, originalIdx);
 
         int perp2Idx;
         // For very shallow angles all the corner points could fuse.
         if (duplicate_pt(perp2, this->point(perp1Idx))) {
             perp2Idx = perp1Idx;
         } else {
-            perp2Idx = this->addPt(perp2, -outset, coverage, false, isCurve);
+            perp2Idx = this->addPt(perp2, -outset, coverage, false, curve);
         }
 
         if (perp2Idx != perp1Idx) {
-            if (isCurve) {
+            if (curve == kCurve_CurveState) {
                 // bevel or round depending upon curvature
                 SkScalar dotProd = normal1.dot(normal2);
                 if (dotProd < kRoundCapThreshold) {
                     // Currently we "round" by creating a single extra point, which produces
                     // good results for common cases. For thick strokes with high curvature, we will
                     // need to add more points; for the time being we simply fall back to software
                     // rendering for thick strokes.
                     SkPoint miter = previousRing.bisector(cur);
                     miter.setLength(-outset);
                     miter += fPts[originalIdx];
 
                     // For very shallow angles all the corner points could fuse
                     if (!duplicate_pt(miter, this->point(perp1Idx))) {
                         int miterIdx;
-                        miterIdx = this->addPt(miter, -outset, coverage, false, false);
+                        miterIdx = this->addPt(miter, -outset, coverage, false, kSharp_CurveState);
                         nextRing->addIdx(miterIdx, originalIdx);
                         // The two triangles for the corner
                         this->addTri(originalIdx, perp1Idx, miterIdx);
                         this->addTri(originalIdx, miterIdx, perp2Idx);
                     }
                 } else {
                     this->addTri(originalIdx, perp1Idx, perp2Idx);
                 }
             } else {
                 switch (fJoin) {
                     case SkPaint::Join::kMiter_Join: {
                         // The bisector outset point
                         SkPoint miter = previousRing.bisector(cur);
                         SkScalar dotProd = normal1.dot(normal2);
                         SkScalar sinHalfAngleSq = SkScalarHalf(SK_Scalar1 + dotProd);
                         SkScalar lengthSq = outsetSq / sinHalfAngleSq;
                         if (lengthSq > miterLimitSq) {
                             // just bevel it
                             this->addTri(originalIdx, perp1Idx, perp2Idx);
                             break;
                         }
                         miter.setLength(-SkScalarSqrt(lengthSq));
                         miter += fPts[originalIdx];
 
                         // For very shallow angles all the corner points could fuse
                         if (!duplicate_pt(miter, this->point(perp1Idx))) {
                             int miterIdx;
-                            miterIdx = this->addPt(miter, -outset, coverage, false, false);
+                            miterIdx = this->addPt(miter, -outset, coverage, false, 
+                                                   kSharp_CurveState);
                             nextRing->addIdx(miterIdx, originalIdx);
                             // The two triangles for the corner
                             this->addTri(originalIdx, perp1Idx, miterIdx);
                             this->addTri(originalIdx, miterIdx, perp2Idx);
                         }
                         break;
                     }
                     case SkPaint::Join::kBevel_Join:
                         this->addTri(originalIdx, perp1Idx, perp2Idx);
                         break;
@@ skipping 163 matching lines @@
 
     // Fold the new ring's points into the global pool
     for (int i = 0; i < fCandidateVerts.numPts(); ++i) {
         int newIdx;
         if (fCandidateVerts.needsToBeNew(i) || forceNew) {
             // if the originating index is still valid then this point wasn't
             // fused (and is thus movable)
             SkScalar coverage = compute_coverage(depth, initialDepth, initialCoverage,
                                                  targetDepth, targetCoverage);
             newIdx = this->addPt(fCandidateVerts.point(i), depth, coverage,
-                                 fCandidateVerts.originatingIdx(i) != -1, false);
+                                 fCandidateVerts.originatingIdx(i) != -1, kSharp_CurveState);
         } else {
             SkASSERT(fCandidateVerts.originatingIdx(i) != -1);
             this->updatePt(fCandidateVerts.originatingIdx(i), fCandidateVerts.point(i), depth,
                            targetCoverage);
             newIdx = fCandidateVerts.originatingIdx(i);
         }
 
         nextRing->addIdx(newIdx, fCandidateVerts.origEdge(i));
     }
 
@@ skipping 98 matching lines @@
         maxDot = 0;
     }
     if (SkScalarNearlyEqual(minDot, 0.0f, 0.005f)) {
         minDot = 0;
     }
     return (maxDot >= 0.0f) == (minDot >= 0.0f);
 }
 
 #endif
 
-void GrAAConvexTessellator::lineTo(SkPoint p, bool isCurve) {
+void GrAAConvexTessellator::lineTo(SkPoint p, CurveState curve) {
     if (this->numPts() > 0 && duplicate_pt(p, this->lastPoint())) {
         return;
     }
 
     SkASSERT(fPts.count() <= 1 || fPts.count() == fNorms.count()+1);
     if (this->numPts() >= 2 &&
         abs_dist_from_line(fPts.top(), fNorms.top(), p) < kClose) {
         // The old last point is on the line from the second to last to the new point
         this->popLastPt();
         fNorms.pop();
-        fIsCurve.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;
-    this->addPt(p, 0.0f, initialRingCoverage, false, isCurve);
+    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, bool isCurve) {
+void GrAAConvexTessellator::lineTo(const SkMatrix& m, SkPoint p, CurveState curve) {
     m.mapPoints(&p, 1);
-    this->lineTo(p, isCurve);
+    this->lineTo(p, curve);
 }
 
 void GrAAConvexTessellator::quadTo(SkPoint pts[3]) {
     int maxCount = GrPathUtils::quadraticPointCount(pts, kQuadTolerance);
     fPointBuffer.setReserve(maxCount);
     SkPoint* target = fPointBuffer.begin();
     int count = GrPathUtils::generateQuadraticPoints(pts[0], pts[1], pts[2],
             kQuadTolerance, &target, maxCount);
     fPointBuffer.setCount(count);
-    for (int i = 0; i < count; i++) {
-        lineTo(fPointBuffer[i], true);
+    for (int i = 0; i < count - 1; i++) {
+        lineTo(fPointBuffer[i], kCurve_CurveState);
     }
+    lineTo(fPointBuffer[count - 1], kIndeterminate_CurveState);
 }
 
 void GrAAConvexTessellator::quadTo(const SkMatrix& m, SkPoint pts[3]) {
     SkPoint transformed[3];
     transformed[0] = pts[0];
     transformed[1] = pts[1];
     transformed[2] = pts[2];
     m.mapPoints(transformed, 3);
     quadTo(transformed);
 }
 
 void GrAAConvexTessellator::cubicTo(const SkMatrix& m, SkPoint pts[4]) {
     m.mapPoints(pts, 4);
     int maxCount = GrPathUtils::cubicPointCount(pts, kCubicTolerance);
     fPointBuffer.setReserve(maxCount);
     SkPoint* target = fPointBuffer.begin();
     int count = GrPathUtils::generateCubicPoints(pts[0], pts[1], pts[2], pts[3],
             kCubicTolerance, &target, maxCount);
     fPointBuffer.setCount(count);
-    for (int i = 0; i < count; i++) {
-        lineTo(fPointBuffer[i], true);
+    for (int i = 0; i < count - 1; i++) {
+        lineTo(fPointBuffer[i], kCurve_CurveState);
     }
+    lineTo(fPointBuffer[count - 1], kIndeterminate_CurveState);
 }
 
 // include down here to avoid compilation errors caused by "-" overload in SkGeometry.h
 #include "SkGeometry.h"
 
 void GrAAConvexTessellator::conicTo(const SkMatrix& m, SkPoint pts[3], SkScalar w) {
     m.mapPoints(pts, 3);
     SkAutoConicToQuads quadder;
     const SkPoint* quads = quadder.computeQuads(pts, w, kConicTolerance);
     SkPoint lastPoint = *(quads++);
@@ skipping 121 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