Fix repeated point quads/cubics in convex pr and update convexpaths GM

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"
 
 #include "GrContext.h"
 #include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
 #include "GrEffect.h"
 #include "GrPathUtils.h"
 #include "GrTBackendEffectFactory.h"
 #include "SkString.h"
 #include "SkStrokeRec.h"
 #include "SkTrace.h"
 
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
 
 GrAAConvexPathRenderer::GrAAConvexPathRenderer() {
 }
 
-namespace {
-
 struct Segment {
     enum {
         // These enum values are assumed in member functions below.
         kLine = 0,
         kQuad = 1,
     } fType;
 
     // line uses one pt, quad uses 2 pts
     GrPoint fPts[2];
     // normal to edge ending at each pt
@@ skipping 11 matching lines @@
         return fPts[fType];
     };
     const SkPoint& endNorm() const {
         GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
         return fNorms[fType];
     };
 };
 
 typedef SkTArray<Segment, true> SegmentArray;
 
-void center_of_mass(const SegmentArray& segments, SkPoint* c) {
+static void center_of_mass(const SegmentArray& segments, SkPoint* c) {
     SkScalar area = 0;
     SkPoint center = {0, 0};
     int count = segments.count();
     SkPoint p0 = {0, 0};
     if (count > 2) {
         // We translate the polygon so that the first point is at the origin.
         // This avoids some precision issues with small area polygons far away
         // from the origin.
         p0 = segments[0].endPt();
         SkPoint pi;
@@ skipping 30 matching lines @@
         area *= 3;
         area = SkScalarDiv(SK_Scalar1, area);
         center.fX = SkScalarMul(center.fX, area);
         center.fY = SkScalarMul(center.fY, area);
         // undo the translate of p0 to the origin.
         *c = center + p0;
     }
     GrAssert(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY));
 }
 
-void compute_vectors(SegmentArray* segments,
-                     SkPoint* fanPt,
-                     SkPath::Direction dir,
-                     int* vCount,
-                     int* iCount) {
+static void compute_vectors(SegmentArray* segments,
+                            SkPoint* fanPt,
+                            SkPath::Direction dir,
+                            int* vCount,
+                            int* iCount) {
     center_of_mass(*segments, fanPt);
     int count = segments->count();
 
     // Make the normals point towards the outside
     GrPoint::Side normSide;
     if (dir == SkPath::kCCW_Direction) {
         normSide = GrPoint::kRight_Side;
     } else {
         normSide = GrPoint::kLeft_Side;
     }
@@ skipping 44 matching lines @@
         kInitial,
         kPoint,
         kLine,
         kNonDegenerate
     }           fStage;
     GrPoint     fFirstPoint;
     GrVec       fLineNormal;
     SkScalar    fLineC;
 };
 
