Revert of Oval and stroke AA rect now batch

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrGpu.h"
 #include "gl/builders/GrGLProgramBuilder.h"
@@ skipping 293 matching lines @@
     1, 2, 6, 6, 5, 1,
     2, 3, 7, 7, 6, 2,
     3, 0, 4, 4, 7, 3,
     4, 5, 6, 6, 7, 4,
 };
 
 static const int kIndicesPerAAFillRect = SK_ARRAY_COUNT(gFillAARectIdx);
 static const int kVertsPerAAFillRect = 8;
 static const int kNumAAFillRectsInIndexBuffer = 256;
 
+GrIndexBuffer* GrAARectRenderer::aaFillRectIndexBuffer(GrGpu* gpu) {
+    static const size_t kAAFillRectIndexBufferSize = kIndicesPerAAFillRect *
+                                                     sizeof(uint16_t) *
+                                                     kNumAAFillRectsInIndexBuffer;
+
+    if (NULL == fAAFillRectIndexBuffer) {
+        fAAFillRectIndexBuffer = gpu->createIndexBuffer(kAAFillRectIndexBufferSize, false);
+        if (fAAFillRectIndexBuffer) {
+            uint16_t* data = (uint16_t*) fAAFillRectIndexBuffer->map();
+            bool useTempData = (NULL == data);
+            if (useTempData) {
+                data = SkNEW_ARRAY(uint16_t, kNumAAFillRectsInIndexBuffer * kIndicesPerAAFillRect);
+            }
+            for (int i = 0; i < kNumAAFillRectsInIndexBuffer; ++i) {
+                // Each AA filled rect is drawn with 8 vertices and 10 triangles (8 around
+                // the inner rect (for AA) and 2 for the inner rect.
+                int baseIdx = i * kIndicesPerAAFillRect;
+                uint16_t baseVert = (uint16_t)(i * kVertsPerAAFillRect);
+                for (int j = 0; j < kIndicesPerAAFillRect; ++j) {
+                    data[baseIdx+j] = baseVert + gFillAARectIdx[j];
+                }
+            }
+            if (useTempData) {
+                if (!fAAFillRectIndexBuffer->updateData(data, kAAFillRectIndexBufferSize)) {
+                    SkFAIL("Can't get AA Fill Rect indices into buffer!");
+                }
+                SkDELETE_ARRAY(data);
+            } else {
+                fAAFillRectIndexBuffer->unmap();
+            }
+        }
+    }
+
+    return fAAFillRectIndexBuffer;
+}
+
 static const uint16_t gMiterStrokeAARectIdx[] = {
     0 + 0, 1 + 0, 5 + 0, 5 + 0, 4 + 0, 0 + 0,
     1 + 0, 2 + 0, 6 + 0, 6 + 0, 5 + 0, 1 + 0,
     2 + 0, 3 + 0, 7 + 0, 7 + 0, 6 + 0, 2 + 0,
     3 + 0, 0 + 0, 4 + 0, 4 + 0, 7 + 0, 3 + 0,
 
     0 + 4, 1 + 4, 5 + 4, 5 + 4, 4 + 4, 0 + 4,
     1 + 4, 2 + 4, 6 + 4, 6 + 4, 5 + 4, 1 + 4,
     2 + 4, 3 + 4, 7 + 4, 7 + 4, 6 + 4, 2 + 4,
     3 + 4, 0 + 4, 4 + 4, 4 + 4, 7 + 4, 3 + 4,
 
     0 + 8, 1 + 8, 5 + 8, 5 + 8, 4 + 8, 0 + 8,
     1 + 8, 2 + 8, 6 + 8, 6 + 8, 5 + 8, 1 + 8,
     2 + 8, 3 + 8, 7 + 8, 7 + 8, 6 + 8, 2 + 8,
     3 + 8, 0 + 8, 4 + 8, 4 + 8, 7 + 8, 3 + 8,
 };
 
