Simplify GrDrawBatch uploads and token uage.

gm/beziereffects.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This test only works with the GPU backend.
 
 #include "gm.h"
@@ skipping 14 matching lines @@
 
 static inline SkScalar eval_line(const SkPoint& p, const SkScalar lineEq[3], SkScalar sign) {
     return sign * (lineEq[0] * p.fX + lineEq[1] * p.fY + lineEq[2]);
 }
 
 namespace skiagm {
 
 class BezierCubicOrConicTestBatch : public GrTestBatch {
 public:
     DEFINE_BATCH_CLASS_ID
-    struct Geometry : public GrTestBatch::Geometry {
-        SkRect fBounds;
-    };
 
     const char* name() const override { return "BezierCubicOrConicTestBatch"; }
 
-    static GrDrawBatch* Create(const GrGeometryProcessor* gp, const Geometry& geo,
-                               const SkScalar klmEqs[9], SkScalar sign) {
-        return new BezierCubicOrConicTestBatch(gp, geo, klmEqs, sign);
+    BezierCubicOrConicTestBatch(const GrGeometryProcessor* gp, const SkRect& bounds,
+                                GrColor color, const SkScalar klmEqs[9], SkScalar sign)
+        : INHERITED(ClassID(), bounds, color)
+        , fGeometryProcessor(SkRef(gp)) {
+        for (int i = 0; i < 9; i++) {
+            fKlmEqs[i] = klmEqs[i];
+        }
+        fSign = sign;
     }
 
 private:
-    BezierCubicOrConicTestBatch(const GrGeometryProcessor* gp, const Geometry& geo,
-                                const SkScalar klmEqs[9], SkScalar sign)
-        : INHERITED(ClassID(), gp, geo.fBounds) {
-        for (int i = 0; i < 9; i++) {
-            fKlmEqs[i] = klmEqs[i];
-        }
-
-        fGeometry = geo;
-        fSign = sign;
-    }
 
     struct Vertex {
         SkPoint fPosition;
         float   fKLM[4]; // The last value is ignored. The effect expects a vec4f.
     };
 
-    Geometry* geoData(int index) override {
-        SkASSERT(0 == index);
-        return &fGeometry;
-    }
-
-    const Geometry* geoData(int index) const override {
-        SkASSERT(0 == index);
-        return &fGeometry;
-    }
-
-    void generateGeometry(Target* target) const override {
+    void onPrepareDraws(Target* target) const override {
         QuadHelper helper;
-        size_t vertexStride = this->geometryProcessor()->getVertexStride();
+        size_t vertexStride = fGeometryProcessor->getVertexStride();
         SkASSERT(vertexStride == sizeof(Vertex));
         Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, vertexStride, 1));
         if (!verts) {
             return;
         }
-
-        verts[0].fPosition.setRectFan(fGeometry.fBounds.fLeft, fGeometry.fBounds.fTop,
-                                      fGeometry.fBounds.fRight, fGeometry.fBounds.fBottom,
+        const SkRect& bounds = this->bounds();
+        verts[0].fPosition.setRectFan(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom,
                                       sizeof(Vertex));
         for (int v = 0; v < 4; ++v) {
             verts[v].fKLM[0] = eval_line(verts[v].fPosition, fKlmEqs + 0, fSign);
             verts[v].fKLM[1] = eval_line(verts[v].fPosition, fKlmEqs + 3, fSign);
             verts[v].fKLM[2] = eval_line(verts[v].fPosition, fKlmEqs + 6, 1.f);
         }
-        helper.recordDraw(target);
+        helper.recordDraw(target, fGeometryProcessor);
     }
 
-    Geometry fGeometry;
-    SkScalar fKlmEqs[9];
-    SkScalar fSign;
+    SkScalar                                fKlmEqs[9];
+    SkScalar                                fSign;
+    SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
 
     static const int kVertsPerCubic = 4;
     static const int kIndicesPerCubic = 6;
 
     typedef GrTestBatch INHERITED;
 };
 
 /**
  * This GM directly exercises effects that draw Bezier curves in the GPU backend.
  */
@@ skipping 105 matching lines @@
                     boundsPaint.setColor(0xff808080);
                     boundsPaint.setStrokeWidth(0);
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPipelineBuilder pipelineBuilder;
                     pipelineBuilder.setXPFactory(
                         GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
                     pipelineBuilder.setRenderTarget(rt);
 
-                    BezierCubicOrConicTestBatch::Geometry geometry;
-                    geometry.fColor = color;
-                    geometry.fBounds = bounds;
-
                     SkAutoTUnref<GrDrawBatch> batch(
-                            BezierCubicOrConicTestBatch::Create(gp, geometry, klmEqs, klmSigns[c]));
+                        new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, klmSigns[c]));
 
                     drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
                     ++row;
                 }
             }
         }
@@ skipping 115 matching lines @@
                     boundsPaint.setColor(0xff808080);
                     boundsPaint.setStrokeWidth(0);
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPipelineBuilder pipelineBuilder;
                     pipelineBuilder.setXPFactory(
                         GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
                     pipelineBuilder.setRenderTarget(rt);
 
-                    BezierCubicOrConicTestBatch::Geometry geometry;
-                    geometry.fColor = color;
-                    geometry.fBounds = bounds;
-
                     SkAutoTUnref<GrDrawBatch> batch(
-                            BezierCubicOrConicTestBatch::Create(gp, geometry, klmEqs, 1.f));
+                        new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, 1.f));
 
                     drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
                     ++row;
                 }
             }
         }
@@ skipping 38 matching lines @@
     }
 
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class BezierQuadTestBatch : public GrTestBatch {
 public:
     DEFINE_BATCH_CLASS_ID
-    struct Geometry : public GrTestBatch::Geometry {
-        SkRect fBounds;
-    };
-
     const char* name() const override { return "BezierQuadTestBatch"; }
 
-    static GrDrawBatch* Create(const GrGeometryProcessor* gp, const Geometry& geo,
-                               const GrPathUtils::QuadUVMatrix& devToUV) {
-        return new BezierQuadTestBatch(gp, geo, devToUV);
+    BezierQuadTestBatch(const GrGeometryProcessor* gp, const SkRect& bounds, GrColor color,
+                        const GrPathUtils::QuadUVMatrix& devToUV)
+        : INHERITED(ClassID(), bounds, color)
+        , fDevToUV(devToUV)
+        , fGeometryProcessor(SkRef(gp)) {
     }
 
 private:
-    BezierQuadTestBatch(const GrGeometryProcessor* gp, const Geometry& geo,
-                        const GrPathUtils::QuadUVMatrix& devToUV)
-        : INHERITED(ClassID(), gp, geo.fBounds)
-        , fGeometry(geo)
-        , fDevToUV(devToUV) {
-    }
 
     struct Vertex {
         SkPoint fPosition;
         float   fKLM[4]; // The last value is ignored. The effect expects a vec4f.
     };
 
-    Geometry* geoData(int index) override {
-        SkASSERT(0 == index);
-        return &fGeometry;
-    }
-
-    const Geometry* geoData(int index) const override {
-        SkASSERT(0 == index);
-        return &fGeometry;
-    }
-
-    void generateGeometry(Target* target) const override {
+    void onPrepareDraws(Target* target) const override {
         QuadHelper helper;
-        size_t vertexStride = this->geometryProcessor()->getVertexStride();
+        size_t vertexStride = fGeometryProcessor->getVertexStride();
         SkASSERT(vertexStride == sizeof(Vertex));
         Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, vertexStride, 1));
         if (!verts) {
             return;
         }
-        verts[0].fPosition.setRectFan(fGeometry.fBounds.fLeft, fGeometry.fBounds.fTop,
-                                      fGeometry.fBounds.fRight, fGeometry.fBounds.fBottom,
+        const SkRect& bounds = this->bounds();
+        verts[0].fPosition.setRectFan(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom,
                                       sizeof(Vertex));
         fDevToUV.apply<4, sizeof(Vertex), sizeof(SkPoint)>(verts);
-        helper.recordDraw(target);
+        helper.recordDraw(target, fGeometryProcessor);
     }
 
-    Geometry fGeometry;
-    GrPathUtils::QuadUVMatrix fDevToUV;
+    GrPathUtils::QuadUVMatrix               fDevToUV;
+    SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
 
     static const int kVertsPerCubic = 4;
     static const int kIndicesPerCubic = 6;
 
     typedef GrTestBatch INHERITED;
 };
 
 /**
  * This GM directly exercises effects that draw Bezier quad curves in the GPU backend.
  */
@@ skipping 101 matching lines @@
                     boundsPaint.setStyle(SkPaint::kStroke_Style);
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPipelineBuilder pipelineBuilder;
                     pipelineBuilder.setXPFactory(
                         GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
                     pipelineBuilder.setRenderTarget(rt);
 
                     GrPathUtils::QuadUVMatrix DevToUV(pts);
 
-                    BezierQuadTestBatch::Geometry geometry;
-                    geometry.fColor = color;
-                    geometry.fBounds = bounds;
-
-                    SkAutoTUnref<GrDrawBatch> batch(BezierQuadTestBatch::Create(gp, geometry,
-                                                                                DevToUV));
+                    SkAutoTUnref<GrDrawBatch> batch(
+                        new BezierQuadTestBatch(gp, bounds, color, DevToUV));
 
                     drawContext->drawContextPriv().testingOnly_drawBatch(pipelineBuilder, batch);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
                     ++row;
                 }
             }
         }
     }
 
 private:
     typedef GM INHERITED;
 };
 
 DEF_GM(return new BezierCubicEffects;)
 DEF_GM(return new BezierConicEffects;)
 DEF_GM(return new BezierQuadEffects;)
 }
 
 #endif