Added GrAAFlatteningConvexPathRenderer

src/gpu/GrAAConvexTessellator.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAAConvexTessellator_DEFINED
 #define GrAAConvexTessellator_DEFINED
 
@@ skipping 30 matching lines @@
 
     // The next five should only be called after tessellate to extract the result
     int numPts() const { return fPts.count(); }
     int numIndices() const { return fIndices.count(); }
 
     const SkPoint& lastPoint() const { return fPts.top(); }
     const SkPoint& point(int index) const { return fPts[index]; }
     int index(int index) const { return fIndices[index]; }
     SkScalar depth(int index) const {return fDepths[index]; }
 
-#if GR_AA_CONVEX_TESSELLATOR_VIZ
+#if GR_AA__CONVEX_TESSELLATOR_VIZ

[bsalomon, 2015/05/29 15:07:56]

why the extra underscore?

[ethannicholas, 2015/06/02 20:20:41]

Screwed up a search and repla... errr.... I mean.... quantum mechanics.

You wouldn't understand.

Fixed!

     void draw(SkCanvas* canvas) const;
 #endif
 
     // The tessellator can be reused for multiple paths by rewinding in between
     void rewind();
 
 private:
     // CandidateVerts holds the vertices for the next ring while they are 
     // being generated. Its main function is to de-dup the points.
     class CandidateVerts {
@@ skipping 71 matching lines @@
 
         // init should be called after all the indices have been added (via addIdx)
         void init(const GrAAConvexTessellator& tess);
         void init(const SkTDArray<SkVector>& norms, const SkTDArray<SkVector>& bisectors);
 
         const SkPoint& norm(int index) const { return fPts[index].fNorm; }
         const SkPoint& bisector(int index) const { return fPts[index].fBisector; }
         int index(int index) const { return fPts[index].fIndex; }
         int origEdgeID(int index) const { return fPts[index].fOrigEdgeId; }
 
-    #if GR_AA_CONVEX_TESSELLATOR_VIZ
+    #if GR_AA__CONVEX_TESSELLATOR_VIZ

[bsalomon, 2015/05/29 15:07:56]

and here?

         void draw(SkCanvas* canvas, const GrAAConvexTessellator& tess) const;
     #endif
 
     private:
         void computeNormals(const GrAAConvexTessellator& result);
         void computeBisectors(const GrAAConvexTessellator& tess);
 
         SkDEBUGCODE(bool isConvex(const GrAAConvexTessellator& tess) const;)
 
         struct PointData {
             SkPoint fNorm;
             SkPoint fBisector;
             int     fIndex;
             int     fOrigEdgeId;
         };
 
         SkTDArray<PointData> fPts;
     };
 
     bool movable(int index) const { return fMovable[index]; }
 
     // Movable points are those that can be slid along their bisector.
     // Basically, a point is immovable if it is part of the original
     // polygon or it results from the fusing of two bisectors.
-    int addPt(const SkPoint& pt, SkScalar depth, bool movable);
+    int addPt(const SkPoint& pt, SkScalar depth, bool movable, bool isCurve);
     void popLastPt();
     void popFirstPtShuffle();
 
     void updatePt(int index, const SkPoint& pt, SkScalar depth);
 
     void addTri(int i0, int i1, int i2);
 
     void reservePts(int count) {
         fPts.setReserve(count);
         fDepths.setReserve(count);  
         fMovable.setReserve(count);
     }
 
     SkScalar computeDepthFromEdge(int edgeIdx, const SkPoint& p) const;
 
     bool computePtAlongBisector(int startIdx, const SkPoint& bisector,
                                 int edgeIdx, SkScalar desiredDepth,
                                 SkPoint* result) const;
 
+    void lineTo(const SkMatrix& m, SkPoint p, bool isCurve);
+
+    void quadTo(const SkMatrix& m, SkPoint* pts);

[bsalomon, 2015/05/29 15:07:56]

pts[2] (and similar for below two funcs)?

+
+    void cubicTo(const SkMatrix& m, SkPoint* pts);
+
+    void conicTo(const SkMatrix& m, SkPoint* pts, SkScalar w);
+
     void terminate(const Ring& lastRing);
 
     // return false on failure/degenerate path
     bool extractFromPath(const SkMatrix& m, const SkPath& path);
     void computeBisectors();
 
     void fanRing(const Ring& ring);
     void createOuterRing();
 
     Ring* getNextRing(Ring* lastRing);
@@ skipping 12 matching lines @@
     SkTDArray<SkPoint>  fPts;
     SkTDArray<SkScalar> fDepths;
     // movable points are those that can be slid further along their bisector
     SkTDArray<bool>     fMovable;
 
     // The outward facing normals for the original polygon
     SkTDArray<SkVector> fNorms;
     // The inward facing bisector at each point in the original polygon. Only
     // needed for exterior ring creation and then handed off to the initial ring.
     SkTDArray<SkVector> fBisectors;
+
+    // Tracks whether a given point is interior to a curve. Such points are 
+    // assumed to have shallow curvature.
+    SkTDArray<bool> fIsCurve;
+
     SkPoint::Side       fSide;    // winding of the original polygon
 
     // The triangulation of the points
     SkTDArray<int>      fIndices;
 
     Ring                fInitialRing;
-#if GR_AA_CONVEX_TESSELLATOR_VIZ
+#if GR_AA__CONVEX_TESSELLATOR_VIZ

[bsalomon, 2015/05/29 15:07:56]

and here

     // When visualizing save all the rings
     SkTDArray<Ring*>    fRings;
 #else
     Ring                fRings[2];
 #endif
     CandidateVerts      fCandidateVerts;
 
     SkScalar            fTargetDepth;
 
+    SkTDArray<SkPoint>  fPointBuffer;
+
     // If some goes wrong with the inset computation the tessellator will 
     // truncate the creation of the inset polygon. In this case the depth
     // check will complain.
     SkDEBUGCODE(bool fShouldCheckDepths;)
 };
 
 
 #endif