Tesellating path renderer: typecast cleanup; logging build fix.

src/gpu/GrTessellatingPathRenderer.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 "GrTessellatingPathRenderer.h"
 
 #include "GrBatch.h"
@@ skipping 167 matching lines @@
 }
 
 bool sweep_gt_horiz(const SkPoint& a, const SkPoint& b) {
     return a.fX == b.fX ? a.fY < b.fY : a.fX > b.fX;
 }
 
 bool sweep_gt_vert(const SkPoint& a, const SkPoint& b) {
     return a.fY == b.fY ? a.fX > b.fX : a.fY > b.fY;
 }
 
-inline void* emit_vertex(Vertex* v, void* data) {
-    SkPoint* d = static_cast<SkPoint*>(data);
-    *d++ = v->fPoint;
-    return d;
+inline SkPoint* emit_vertex(Vertex* v, SkPoint* data) {
+    *data++ = v->fPoint;
+    return data;
 }
 
-void* emit_triangle(Vertex* v0, Vertex* v1, Vertex* v2, void* data) {
+SkPoint* emit_triangle(Vertex* v0, Vertex* v1, Vertex* v2, SkPoint* data) {
 #if WIREFRAME
     data = emit_vertex(v0, data);
     data = emit_vertex(v1, data);
     data = emit_vertex(v1, data);
     data = emit_vertex(v2, data);
     data = emit_vertex(v2, data);
     data = emit_vertex(v0, data);
 #else
     data = emit_vertex(v0, data);
     data = emit_vertex(v1, data);
@@ skipping 148 matching lines @@
                 fTail->fNext = newV;
                 fTail = newV;
             } else {
                 newV->fNext = fHead;
                 fHead->fPrev = newV;
                 fHead = newV;
             }
             return done;
         }
 
-        void* emit(void* data) {
+        SkPoint* emit(SkPoint* data) {
             Vertex* first = fHead;
             Vertex* v = first->fNext;
             while (v != fTail) {
                 SkASSERT(v && v->fPrev && v->fNext);
                 Vertex* prev = v->fPrev;
                 Vertex* curr = v;
                 Vertex* next = v->fNext;
                 double ax = static_cast<double>(curr->fPoint.fX) - prev->fPoint.fX;
                 double ay = static_cast<double>(curr->fPoint.fY) - prev->fPoint.fY;
                 double bx = static_cast<double>(next->fPoint.fX) - curr->fPoint.fX;
@@ skipping 47 matching lines @@
         fCount++;
         return poly;
     }
     void end(Vertex* v, SkChunkAlloc& alloc) {
         LOG("end() %d at %g, %g\n", fID, v->fPoint.fX, v->fPoint.fY);
         if (fPartner) {
             fPartner = fPartner->fPartner = NULL;
         }
         addVertex(v, fActive->fSide == kLeft_Side ? kRight_Side : kLeft_Side, alloc);
     }
-    void* emit(void *data) {
+    SkPoint* emit(SkPoint *data) {
         if (fCount < 3) {
             return data;
         }
         LOG("emit() %d, size %d\n", fID, fCount);
         for (MonotonePoly* m = fHead; m != NULL; m = m->fNext) {
             data = m->emit(data);
         }
         return data;
     }
     int fWinding;
@@ skipping 828 matching lines @@
                 if (winding != 0) {
                     Poly* poly = new_poly(&polys, v, winding, alloc);
                     leftEdge->fRightPoly = rightEdge->fLeftPoly = poly;
                 }
                 leftEdge = rightEdge;
             }
             v->fLastEdgeBelow->fRightPoly = rightPoly;
         }
 #if LOGGING_ENABLED
         LOG("\nactive edges:\n");
-        for (Edge* e = activeEdges->fHead; e != NULL; e = e->fRight) {
+        for (Edge* e = activeEdges.fHead; e != NULL; e = e->fRight) {
             LOG("%g -> %g, lpoly %d, rpoly %d\n", e->fTop->fID, e->fBottom->fID,
                 e->fLeftPoly ? e->fLeftPoly->fID : -1, e->fRightPoly ? e->fRightPoly->fID : -1);
         }
 #endif
     }
     return polys;
 }
 
 // This is a driver function which calls stages 2-5 in turn.
 
@@ skipping 22 matching lines @@
         static float gID = 0.0f;
         v->fID = gID++;
     }
 #endif
     simplify(vertices, c, alloc);
     return tessellate(vertices, alloc);
 }
 
 // Stage 6: Triangulate the monotone polygons into a vertex buffer.
 
-void* polys_to_triangles(Poly* polys, SkPath::FillType fillType, void* data) {
-    void* d = data;
+SkPoint* polys_to_triangles(Poly* polys, SkPath::FillType fillType, SkPoint* data) {
+    SkPoint* d = data;
     for (Poly* poly = polys; poly; poly = poly->fNext) {
         if (apply_fill_type(fillType, poly->fWinding)) {
             d = poly->emit(d);
         }
     }
     return d;
 }
 
 };
 
@@ skipping 96 matching lines @@
         for (Poly* poly = polys; poly; poly = poly->fNext) {
             if (apply_fill_type(fillType, poly->fWinding) && poly->fCount >= 3) {
                 count += (poly->fCount - 2) * (WIREFRAME ? 6 : 3);
             }
         }
         if (0 == count) {
             return;
         }
 
         size_t stride = gp->getVertexStride();
+        SkASSERT(stride == sizeof(SkPoint));
         const GrVertexBuffer* vertexBuffer;
         int firstVertex;
-        void* verts = batchTarget->makeVertSpace(stride, count, &vertexBuffer, &firstVertex);
+        SkPoint* verts = static_cast<SkPoint*>(
+            batchTarget->makeVertSpace(stride, count, &vertexBuffer, &firstVertex));
         if (!verts) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         LOG("emitting %d verts\n", count);
-        void* end = polys_to_triangles(polys, fillType, verts);
-        int actualCount = static_cast<int>(
-            (static_cast<char*>(end) - static_cast<char*>(verts)) / stride);
+        SkPoint* end = polys_to_triangles(polys, fillType, verts);
+        int actualCount = static_cast<int>(end - verts);
         LOG("actual count: %d\n", actualCount);
         SkASSERT(actualCount <= count);
 
         GrPrimitiveType primitiveType = WIREFRAME ? kLines_GrPrimitiveType
                                                   : kTriangles_GrPrimitiveType;
         GrVertices vertices;
         vertices.init(primitiveType, vertexBuffer, firstVertex, actualCount);
         batchTarget->draw(vertices);
 
         batchTarget->putBackVertices((size_t)(count - actualCount), stride);
@@ skipping 65 matching lines @@
     SkMatrix vmi;
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
     return TessellatingPathBatch::Create(color, path, viewMatrix, clipBounds);
 }
 
 #endif