Simplify GrDrawBatch uploads and token uage.

src/gpu/batches/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"
 
@@ skipping 159 matching lines @@
         }
         overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
 
         // setup batch properties
         fBatch.fColorIgnored = !overrides.readsColor();
         fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
         fBatch.fCoverageIgnored = !overrides.readsCoverage();
     }
 
     struct FlushInfo {
-        SkAutoTUnref<const GrBuffer> fVertexBuffer;
-        SkAutoTUnref<const GrBuffer> fIndexBuffer;
+        SkAutoTUnref<const GrBuffer>            fVertexBuffer;
+        SkAutoTUnref<const GrBuffer>            fIndexBuffer;
+        SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
         int fVertexOffset;
         int fInstancesToFlush;
     };
 
     void onPrepareDraws(Target* target) const override {
         int instanceCount = fGeoData.count();
 
         SkMatrix invert;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
             SkDebugf("Could not invert viewmatrix\n");
             return;
         }
 
         const SkMatrix& ctm = this->viewMatrix();
         uint32_t flags = 0;
         flags |= ctm.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
         flags |= ctm.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
 
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
 
+        FlushInfo flushInfo;
+
         // Setup GrGeometryProcessor
         GrBatchAtlas* atlas = fAtlas;
-        SkAutoTUnref<GrGeometryProcessor> dfProcessor(
+        flushInfo.fGeometryProcessor.reset(
                 GrDistanceFieldPathGeoProc::Create(this->color(),
                                                    this->viewMatrix(),
                                                    atlas->getTexture(),
                                                    params,
                                                    flags,
                                                    this->usesLocalCoords()));
 
-        target->initDraw(dfProcessor);
-
-        FlushInfo flushInfo;
-
         // allocate vertices
-        size_t vertexStride = dfProcessor->getVertexStride();
+        size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride();
         SkASSERT(vertexStride == 2 * sizeof(SkPoint) + sizeof(GrColor));
 
         const GrBuffer* vertexBuffer;
         void* vertices = target->makeVertexSpace(vertexStride,
                                                  kVerticesPerQuad * instanceCount,
                                                  &vertexBuffer,
                                                  &flushInfo.fVertexOffset);
         flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
         flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
         if (!vertices || !flushInfo.fIndexBuffer) {
@@ skipping 25 matching lines @@
             if (nullptr == pathData || !atlas->hasID(pathData->fID)) {
                 // Remove the stale cache entry
                 if (pathData) {
                     fPathCache->remove(pathData->fKey);
                     fPathList->remove(pathData);
                     delete pathData;
                 }
                 SkScalar scale = desiredDimension/maxDim;
                 pathData = new PathData;
                 if (!this->addPathToAtlas(target,
-                                          dfProcessor,
-                                          this->pipeline(),
                                           &flushInfo,
                                           atlas,
                                           pathData,
                                           args.fPath,
                                           args.fGenID,
                                           args.fStroke,
                                           args.fAntiAlias,
                                           desiredDimension,
                                           scale)) {
                     SkDebugf("Can't rasterize path\n");
                     return;
                 }
             }
 
-            atlas->setLastUseToken(pathData->fID, target->currentToken());
+            atlas->setLastUseToken(pathData->fID, target->nextDrawToken());
 
             // Now set vertices
             intptr_t offset = reinterpret_cast<intptr_t>(vertices);
             offset += i * kVerticesPerQuad * vertexStride;
             this->writePathVertices(target,
                                     atlas,
-                                    this->pipeline(),
-                                    dfProcessor,
                                     offset,
                                     args.fColor,
                                     vertexStride,
                                     this->viewMatrix(),
                                     args.fPath,
                                     pathData);
             flushInfo.fInstancesToFlush++;
         }
 
         this->flush(target, &flushInfo);
@@ skipping 12 matching lines @@
         fAtlas = atlas;
         fPathCache = pathCache;
         fPathList = pathList;
 
         // Compute bounds
         fBounds = geometry.fPath.getBounds();
         viewMatrix.mapRect(&fBounds);
     }
 
     bool addPathToAtlas(GrVertexBatch::Target* target,
-                        const GrGeometryProcessor* dfProcessor,
-                        const GrPipeline* pipeline,
                         FlushInfo* flushInfo,
                         GrBatchAtlas* atlas,
                         PathData* pathData,
                         const SkPath& path,
                         uint32_t genID,
                         const SkStrokeRec& stroke,
                         bool antiAlias,
                         uint32_t dimension,
                         SkScalar scale) const {
         const SkRect& bounds = path.getBounds();
@@ skipping 68 matching lines @@
                                            (const unsigned char*)dst.addr(),
                                            dst.width(), dst.height(), dst.rowBytes());
 
         // add to atlas
         SkIPoint16 atlasLocation;
         GrBatchAtlas::AtlasID id;
         bool success = atlas->addToAtlas(&id, target, width, height, dfStorage.get(),
                                          &atlasLocation);
         if (!success) {
             this->flush(target, flushInfo);
-            target->initDraw(dfProcessor);
 
             SkDEBUGCODE(success =) atlas->addToAtlas(&id, target, width, height,
                                                      dfStorage.get(), &atlasLocation);
             SkASSERT(success);
 
         }
 
         // add to cache
         pathData->fKey = PathData::Key(genID, dimension, stroke);
         pathData->fScale = scale;
@@ skipping 16 matching lines @@
         fPathCache->add(pathData);
         fPathList->addToTail(pathData);
 #ifdef DF_PATH_TRACKING
         ++g_NumCachedPaths;
 #endif
         return true;
     }
 
     void writePathVertices(GrDrawBatch::Target* target,
                            GrBatchAtlas* atlas,
-                           const GrPipeline* pipeline,
-                           const GrGeometryProcessor* gp,
                            intptr_t offset,
                            GrColor color,
                            size_t vertexStride,
                            const SkMatrix& viewMatrix,
                            const SkPath& path,
                            const PathData* pathData) const {
         GrTexture* texture = atlas->getTexture();
 
         SkScalar dx = pathData->fBounds.fLeft;
         SkScalar dy = pathData->fBounds.fTop;
@@ skipping 31 matching lines @@
                                   vertexStride);
     }
 
     void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
         GrMesh mesh;
         int maxInstancesPerDraw =
             static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
         mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
             flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
             kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw);
-        target->draw(mesh);
+        target->draw(flushInfo->fGeometryProcessor, mesh);
         flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
         flushInfo->fInstancesToFlush = 0;
     }
 
     GrColor color() const { return fGeoData[0].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 137 matching lines @@
     geometry.fAntiAlias = random->nextBool();
     geometry.fGenID = random->nextU();
 
     return AADistanceFieldPathBatch::Create(geometry, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif