Revert of Start on simplifying generateGeometry() overrides

src/gpu/GrAADistanceFieldPathRenderer.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrBufferAllocPool.h"
 #include "GrContext.h"
 #include "GrPipelineBuilder.h"
-#include "GrResourceProvider.h"
 #include "GrSurfacePriv.h"
 #include "GrSWMaskHelper.h"
+#include "GrResourceProvider.h"
 #include "GrTexturePriv.h"
 #include "GrVertexBuffer.h"
 #include "effects/GrDistanceFieldGeoProc.h"
 
 #include "SkDistanceFieldGen.h"
 #include "SkRTConf.h"
 
 #define ATLAS_TEXTURE_WIDTH 1024
 #define ATLAS_TEXTURE_HEIGHT 2048
 #define PLOT_WIDTH  256
@@ skipping 133 matching lines @@
         } else if (GrColor_ILLEGAL != init.fOverrideColor) {
             fBatch.fColor = init.fOverrideColor;
         }
 
         // setup batch properties
         fBatch.fColorIgnored = init.fColorIgnored;
         fBatch.fUsesLocalCoords = init.fUsesLocalCoords;
         fBatch.fCoverageIgnored = init.fCoverageIgnored;
     }
 
-    struct FlushInfo {
-        SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
-        SkAutoTUnref<const GrIndexBuffer>  fIndexBuffer;
-        int fVertexOffset;
-        int fInstancesToFlush;
-    };
-
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         int instanceCount = fGeoData.count();
 
         SkMatrix invert;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
             SkDebugf("Could not invert viewmatrix\n");
             return;
         }
 
         uint32_t flags = 0;
         flags |= this->viewMatrix().isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
 
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
 
         // Setup GrGeometryProcessor
         GrBatchAtlas* atlas = fAtlas;
         SkAutoTUnref<GrGeometryProcessor> dfProcessor(
                 GrDistanceFieldPathGeoProc::Create(this->color(),
                                                    this->viewMatrix(),
                                                    atlas->getTexture(),
                                                    params,
                                                    flags,
                                                    false));
 
         this->initDraw(batchTarget, dfProcessor, pipeline);
 
-        FlushInfo flushInfo;
+        static const int kVertsPerQuad = 4;
+        static const int kIndicesPerQuad = 6;
+
+        SkAutoTUnref<const GrIndexBuffer> indexBuffer(
+            batchTarget->resourceProvider()->refQuadIndexBuffer());
 
         // allocate vertices
         size_t vertexStride = dfProcessor->getVertexStride();
         SkASSERT(vertexStride == 2 * sizeof(SkPoint));
+        const GrVertexBuffer* vertexBuffer;
+        int vertexCount = kVertsPerQuad * instanceCount;
+        int firstVertex;
 
-        const GrVertexBuffer* vertexBuffer;
         void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
-                                                              kVerticesPerQuad * instanceCount,
+                                                              vertexCount,
                                                               &vertexBuffer,
-                                                              &flushInfo.fVertexOffset);
-        flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
-        flushInfo.fIndexBuffer.reset(batchTarget->resourceProvider()->refQuadIndexBuffer());
-        if (!vertices || !flushInfo.fIndexBuffer) {
+                                                              &firstVertex);
+
+        if (!vertices || !indexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
-        flushInfo.fInstancesToFlush = 0;
+        // We may have to flush while uploading path data to the atlas, so we set up the draw here
+        int maxInstancesPerDraw = indexBuffer->maxQuads();
+
+        GrDrawTarget::DrawInfo drawInfo;
+        drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
+        drawInfo.setStartVertex(0);
+        drawInfo.setStartIndex(0);
+        drawInfo.setVerticesPerInstance(kVertsPerQuad);
+        drawInfo.setIndicesPerInstance(kIndicesPerQuad);
+        drawInfo.adjustStartVertex(firstVertex);
+        drawInfo.setVertexBuffer(vertexBuffer);
+        drawInfo.setIndexBuffer(indexBuffer);
+
+        int instancesToFlush = 0;
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
 
             // get mip level
             SkScalar maxScale = this->viewMatrix().getMaxScale();
             const SkRect& bounds = args.fPath.getBounds();
             SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
             SkScalar size = maxScale * maxDim;
             uint32_t desiredDimension;
             if (size <= kSmallMIP) {
@@ skipping 13 matching lines @@
                 if (args.fPathData) {
                     fPathCache->remove(args.fPathData->fKey);
                     fPathList->remove(args.fPathData);
                     SkDELETE(args.fPathData);
                 }
                 SkScalar scale = desiredDimension/maxDim;
                 args.fPathData = SkNEW(PathData);
                 if (!this->addPathToAtlas(batchTarget,
                                           dfProcessor,
                                           pipeline,
-                                          &flushInfo,
+                                          &drawInfo,
+                                          &instancesToFlush,
+                                          maxInstancesPerDraw,
                                           atlas,
                                           args.fPathData,
                                           args.fPath,
                                           args.fStroke,
                                           args.fAntiAlias,
                                           desiredDimension,
                                           scale)) {
                     SkDebugf("Can't rasterize path\n");
                     return;
                 }
             }
 
             atlas->setLastUseToken(args.fPathData->fID, batchTarget->currentToken());
 
             // Now set vertices
             intptr_t offset = reinterpret_cast<intptr_t>(vertices);
-            offset += i * kVerticesPerQuad * vertexStride;
+            offset += i * kVertsPerQuad * vertexStride;
             SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
-            this->writePathVertices(batchTarget,
-                                    atlas,
-                                    pipeline,
-                                    dfProcessor,
-                                    positions,
-                                    vertexStride,
-                                    this->viewMatrix(),
-                                    args.fPath,
-                                    args.fPathData);
-            flushInfo.fInstancesToFlush++;
+            this->drawPath(batchTarget,
+                           atlas,
+                           pipeline,
+                           dfProcessor,
+                           positions,
+                           vertexStride,
+                           this->viewMatrix(),
+                           args.fPath,
+                           args.fPathData);
+            instancesToFlush++;
         }
 
-        this->flush(batchTarget, &flushInfo);
+        this->flush(batchTarget, &drawInfo, instancesToFlush, maxInstancesPerDraw);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     AADistanceFieldPathBatch(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
                              GrBatchAtlas* atlas,
                              PathCache* pathCache, PathDataList* pathList) {
         this->initClassID<AADistanceFieldPathBatch>();
         fBatch.fColor = color;
         fBatch.fViewMatrix = viewMatrix;
         fGeoData.push_back(geometry);
         fGeoData.back().fPathData = NULL;
 
         fAtlas = atlas;
         fPathCache = pathCache;
         fPathList = pathList;
 
         // Compute bounds
         fBounds = geometry.fPath.getBounds();
         viewMatrix.mapRect(&fBounds);
     }
 
     bool addPathToAtlas(GrBatchTarget* batchTarget,
                         const GrGeometryProcessor* dfProcessor,
                         const GrPipeline* pipeline,
-                        FlushInfo* flushInfo,
+                        GrDrawTarget::DrawInfo* drawInfo,
+                        int* instancesToFlush,
+                        int maxInstancesPerDraw,
                         GrBatchAtlas* atlas,
                         PathData* pathData,
                         const SkPath& path,
                         const SkStrokeRec&
                         stroke, bool antiAlias,
                         uint32_t dimension,
                         SkScalar scale) {
         const SkRect& bounds = path.getBounds();
 
         // generate bounding rect for bitmap draw
@@ skipping 81 matching lines @@
                                                (const unsigned char*)bmp.getPixels(),
                                                bmp.width(), bmp.height(), bmp.rowBytes());
         }
 
         // add to atlas
         SkIPoint16 atlasLocation;
         GrBatchAtlas::AtlasID id;
         bool success = atlas->addToAtlas(&id, batchTarget, width, height, dfStorage.get(),
                                          &atlasLocation);
         if (!success) {
-            this->flush(batchTarget, flushInfo);
+            this->flush(batchTarget, drawInfo, *instancesToFlush, maxInstancesPerDraw);
             this->initDraw(batchTarget, dfProcessor, pipeline);
+            *instancesToFlush = 0;
 
             SkDEBUGCODE(success =) atlas->addToAtlas(&id, batchTarget, width, height,
                                                      dfStorage.get(), &atlasLocation);
             SkASSERT(success);
 
         }
 
         // add to cache
         pathData->fKey.fGenID = path.getGenerationID();
         pathData->fKey.fDimension = dimension;
@@ skipping 15 matching lines @@
         pathData->fAtlasLocation = atlasLocation;
 
         fPathCache->add(pathData);
         fPathList->addToTail(pathData);
 #ifdef DF_PATH_TRACKING
         ++g_NumCachedPaths;
 #endif
         return true;
     }
 
-    void writePathVertices(GrBatchTarget* target,
-                           GrBatchAtlas* atlas,
-                           const GrPipeline* pipeline,
-                           const GrGeometryProcessor* gp,
-                           SkPoint* positions,
-                           size_t vertexStride,
-                           const SkMatrix& viewMatrix,
-                           const SkPath& path,
-                           const PathData* pathData) {
+    void drawPath(GrBatchTarget* target,
+                  GrBatchAtlas* atlas,
+                  const GrPipeline* pipeline,
+                  const GrGeometryProcessor* gp,
+                  SkPoint* positions,
+                  size_t vertexStride,
+                  const SkMatrix& viewMatrix,
+                  const SkPath& path,
+                  const PathData* pathData) {
         GrTexture* texture = atlas->getTexture();
 
         SkScalar dx = pathData->fBounds.fLeft;
         SkScalar dy = pathData->fBounds.fTop;
         SkScalar width = pathData->fBounds.width();
         SkScalar height = pathData->fBounds.height();
 
         SkScalar invScale = 1.0f / pathData->fScale;
         dx *= invScale;
         dy *= invScale;
@@ skipping 26 matching lines @@
 
         // TODO remove this when batch is everywhere
         GrPipelineInfo init;
         init.fColorIgnored = fBatch.fColorIgnored;
         init.fOverrideColor = GrColor_ILLEGAL;
         init.fCoverageIgnored = fBatch.fCoverageIgnored;
         init.fUsesLocalCoords = this->usesLocalCoords();
         dfProcessor->initBatchTracker(batchTarget->currentBatchTracker(), init);
     }
 
-    void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) {
-        GrDrawTarget::DrawInfo drawInfo;
-        int instancesToFlush = flushInfo->fInstancesToFlush;
-        int maxInstancesPerDraw = flushInfo->fIndexBuffer->maxQuads();
-        drawInfo.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
-            flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
-            kIndicesPerQuad, &instancesToFlush, maxInstancesPerDraw);
-        do {
-            batchTarget->draw(drawInfo);
-        } while (drawInfo.nextInstances(&instancesToFlush, maxInstancesPerDraw));
-        flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
-        flushInfo->fInstancesToFlush = 0;
+    void flush(GrBatchTarget* batchTarget,
+               GrDrawTarget::DrawInfo* drawInfo,
+               int instanceCount,
+               int maxInstancesPerDraw) {
+        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();
+       }
     }
 
     GrColor color() const { return fBatch.fColor; }
     const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
 
     bool onCombineIfPossible(GrBatch* t) override {
         AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
 
         // TODO we could actually probably do a bunch of this work on the CPU, ie map viewMatrix,
@@ skipping 65 matching lines @@
     geometry.fPath = path;
     geometry.fAntiAlias = antiAlias;
 
     SkAutoTUnref<GrBatch> batch(AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                                                  fAtlas, &fPathCache, &fPathList));
     target->drawBatch(pipelineBuilder, batch);
 
     return true;
 }