Batch all circular rrects together

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 1344 matching lines @@
 //    ____________
 //   |_|________|_|
 //   | |\ ____ /| |
 //   | | |    | | |
 //   | | |____| | |
 //   |_|/______\|_|
 //   |_|________|_|
 //
 // We don't draw the center quad from the fill rect in this case.
 
-static const uint16_t gRRectOverstrokeIndices[] = {
+static const uint16_t gOverstrokeRRectIndices[] = {
     // overstroke quads
     // we place this at the beginning so that we can skip these indices when rendering normally
     16, 17, 19, 16, 19, 18,
     19, 17, 23, 19, 23, 21,
     21, 23, 22, 21, 22, 20,
     22, 16, 18, 22, 18, 20,
 
     // corners
     0, 1, 5, 0, 5, 4,
     2, 3, 7, 2, 7, 6,
     8, 9, 13, 8, 13, 12,
     10, 11, 15, 10, 15, 14,
 
     // edges
     1, 2, 6, 1, 6, 5,
     4, 5, 9, 4, 9, 8,
     6, 7, 11, 6, 11, 10,
     9, 10, 14, 9, 14, 13,
 
     // center
     // we place this at the end so that we can ignore these indices when not rendering as filled
     5, 6, 10, 5, 10, 9,
 };
+// fill and standard stroke indices skip the overstroke "ring"
+static const uint16_t* gStandardRRectIndices = gOverstrokeRRectIndices + 6*4;
 
-static const uint16_t* gRRectIndices = gRRectOverstrokeIndices + 6*4;
-
-// overstroke count is arraysize 
-static const int kIndicesPerOverstrokeRRect = SK_ARRAY_COUNT(gRRectOverstrokeIndices) - 6;
+// overstroke count is arraysize minus the center indices
+static const int kIndicesPerOverstrokeRRect = SK_ARRAY_COUNT(gOverstrokeRRectIndices) - 6;
+// fill count skips overstroke indices and includes center
 static const int kIndicesPerFillRRect = kIndicesPerOverstrokeRRect - 6*4 + 6;
+// stroke count is fill count minus center indices
 static const int kIndicesPerStrokeRRect = kIndicesPerFillRRect - 6;
 static const int kVertsPerStandardRRect = 16;
 static const int kVertsPerOverstrokeRRect = 24;
-static const int kNumRRectsInIndexBuffer = 256;
 
 enum RRectType {
     kFill_RRectType,
     kStroke_RRectType,
-    kOverstroke_RRectType
+    kOverstroke_RRectType,
 };
 
-GR_DECLARE_STATIC_UNIQUE_KEY(gStrokeRRectOnlyIndexBufferKey);
-GR_DECLARE_STATIC_UNIQUE_KEY(gRRectOnlyIndexBufferKey);
-GR_DECLARE_STATIC_UNIQUE_KEY(gOverstrokeRRectOnlyIndexBufferKey);
-static const GrBuffer* ref_rrect_index_buffer(RRectType type,
-                                              GrResourceProvider* resourceProvider) {
-    GR_DEFINE_STATIC_UNIQUE_KEY(gStrokeRRectOnlyIndexBufferKey);
-    GR_DEFINE_STATIC_UNIQUE_KEY(gRRectOnlyIndexBufferKey);
-    GR_DEFINE_STATIC_UNIQUE_KEY(gOverstrokeRRectOnlyIndexBufferKey);
-    switch (type) {
-        case kFill_RRectType:
-        default:
-            return resourceProvider->findOrCreateInstancedIndexBuffer(
-                gRRectIndices, kIndicesPerFillRRect, kNumRRectsInIndexBuffer,
-                kVertsPerStandardRRect, gRRectOnlyIndexBufferKey);
-        case kStroke_RRectType:
-            return resourceProvider->findOrCreateInstancedIndexBuffer(
-                gRRectIndices, kIndicesPerStrokeRRect, kNumRRectsInIndexBuffer,
-                kVertsPerStandardRRect, gStrokeRRectOnlyIndexBufferKey);
-        case kOverstroke_RRectType:
-            return resourceProvider->findOrCreateInstancedIndexBuffer(
-                gRRectOverstrokeIndices, kIndicesPerOverstrokeRRect, kNumRRectsInIndexBuffer,
-                kVertsPerOverstrokeRRect, gOverstrokeRRectOnlyIndexBufferKey);
+static int rrect_type_to_vert_count(RRectType type) {
+    static const int kTypeToVertCount[] = {
+        kVertsPerStandardRRect,
+        kVertsPerStandardRRect,
+        kVertsPerOverstrokeRRect,
     };
+
+    return kTypeToVertCount[type];
+}
+
+static int rrect_type_to_index_count(RRectType type) {
+    static const int kTypeToIndexCount[] = {
+        kIndicesPerFillRRect,
+        kIndicesPerStrokeRRect,
+        kIndicesPerOverstrokeRRect,
+    };
+
+    return kTypeToIndexCount[type];
+}
+
+static const uint16_t* rrect_type_to_indices(RRectType type) {
+    static const uint16_t* kTypeToIndices[] = {
+        gStandardRRectIndices,
+        gStandardRRectIndices,
+        gOverstrokeRRectIndices,
+    };
+
+    return kTypeToIndices[type];
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class RRectCircleRendererBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     // A devStrokeWidth <= 0 indicates a fill only. If devStrokeWidth > 0 then strokeOnly indicates
     // whether the rrect is only stroked or stroked and filled.
     RRectCircleRendererBatch(GrColor color, const SkMatrix& viewMatrix, const SkRect& devRect,
                              float devRadius, float devStrokeWidth, bool strokeOnly)
             : INHERITED(ClassID())
             , fViewMatrixIfUsingLocalCoords(viewMatrix) {
         SkRect bounds = devRect;
         SkASSERT(!(devStrokeWidth <= 0 && strokeOnly));
         SkScalar innerRadius = 0.0f;
         SkScalar outerRadius = devRadius;
         SkScalar halfWidth = 0;
-        fType = kFill_RRectType;
+        RRectType type = kFill_RRectType;
         if (devStrokeWidth > 0) {
             if (SkScalarNearlyZero(devStrokeWidth)) {
                 halfWidth = SK_ScalarHalf;
             } else {
                 halfWidth = SkScalarHalf(devStrokeWidth);
             }
 
             if (strokeOnly) {
                 // Outset stroke by 1/4 pixel
                 devStrokeWidth += 0.25f;
                 // If stroke is greater than width or height, this is still a fill
                 // Otherwise we compute stroke params
                 if (devStrokeWidth <= devRect.width() &&
                     devStrokeWidth <= devRect.height()) {
                     innerRadius = devRadius - halfWidth;
-                    fType = (innerRadius >= 0) ? kStroke_RRectType : kOverstroke_RRectType;
+                    type = (innerRadius >= 0) ? kStroke_RRectType : kOverstroke_RRectType;
                 }
             }
             outerRadius += halfWidth;
             bounds.outset(halfWidth, 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 rrect
         // corners.
         outerRadius += SK_ScalarHalf;
         innerRadius -= SK_ScalarHalf;
 
         this->setBounds(bounds, HasAABloat::kYes, IsZeroArea::kNo);
 
         // Expand the rect for aa to generate correct vertices.
         bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
 
-        fGeoData.emplace_back(Geometry { color, innerRadius, outerRadius, bounds });
+        fGeoData.emplace_back(Geometry{ color, innerRadius, outerRadius, bounds, type });
+        fVertCount = rrect_type_to_vert_count(type);
+        fIndexCount = rrect_type_to_index_count(type);
+        fAllFill = (kFill_RRectType == type);
     }
 
     const char* name() const override { return "RRectCircleBatch"; }
 
     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",
                            fGeoData[i].fColor,
@@ skipping 24 matching lines @@
     }
 
     void onPrepareDraws(Target* target) const override {
         // Invert the view matrix as a local matrix (if any other processors require coords).
         SkMatrix localMatrix;
         if (!fViewMatrixIfUsingLocalCoords.invert(&localMatrix)) {
             return;
         }
 
         // Setup geometry processor
-        SkAutoTUnref<GrGeometryProcessor> gp(new CircleGeometryProcessor(kFill_RRectType != fType,
+        SkAutoTUnref<GrGeometryProcessor> gp(new CircleGeometryProcessor(fAllFill,
                                                                          false, false,
                                                                          false, localMatrix));
-
         struct CircleVertex {
             SkPoint  fPos;
             GrColor  fColor;
             SkPoint  fOffset;
             SkScalar fOuterRadius;
             SkScalar fInnerRadius;
             // No half plane, we don't use it here.
         };
 
         int instanceCount = fGeoData.count();
         size_t vertexStride = gp->getVertexStride();
-        SkASSERT(vertexStride == sizeof(CircleVertex));
+        SkASSERT(sizeof(CircleVertex) == vertexStride);
 
-        // drop out the middle quad if we're stroked
-        int indicesPerInstance = kIndicesPerFillRRect;
-        if (kStroke_RRectType == fType) {
-            indicesPerInstance = kIndicesPerStrokeRRect;
-        } else if (kOverstroke_RRectType == fType) {
-            indicesPerInstance = kIndicesPerOverstrokeRRect;
-        }
-        SkAutoTUnref<const GrBuffer> indexBuffer(
-            ref_rrect_index_buffer(fType, target->resourceProvider()));
+        const GrBuffer* vertexBuffer;
+        int firstVertex;
 
-        InstancedHelper helper;
-        int vertexCount = (kOverstroke_RRectType == fType) ? kVertsPerOverstrokeRRect 
-                                                           : kVertsPerStandardRRect;
-        CircleVertex* verts = reinterpret_cast<CircleVertex*>(helper.init(target,
-            kTriangles_GrPrimitiveType, vertexStride, indexBuffer, vertexCount,
-            indicesPerInstance, instanceCount));
-        if (!verts || !indexBuffer) {
+        CircleVertex* verts = (CircleVertex*) target->makeVertexSpace(vertexStride, fVertCount,
+                                                                      &vertexBuffer, &firstVertex);
+        if (!verts) {
             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& args = fGeoData[i];
 
             GrColor color = args.fColor;
             SkScalar outerRadius = args.fOuterRadius;
 
             const SkRect& bounds = args.fDevBounds;
 
             SkScalar yCoords[4] = {
                 bounds.fTop,
                 bounds.fTop + outerRadius,
                 bounds.fBottom - outerRadius,
                 bounds.fBottom
             };
 
             SkScalar yOuterRadii[4] = {-1, 0, 0, 1 };
             // The inner radius in the vertex data must be specified in normalized space.
-            SkScalar innerRadius = args.fInnerRadius / args.fOuterRadius;
+            // For fills, specifying -1/outerRadius guarantees an alpha of 1.0 at the inner radius.
+            SkScalar innerRadius = args.fType != kFill_RRectType
+                                   ? args.fInnerRadius / args.fOuterRadius
+                                   : -1.0f / args.fOuterRadius;
             for (int i = 0; i < 4; ++i) {
                 verts->fPos = SkPoint::Make(bounds.fLeft, yCoords[i]);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(-1, yOuterRadii[i]);
                 verts->fOuterRadius = outerRadius;
                 verts->fInnerRadius = innerRadius;
                 verts++;
 
                 verts->fPos = SkPoint::Make(bounds.fLeft + outerRadius, yCoords[i]);
                 verts->fColor = color;
@@ skipping 17 matching lines @@
                 verts++;
             }
             // Add the additional vertices for overstroked rrects.
             // Effectively this is an additional stroked rrect, with its
             // outer radius = outerRadius - innerRadius, and inner radius = 0.
             // This will give us correct AA in the center and the correct
             // distance to the outer edge.
             //
             // Also, the outer offset is a constant vector pointing to the right, which
             // guarantees that the distance value along the outer rectangle is constant.
-            if (kOverstroke_RRectType == fType) {
+            if (kOverstroke_RRectType == args.fType) {
                 SkScalar overstrokeOuterRadius = outerRadius - args.fInnerRadius;
                 // this is the normalized distance from the outer rectangle of this
                 // geometry to the outer edge
-                SkScalar maxOffset = -args.fInnerRadius/overstrokeOuterRadius;
+                SkScalar maxOffset = -args.fInnerRadius / overstrokeOuterRadius;
 
                 verts->fPos = SkPoint::Make(bounds.fLeft + outerRadius, yCoords[1]);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(maxOffset, 0);
                 verts->fOuterRadius = overstrokeOuterRadius;
                 verts->fInnerRadius = 0;
                 verts++;
 
                 verts->fPos = SkPoint::Make(bounds.fRight - outerRadius, yCoords[1]);
                 verts->fColor = color;
@@ skipping 41 matching lines @@
                 verts->fInnerRadius = 0;
                 verts++;
 
                 verts->fPos = SkPoint::Make(bounds.fRight - outerRadius, yCoords[2]);
                 verts->fColor = color;
                 verts->fOffset = SkPoint::Make(maxOffset, 0);
                 verts->fOuterRadius = overstrokeOuterRadius;
                 verts->fInnerRadius = 0;
                 verts++;
             }
+
+            const uint16_t* primIndices = rrect_type_to_indices(args.fType);
+            const int primIndexCount = rrect_type_to_index_count(args.fType);
+            for (int i = 0; i < primIndexCount; ++i) {
+                *indices++ = primIndices[i] + currStartVertex;
+            }
+
+            currStartVertex += rrect_type_to_vert_count(args.fType);
         }
 
-        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 {
         RRectCircleRendererBatch* that = t->cast<RRectCircleRendererBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                     that->bounds(), caps)) {
             return false;
         }
 
-        if (fType != that->fType) {
-            return false;
-        }
-
         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;
         SkRect fDevBounds;
+        RRectType fType;
     };
 
-    RRectType                    fType;
+    SkSTArray<1, Geometry, true> fGeoData;
     SkMatrix                     fViewMatrixIfUsingLocalCoords;
-    SkSTArray<1, Geometry, true> fGeoData;
+    int                          fVertCount;
+    int                          fIndexCount;
+    bool                         fAllFill;
 
     typedef GrVertexBatch INHERITED;
 };
 
+static const int kNumRRectsInIndexBuffer = 256;
+
+GR_DECLARE_STATIC_UNIQUE_KEY(gStrokeRRectOnlyIndexBufferKey);
+GR_DECLARE_STATIC_UNIQUE_KEY(gRRectOnlyIndexBufferKey);
+static const GrBuffer* ref_rrect_index_buffer(RRectType type,
+                                              GrResourceProvider* resourceProvider) {
+    GR_DEFINE_STATIC_UNIQUE_KEY(gStrokeRRectOnlyIndexBufferKey);
+    GR_DEFINE_STATIC_UNIQUE_KEY(gRRectOnlyIndexBufferKey);
+    switch (type) {
+        case kFill_RRectType:
+            return resourceProvider->findOrCreateInstancedIndexBuffer(
+                gStandardRRectIndices, kIndicesPerFillRRect, kNumRRectsInIndexBuffer,
+                kVertsPerStandardRRect, gRRectOnlyIndexBufferKey);
+        case kStroke_RRectType:
+            return resourceProvider->findOrCreateInstancedIndexBuffer(
+                gStandardRRectIndices, kIndicesPerStrokeRRect, kNumRRectsInIndexBuffer,
+                kVertsPerStandardRRect, gStrokeRRectOnlyIndexBufferKey);
+        default:
+            SkASSERT(false);
+            return nullptr;
+    };
+}
+
 class RRectEllipseRendererBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     // If devStrokeWidths values are <= 0 indicates then fill only. Otherwise, strokeOnly indicates
     // whether the rrect is only stroked or stroked and filled.
     static GrDrawBatch* Create(GrColor color, const SkMatrix& viewMatrix, const SkRect& devRect,
                                float devXRadius, float devYRadius, SkVector devStrokeWidths,
                                bool strokeOnly) {
         SkASSERT(devXRadius > 0.5);
@@ skipping 391 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