Revert of Start on simplifying generateGeometry() overrides

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrDefaultGeoProcFactory.h"
+#include "GrResourceProvider.h"
 #include "GrTemplates.h"
 
 GrInOrderDrawBuffer::GrInOrderDrawBuffer(GrContext* context,
                                          GrVertexBufferAllocPool* vertexPool,
                                          GrIndexBufferAllocPool* indexPool)
     : INHERITED(context, vertexPool, indexPool)
     , fCommands(context->getGpu(), vertexPool, indexPool)
     , fPathIndexBuffer(kPathIdxBufferMinReserve * sizeof(char)/4)
     , fPathTransformBuffer(kPathXformBufferMinReserve * sizeof(float)/4)
     , fDrawID(0) {
@@ skipping 102 matching lines @@
         // TODO this is hacky, but the only way we have to initialize the GP is to use the
         // GrPipelineInfo struct so we can generate the correct shader.  Once we have GrBatch
         // everywhere we can remove this nastiness
         GrPipelineInfo init;
         init.fColorIgnored = fBatch.fColorIgnored;
         init.fOverrideColor = GrColor_ILLEGAL;
         init.fCoverageIgnored = fBatch.fCoverageIgnored;
         init.fUsesLocalCoords = this->usesLocalCoords();
         gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
 
-        int instanceCount = fGeoData.count();
         size_t vertexStride = gp->getVertexStride();
+
         SkASSERT(hasExplicitLocalCoords ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
-        QuadHelper helper;
-        void* vertices = helper.init(batchTarget, vertexStride, instanceCount);
 
-        if (!vertices) {
+        int instanceCount = fGeoData.count();
+        SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+            batchTarget->resourceProvider()->refQuadIndexBuffer());
+
+        int vertexCount = kVertsPerRect * instanceCount;
+        const GrVertexBuffer* vertexBuffer;
+        int firstVertex;
+        void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
+                                                              vertexCount,
+                                                              &vertexBuffer,
+                                                              &firstVertex);
+
+        if (!vertices || !indexBuffer) {
+            SkDebugf("Could not allocate buffers\n");
             return;
         }
 
+        for (int i = 0; i < instanceCount; i++) {
+            const Geometry& args = fGeoData[i];
 
-        for (int i = 0; i < instanceCount; i++) {
-            const Geometry& geom = fGeoData[i];
-
-            intptr_t offset = GrTCast<intptr_t>(vertices) + kVerticesPerQuad * i * vertexStride;
+            intptr_t offset = GrTCast<intptr_t>(vertices) + kVertsPerRect * i * vertexStride;
             SkPoint* positions = GrTCast<SkPoint*>(offset);
 
-            positions->setRectFan(geom.fRect.fLeft, geom.fRect.fTop,
-                                  geom.fRect.fRight, geom.fRect.fBottom, vertexStride);
-            geom.fViewMatrix.mapPointsWithStride(positions, vertexStride, kVerticesPerQuad);
+            positions->setRectFan(args.fRect.fLeft, args.fRect.fTop,
+                                  args.fRect.fRight, args.fRect.fBottom, vertexStride);
+            args.fViewMatrix.mapPointsWithStride(positions, vertexStride, kVertsPerRect);
 
-            if (geom.fHasLocalRect) {
+            if (args.fHasLocalRect) {
                 static const int kLocalOffset = sizeof(SkPoint) + sizeof(GrColor);
                 SkPoint* coords = GrTCast<SkPoint*>(offset + kLocalOffset);
-                coords->setRectFan(geom.fLocalRect.fLeft, geom.fLocalRect.fTop,
-                                   geom.fLocalRect.fRight, geom.fLocalRect.fBottom,
+                coords->setRectFan(args.fLocalRect.fLeft, args.fLocalRect.fTop,
+                                   args.fLocalRect.fRight, args.fLocalRect.fBottom,
                                    vertexStride);
-                if (geom.fHasLocalMatrix) {
-                    geom.fLocalMatrix.mapPointsWithStride(coords, vertexStride, kVerticesPerQuad);
+                if (args.fHasLocalMatrix) {
+                    args.fLocalMatrix.mapPointsWithStride(coords, vertexStride, kVertsPerRect);
                 }
             }
 
             static const int kColorOffset = sizeof(SkPoint);
             GrColor* vertColor = GrTCast<GrColor*>(offset + kColorOffset);
             for (int j = 0; j < 4; ++j) {
-                *vertColor = geom.fColor;
+                *vertColor = args.fColor;
                 vertColor = (GrColor*) ((intptr_t) vertColor + vertexStride);
             }
         }
 
-        helper.issueDraws(batchTarget);
+        GrDrawTarget::DrawInfo drawInfo;
+        drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+        drawInfo.setStartVertex(0);
+        drawInfo.setStartIndex(0);
+        drawInfo.setVerticesPerInstance(kVertsPerRect);
+        drawInfo.setIndicesPerInstance(kIndicesPerRect);
+        drawInfo.adjustStartVertex(firstVertex);
+        drawInfo.setVertexBuffer(vertexBuffer);
+        drawInfo.setIndexBuffer(indexBuffer);
+
+        int maxInstancesPerDraw = indexBuffer->maxQuads();
+        while (instanceCount) {
+            drawInfo.setInstanceCount(SkTMin(instanceCount, maxInstancesPerDraw));
+            drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
+            drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
+
+            batchTarget->draw(drawInfo);
+
+            drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
+            instanceCount -= drawInfo.instanceCount();
+       }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     RectBatch(const Geometry& geometry) {
         this->initClassID<RectBatch>();
         fGeoData.push_back(geometry);
 
         fBounds = geometry.fRect;
@@ skipping 38 matching lines @@
         return true;
     }
 
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
+    const static int kVertsPerRect = 4;
+    const static int kIndicesPerRect = 6;
+
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
 void GrInOrderDrawBuffer::onDrawRect(GrPipelineBuilder* pipelineBuilder,
                                      GrColor color,
                                      const SkMatrix& viewMatrix,
                                      const SkRect& rect,
                                      const SkRect* localRect,
                                      const SkMatrix* localMatrix) {
@@ skipping 115 matching lines @@
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         if (cmd->isTraced()) {
             fGpuCmdMarkers[cmd->markerID()].addSet(activeTraceMarkers);
         } else {
             cmd->setMarkerID(fGpuCmdMarkers.count());
             fGpuCmdMarkers.push_back(activeTraceMarkers);
         }
     }
 }