Fix convex path renderer bounds computation

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 200 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;
 }
 
-static inline void add_line_to_segment(const SkPoint& pt, SegmentArray* segments) {
+static inline void add_line_to_segment(const SkPoint& pt,
+                                       SegmentArray* segments,
+                                       SkRect* devBounds) {
     segments->push_back();
     segments->back().fType = Segment::kLine;
     segments->back().fPts[0] = pt;
+    devBounds->growToInclude(pt.fX, pt.fY);
 }
 
-static inline void add_quad_segment(const SkPoint pts[3], SegmentArray* segments) {
+static inline bool contains_inclusive(const SkRect& rect, const SkPoint& p) {
+    return p.fX >= rect.fLeft && p.fX <= rect.fRight && p.fY >= rect.fTop && p.fY <= rect.fBottom;
+}
+static inline void add_quad_segment(const SkPoint pts[3],
+                                    SegmentArray* segments,
+                                    SkRect* devBounds) {
     if (pts[0].distanceToSqd(pts[1]) < kCloseSqd || pts[1].distanceToSqd(pts[2]) < kCloseSqd) {
         if (pts[0] != pts[2]) {
-            add_line_to_segment(pts[2], segments);
+            add_line_to_segment(pts[2], segments, devBounds);
         }
     } else {
         segments->push_back();
         segments->back().fType = Segment::kQuad;
         segments->back().fPts[0] = pts[1];
         segments->back().fPts[1] = pts[2];
+        SkASSERT(contains_inclusive(*devBounds, pts[0]));
+        devBounds->growToInclude(pts + 1, 2);
     }
 }
 
 static inline void add_cubic_segments(const SkPoint pts[4],
                                       SkPath::Direction dir,
-                                      SegmentArray* segments) {
+                                      SegmentArray* segments,
+                                      SkRect* devBounds) {
     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, devBounds);
     }
 }
 
 static bool get_segments(const SkPath& path,
                          const SkMatrix& m,
                          SegmentArray* segments,
                          SkPoint* fanPt,
                          int* vCount,
-                         int* iCount) {
+                         int* iCount,
+                         SkRect* devBounds) {
     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;
     }
 
     for (;;) {
         GrPoint pts[4];
         SkPath::Verb verb = iter.next(pts);
         switch (verb) {
             case SkPath::kMove_Verb:
                 m.mapPoints(pts, 1);
                 update_degenerate_test(&degenerateData, pts[0]);
+                devBounds->set(pts->fX, pts->fY, pts->fX, pts->fY);
                 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, devBounds);
                 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, devBounds);
                 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, devBounds);
                 break;
             };
             case SkPath::kDone_Verb:
                 if (degenerateData.isDegenerate()) {
                     return false;
                 } else {
                     compute_vectors(segments, fanPt, dir, vCount, iCount);
                     return true;
                 }
             default:
@@ skipping 330 matching lines @@
 
     int vCount;
     int iCount;
     enum {
         kPreallocSegmentCnt = 512 / sizeof(Segment),
         kPreallocDrawCnt = 4,
     };
     SkSTArray<kPreallocSegmentCnt, Segment, true> segments;
     SkPoint fanPt;
 
-    if (!get_segments(*path, viewMatrix, &segments, &fanPt, &vCount, &iCount)) {
+    // We can't simply use the path bounds because we may degenerate cubics to quads which produces
+    // new control points outside the original convex hull.
+    SkRect devBounds;
+    if (!get_segments(*path, viewMatrix, &segments, &fanPt, &vCount, &iCount, &devBounds)) {
         return false;
     }
 
+    // Our computed verts should all be within one pixel of the segment control points.
+    devBounds.outset(SK_Scalar1, SK_Scalar1);
+
     drawState->setVertexAttribs<gPathAttribs>(SK_ARRAY_COUNT(gPathAttribs));
 
     static const int kEdgeAttrIndex = 1;
     GrEffectRef* quadEffect = QuadEdgeEffect::Create();
     drawState->addCoverageEffect(quadEffect, kEdgeAttrIndex)->unref();
 
     GrDrawTarget::AutoReleaseGeometry arg(target, vCount, iCount);
     if (!arg.succeeded()) {
         return false;
     }
     SkASSERT(sizeof(QuadVertex) == drawState->getVertexSize());
     verts = reinterpret_cast<QuadVertex*>(arg.vertices());
     idxs = reinterpret_cast<uint16_t*>(arg.indices());
 
     SkSTArray<kPreallocDrawCnt, Draw, true> draws;
     create_vertices(segments, fanPt, &draws, verts, idxs);
 
-    // This is valid because all the computed verts are within 1 pixel of the path control points.
-    SkRect devBounds;
-    devBounds = path->getBounds();
-    viewMatrix.mapRect(&devBounds);
-    devBounds.outset(SK_Scalar1, SK_Scalar1);
-
     // Check devBounds
 #ifdef SK_DEBUG
     SkRect tolDevBounds = devBounds;
     tolDevBounds.outset(SK_Scalar1 / 10000, SK_Scalar1 / 10000);
     SkRect actualBounds;
     actualBounds.set(verts[0].fPos, verts[1].fPos);
     for (int i = 2; i < vCount; ++i) {
         actualBounds.growToInclude(verts[i].fPos.fX, verts[i].fPos.fY);
     }
     SkASSERT(tolDevBounds.contains(actualBounds));
 #endif
 
     int vOffset = 0;
     for (int i = 0; i < draws.count(); ++i) {
         const Draw& draw = draws[i];
         target->drawIndexed(kTriangles_GrPrimitiveType,
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }