GrTessellator: make inverse fill types more sane.

src/gpu/GrTessellator.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 "GrTessellator.h"
 
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 658 matching lines @@
 
     SkPoint pts[4];
     bool done = false;
     *isLinear = true;
     SkPath::Iter iter(path, false);
     Vertex* prev = nullptr;
     Vertex* head = nullptr;
     if (path.isInverseFillType()) {
         SkPoint quad[4];
         clipBounds.toQuad(quad);
-        for (int i = 0; i < 4; i++) {
+        for (int i = 3; i >= 0; i--) {
             prev = append_point_to_contour(quad[i], prev, &head, alloc);
         }
         head->fPrev = prev;
         prev->fNext = head;
         *contours++ = head;
         head = prev = nullptr;
     }
     SkAutoConicToQuads converter;
     while (!done) {
         SkPath::Verb verb = iter.next(pts);
@@ skipping 61 matching lines @@
     if (!poly) {
         return false;
     }
     int winding = poly->fWinding;
     switch (fillType) {
         case SkPath::kWinding_FillType:
             return winding != 0;
         case SkPath::kEvenOdd_FillType:
             return (winding & 1) != 0;
         case SkPath::kInverseWinding_FillType:
-            return winding == -1;
+            return winding == 1;
         case SkPath::kInverseEvenOdd_FillType:
             return (winding & 1) == 1;
         default:
             SkASSERT(false);
             return false;
     }
 }
 
 Edge* new_edge(Vertex* prev, Vertex* next, SkChunkAlloc& alloc, Comparator& c,
                int winding_scale = 1) {
@@ skipping 858 matching lines @@
         LOG("path.moveTo(%20.20g, %20.20g);\n", v->fPoint.fX, v->fPoint.fY);
         for (v = v->fNext; v != contours[i]; v = v->fNext) {
             LOG("path.lineTo(%20.20g, %20.20g);\n", v->fPoint.fX, v->fPoint.fY);
         }
     }
 #endif
     sanitize_contours(contours, contourCnt, antialias);
     return build_edges(contours, contourCnt, c, alloc);
 }
 
-Poly* mesh_to_polys(Vertex** vertices, SkPath::FillType fillType, Comparator& c,
-                    SkChunkAlloc& alloc) {
+Poly* mesh_to_polys(Vertex** vertices, Comparator& c, SkChunkAlloc& alloc) {
     if (!vertices || !*vertices) {
         return nullptr;
     }
 
     // Sort vertices in Y (secondarily in X).
     merge_sort(vertices, c);
     merge_coincident_vertices(vertices, c, alloc);
 #if LOGGING_ENABLED
     for (Vertex* v = *vertices; v != nullptr; v = v->fNext) {
         static float gID = 0.0f;
         v->fID = gID++;
     }
 #endif
     simplify(*vertices, c, alloc);
     return tessellate(*vertices, alloc);
 }
 
 Poly* contours_to_polys(Vertex** contours, int contourCnt, SkPath::FillType fillType,
                         const SkRect& pathBounds, bool antialias,
                         SkChunkAlloc& alloc) {
     Comparator c;
     if (pathBounds.width() > pathBounds.height()) {
         c.sweep_lt = sweep_lt_horiz;
         c.sweep_gt = sweep_gt_horiz;
     } else {
         c.sweep_lt = sweep_lt_vert;
         c.sweep_gt = sweep_gt_vert;
     }
     Vertex* mesh = contours_to_mesh(contours, contourCnt, antialias, c, alloc);
-    Poly* polys = mesh_to_polys(&mesh, fillType, c, alloc);
+    Poly* polys = mesh_to_polys(&mesh, c, alloc);
     if (antialias) {
         EdgeList* boundaries = extract_boundaries(mesh, fillType, alloc);
         VertexList aaMesh;
         for (EdgeList* boundary = boundaries; boundary != nullptr; boundary = boundary->fNext) {
             simplify_boundary(boundary, c, alloc);
             if (boundary->fCount > 2) {
                 boundary_to_aa_mesh(boundary, &aaMesh, c, alloc);
             }
         }
-        return mesh_to_polys(&aaMesh.fHead, SkPath::kWinding_FillType, c, alloc);
+        return mesh_to_polys(&aaMesh.fHead, c, alloc);
     }
     return polys;
 }
 
 // Stage 6: Triangulate the monotone polygons into a vertex buffer.
 void* polys_to_triangles(Poly* polys, SkPath::FillType fillType, const AAParams* aaParams,
                          void* data) {
     for (Poly* poly = polys; poly; poly = poly->fNext) {
         if (apply_fill_type(fillType, poly)) {
             data = poly->emit(aaParams, data);
@@ skipping 56 matching lines @@
     int contourCnt;
     int sizeEstimate;
     get_contour_count_and_size_estimate(path, tolerance, &contourCnt, &sizeEstimate);
     if (contourCnt <= 0) {
         *isLinear = true;
         return 0;
     }
     SkChunkAlloc alloc(sizeEstimate);
     Poly* polys = path_to_polys(path, tolerance, clipBounds, contourCnt, alloc, antialias,
                                 isLinear);
-    SkPath::FillType fillType = path.getFillType();
+    SkPath::FillType fillType = antialias ? SkPath::kWinding_FillType : path.getFillType();
     int count = count_points(polys, fillType);
     if (0 == count) {
         return 0;
     }
 
     void* verts = vertexAllocator->lock(count);
     if (!verts) {
         SkDebugf("Could not allocate vertices\n");
         return 0;
     }
@@ skipping 46 matching lines @@
         }
     }
     int actualCount = static_cast<int>(vertsEnd - *verts);
     SkASSERT(actualCount <= count);
     SkASSERT(pointsEnd - points == actualCount);
     delete[] points;
     return actualCount;
 }
 
 } // namespace