-static const int kIndicesPerMiterStrokeRect = SK_ARRAY_COUNT(gMiterStrokeAARectIdx);
-static const int kVertsPerMiterStrokeRect = 16;
-static const int kNumMiterStrokeRectsInIndexBuffer = 256;
-
 /**
  * As in miter-stroke, index = a + b, and a is the current index, b is the shift
  * from the first index. The index layout:
  * outer AA line: 0~3, 4~7
  * outer edge:    8~11, 12~15
  * inner edge:    16~19
  * inner AA line: 20~23
  * Following comes a bevel-stroke rect and its indices:
  *
  *           4                                 7
@@ skipping 37 matching lines @@
     7 + 8, 4 + 8, 8 + 8, 8 + 8, 11 + 8, 7 + 8,
     4 + 8, 0 + 8, 8 + 8,
 
     // Draw the inner AA, from inner edge to inner AA line, shift is 16.
     0 + 16, 1 + 16, 5 + 16, 5 + 16, 4 + 16, 0 + 16,
     1 + 16, 2 + 16, 6 + 16, 6 + 16, 5 + 16, 1 + 16,
     2 + 16, 3 + 16, 7 + 16, 7 + 16, 6 + 16, 2 + 16,
     3 + 16, 0 + 16, 4 + 16, 4 + 16, 7 + 16, 3 + 16,
 };
 
-static const int kIndicesPerBevelStrokeRect = SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
-static const int kVertsPerBevelStrokeRect = 24;
-static const int kNumBevelStrokeRectsInIndexBuffer = 256;
-
 int GrAARectRenderer::aaStrokeRectIndexCount(bool miterStroke) {
     return miterStroke ? SK_ARRAY_COUNT(gMiterStrokeAARectIdx) :
                          SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
 }
 
 GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(GrGpu* gpu, bool miterStroke) {
     if (miterStroke) {
         if (NULL == fAAMiterStrokeRectIndexBuffer) {
             fAAMiterStrokeRectIndexBuffer =
-                    gpu->createInstancedIndexBuffer(gMiterStrokeAARectIdx,
-                                                    kIndicesPerMiterStrokeRect,
-                                                    kNumMiterStrokeRectsInIndexBuffer,
-                                                    kVertsPerMiterStrokeRect);
+                gpu->createIndexBuffer(sizeof(gMiterStrokeAARectIdx), false);
+            if (fAAMiterStrokeRectIndexBuffer) {
+#ifdef SK_DEBUG
+                bool updated =
+#endif
+                fAAMiterStrokeRectIndexBuffer->updateData(gMiterStrokeAARectIdx,
+                                                          sizeof(gMiterStrokeAARectIdx));
+                GR_DEBUGASSERT(updated);
+            }
         }
         return fAAMiterStrokeRectIndexBuffer;
     } else {
         if (NULL == fAABevelStrokeRectIndexBuffer) {
             fAABevelStrokeRectIndexBuffer =
-                    gpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
-                                                    kIndicesPerBevelStrokeRect,
-                                                    kNumBevelStrokeRectsInIndexBuffer,
-                                                    kVertsPerBevelStrokeRect);
+                gpu->createIndexBuffer(sizeof(gBevelStrokeAARectIdx), false);
+            if (fAABevelStrokeRectIndexBuffer) {
+#ifdef SK_DEBUG
+                bool updated =
+#endif
+                fAABevelStrokeRectIndexBuffer->updateData(gBevelStrokeAARectIdx,
+                                                          sizeof(gBevelStrokeAARectIdx));
+                GR_DEBUGASSERT(updated);
+            }
         }
         return fAABevelStrokeRectIndexBuffer;
     }
 }
 
 void GrAARectRenderer::geometryFillAARect(GrGpu* gpu,
                                           GrDrawTarget* target,
                                           const SkRect& rect,
                                           const SkMatrix& combinedMatrix,
                                           const SkRect& devRect) {
     GrDrawState* drawState = target->drawState();
 
     GrColor color = drawState->getColor();
 
     CoverageAttribType covAttribType = set_rect_attribs(drawState);
     if (kUseCoverage_CoverageAttribType == covAttribType && GrColorIsOpaque(color)) {
         drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true);
     }
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 8, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
 
-    if (NULL == fAAFillRectIndexBuffer) {
-        fAAFillRectIndexBuffer = gpu->createInstancedIndexBuffer(gFillAARectIdx,
-                                                                 kIndicesPerAAFillRect,
-                                                                 kNumAAFillRectsInIndexBuffer,
-                                                                 kVertsPerAAFillRect);
-    }
-    GrIndexBuffer* indexBuffer = fAAFillRectIndexBuffer;
+    GrIndexBuffer* indexBuffer = this->aaFillRectIndexBuffer(gpu);
     if (NULL == indexBuffer) {
         GrPrintf("Failed to create index buffer!\n");
         return;
     }
 
     intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices());
     size_t vstride = drawState->getVertexStride();
 
     SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
     SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vstride);
@@ skipping 434 matching lines @@
     for (int i = 0; i < innerVertexNum; ++i) {
         if (kUseCoverage_CoverageAttribType == covAttribType) {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
             *reinterpret_cast<GrColor*>(verts + i * vstride + sizeof(GrColor)) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = 0;
         }
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
-    target->drawIndexedInstances(kTriangles_GrPrimitiveType, 1,
-                                 totalVertexNum, aaStrokeRectIndexCount(miterStroke));
-    target->resetIndexSource();
+    target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0,
+                        totalVertexNum, aaStrokeRectIndexCount(miterStroke));
 }
 
 void GrAARectRenderer::fillAANestedRects(GrGpu* gpu,
                                          GrDrawTarget* target,
                                          const SkRect rects[2],
                                          const SkMatrix& combinedMatrix) {
     SkASSERT(combinedMatrix.rectStaysRect());
     SkASSERT(!rects[1].isEmpty());
 
     SkRect devOutside, devOutsideAssist, devInside;
     combinedMatrix.mapRect(&devOutside, rects[0]);
     // can't call mapRect for devInside since it calls sort
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
         this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
     this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, true);
 }