Fix double blend in GrAAConvexPathRenderer

src/gpu/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
@@ skipping 205 matching lines @@
     }
     // check whether m reverses the orientation
     SkASSERT(!m.hasPerspective());
     SkScalar det2x2 = SkScalarMul(m.get(SkMatrix::kMScaleX), m.get(SkMatrix::kMScaleY)) -
                       SkScalarMul(m.get(SkMatrix::kMSkewX), m.get(SkMatrix::kMSkewY));
     if (det2x2 < 0) {
         *dir = SkPath::OppositeDirection(*dir);
     }
     return true;
 }
 

[robertphillips, 2015/04/24 12:32:55]

Seems like we should do this in terms of pixels.

[bsalomon, 2015/04/24 14:19:55]

Are we not in device space here?

[Chris Dalton, 2015/04/24 18:36:27]

Doing it in pixels is fine, it just comes at the cost of an extra sqrt.

I also reduced the threshold quite a bit, which causes pixel variance in
conicpaths.

+static inline bool are_colinear(const SkPoint& startPt,
+                                const SkPoint& testPt,
+                                const SkPoint& endPt,
+                                SkScalar threshold = 1e-5f) {
+    // Returns whether the distance from testPt to the line defined by [startPt, endPt] is within
+    // a fraction of the distance from startPt to endPt.
+    // TODO: It may (or may not) make more sense for the threshold to instead be in terms of pixels.
+    SkVector ortho;
+    ortho.setOrthog(endPt - startPt);
+    return fabsf(ortho.dot(startPt) - ortho.dot(testPt)) < threshold * ortho.dot(ortho);
+}
+
 static inline void add_line_to_segment(const SkPoint& pt,
-                                       SegmentArray* segments) {
+                                       SegmentArray* segments,
+                                       const SkPoint& pathStartPt) {
+    if (!segments->empty() && Segment::kLine == segments->back().fType) {
+        const SkPoint& prevLineStartPt = segments->count() > 2 ?
+            (*segments)[segments->count() - 2].endPt() : pathStartPt;
+        if (are_colinear(prevLineStartPt, segments->back().fPts[0], pt)) {
+            // Combine with the previous line, since it is colinear.
+            segments->back().fPts[0] = pt;
+            return;
+        }
+    }
     segments->push_back();
     segments->back().fType = Segment::kLine;
     segments->back().fPts[0] = pt;
 }
 
 static inline void add_quad_segment(const SkPoint pts[3],
-                                    SegmentArray* segments) {
-    if (pts[0].distanceToSqd(pts[1]) < kCloseSqd || pts[1].distanceToSqd(pts[2]) < kCloseSqd) {
+                                    SegmentArray* segments,
+                                    const SkPoint& pathStartPt) {
+    if (pts[0].distanceToSqd(pts[1]) < kCloseSqd || pts[1].distanceToSqd(pts[2]) < kCloseSqd ||
+        are_colinear(pts[0], pts[1], pts[2])) {
         if (pts[0] != pts[2]) {
-            add_line_to_segment(pts[2], segments);
+            add_line_to_segment(pts[2], segments, pathStartPt);
         }
     } else {
         segments->push_back();
         segments->back().fType = Segment::kQuad;
         segments->back().fPts[0] = pts[1];
         segments->back().fPts[1] = pts[2];
     }
 }
 
 static inline void add_cubic_segments(const SkPoint pts[4],
                                       SkPath::Direction dir,
-                                      SegmentArray* segments) {
+                                      SegmentArray* segments,
+                                      const SkPoint& pathStartPt) {
     SkSTArray<15, SkPoint, true> quads;
     GrPathUtils::convertCubicToQuads(pts, SK_Scalar1, true, dir, &quads);
     int count = quads.count();
     for (int q = 0; q < count; q += 3) {
-        add_quad_segment(&quads[q], segments);
+        add_quad_segment(&quads[q], segments, pathStartPt);
     }
 }
 
 static bool get_segments(const SkPath& path,
                          const SkMatrix& m,
                          SegmentArray* segments,
                          SkPoint* fanPt,
                          int* vCount,
                          int* iCount) {
     SkPath::Iter iter(path, true);
     // This renderer over-emphasizes very thin path regions. We use the distance
     // to the path from the sample to compute coverage. Every pixel intersected
     // by the path will be hit and the maximum distance is sqrt(2)/2. We don't
     // notice that the sample may be close to a very thin area of the path and
     // thus should be very light. This is particularly egregious for degenerate
     // line paths. We detect paths that are very close to a line (zero area) and
     // draw nothing.
     DegenerateTestData degenerateData;
     SkPath::Direction dir;
     // get_direction can fail for some degenerate paths.
     if (!get_direction(path, m, &dir)) {
         return false;
     }
 
+    SkPoint pts[4];
+    SkPath::Verb verb = iter.next(pts);
+    SkPoint pathStartPt;
+    m.mapPoints(&pathStartPt, pts, 1);
+
     for (;;) {
-        SkPoint pts[4];
-        SkPath::Verb verb = iter.next(pts);
         switch (verb) {
             case SkPath::kMove_Verb:
                 m.mapPoints(pts, 1);
                 update_degenerate_test(&degenerateData, pts[0]);
                 break;
             case SkPath::kLine_Verb: {
                 m.mapPoints(&pts[1], 1);
                 update_degenerate_test(&degenerateData, pts[1]);
-                add_line_to_segment(pts[1], segments);
+                add_line_to_segment(pts[1], segments, pathStartPt);
                 break;
             }
             case SkPath::kQuad_Verb:
                 m.mapPoints(pts, 3);
                 update_degenerate_test(&degenerateData, pts[1]);
                 update_degenerate_test(&degenerateData, pts[2]);
-                add_quad_segment(pts, segments);
+                add_quad_segment(pts, segments, pathStartPt);
                 break;
             case SkPath::kConic_Verb: {
                 m.mapPoints(pts, 3);
                 SkScalar weight = iter.conicWeight();
                 SkAutoConicToQuads converter;
                 const SkPoint* quadPts = converter.computeQuads(pts, weight, 0.5f);
                 for (int i = 0; i < converter.countQuads(); ++i) {
                     update_degenerate_test(&degenerateData, quadPts[2*i + 1]);
                     update_degenerate_test(&degenerateData, quadPts[2*i + 2]);
-                    add_quad_segment(quadPts + 2*i, segments);
+                    add_quad_segment(quadPts + 2*i, segments, pathStartPt);
                 }
                 break;
             }
             case SkPath::kCubic_Verb: {
                 m.mapPoints(pts, 4);
                 update_degenerate_test(&degenerateData, pts[1]);
                 update_degenerate_test(&degenerateData, pts[2]);
                 update_degenerate_test(&degenerateData, pts[3]);
-                add_cubic_segments(pts, dir, segments);
+                add_cubic_segments(pts, dir, segments, pathStartPt);
                 break;
             };
             case SkPath::kDone_Verb:
                 if (degenerateData.isDegenerate()) {
                     return false;
                 } else {
+                    if (segments->count() > 2 &&
+                        Segment::kLine == segments->front().fType &&
+                        Segment::kLine == segments->back().fType &&
+                        are_colinear((*segments)[segments->count() - 2].endPt(),
+                                    pathStartPt,
+                                    segments->front().endPt())) {
+                        // First and last lines are colinear.
+                        segments->pop_back();
+                    }
                     compute_vectors(segments, fanPt, dir, vCount, iCount);
                     return true;
                 }
             default:
                 break;
         }
+
+        verb = iter.next(pts);
     }
 }
 
 struct QuadVertex {
     SkPoint  fPos;
     SkPoint  fUV;
     SkScalar fD0;
     SkScalar fD1;
 };
 
@@ skipping 78 matching lines @@
             verts[*v + 2].fUV.set(0, 0);
             verts[*v + 3].fUV.set(0, -SK_Scalar1);
             verts[*v + 4].fUV.set(0, -SK_Scalar1);
 
             verts[*v + 0].fD0 = verts[*v + 0].fD1 = -SK_Scalar1;
             verts[*v + 1].fD0 = verts[*v + 1].fD1 = -SK_Scalar1;
             verts[*v + 2].fD0 = verts[*v + 2].fD1 = -SK_Scalar1;
             verts[*v + 3].fD0 = verts[*v + 3].fD1 = -SK_Scalar1;
             verts[*v + 4].fD0 = verts[*v + 4].fD1 = -SK_Scalar1;
 
-            idxs[*i + 0] = *v + 0;
-            idxs[*i + 1] = *v + 2;
-            idxs[*i + 2] = *v + 1;
+            idxs[*i + 0] = *v + 3;
+            idxs[*i + 1] = *v + 1;
+            idxs[*i + 2] = *v + 2;
 
-            idxs[*i + 3] = *v + 3;
-            idxs[*i + 4] = *v + 1;
+            idxs[*i + 3] = *v + 4;
+            idxs[*i + 4] = *v + 3;
             idxs[*i + 5] = *v + 2;
 
-            idxs[*i + 6] = *v + 4;
-            idxs[*i + 7] = *v + 3;
-            idxs[*i + 8] = *v + 2;
+            *i += 6;
+
+            // Draw the interior fan if it exists. Colinear line segments have already been combined
+            // by this point, so we know the fan exists as long as there are at least 3 segments.
+            if (count >= 3) {
+                idxs[*i + 0] = *v + 0;
+                idxs[*i + 1] = *v + 2;
+                idxs[*i + 2] = *v + 1;
+
+                *i += 3;
+            }
 
             *v += 5;
-            *i += 9;
         } else {
             SkPoint qpts[] = {sega.endPt(), segb.fPts[0], segb.fPts[1]};
 
             SkVector midVec = segb.fNorms[0] + segb.fNorms[1];
             midVec.normalize();
 
             verts[*v + 0].fPos = fanPt;
             verts[*v + 1].fPos = qpts[0];
             verts[*v + 2].fPos = qpts[2];
             verts[*v + 3].fPos = qpts[0] + segb.fNorms[0];
@@ skipping 23 matching lines @@
             idxs[*i + 1] = *v + 1;
             idxs[*i + 2] = *v + 2;
             idxs[*i + 3] = *v + 4;
             idxs[*i + 4] = *v + 3;
             idxs[*i + 5] = *v + 2;
 
             idxs[*i + 6] = *v + 5;
             idxs[*i + 7] = *v + 3;
             idxs[*i + 8] = *v + 4;
 
-            idxs[*i +  9] = *v + 0;
-            idxs[*i + 10] = *v + 2;
-            idxs[*i + 11] = *v + 1;
+            *i += 9;
+
+            // Draw the interior fan if it exists. Colinear line segments have already been combined
+            // by this point, so we know the fan exists as long as there are at least 3 segments.
+            if (count >= 3) {
+                idxs[*i + 0] = *v + 0;
+                idxs[*i + 1] = *v + 2;
+                idxs[*i + 2] = *v + 1;
+
+                *i += 3;
+            }
 
             *v += 6;
-            *i += 12;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
  * Quadratic specified by 0=u^2-v canonical coords. u and v are the first
  * two components of the vertex attribute. Coverage is based on signed
  * distance with negative being inside, positive outside. The edge is specified in
@@ skipping 384 matching lines @@
     geometry.fColor = color;
     geometry.fViewMatrix = vm;
     geometry.fPath = path;
 
     SkAutoTUnref<GrBatch> batch(AAConvexPathBatch::Create(geometry));
     target->drawBatch(pipelineBuilder, batch, &devRect);
 
     return true;
 
 }