Make GrVertexBatch objects hold their own draws during GrDrawTarget flush

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 "GrBatchTarget.h"
+#include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrContext.h"
 #include "GrPipelineBuilder.h"
 #include "GrResourceProvider.h"
 #include "GrSurfacePriv.h"
 #include "GrSWMaskHelper.h"
 #include "GrTexturePriv.h"
 #include "GrVertexBuffer.h"
 #include "batches/GrVertexBatch.h"
 #include "effects/GrDistanceFieldGeoProc.h"
@@ skipping 130 matching lines @@
         fBatch.fCoverageIgnored = !opt.readsCoverage();
     }
 
     struct FlushInfo {
         SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
         SkAutoTUnref<const GrIndexBuffer>  fIndexBuffer;
         int fVertexOffset;
         int fInstancesToFlush;
     };
 
-    void generateGeometry(GrBatchTarget* batchTarget) override {
+    void onPrepareDraws(Target* target) 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,
                                                    this->usesLocalCoords()));
 
-        batchTarget->initDraw(dfProcessor, this->pipeline());
+        target->initDraw(dfProcessor, this->pipeline());
 
         FlushInfo flushInfo;
 
         // allocate vertices
         size_t vertexStride = dfProcessor->getVertexStride();
         SkASSERT(vertexStride == 2 * sizeof(SkPoint));
 
         const GrVertexBuffer* vertexBuffer;
-        void* vertices = batchTarget->makeVertSpace(vertexStride,
-                                                    kVerticesPerQuad * instanceCount,
-                                                    &vertexBuffer,
-                                                    &flushInfo.fVertexOffset);
+        void* vertices = target->makeVertexSpace(vertexStride,
+                                                 kVerticesPerQuad * instanceCount,
+                                                 &vertexBuffer,
+                                                 &flushInfo.fVertexOffset);
         flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
-        flushInfo.fIndexBuffer.reset(batchTarget->resourceProvider()->refQuadIndexBuffer());
+        flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
         if (!vertices || !flushInfo.fIndexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         flushInfo.fInstancesToFlush = 0;
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
 
             // get mip level
@@ skipping 16 matching lines @@
             args.fPathData = fPathCache->find(key);
             if (NULL == args.fPathData || !atlas->hasID(args.fPathData->fID)) {
                 // Remove the stale cache entry
                 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,
+                if (!this->addPathToAtlas(target,
                                           dfProcessor,
                                           this->pipeline(),
                                           &flushInfo,
                                           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());
+            atlas->setLastUseToken(args.fPathData->fID, target->currentToken());
 
             // Now set vertices
             intptr_t offset = reinterpret_cast<intptr_t>(vertices);
             offset += i * kVerticesPerQuad * vertexStride;
             SkPoint* positions = reinterpret_cast<SkPoint*>(offset);
-            this->writePathVertices(batchTarget,
+            this->writePathVertices(target,
                                     atlas,
                                     this->pipeline(),
                                     dfProcessor,
                                     positions,
                                     vertexStride,
                                     this->viewMatrix(),
                                     args.fPath,
                                     args.fPathData);
             flushInfo.fInstancesToFlush++;
         }
 
-        this->flush(batchTarget, &flushInfo);
+        this->flush(target, &flushInfo);
     }
 
     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,
+    bool addPathToAtlas(GrVertexBatch::Target* target,
                         const GrGeometryProcessor* dfProcessor,
                         const GrPipeline* pipeline,
                         FlushInfo* flushInfo,
                         GrBatchAtlas* atlas,
                         PathData* pathData,
                         const SkPath& path,
                         const SkStrokeRec&
                         stroke, bool antiAlias,
                         uint32_t dimension,
                         SkScalar scale) {
@@ skipping 75 matching lines @@
         SkAutoSMalloc<1024> dfStorage(width * height * sizeof(unsigned char));
 
         // Generate signed distance field
         SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(),
                                            (const unsigned char*)dst.addr(),
                                            dst.width(), dst.height(), dst.rowBytes());
 
         // add to atlas
         SkIPoint16 atlasLocation;
         GrBatchAtlas::AtlasID id;
-        bool success = atlas->addToAtlas(&id, batchTarget, width, height, dfStorage.get(),
+        bool success = atlas->addToAtlas(&id, target, width, height, dfStorage.get(),
                                          &atlasLocation);
         if (!success) {
-            this->flush(batchTarget, flushInfo);
-            batchTarget->initDraw(dfProcessor, pipeline);
+            this->flush(target, flushInfo);
+            target->initDraw(dfProcessor, pipeline);
 
-            SkDEBUGCODE(success =) atlas->addToAtlas(&id, batchTarget, width, height,
+            SkDEBUGCODE(success =) atlas->addToAtlas(&id, target, width, height,
                                                      dfStorage.get(), &atlasLocation);
             SkASSERT(success);
 
         }
 
         // add to cache
         pathData->fKey.fGenID = path.getGenerationID();
         pathData->fKey.fDimension = dimension;
         pathData->fScale = scale;
         pathData->fID = id;
@@ skipping 13 matching lines @@
         pathData->fAtlasLocation = atlasLocation;
 
         fPathCache->add(pathData);
         fPathList->addToTail(pathData);
 #ifdef DF_PATH_TRACKING
         ++g_NumCachedPaths;
 #endif
         return true;
     }
 
-    void writePathVertices(GrBatchTarget* target,
+    void writePathVertices(GrDrawBatch::Target* 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();
 
@@ skipping 20 matching lines @@
 
         // vertex texture coords
         SkPoint* textureCoords = positions + 1;
         textureCoords->setRectFan(SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx + tw)),
                                   SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty + th)),
                                   vertexStride);
     }
 
-    void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) {
+    void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) {
         GrVertices vertices;
         int maxInstancesPerDraw = flushInfo->fIndexBuffer->maxQuads();
         vertices.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
             flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
             kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw);
-        batchTarget->draw(vertices);
+        target->draw(vertices);
         flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
         flushInfo->fInstancesToFlush = 0;
     }
 
     GrColor color() const { return fBatch.fColor; }
     const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
@@ skipping 128 matching lines @@
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
 
     return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif