Start on simplifying generateGeometry() overrides

src/gpu/effects/GrDashingEffect.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 "GrDashingEffect.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrBatchTest.h"
 #include "GrBufferAllocPool.h"
 #include "GrGeometryProcessor.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawTarget.h"
 #include "GrDrawTargetCaps.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
-#include "GrResourceProvider.h"
 #include "GrStrokeInfo.h"
 #include "GrVertexBuffer.h"
 #include "SkGr.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLSL.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 308 matching lines @@
         bool fullDash = this->fullDash();
 
         // We do two passes over all of the dashes.  First we setup the start, end, and bounds,
         // rectangles.  We preserve all of this work in the rects / draws arrays below.  Then we
         // iterate again over these decomposed dashes to generate vertices
         SkSTArray<128, SkRect, true> rects;
         SkSTArray<128, DashDraw, true> draws;
 
         int totalRectCount = 0;
         int rectOffset = 0;
+        rects.push_back_n(3 * instanceCount);
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
 
             bool hasCap = SkPaint::kButt_Cap != cap && 0 != args.fSrcStrokeWidth;
 
             // We always want to at least stroke out half a pixel on each side in device space
             // so 0.5f / perpScale gives us this min in src space
             SkScalar halfSrcStroke =
                     SkMaxScalar(args.fSrcStrokeWidth * 0.5f, 0.5f / args.fPerpendicularScale);
 
             SkScalar strokeAdj;
             if (!hasCap) {
                 strokeAdj = 0.f;
             } else {
                 strokeAdj = halfSrcStroke;
             }
 
             SkScalar startAdj = 0;
 
             bool lineDone = false;
 
             // Too simplify the algorithm, we always push back rects for start and end rect.
             // Otherwise we'd have to track start / end rects for each individual geometry
-            rects.push_back();
-            rects.push_back();
-            rects.push_back();
             SkRect& bounds = rects[rectOffset++];
             SkRect& startRect = rects[rectOffset++];
             SkRect& endRect = rects[rectOffset++];
 
             bool hasStartRect = false;
             // If we are using AA, check to see if we are drawing a partial dash at the start. If so
             // draw it separately here and adjust our start point accordingly
             if (useAA) {
                 if (args.fPhase > 0 && args.fPhase < args.fIntervals[0]) {
                     SkPoint startPts[2];
@@ skipping 142 matching lines @@
             draw.fStartOffset = startOffset;
             draw.fDevBloatX = devBloatX;
             draw.fDevBloatY = devBloatY;
             draw.fHalfDevStroke = halfDevStroke;
             draw.fStrokeWidth = strokeWidth;
             draw.fHasStartRect = hasStartRect;
             draw.fLineDone = lineDone;
             draw.fHasEndRect = hasEndRect;
         }
 
-        SkAutoTUnref<const GrIndexBuffer> indexBuffer(
-            batchTarget->resourceProvider()->refQuadIndexBuffer());
+        if (!totalRectCount) {
+            return;
+        }
 
-        const GrVertexBuffer* vertexBuffer;
-        int firstVertex;
-        size_t vertexStride = gp->getVertexStride();
-        void* vertices = batchTarget->vertexPool()->makeSpace(vertexStride,
-                                                              totalRectCount * kVertsPerDash,
-                                                              &vertexBuffer,
-                                                              &firstVertex);
-        if (!vertices || !indexBuffer) {
-            SkDebugf("Could not allocate buffers\n");
+        QuadHelper helper;
+        void* vertices = helper.init(batchTarget, gp->getVertexStride(), totalRectCount);
+        if (!vertices) {
             return;
         }
 
         int curVIdx = 0;
         int rectIndex = 0;
         for (int i = 0; i < instanceCount; i++) {
-            Geometry& args = fGeoData[i];
+            Geometry& geom = fGeoData[i];
 
             if (!draws[i].fLineDone) {
                 if (fullDash) {
-                    setup_dashed_rect(rects[rectIndex], vertices, curVIdx, args.fSrcRotInv,
+                    setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv,
                                       draws[i].fStartOffset, draws[i].fDevBloatX,
                                       draws[i].fDevBloatY, draws[i].fLineLength,
-                                      draws[i].fHalfDevStroke, args.fIntervals[0],
-                                      args.fIntervals[1], draws[i].fStrokeWidth,
+                                      draws[i].fHalfDevStroke, geom.fIntervals[0],
+                                      geom.fIntervals[1], draws[i].fStrokeWidth,
                                       capType, gp->getVertexStride());
                 } else {
                     SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
                     SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
-                    setup_dashed_rect_pos(rects[rectIndex], curVIdx, args.fSrcRotInv, verts);
+                    setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts);
                 }
                 curVIdx += 4;
             }
             rectIndex++;
 
             if (draws[i].fHasStartRect) {
                 if (fullDash) {
-                    setup_dashed_rect(rects[rectIndex], vertices, curVIdx, args.fSrcRotInv,
+                    setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv,
                                       draws[i].fStartOffset, draws[i].fDevBloatX,
-                                      draws[i].fDevBloatY, args.fIntervals[0],
-                                      draws[i].fHalfDevStroke, args.fIntervals[0],
-                                      args.fIntervals[1], draws[i].fStrokeWidth, capType,
+                                      draws[i].fDevBloatY, geom.fIntervals[0],
+                                      draws[i].fHalfDevStroke, geom.fIntervals[0],
+                                      geom.fIntervals[1], draws[i].fStrokeWidth, capType,
                                       gp->getVertexStride());
                 } else {
                     SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
                     SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
-                    setup_dashed_rect_pos(rects[rectIndex], curVIdx, args.fSrcRotInv, verts);
+                    setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts);
                 }
-
                 curVIdx += 4;
             }
             rectIndex++;
 
             if (draws[i].fHasEndRect) {
                 if (fullDash) {
-                    setup_dashed_rect(rects[rectIndex], vertices, curVIdx, args.fSrcRotInv,
+                    setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv,
                                       draws[i].fStartOffset, draws[i].fDevBloatX,
-                                      draws[i].fDevBloatY, args.fIntervals[0],
-                                      draws[i].fHalfDevStroke, args.fIntervals[0],
-                                      args.fIntervals[1], draws[i].fStrokeWidth, capType,
+                                      draws[i].fDevBloatY, geom.fIntervals[0],
+                                      draws[i].fHalfDevStroke, geom.fIntervals[0],
+                                      geom.fIntervals[1], draws[i].fStrokeWidth, capType,
                                       gp->getVertexStride());
                 } else {
                     SkPoint* verts = reinterpret_cast<SkPoint*>(vertices);
                     SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
-                    setup_dashed_rect_pos(rects[rectIndex], curVIdx, args.fSrcRotInv, verts);
+                    setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts);
                 }
                 curVIdx += 4;
             }
             rectIndex++;
         }
-
-        GrDrawTarget::DrawInfo drawInfo;
-        drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
-        drawInfo.setStartVertex(0);
-        drawInfo.setStartIndex(0);
-        drawInfo.setVerticesPerInstance(kVertsPerDash);
-        drawInfo.setIndicesPerInstance(kIndicesPerDash);
-        drawInfo.adjustStartVertex(firstVertex);
-        drawInfo.setVertexBuffer(vertexBuffer);
-        drawInfo.setIndexBuffer(indexBuffer);
-
-        int maxInstancesPerDraw = indexBuffer->maxQuads();
-        while (totalRectCount) {
-            drawInfo.setInstanceCount(SkTMin(totalRectCount, maxInstancesPerDraw));
-            drawInfo.setVertexCount(drawInfo.instanceCount() * drawInfo.verticesPerInstance());
-            drawInfo.setIndexCount(drawInfo.instanceCount() * drawInfo.indicesPerInstance());
-
-            batchTarget->draw(drawInfo);
-
-            drawInfo.setStartVertex(drawInfo.startVertex() + drawInfo.vertexCount());
-            totalRectCount -= drawInfo.instanceCount();
-       }
+        SkASSERT(0 == (curVIdx % 4) && (curVIdx / 4) == totalRectCount);
+        helper.issueDraws(batchTarget);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     DashBatch(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode, bool fullDash) {
         this->initClassID<DashBatch>();
         fGeoData.push_back(geometry);
 
         fBatch.fAAMode = aaMode;
@@ skipping 729 matching lines @@
     info.fIntervals = intervals;
     info.fCount = 2;
     info.fPhase = phase;
     SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
     SkASSERT(success);
 
     return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
 }
 
 #endif