Introduce GrBatch subclasses GrDrawBatch and GrVertexBatch to prepare for non-drawing batches

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"
 
@@ skipping 91 matching lines @@
     const SkRect& bounds = args.fPath->getBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
     return maxDim < 64.f && maxDim * maxScale < 256.f;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // padding around path bounds to allow for antialiased pixels
 static const SkScalar kAntiAliasPad = 1.0f;
 
-class AADistanceFieldPathBatch : public GrBatch {
+class AADistanceFieldPathBatch : public GrVertexBatch {
 public:
     typedef GrAADistanceFieldPathRenderer::PathData PathData;
     typedef SkTDynamicHash<PathData, PathData::Key> PathCache;
     typedef GrAADistanceFieldPathRenderer::PathDataList PathDataList;
 
     struct Geometry {
         Geometry(const SkStrokeRec& stroke) : fStroke(stroke) {}
         SkPath fPath;
         SkStrokeRec fStroke;
         bool fAntiAlias;
         PathData* fPathData;
     };
 
-    static GrBatch* Create(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
-                           GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
+    static GrDrawBatch* Create(const Geometry& geometry, GrColor color, const SkMatrix& viewMatrix,
+                               GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
         return SkNEW_ARGS(AADistanceFieldPathBatch, (geometry, color, viewMatrix,
                                                      atlas, pathCache, pathList));
     }
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         out->setKnownFourComponents(fBatch.fColor);
     }
 
@@ skipping 340 matching lines @@
         batchTarget->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 {
-        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(), t->bounds(),
-                                    caps)) {
+        AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
+        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                    that->bounds(), caps)) {
             return false;
         }
 
-        AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
-
         // TODO we could actually probably do a bunch of this work on the CPU, ie map viewMatrix,
         // maybe upload color via attribute
         if (this->color() != that->color()) {
             return false;
         }
 
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
@@ skipping 31 matching lines @@
                                                      (void*)this);
         if (!fAtlas) {
             return false;
         }
     }
 
     AADistanceFieldPathBatch::Geometry geometry(*args.fStroke);
     geometry.fPath = *args.fPath;
     geometry.fAntiAlias = args.fAntiAlias;
 
-    SkAutoTUnref<GrBatch> batch(AADistanceFieldPathBatch::Create(geometry, args.fColor,
-                                                                 *args.fViewMatrix, fAtlas,
-                                                                 &fPathCache, &fPathList));
+    SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry, args.fColor,
+                                                                     *args.fViewMatrix, fAtlas,
+                                                                     &fPathCache, &fPathList));
     args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 struct PathTestStruct {
@@ skipping 31 matching lines @@
             }
         }
     }
 
     uint32_t fContextID;
     GrBatchAtlas* fAtlas;
     PathCache fPathCache;
     PathDataList fPathList;
 };
 
-BATCH_TEST_DEFINE(AADistanceFieldPathBatch) {
+DRAW_BATCH_TEST_DEFINE(AADistanceFieldPathBatch) {
     static PathTestStruct gTestStruct;
 
     if (context->uniqueID() != gTestStruct.fContextID) {
         gTestStruct.fContextID = context->uniqueID();
         gTestStruct.reset();
         gTestStruct.fAtlas =
                 context->resourceProvider()->createAtlas(kAlpha_8_GrPixelConfig,
                                                      ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT,
                                                      NUM_PLOTS_X, NUM_PLOTS_Y,
                                                      &PathTestStruct::HandleEviction,
                                                      (void*)&gTestStruct);
     }
 
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
 
     AADistanceFieldPathBatch::Geometry geometry(GrTest::TestStrokeRec(random));
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
 
     return AADistanceFieldPathBatch::Create(geometry, color, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
                                             &gTestStruct.fPathList);
 }
 
 #endif