Start on simplifying generateGeometry() overrides

src/gpu/GrAtlasTextContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrAtlasTextContext.h"
 
 #include "GrBatch.h"
 #include "GrBatchFontCache.h"
@@ skipping 1456 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 fGlyphsToFlush;
+        int fVertexOffset;
+    };
+
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
         // TODO actually only invert if we don't have RGBA
         SkMatrix localMatrix;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
             SkDebugf("Cannot invert viewmatrix\n");
             return;
         }
 
         GrTexture* texture = fFontCache->getTexture(fMaskFormat);
@@ skipping 12 matching lines @@
             // This will be ignored in the non A8 case
             bool opaqueVertexColors = GrColorIsOpaque(this->color());
             gp.reset(GrBitmapTextGeoProc::Create(this->color(),
                                                  texture,
                                                  params,
                                                  fMaskFormat,
                                                  opaqueVertexColors,
                                                  localMatrix));
         }
 
+        FlushInfo flushInfo;
+        flushInfo.fGlyphsToFlush = 0;
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(vertexStride == (fUseDistanceFields ?
                                   get_vertex_stride_df(fMaskFormat, fUseLCDText) :
                                   get_vertex_stride(fMaskFormat)));
 
         this->initDraw(batchTarget, gp, pipeline);
 
         int glyphCount = this->numGlyphs();
         int instanceCount = fInstanceCount;
-        SkAutoTUnref<const GrIndexBuffer> indexBuffer(
-            batchTarget->resourceProvider()->refQuadIndexBuffer());
+        const GrVertexBuffer* vertexBuffer;
 
-        const GrVertexBuffer* vertexBuffer;
-        int firstVertex;
         void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
                                                               glyphCount * kVerticesPerGlyph,
                                                               &vertexBuffer,
-                                                              &firstVertex);
-        if (!vertices || !indexBuffer) {
+                                                              &flushInfo.fVertexOffset);
+        flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
+        flushInfo.fIndexBuffer.reset(batchTarget->resourceProvider()->refQuadIndexBuffer());
+        if (!vertices || !flushInfo.fVertexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         unsigned char* currVertex = reinterpret_cast<unsigned char*>(vertices);
 
-        // setup drawinfo
-        int maxInstancesPerDraw = indexBuffer->maxQuads();
-
-        GrDrawTarget::DrawInfo drawInfo;
-        drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
-        drawInfo.setStartVertex(0);
-        drawInfo.setStartIndex(0);
-        drawInfo.setVerticesPerInstance(kVerticesPerGlyph);
-        drawInfo.setIndicesPerInstance(kIndicesPerGlyph);
-        drawInfo.adjustStartVertex(firstVertex);
-        drawInfo.setVertexBuffer(vertexBuffer);
-        drawInfo.setIndexBuffer(indexBuffer);
-
         // We cache some values to avoid going to the glyphcache for the same fontScaler twice
         // in a row
         const SkDescriptor* desc = NULL;
         SkGlyphCache* cache = NULL;
         GrFontScaler* scaler = NULL;
         SkTypeface* typeface = NULL;
 
-        int instancesToFlush = 0;
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
             Blob* blob = args.fBlob;
             Run& run = blob->fRuns[args.fRun];
             TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(fMaskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen;
             bool regenerateColors;
             if (fUseDistanceFields) {
@@ skipping 63 matching lines @@
                             // the glyph.
                             glyph = blob->fGlyphs[glyphOffset];
                             blob->fGlyphs[glyphOffset] = strike->getGlyph(glyph->fPackedID,
                                                                           scaler);
                         }
                         glyph = blob->fGlyphs[glyphOffset];
                         SkASSERT(glyph);
 
                         if (!fFontCache->hasGlyph(glyph) &&
                             !strike->addGlyphToAtlas(batchTarget, glyph, scaler)) {
-                            this->flush(batchTarget, &drawInfo, instancesToFlush,
-                                        maxInstancesPerDraw);
+                            this->flush(batchTarget, &flushInfo);
                             this->initDraw(batchTarget, gp, pipeline);
-                            instancesToFlush = 0;
                             brokenRun = glyphIdx > 0;
 
                             SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget,
                                                                                 glyph,
                                                                                 scaler);
                             SkASSERT(success);
                         }
                         fFontCache->addGlyphToBulkAndSetUseToken(&info.fBulkUseToken, glyph,
                                                                  batchTarget->currentToken());
 
@@ skipping 15 matching lines @@
                     }
 
                     if (regeneratePositions) {
                         intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
                         vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
                         SkScalar transX = args.fTransX;
                         SkScalar transY = args.fTransY;
                         this->regeneratePositions(vertex, vertexStride, transX, transY);
                     }
-                    instancesToFlush++;
+                    flushInfo.fGlyphsToFlush++;
                 }
 
                 // We my have changed the color so update it here
                 run.fColor = args.fColor;
                 if (regenerateTextureCoords) {
                     if (regenerateGlyphs) {
                         run.fStrike.reset(SkRef(strike));
                     }
                     info.fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
                                                         fFontCache->atlasGeneration(fMaskFormat);
                 }
             } else {
-                instancesToFlush += glyphCount;
+                flushInfo.fGlyphsToFlush += glyphCount;
 
                 // set use tokens for all of the glyphs in our subrun.  This is only valid if we
                 // have a valid atlas generation
                 fFontCache->setUseTokenBulk(info.fBulkUseToken,
                                             batchTarget->currentToken(),
                                             fMaskFormat);
             }
 
             // now copy all vertices
             size_t byteCount = info.fVertexEndIndex - info.fVertexStartIndex;
             memcpy(currVertex, blob->fVertices + info.fVertexStartIndex, byteCount);
 
             currVertex += byteCount;
         }
         // Make sure to attach the last cache if applicable
         if (cache) {
             SkGlyphCache::AttachCache(cache);
         }
-        this->flush(batchTarget, &drawInfo, instancesToFlush, maxInstancesPerDraw);
+        this->flush(batchTarget, &flushInfo);
     }
 
     // The minimum number of Geometry we will try to allocate.
     static const int kMinAllocated = 32;
 
     // Total number of Geometry this Batch owns
     int instanceCount() const { return fInstanceCount; }
     SkAutoSTMalloc<kMinAllocated, Geometry>* geoData() { return &fGeoData; }
 
     // to avoid even the initial copy of the struct, we have a getter for the first item which
@@ skipping 106 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();
         gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
     }
 
-    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();
-       }
+    void flush(GrBatchTarget* batchTarget, FlushInfo* flushInfo) {
+        GrDrawTarget::DrawInfo drawInfo;
+        int glyphsToFlush = flushInfo->fGlyphsToFlush;
+        int maxGlyphsPerDraw = flushInfo->fIndexBuffer->maxQuads();
+        drawInfo.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
+                               flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
+                               kVerticesPerGlyph, kIndicesPerGlyph, &glyphsToFlush,
+                               maxGlyphsPerDraw);
+        do {
+            batchTarget->draw(drawInfo);
+        } while (drawInfo.nextInstances(&glyphsToFlush, maxGlyphsPerDraw));
+        flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
+        flushInfo->fGlyphsToFlush = 0;
     }
 
     GrColor color() const { return fBatch.fColor; }
     const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     int numGlyphs() const { return fBatch.fNumGlyphs; }
 
     bool onCombineIfPossible(GrBatch* t) override {
         BitmapTextBatch* that = t->cast<BitmapTextBatch>();
 
@@ skipping 301 matching lines @@
     pipelineBuilder.setFromPaint(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, 0, 0, skPaint);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }