Reduce geometry size for circles to help fill rate.

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 537 matching lines @@
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseGeometryProcessor);
 
 sk_sp<GrGeometryProcessor> DIEllipseGeometryProcessor::TestCreate(GrProcessorTestData* d) {
     return sk_sp<GrGeometryProcessor>(
         new DIEllipseGeometryProcessor(GrTest::TestMatrix(d->fRandom),
                                        (DIEllipseStyle)(d->fRandom->nextRangeU(0,2))));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+// We have two possible cases for geometry for a circle:
+
+// In the case of a normal fill, we draw geometry for the circle as an octagon.
+static const uint16_t gFillCircleIndices[] = {
+    // enter the octagon
+    0, 1, 8, 1, 2, 8,
+    2, 3, 8, 3, 4, 8,
+    4, 5, 8, 5, 6, 8,
+    6, 7, 8, 7, 0, 8,
+};
+
+// For stroked circles, we use two nested octagons.
+static const uint16_t gStrokeCircleIndices[] = {
+    // enter the octagon
+    0, 1, 9, 0, 9, 8,
+    1, 2, 10, 1, 10, 9,
+    2, 3, 11, 2, 11, 10,
+    3, 4, 12, 3, 12, 11,
+    4, 5, 13, 4, 13, 12,
+    5, 6, 14, 5, 14, 13,
+    6, 7, 15, 6, 15, 14,
+    7, 0, 8, 7, 8, 15,
+};
+
+static const int kIndicesPerFillCircle = SK_ARRAY_COUNT(gFillCircleIndices);
+static const int kIndicesPerStrokeCircle = SK_ARRAY_COUNT(gStrokeCircleIndices);
+static const int kVertsPerStrokeCircle = 16;
+static const int kVertsPerFillCircle = 9;
+
+static int circle_type_to_vert_count(bool stroked) {
+    return stroked ? kVertsPerStrokeCircle : kVertsPerFillCircle;
+}
+
+static int circle_type_to_index_count(bool stroked) {
+    return stroked ? kIndicesPerStrokeCircle : kIndicesPerFillCircle;
+}
+
+static const uint16_t* circle_type_to_indices(bool stroked) {
+    return stroked ? gStrokeCircleIndices : gFillCircleIndices;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 class CircleBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     /** Optional extra params to render a partial arc rather than a full circle. */
     struct ArcParams {
         SkScalar fStartAngleRadians;
         SkScalar fSweepAngleRadians;
         bool fUseCenter;
     };
@@ skipping 26 matching lines @@
         }
 
         viewMatrix.mapPoints(&center, 1);
         radius = viewMatrix.mapRadius(radius);
         SkScalar strokeWidth = viewMatrix.mapRadius(stroke.getWidth());
 
         bool isStrokeOnly = SkStrokeRec::kStroke_Style == recStyle ||
                             SkStrokeRec::kHairline_Style == recStyle;
         bool hasStroke = isStrokeOnly || SkStrokeRec::kStrokeAndFill_Style == recStyle;
 
-        SkScalar innerRadius = 0.0f;
+        SkScalar innerRadius = -SK_ScalarHalf;
         SkScalar outerRadius = radius;
         SkScalar halfWidth = 0;
         if (hasStroke) {
             if (SkScalarNearlyZero(strokeWidth)) {
                 halfWidth = SK_ScalarHalf;
             } else {
                 halfWidth = SkScalarHalf(strokeWidth);
             }
 
             outerRadius += halfWidth;
             if (isStrokeOnly) {
                 innerRadius = radius - halfWidth;
             }
         }
 
         // The radii are outset for two reasons. First, it allows the shader to simply perform
         // simpler computation because the computed alpha is zero, rather than 50%, at the radius.
         // Second, the outer radius is used to compute the verts of the bounding box that is
         // rendered and the outset ensures the box will cover all partially covered by the circle.
         outerRadius += SK_ScalarHalf;
         innerRadius -= SK_ScalarHalf;
+        bool stroked = isStrokeOnly && innerRadius > 0.0f;
         CircleBatch* batch = new CircleBatch();
         batch->fViewMatrixIfUsingLocalCoords = viewMatrix;
 
         // This makes every point fully inside the intersection plane.
         static constexpr SkScalar kUnusedIsectPlane[] = {0.f, 0.f, 1.f};
         // This makes every point fully outside the union plane.
         static constexpr SkScalar kUnusedUnionPlane[] = {0.f, 0.f, 0.f};
         SkRect devBounds = SkRect::MakeLTRB(center.fX - outerRadius, center.fY - outerRadius,
                                             center.fX + outerRadius, center.fY + outerRadius);
-
         if (arcParams) {
             // The shader operates in a space where the circle is translated to be centered at the
             // origin. Here we compute points on the unit circle at the starting and ending angles.
             SkPoint startPoint, stopPoint;
             startPoint.fY = SkScalarSinCos(arcParams->fStartAngleRadians, &startPoint.fX);
             SkScalar endAngle = arcParams->fStartAngleRadians + arcParams->fSweepAngleRadians;
             stopPoint.fY = SkScalarSinCos(endAngle, &stopPoint.fX);
             // Like a fill without useCenter, butt-cap stroke can be implemented by clipping against
             // radial lines. However, in both cases we have to be careful about the half-circle.
             // case. In that case the two radial lines are equal and so that edge gets clipped
@@ skipping 12 matching lines @@
                 }
                 batch->fClipPlane = true;
                 if (SkScalarAbs(arcParams->fSweepAngleRadians) > SK_ScalarPI) {
                     batch->fGeoData.emplace_back(Geometry {
                             color,
                             innerRadius,
                             outerRadius,
                             {norm0.fX, norm0.fY, 0.5f},
                             {kUnusedIsectPlane[0], kUnusedIsectPlane[1], kUnusedIsectPlane[2]},
                             {norm1.fX, norm1.fY, 0.5f},
-                            devBounds
+                            devBounds,
+                            stroked
                     });
                     batch->fClipPlaneIsect = false;
                     batch->fClipPlaneUnion = true;
                 } else {
                     batch->fGeoData.emplace_back(Geometry {
                             color,
                             innerRadius,
                             outerRadius,
                             {norm0.fX, norm0.fY, 0.5f},
                             {norm1.fX, norm1.fY, 0.5f},
                             {kUnusedUnionPlane[0], kUnusedUnionPlane[1], kUnusedUnionPlane[2]},
-                            devBounds
+                            devBounds,
+                            stroked
                     });
                     batch->fClipPlaneIsect = true;
                     batch->fClipPlaneUnion = false;
                 }
             } else {
                 // We clip to a secant of the original circle.
                 startPoint.scale(radius);
                 stopPoint.scale(radius);
                 SkVector norm = {startPoint.fY - stopPoint.fY, stopPoint.fX - startPoint.fX};
                 norm.normalize();
                 if (arcParams->fSweepAngleRadians > 0) {
                     norm.negate();
                 }
                 SkScalar d = -norm.dot(startPoint) + 0.5f;
 
                 batch->fGeoData.emplace_back(Geometry {
                         color,
                         innerRadius,
                         outerRadius,
                         {norm.fX, norm.fY, d},
                         {kUnusedIsectPlane[0], kUnusedIsectPlane[1], kUnusedIsectPlane[2]},
                         {kUnusedUnionPlane[0], kUnusedUnionPlane[1], kUnusedUnionPlane[2]},
-                        devBounds
+                        devBounds,
+                        stroked
                 });
                 batch->fClipPlane = true;
                 batch->fClipPlaneIsect = false;
                 batch->fClipPlaneUnion = false;
             }
         } else {
             batch->fGeoData.emplace_back(Geometry {
                 color,
                 innerRadius,
                 outerRadius,
                 {kUnusedIsectPlane[0], kUnusedIsectPlane[1], kUnusedIsectPlane[2]},
                 {kUnusedIsectPlane[0], kUnusedIsectPlane[1], kUnusedIsectPlane[2]},
                 {kUnusedUnionPlane[0], kUnusedUnionPlane[1], kUnusedUnionPlane[2]},
-                devBounds
+                devBounds,
+                stroked
             });
             batch->fClipPlane = false;
             batch->fClipPlaneIsect = false;
             batch->fClipPlaneUnion = false;
         }
         // Use the original radius and stroke radius for the bounds so that it does not include the
         // AA bloat.
         radius += halfWidth;
         batch->setBounds({center.fX - radius, center.fY - radius,
                           center.fX + radius, center.fY + radius},
                           HasAABloat::kYes, IsZeroArea::kNo);
-        batch->fStroked = isStrokeOnly && innerRadius > 0;
+        batch->fVertCount = circle_type_to_vert_count(stroked);
+        batch->fIndexCount = circle_type_to_index_count(stroked);
+        batch->fAllFill = !stroked;
         return batch;
     }
 
     const char* name() const override { return "CircleBatch"; }
 
     SkString dumpInfo() const override {
         SkString string;
         for (int i = 0; i < fGeoData.count(); ++i) {
             string.appendf("Color: 0x%08x Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f],"
                            "InnerRad: %.2f, OuterRad: %.2f\n",
@@ skipping 25 matching lines @@
         }
     }
 
     void onPrepareDraws(Target* target) const override {
         SkMatrix localMatrix;
         if (!fViewMatrixIfUsingLocalCoords.invert(&localMatrix)) {
             return;
         }
 
         // Setup geometry processor
-        SkAutoTUnref<GrGeometryProcessor> gp(new CircleGeometryProcessor(fStroked, fClipPlane,
+        SkAutoTUnref<GrGeometryProcessor> gp(new CircleGeometryProcessor(!fAllFill, fClipPlane,
                                                                          fClipPlaneIsect,
                                                                          fClipPlaneUnion,
                                                                          localMatrix));
 
         struct CircleVertex {
             SkPoint  fPos;
             GrColor  fColor;
             SkPoint  fOffset;
             SkScalar fOuterRadius;
             SkScalar fInnerRadius;
             // These planes may or may not be present in the vertex buffer.
             SkScalar fHalfPlanes[3][3];
         };
 
         int instanceCount = fGeoData.count();
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(vertexStride == sizeof(CircleVertex) - (fClipPlane ? 0 : 3 * sizeof(SkScalar))
                                                       - (fClipPlaneIsect? 0 : 3 * sizeof(SkScalar))
                                                       - (fClipPlaneUnion? 0 : 3 * sizeof(SkScalar)));
-        QuadHelper helper;
-        char* vertices = reinterpret_cast<char*>(helper.init(target, vertexStride, instanceCount));
+
+        const GrBuffer* vertexBuffer;
+        int firstVertex;
+        char* vertices = (char*)target->makeVertexSpace(vertexStride, fVertCount,
+                                                        &vertexBuffer, &firstVertex);
         if (!vertices) {
+            SkDebugf("Could not allocate vertices\n");
             return;
         }
 
+        const GrBuffer* indexBuffer = nullptr;
+        int firstIndex = 0;
+        uint16_t* indices = target->makeIndexSpace(fIndexCount, &indexBuffer, &firstIndex);
+        if (!indices) {
+            SkDebugf("Could not allocate indices\n");
+            return;
+        }
+
+        int currStartVertex = 0;
         for (int i = 0; i < instanceCount; i++) {
             const Geometry& geom = fGeoData[i];
 
             GrColor color = geom.fColor;
             SkScalar innerRadius = geom.fInnerRadius;
             SkScalar outerRadius = geom.fOuterRadius;
 
             const SkRect& bounds = geom.fDevBounds;
-            CircleVertex* v0 = reinterpret_cast<CircleVertex*>(vertices + (4 * i + 0)*vertexStride);
-            CircleVertex* v1 = reinterpret_cast<CircleVertex*>(vertices + (4 * i + 1)*vertexStride);
-            CircleVertex* v2 = reinterpret_cast<CircleVertex*>(vertices + (4 * i + 2)*vertexStride);
-            CircleVertex* v3 = reinterpret_cast<CircleVertex*>(vertices + (4 * i + 3)*vertexStride);
+            CircleVertex* v0 = reinterpret_cast<CircleVertex*>(vertices + 0*vertexStride);
+            CircleVertex* v1 = reinterpret_cast<CircleVertex*>(vertices + 1*vertexStride);
+            CircleVertex* v2 = reinterpret_cast<CircleVertex*>(vertices + 2*vertexStride);
+            CircleVertex* v3 = reinterpret_cast<CircleVertex*>(vertices + 3*vertexStride);
+            CircleVertex* v4 = reinterpret_cast<CircleVertex*>(vertices + 4*vertexStride);
+            CircleVertex* v5 = reinterpret_cast<CircleVertex*>(vertices + 5*vertexStride);
+            CircleVertex* v6 = reinterpret_cast<CircleVertex*>(vertices + 6*vertexStride);
+            CircleVertex* v7 = reinterpret_cast<CircleVertex*>(vertices + 7*vertexStride);
 
             // The inner radius in the vertex data must be specified in normalized space.
             innerRadius = innerRadius / outerRadius;
-            v0->fPos = SkPoint::Make(bounds.fLeft,  bounds.fTop);
+
+            SkPoint center = SkPoint::Make(bounds.centerX(), bounds.centerY());
+            SkScalar halfWidth = 0.5f*bounds.width();
+            SkScalar octOffset = 0.41421356237f;  // sqrt(2) - 1
+            
+            v0->fPos = center + SkPoint::Make(-octOffset*halfWidth, -halfWidth);
             v0->fColor = color;
-            v0->fOffset = SkPoint::Make(-1, -1);
+            v0->fOffset = SkPoint::Make(-octOffset, -1);
             v0->fOuterRadius = outerRadius;
             v0->fInnerRadius = innerRadius;
 
-            v1->fPos = SkPoint::Make(bounds.fLeft,  bounds.fBottom);
+            v1->fPos = center + SkPoint::Make(octOffset*halfWidth, -halfWidth);
             v1->fColor = color;
-            v1->fOffset = SkPoint::Make(-1, 1);
+            v1->fOffset = SkPoint::Make(octOffset, -1);
             v1->fOuterRadius = outerRadius;
             v1->fInnerRadius = innerRadius;
 
-            v2->fPos = SkPoint::Make(bounds.fRight, bounds.fBottom);
+            v2->fPos = center + SkPoint::Make(halfWidth, -octOffset*halfWidth);
             v2->fColor = color;
-            v2->fOffset = SkPoint::Make(1, 1);
+            v2->fOffset = SkPoint::Make(1, -octOffset);
             v2->fOuterRadius = outerRadius;
             v2->fInnerRadius = innerRadius;
 
-            v3->fPos = SkPoint::Make(bounds.fRight, bounds.fTop);
+            v3->fPos = center + SkPoint::Make(halfWidth, octOffset*halfWidth);
             v3->fColor = color;
-            v3->fOffset = SkPoint::Make(1, -1);
+            v3->fOffset = SkPoint::Make(1, octOffset);
             v3->fOuterRadius = outerRadius;
             v3->fInnerRadius = innerRadius;
 
+            v4->fPos = center + SkPoint::Make(octOffset*halfWidth, halfWidth);
+            v4->fColor = color;
+            v4->fOffset = SkPoint::Make(octOffset, 1);
+            v4->fOuterRadius = outerRadius;
+            v4->fInnerRadius = innerRadius;
+
+            v5->fPos = center + SkPoint::Make(-octOffset*halfWidth, halfWidth);
+            v5->fColor = color;
+            v5->fOffset = SkPoint::Make(-octOffset, 1);
+            v5->fOuterRadius = outerRadius;
+            v5->fInnerRadius = innerRadius;
+
+            v6->fPos = center + SkPoint::Make(-halfWidth, octOffset*halfWidth);
+            v6->fColor = color;
+            v6->fOffset = SkPoint::Make(-1, octOffset);
+            v6->fOuterRadius = outerRadius;
+            v6->fInnerRadius = innerRadius;
+
+            v7->fPos = center + SkPoint::Make(-halfWidth, -octOffset*halfWidth);
+            v7->fColor = color;
+            v7->fOffset = SkPoint::Make(-1, -octOffset);
+            v7->fOuterRadius = outerRadius;
+            v7->fInnerRadius = innerRadius;
+
             if (fClipPlane) {
                 memcpy(v0->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
                 memcpy(v1->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
                 memcpy(v2->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
                 memcpy(v3->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                memcpy(v4->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                memcpy(v5->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                memcpy(v6->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                memcpy(v7->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
             }
             int unionIdx = 1;
             if (fClipPlaneIsect) {
                 memcpy(v0->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
                 memcpy(v1->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
                 memcpy(v2->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
                 memcpy(v3->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                memcpy(v4->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                memcpy(v5->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                memcpy(v6->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                memcpy(v7->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
                 unionIdx = 2;
             }
             if (fClipPlaneUnion) {
                 memcpy(v0->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
                 memcpy(v1->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
                 memcpy(v2->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
                 memcpy(v3->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                memcpy(v4->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                memcpy(v5->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                memcpy(v6->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                memcpy(v7->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
             }
+
+            if (geom.fStroked) {

[robertphillips, 2016/10/06 20:09:56]

Could this path share a "FillInOctVerts" subroutine with the above path ?

[jvanverth1, 2016/10/06 21:46:19]

I tried that but got stymied -- I'll take another stab at it.

[robertphillips, 2016/10/06 21:51:22]

It should probably be a follow up CL.

+                // compute the inner ring
+                CircleVertex* v0 = reinterpret_cast<CircleVertex*>(vertices + 8 * vertexStride);
+                CircleVertex* v1 = reinterpret_cast<CircleVertex*>(vertices + 9 * vertexStride);
+                CircleVertex* v2 = reinterpret_cast<CircleVertex*>(vertices + 10 * vertexStride);
+                CircleVertex* v3 = reinterpret_cast<CircleVertex*>(vertices + 11 * vertexStride);
+                CircleVertex* v4 = reinterpret_cast<CircleVertex*>(vertices + 12 * vertexStride);
+                CircleVertex* v5 = reinterpret_cast<CircleVertex*>(vertices + 13 * vertexStride);
+                CircleVertex* v6 = reinterpret_cast<CircleVertex*>(vertices + 14 * vertexStride);
+                CircleVertex* v7 = reinterpret_cast<CircleVertex*>(vertices + 15 * vertexStride);
+
+                // cosine and sine of pi/8
+                SkScalar c = 0.923579533f;
+                SkScalar s = 0.382683432f;
+                SkScalar r = geom.fInnerRadius;
+
+                v0->fPos = center + SkPoint::Make(-s*r, -c*r);
+                v0->fColor = color;
+                v0->fOffset = SkPoint::Make(-s*innerRadius, -c*innerRadius);
+                v0->fOuterRadius = outerRadius;
+                v0->fInnerRadius = innerRadius;
+
+                v1->fPos = center + SkPoint::Make(s*r, -c*r);
+                v1->fColor = color;
+                v1->fOffset = SkPoint::Make(s*innerRadius, -c*innerRadius);
+                v1->fOuterRadius = outerRadius;
+                v1->fInnerRadius = innerRadius;
+
+                v2->fPos = center + SkPoint::Make(c*r, -s*r);
+                v2->fColor = color;
+                v2->fOffset = SkPoint::Make(c*innerRadius, -s*innerRadius);
+                v2->fOuterRadius = outerRadius;
+                v2->fInnerRadius = innerRadius;
+
+                v3->fPos = center + SkPoint::Make(c*r, s*r);
+                v3->fColor = color;
+                v3->fOffset = SkPoint::Make(c*innerRadius, s*innerRadius);
+                v3->fOuterRadius = outerRadius;
+                v3->fInnerRadius = innerRadius;
+
+                v4->fPos = center + SkPoint::Make(s*r, c*r);
+                v4->fColor = color;
+                v4->fOffset = SkPoint::Make(s*innerRadius, c*innerRadius);
+                v4->fOuterRadius = outerRadius;
+                v4->fInnerRadius = innerRadius;
+
+                v5->fPos = center + SkPoint::Make(-s*r, c*r);
+                v5->fColor = color;
+                v5->fOffset = SkPoint::Make(-s*innerRadius, c*innerRadius);
+                v5->fOuterRadius = outerRadius;
+                v5->fInnerRadius = innerRadius;
+
+                v6->fPos = center + SkPoint::Make(-c*r, s*r);
+                v6->fColor = color;
+                v6->fOffset = SkPoint::Make(-c*innerRadius, s*innerRadius);
+                v6->fOuterRadius = outerRadius;
+                v6->fInnerRadius = innerRadius;
+
+                v7->fPos = center + SkPoint::Make(-c*r, -s*r);
+                v7->fColor = color;
+                v7->fOffset = SkPoint::Make(-c*innerRadius, -s*innerRadius);
+                v7->fOuterRadius = outerRadius;
+                v7->fInnerRadius = innerRadius;
+
+                if (fClipPlane) {
+                    memcpy(v0->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                    memcpy(v1->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                    memcpy(v2->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                    memcpy(v3->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                    memcpy(v4->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                    memcpy(v5->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                    memcpy(v6->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                    memcpy(v7->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                }
+                int unionIdx = 1;
+                if (fClipPlaneIsect) {
+                    memcpy(v0->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    memcpy(v1->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    memcpy(v2->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    memcpy(v3->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    memcpy(v4->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    memcpy(v5->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    memcpy(v6->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    memcpy(v7->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    unionIdx = 2;
+                }
+                if (fClipPlaneUnion) {
+                    memcpy(v0->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                    memcpy(v1->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                    memcpy(v2->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                    memcpy(v3->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                    memcpy(v4->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                    memcpy(v5->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                    memcpy(v6->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                    memcpy(v7->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                }
+            } else {
+                // filled
+                CircleVertex* v8 = reinterpret_cast<CircleVertex*>(vertices + 8 * vertexStride);
+                v8->fPos = center;
+                v8->fColor = color;
+                v8->fOffset = SkPoint::Make(0, 0);
+                v8->fOuterRadius = outerRadius;
+                v8->fInnerRadius = innerRadius;
+                if (fClipPlane) {
+                    memcpy(v8->fHalfPlanes[0], geom.fClipPlane, 3 * sizeof(SkScalar));
+                }
+                int unionIdx = 1;
+                if (fClipPlaneIsect) {
+                    memcpy(v8->fHalfPlanes[1], geom.fIsectPlane, 3 * sizeof(SkScalar));
+                    unionIdx = 2;
+                }
+                if (fClipPlaneUnion) {
+                    memcpy(v8->fHalfPlanes[unionIdx], geom.fUnionPlane, 3 * sizeof(SkScalar));
+                }
+            }
+
+            const uint16_t* primIndices = circle_type_to_indices(geom.fStroked);
+            const int primIndexCount = circle_type_to_index_count(geom.fStroked);
+            for (int i = 0; i < primIndexCount; ++i) {
+                *indices++ = primIndices[i] + currStartVertex;
+            }
+
+            currStartVertex += circle_type_to_vert_count(geom.fStroked);
+            vertices += circle_type_to_vert_count(geom.fStroked)*vertexStride;
         }
-        helper.recordDraw(target, gp);
+
+        GrMesh mesh;
+        mesh.initIndexed(kTriangles_GrPrimitiveType, vertexBuffer, indexBuffer, firstVertex,
+                         firstIndex, fVertCount, fIndexCount);
+        target->draw(gp.get(), mesh);
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         CircleBatch* that = t->cast<CircleBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                     that->bounds(), caps)) {
             return false;
         }
 
-        if (this->fStroked != that->fStroked) {
+        if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
             return false;
         }
 
         // Because we've set up the batches that don't use the planes with noop values
         // we can just accumulate used planes by later batches.
         fClipPlane |= that->fClipPlane;
         fClipPlaneIsect |= that->fClipPlaneIsect;
         fClipPlaneUnion |= that->fClipPlaneUnion;
 
-        if (!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
-            return false;
-        }
-
         fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
         this->joinBounds(*that);
+        fVertCount += that->fVertCount;
+        fIndexCount += that->fIndexCount;
+        fAllFill = fAllFill && that->fAllFill;
         return true;
     }
 
     struct Geometry {
         GrColor  fColor;
         SkScalar fInnerRadius;
         SkScalar fOuterRadius;
         SkScalar fClipPlane[3];
         SkScalar fIsectPlane[3];
         SkScalar fUnionPlane[3];
         SkRect   fDevBounds;
+        bool     fStroked;
     };
 
-    bool                         fStroked;
+    SkSTArray<1, Geometry, true> fGeoData;
+    SkMatrix                     fViewMatrixIfUsingLocalCoords;
+    int                          fVertCount;
+    int                          fIndexCount;
+    bool                         fAllFill;
     bool                         fClipPlane;
     bool                         fClipPlaneIsect;
     bool                         fClipPlaneUnion;
-    SkMatrix                     fViewMatrixIfUsingLocalCoords;
-    SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class EllipseBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
     static GrDrawBatch* Create(GrColor color, const SkMatrix& viewMatrix, const SkRect& ellipse,
@@ skipping 1246 matching lines @@
 }
 
 DRAW_BATCH_TEST_DEFINE(RRectBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     const SkRRect& rrect = GrTest::TestRRectSimple(random);
     return create_rrect_batch(color, viewMatrix, rrect, GrTest::TestStrokeRec(random));
 }
 
 #endif