Move GrTBatchTesselator to its own file

src/gpu/batches/GrAAFillRectBatch.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 "GrAAFillRectBatch.h"
 
-#include "GrBatchFlushState.h"
 #include "GrColor.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrResourceKey.h"
 #include "GrResourceProvider.h"
+#include "GrTInstanceBatch.h"
 #include "GrTypes.h"
-#include "GrVertexBatch.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
 
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
                     r.fRight - dx, r.fBottom - dy, stride);
 }
@@ skipping 11 matching lines @@
         2, 3, 7, 7, 6, 2,
         3, 0, 4, 4, 7, 3,
         4, 5, 6, 6, 7, 4,
     };
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFillAARectIdx) == kIndicesPerAAFillRect);
     return resourceProvider->findOrCreateInstancedIndexBuffer(gFillAARectIdx,
         kIndicesPerAAFillRect, kNumAAFillRectsInIndexBuffer, kVertsPerAAFillRect,
         gAAFillRectIndexBufferKey);
 }
 
-/*
- * AAFillRectBatch is templated to optionally allow the insertion of an additional
- * attribute for explicit local coordinates.
- * To use this template, an implementation must define the following static functions:
- *     A Geometry struct
- *
- *     bool CanCombine(const Geometry& mine, const Geometry& theirs,
- *                     const GrPipelineOptimizations&)
- *
- *     const GrGeometryProcessor* CreateGP(const Geometry& seedGeometry,
- *                                         const GrPipelineOptimizations& opts)
- *
- *     Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
- *               const GrPipelineOptimizations& opts)
- */
-template <typename Base>
-class AAFillRectBatch : public GrVertexBatch {
-public:
-    typedef typename Base::Geometry Geometry;
-
-    static AAFillRectBatch* Create() {
-        return SkNEW(AAFillRectBatch);
-    }
-
-    const char* name() const override { return "AAFillRectBatch"; }
-
-    void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
-        // When this is called on a batch, there is only one geometry bundle
-        out->setKnownFourComponents(fGeoData[0].fColor);
-    }
-
-    void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
-        out->setUnknownSingleComponent();
-    }
-
-    void initBatchTracker(const GrPipelineOptimizations& opt) override {
-        opt.getOverrideColorIfSet(&fGeoData[0].fColor);
-        fOpts = opt;
-    }
-
-    SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
-
-    // to avoid even the initial copy of the struct, we have a getter for the first item which
-    // is used to seed the batch with its initial geometry.  After seeding, the client should call
-    // init() so the Batch can initialize itself
-    Geometry* geometry() { return &fGeoData[0]; }
-    void init() {
-        const Geometry& geo = fGeoData[0];
-        this->setBounds(geo.fDevRect);
-    }
-
-private:
-    AAFillRectBatch() {
-        this->initClassID<AAFillRectBatch<Base>>();
-
-        // Push back an initial geometry
-        fGeoData.push_back();
-    }
-
-    void onPrepareDraws(Target* target) override {
-        SkAutoTUnref<const GrGeometryProcessor> gp(Base::CreateGP(this->seedGeometry(), fOpts));
-        if (!gp) {
-            SkDebugf("Couldn't create GrGeometryProcessor\n");
-            return;
-        }
-
-        target->initDraw(gp, this->pipeline());
-
-        size_t vertexStride = gp->getVertexStride();
-        int instanceCount = fGeoData.count();
-
-        SkAutoTUnref<const GrIndexBuffer> indexBuffer(get_index_buffer(target->resourceProvider()));
-        InstancedHelper helper;
-        void* vertices = helper.init(target, kTriangles_GrPrimitiveType, vertexStride,
-                                     indexBuffer, kVertsPerAAFillRect, kIndicesPerAAFillRect,
-                                     instanceCount);
-        if (!vertices || !indexBuffer) {
-            SkDebugf("Could not allocate vertices\n");
-            return;
-        }
-
-        for (int i = 0; i < instanceCount; i++) {
-            intptr_t verts = reinterpret_cast<intptr_t>(vertices) +
-                             i * kVertsPerAAFillRect * vertexStride;
-            Base::Tesselate(verts, vertexStride, fGeoData[i], fOpts);
-        }
-        helper.recordDraw(target);
-    }
-
-    const Geometry& seedGeometry() const { return fGeoData[0]; }
-
-    bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
-        AAFillRectBatch* that = t->cast<AAFillRectBatch>();
-        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
-                                    that->bounds(), caps)) {
-            return false;
-        }
-
-        if (!Base::CanCombine(this->seedGeometry(), that->seedGeometry(), fOpts)) {
-            return false;
-        }
-
-        // In the event of two batches, one who can tweak, one who cannot, we just fall back to
-        // not tweaking
-        if (fOpts.canTweakAlphaForCoverage() && !that->fOpts.canTweakAlphaForCoverage()) {
-            fOpts = that->fOpts;
-        }
-
-        fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
-        this->joinBounds(that->bounds());
-        return true;
-    }
-
-    GrPipelineOptimizations fOpts;
-    SkSTArray<1, Geometry, true> fGeoData;
-};
-
 static const GrGeometryProcessor* create_fill_rect_gp(
                                        const SkMatrix& viewMatrix,
                                        const GrPipelineOptimizations& opts,
                                        GrDefaultGeoProcFactory::LocalCoords::Type localCoordsType) {
     using namespace GrDefaultGeoProcFactory;
 
     Color color(Color::kAttribute_Type);
     Coverage::Type coverageType;
     // TODO remove coverage if coverage is ignored
     /*if (coverageIgnored) {
@@ skipping 117 matching lines @@
         if (tweakAlphaForCoverage) {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
             *reinterpret_cast<float*>(verts + i * vertexStride +
                                       coverageOffset) = innerCoverage;
         }
     }
 }
 
-class AAFillRectBatchNoLocalMatrixImp {
+// Common functions
+class AAFillRectBatchBase {
+public:
+    static const int kVertsPerInstance = kVertsPerAAFillRect;
+    static const int kIndicesPerInstance = kIndicesPerAAFillRect;
+
+    inline static const GrIndexBuffer* GetIndexBuffer(GrResourceProvider* rp) {
+        return get_index_buffer(rp);
+    }
+};
+
+class AAFillRectBatchNoLocalMatrixImp : public AAFillRectBatchBase {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkRect fDevRect;
         GrColor fColor;
     };
 
+    inline static const char* Name() { return "AAFillRectBatchNoLocalMatrix"; }
+
     inline static bool CanCombine(const Geometry& mine, const Geometry& theirs,
                                   const GrPipelineOptimizations& opts) {
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
         // local coords then we won't be able to batch.  We could actually upload the viewmatrix
         // using vertex attributes in these cases, but haven't investigated that
         return !opts.readsLocalCoords() || mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix);
     }
 
     inline static const GrGeometryProcessor* CreateGP(const Geometry& geo,
                                                       const GrPipelineOptimizations& opts) {
         const GrGeometryProcessor* gp =
                 create_fill_rect_gp(geo.fViewMatrix, opts,
                                     GrDefaultGeoProcFactory::LocalCoords::kUsePosition_Type);
 
         SkASSERT(opts.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         return gp;
     }
 
     inline static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
                                  const GrPipelineOptimizations& opts) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
                                        geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, opts,
                                        NULL);
     }
 };
 
-class AAFillRectBatchLocalMatrixImp {
+class AAFillRectBatchLocalMatrixImp : public AAFillRectBatchBase {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkMatrix fLocalMatrix;
         SkRect fRect;
         SkRect fDevRect;
         GrColor fColor;
     };
 
+    inline static const char* Name() { return "AAFillRectBatchLocalMatrix"; }
+
     inline static bool CanCombine(const Geometry& mine, const Geometry& theirs,
                                   const GrPipelineOptimizations&) {
         return true;
     }
 
     inline static const GrGeometryProcessor* CreateGP(const Geometry& geo,
                                                       const GrPipelineOptimizations& opts) {
         const GrGeometryProcessor* gp =
                 create_fill_rect_gp(geo.fViewMatrix, opts,
                                     GrDefaultGeoProcFactory::LocalCoords::kHasExplicit_Type);
 
         SkASSERT(opts.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordCoverage));
         return gp;
     }
 
     inline static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
                                  const GrPipelineOptimizations& opts) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
                                        geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, opts,
                                        &geo.fLocalMatrix);
     }
 };
 
-typedef AAFillRectBatch<AAFillRectBatchNoLocalMatrixImp> AAFillRectBatchNoLocalMatrix;
-typedef AAFillRectBatch<AAFillRectBatchLocalMatrixImp> AAFillRectBatchLocalMatrix;
+typedef GrTInstanceBatch<AAFillRectBatchNoLocalMatrixImp> AAFillRectBatchNoLocalMatrix;
+typedef GrTInstanceBatch<AAFillRectBatchLocalMatrixImp> AAFillRectBatchLocalMatrix;
 
 namespace GrAAFillRectBatch {
 
 GrDrawBatch* Create(GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkRect& rect,
                     const SkRect& devRect) {
     AAFillRectBatchNoLocalMatrix* batch = AAFillRectBatchNoLocalMatrix::Create();
     AAFillRectBatchNoLocalMatrix::Geometry& geo = *batch->geometry();
     geo.fColor = color;
@@ skipping 39 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAFillRectBatchLocalMatrix) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkMatrix localMatrix = GrTest::TestMatrix(random);
     SkRect rect = GrTest::TestRect(random);
     SkRect devRect = GrTest::TestRect(random);
     return GrAAFillRectBatch::Create(color, viewMatrix, localMatrix, rect, devRect);
 }
 
 #endif