-void update_degenerate_test(DegenerateTestData* data, const GrPoint& pt) {
-    static const SkScalar TOL = (SK_Scalar1 / 16);
-    static const SkScalar TOL_SQD = SkScalarMul(TOL, TOL);
+static const SkScalar kClose = (SK_Scalar1 / 16);
+static const SkScalar kCloseSqd = SkScalarMul(kClose, kClose);
 
+static void update_degenerate_test(DegenerateTestData* data, const GrPoint& pt) {
     switch (data->fStage) {
         case DegenerateTestData::kInitial:
             data->fFirstPoint = pt;
             data->fStage = DegenerateTestData::kPoint;
             break;
         case DegenerateTestData::kPoint:
-            if (pt.distanceToSqd(data->fFirstPoint) > TOL_SQD) {
+            if (pt.distanceToSqd(data->fFirstPoint) > kCloseSqd) {
                 data->fLineNormal = pt - data->fFirstPoint;
                 data->fLineNormal.normalize();
                 data->fLineNormal.setOrthog(data->fLineNormal);
                 data->fLineC = -data->fLineNormal.dot(data->fFirstPoint);
                 data->fStage = DegenerateTestData::kLine;
             }
             break;
         case DegenerateTestData::kLine:
-            if (SkScalarAbs(data->fLineNormal.dot(pt) + data->fLineC) > TOL) {
+            if (SkScalarAbs(data->fLineNormal.dot(pt) + data->fLineC) > kClose) {
                 data->fStage = DegenerateTestData::kNonDegenerate;
             }
         case DegenerateTestData::kNonDegenerate:
             break;
         default:
             GrCrash("Unexpected degenerate test stage.");
     }
 }
 
-inline bool get_direction(const SkPath& path, const SkMatrix& m, SkPath::Direction* dir) {
+static inline bool get_direction(const SkPath& path, const SkMatrix& m, SkPath::Direction* dir) {
     if (!path.cheapComputeDirection(dir)) {
         return false;
     }
     // check whether m reverses the orientation
     GrAssert(!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;
 }
 
-bool get_segments(const SkPath& path,
-                  const SkMatrix& m,
-                  SegmentArray* segments,
-                  SkPoint* fanPt,
-                  int* vCount,
-                  int* iCount) {
+static inline void add_line_to_segment(const SkPoint& pt, SegmentArray* segments) {
+    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) {
+        if (pts[0] != pts[2]) {
+            add_line_to_segment(pts[2], segments);
+        }
+    } 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) {
+    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);
+    }
+}
+
+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;
     }
 
     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]);
                 break;
             case SkPath::kLine_Verb: {
-                m.mapPoints(pts + 1, 1);
+                m.mapPoints(&pts[1], 1);
                 update_degenerate_test(&degenerateData, pts[1]);
-                segments->push_back();
-                segments->back().fType = Segment::kLine;
-                segments->back().fPts[0] = pts[1];
+                add_line_to_segment(pts[1], segments);
                 break;
             }
             case SkPath::kQuad_Verb:
-                m.mapPoints(pts + 1, 2);
+                m.mapPoints(pts, 3);
                 update_degenerate_test(&degenerateData, pts[1]);
                 update_degenerate_test(&degenerateData, pts[2]);
-                segments->push_back();
-                segments->back().fType = Segment::kQuad;
-                segments->back().fPts[0] = pts[1];
-                segments->back().fPts[1] = pts[2];
+                add_quad_segment(pts, segments);
                 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]);
-                // unlike quads and lines, the pts[0] will also be read (in
-                // convertCubicToQuads).
-                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) {
-                    segments->push_back();
-                    segments->back().fType = Segment::kQuad;
-                    segments->back().fPts[0] = quads[q + 1];
-                    segments->back().fPts[1] = quads[q + 2];
-                }
+                add_cubic_segments(pts, dir, segments);
                 break;
             };
             case SkPath::kDone_Verb:
                 if (degenerateData.isDegenerate()) {
                     return false;
                 } else {
                     compute_vectors(segments, fanPt, dir, vCount, iCount);
                     return true;
                 }
             default:
@@ skipping 10 matching lines @@
 };
 
 struct Draw {
     Draw() : fVertexCnt(0), fIndexCnt(0) {}
     int fVertexCnt;
     int fIndexCnt;
 };
 
 typedef SkTArray<Draw, true> DrawArray;
 
-void create_vertices(const SegmentArray&  segments,
-                     const SkPoint& fanPt,
-                     DrawArray*     draws,
-                     QuadVertex*    verts,
-                     uint16_t*      idxs) {
+static void create_vertices(const SegmentArray&  segments,
+                            const SkPoint& fanPt,
+                            DrawArray*     draws,
+                            QuadVertex*    verts,
+                            uint16_t*      idxs) {
     Draw* draw = &draws->push_back();
     // alias just to make vert/index assignments easier to read.
     int* v = &draw->fVertexCnt;
     int* i = &draw->fIndexCnt;
 
     int count = segments.count();
     for (int a = 0; a < count; ++a) {
         const Segment& sega = segments[a];
         int b = (a + 1) % count;
         const Segment& segb = segments[b];
@@ skipping 122 matching lines @@
             idxs[*i +  9] = *v + 0;
             idxs[*i + 10] = *v + 2;
             idxs[*i + 11] = *v + 1;
 
             *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
  * window space (y-down). If either the third or fourth component of the interpolated
  * vertex coord is > 0 then the pixel is considered outside the edge. This is used to
  * attempt to trim to a portion of the infinite quad.
  * Requires shader derivative instruction support.
@@ skipping 203 matching lines @@
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }