Remove GrTInstanceBatch

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 "SkMatrix.h"
 #include "SkRect.h"
+#include "GrVertexBatch.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);
 }
 
 static const int kNumAAFillRectsInIndexBuffer = 256;
@@ skipping 151 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;
         }
     }
 }
 
-// Common functions
-class AAFillRectBatchBase {
+class AAFillRectNoLocalMatrixBatch : public GrVertexBatch {
 public:
+    DEFINE_BATCH_CLASS_ID
+
+    struct Geometry {
+        SkMatrix fViewMatrix;
+        SkRect fRect;
+        SkRect fDevRect;
+        GrColor fColor;
+    };
+
+    static AAFillRectNoLocalMatrixBatch* Create() { return new AAFillRectNoLocalMatrixBatch; }
+

[robertphillips, 2016/06/30 19:22:16]

rm Name too ?

+    const char* name() const override { return Name(); }
+
+    SkString dumpInfo() const override {
+        SkString str;
+        str.appendf("# batched: %d\n", fGeoData.count());
+        for (int i = 0; i < fGeoData.count(); ++i) {
+            str.append(DumpInfo(fGeoData[i], i));
+        }
+        str.append(INHERITED::dumpInfo());
+        return str;
+    }
+
+    void computePipelineOptimizations(GrInitInvariantOutput* color,
+                                      GrInitInvariantOutput* coverage,
+                                      GrBatchToXPOverrides* overrides) const override {
+        // When this is called on a batch, there is only one geometry bundle
+        color->setKnownFourComponents(fGeoData[0].fColor);

[robertphillips, 2016/06/30 19:22:16]

rm InitInvariantOutput ?

+        InitInvariantOutputCoverage(coverage);
+    }
+
+    void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
+        overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
+        fOverrides = overrides;
+    }
+
+    SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
+
+    // After seeding, the client should call init() so the Batch can initialize itself
+    void init() {
+        const Geometry& geo = fGeoData[0];

[robertphillips, 2016/06/30 19:22:16]

fold this in ?

+        SetBounds(geo, &fBounds);
+    }
+
+    void updateBoundsAfterAppend() {
+        const Geometry& geo = fGeoData.back();

[robertphillips, 2016/06/30 19:22:16]

this too ?

+        UpdateBoundsAfterAppend(geo, &fBounds);
+    }
+
+private:
     static const int kVertsPerInstance = kVertsPerAAFillRect;
     static const int kIndicesPerInstance = kIndicesPerAAFillRect;
 
     static void InitInvariantOutputCoverage(GrInitInvariantOutput* out) {
         out->setUnknownSingleComponent();
     }
 
     static const GrBuffer* GetIndexBuffer(GrResourceProvider* rp) {
         return get_index_buffer(rp);
     }
 
-    template <class Geometry>
     static void SetBounds(const Geometry& geo, SkRect* outBounds) {
         *outBounds = geo.fDevRect;
     }
 
-    template <class Geometry>
     static void UpdateBoundsAfterAppend(const Geometry& geo, SkRect* outBounds) {
         outBounds->join(geo.fDevRect);
     }
-};
-
-class AAFillRectBatchNoLocalMatrixImp : public AAFillRectBatchBase {
-public:
-    struct Geometry {
-        SkMatrix fViewMatrix;
-        SkRect fRect;
-        SkRect fDevRect;
-        GrColor fColor;
-    };
 
     static const char* Name() { return "AAFillRectBatchNoLocalMatrix"; }
 
     static SkString DumpInfo(const Geometry& geo, int index) {
         SkString str;
         str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
                     index,
                     geo.fColor,
                     geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
         return str;
     }
 
     static bool CanCombine(const Geometry& mine, const Geometry& theirs,
                            const GrXPOverridesForBatch& overrides) {
         // 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 !overrides.readsLocalCoords() || mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix);
     }
 
     static sk_sp<GrGeometryProcessor> MakeGP(const Geometry& geo,
-                                               const GrXPOverridesForBatch& overrides) {
+                                             const GrXPOverridesForBatch& overrides) {
         sk_sp<GrGeometryProcessor> gp =
                 create_fill_rect_gp(geo.fViewMatrix, overrides,
                                     GrDefaultGeoProcFactory::LocalCoords::kUsePosition_Type);
 
         SkASSERT(overrides.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         return gp;
     }
 
     static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
                           const GrXPOverridesForBatch& overrides) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
                                        geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect,
                                        overrides, nullptr);
     }
+
+    AAFillRectNoLocalMatrixBatch() : INHERITED(ClassID()) {}
+
+    void onPrepareDraws(Target* target) const override {
+        sk_sp<GrGeometryProcessor> gp(MakeGP(this->seedGeometry(), fOverrides));
+        if (!gp) {
+            SkDebugf("Couldn't create GrGeometryProcessor\n");
+            return;
+        }
+
+        size_t vertexStride = gp->getVertexStride();
+        int instanceCount = fGeoData.count();
+
+        SkAutoTUnref<const GrBuffer> indexBuffer(GetIndexBuffer(target->resourceProvider()));
+        InstancedHelper helper;
+        void* vertices = helper.init(target, kTriangles_GrPrimitiveType, vertexStride,
+                                     indexBuffer, kVertsPerInstance,
+                                     kIndicesPerInstance, 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 * kVertsPerInstance * vertexStride;

[robertphillips, 2016/06/30 19:22:16]

rm Tesselate ?

+            Tesselate(verts, vertexStride, fGeoData[i], fOverrides);
+        }
+        helper.recordDraw(target, gp.get());
+    }
+
+    const Geometry& seedGeometry() const { return fGeoData[0]; }
+
+    bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
+        AAFillRectNoLocalMatrixBatch* that = t->cast<AAFillRectNoLocalMatrixBatch>();
+        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                    that->bounds(), caps)) {
+            return false;
+        }
+
+        if (!CanCombine(this->seedGeometry(), that->seedGeometry(), fOverrides)) {
+            return false;
+        }
+
+        // In the event of two batches, one who can tweak, one who cannot, we just fall back to
+        // not tweaking
+        if (fOverrides.canTweakAlphaForCoverage() && !that->fOverrides.canTweakAlphaForCoverage()) {
+            fOverrides = that->fOverrides;
+        }
+
+        fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
+        return true;
+    }
+
+    GrXPOverridesForBatch fOverrides;
+    SkSTArray<1, Geometry, true> fGeoData;
+
+    typedef GrVertexBatch INHERITED;
 };
 
-class AAFillRectBatchLocalMatrixImp : public AAFillRectBatchBase {
+class AAFillRectLocalMatrixBatch : public GrVertexBatch {
 public:
+    DEFINE_BATCH_CLASS_ID
+
     struct Geometry {
         SkMatrix fViewMatrix;
         SkMatrix fLocalMatrix;
         SkRect fRect;
         SkRect fDevRect;
         GrColor fColor;
     };
 
+    static AAFillRectLocalMatrixBatch* Create() { return new AAFillRectLocalMatrixBatch; }
+

[robertphillips, 2016/06/30 19:22:16]

same here 

+    const char* name() const override { return Name(); }
+
+    SkString dumpInfo() const override {
+        SkString str;
+        str.appendf("# batched: %d\n", fGeoData.count());
+        for (int i = 0; i < fGeoData.count(); ++i) {
+            str.append(DumpInfo(fGeoData[i], i));
+        }
+        str.append(INHERITED::dumpInfo());
+        return str;
+    }
+
+    void computePipelineOptimizations(GrInitInvariantOutput* color,
+                                      GrInitInvariantOutput* coverage,
+                                      GrBatchToXPOverrides* overrides) const override {
+        // When this is called on a batch, there is only one geometry bundle
+        color->setKnownFourComponents(fGeoData[0].fColor);

[robertphillips, 2016/06/30 19:22:16]

rm InitInvariantOutput ?

+        InitInvariantOutputCoverage(coverage);
+    }
+
+    void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
+        overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
+        fOverrides = overrides;
+    }
+
+    SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
+
+    // After seeding, the client should call init() so the Batch can initialize itself
+    void init() {
+        const Geometry& geo = fGeoData[0];
+        SetBounds(geo, &fBounds);
+    }
+
+    void updateBoundsAfterAppend() {
+        const Geometry& geo = fGeoData.back();
+        UpdateBoundsAfterAppend(geo, &fBounds);
+    }
+
+private:
+    static const int kVertsPerInstance = kVertsPerAAFillRect;
+    static const int kIndicesPerInstance = kIndicesPerAAFillRect;
+
+    static void InitInvariantOutputCoverage(GrInitInvariantOutput* out) {
+        out->setUnknownSingleComponent();
+    }
+
+    static const GrBuffer* GetIndexBuffer(GrResourceProvider* rp) {
+        return get_index_buffer(rp);
+    }
+
+    static void SetBounds(const Geometry& geo, SkRect* outBounds) {
+        *outBounds = geo.fDevRect;
+    }
+
+    static void UpdateBoundsAfterAppend(const Geometry& geo, SkRect* outBounds) {
+        outBounds->join(geo.fDevRect);
+    }
+
     static const char* Name() { return "AAFillRectBatchLocalMatrix"; }
 
     static SkString DumpInfo(const Geometry& geo, int index) {
         SkString str;
         str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
                     index,
                     geo.fColor,
                     geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
         return str;
     }
@@ skipping 16 matching lines @@
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordCoverage));
         return gp;
     }
 
     static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
                           const GrXPOverridesForBatch& overrides) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
                                        geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect,
                                        overrides, &geo.fLocalMatrix);
     }
+
+    AAFillRectLocalMatrixBatch() : INHERITED(ClassID()) {}
+
+    void onPrepareDraws(Target* target) const override {
+        sk_sp<GrGeometryProcessor> gp(MakeGP(this->seedGeometry(), fOverrides));
+        if (!gp) {
+            SkDebugf("Couldn't create GrGeometryProcessor\n");
+            return;
+        }
+
+        size_t vertexStride = gp->getVertexStride();
+        int instanceCount = fGeoData.count();
+
+        SkAutoTUnref<const GrBuffer> indexBuffer(GetIndexBuffer(target->resourceProvider()));
+        InstancedHelper helper;
+        void* vertices = helper.init(target, kTriangles_GrPrimitiveType, vertexStride,
+                                     indexBuffer, kVertsPerInstance,
+                                     kIndicesPerInstance, 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 * kVertsPerInstance * vertexStride;

[robertphillips, 2016/06/30 19:22:16]

rm Tesselate here too ?

+            Tesselate(verts, vertexStride, fGeoData[i], fOverrides);
+        }
+        helper.recordDraw(target, gp.get());
+    }
+
+    const Geometry& seedGeometry() const { return fGeoData[0]; }
+
+    bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
+        AAFillRectLocalMatrixBatch* that = t->cast<AAFillRectLocalMatrixBatch>();
+        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                    that->bounds(), caps)) {
+            return false;
+        }
+
+        if (!CanCombine(this->seedGeometry(), that->seedGeometry(), fOverrides)) {
+            return false;
+        }
+
+        // In the event of two batches, one who can tweak, one who cannot, we just fall back to
+        // not tweaking
+        if (fOverrides.canTweakAlphaForCoverage() && !that->fOverrides.canTweakAlphaForCoverage()) {
+            fOverrides = that->fOverrides;
+        }
+
+        fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
+        return true;
+    }
+
+    GrXPOverridesForBatch fOverrides;
+    SkSTArray<1, Geometry, true> fGeoData;
+
+    typedef GrVertexBatch INHERITED;
 };
 
-typedef GrTInstanceBatch<AAFillRectBatchNoLocalMatrixImp> AAFillRectBatchNoLocalMatrix;
-typedef GrTInstanceBatch<AAFillRectBatchLocalMatrixImp> AAFillRectBatchLocalMatrix;
-
-inline static void append_to_batch(AAFillRectBatchNoLocalMatrix* batch, GrColor color,
+inline static void append_to_batch(AAFillRectNoLocalMatrixBatch* batch, GrColor color,
                                    const SkMatrix& viewMatrix, const SkRect& rect,
                                    const SkRect& devRect) {
-    AAFillRectBatchNoLocalMatrix::Geometry& geo = batch->geoData()->push_back();
+    AAFillRectNoLocalMatrixBatch::Geometry& geo = batch->geoData()->push_back();
     geo.fColor = color;
     geo.fViewMatrix = viewMatrix;
     geo.fRect = rect;
     geo.fDevRect = devRect;
 }
 
-inline static void append_to_batch(AAFillRectBatchLocalMatrix* batch, GrColor color,
+inline static void append_to_batch(AAFillRectLocalMatrixBatch* batch, GrColor color,
                                    const SkMatrix& viewMatrix, const SkMatrix& localMatrix,
                                    const SkRect& rect, const SkRect& devRect) {
-    AAFillRectBatchLocalMatrix::Geometry& geo = batch->geoData()->push_back();
+    AAFillRectLocalMatrixBatch::Geometry& geo = batch->geoData()->push_back();
     geo.fColor = color;
     geo.fViewMatrix = viewMatrix;
     geo.fLocalMatrix = localMatrix;
     geo.fRect = rect;
     geo.fDevRect = devRect;
 }
 
 namespace GrAAFillRectBatch {
 
 GrDrawBatch* Create(GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkRect& rect,
                     const SkRect& devRect) {
-    AAFillRectBatchNoLocalMatrix* batch = AAFillRectBatchNoLocalMatrix::Create();
+    AAFillRectNoLocalMatrixBatch* batch = AAFillRectNoLocalMatrixBatch::Create();
     append_to_batch(batch, color, viewMatrix, rect, devRect);
     batch->init();
     return batch;
 }
 
 GrDrawBatch* Create(GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkMatrix& localMatrix,
                     const SkRect& rect,
                     const SkRect& devRect) {
-    AAFillRectBatchLocalMatrix* batch = AAFillRectBatchLocalMatrix::Create();
+    AAFillRectLocalMatrixBatch* batch = AAFillRectLocalMatrixBatch::Create();
     append_to_batch(batch, color, viewMatrix, localMatrix, rect, devRect);
     batch->init();
     return batch;
 }
 
 GrDrawBatch* Create(GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkMatrix& localMatrix,
                     const SkRect& rect) {
     SkRect devRect;
@@ skipping 12 matching lines @@
         return nullptr;
     }
     return Create(color, viewMatrix, localMatrix, rect, devRect);
 }
 
 void Append(GrBatch* origBatch,
             GrColor color,
             const SkMatrix& viewMatrix,
             const SkRect& rect,
             const SkRect& devRect) {
-    AAFillRectBatchNoLocalMatrix* batch = origBatch->cast<AAFillRectBatchNoLocalMatrix>();
+    AAFillRectNoLocalMatrixBatch* batch = origBatch->cast<AAFillRectNoLocalMatrixBatch>();
     append_to_batch(batch, color, viewMatrix, rect, devRect);
     batch->updateBoundsAfterAppend();
 }
 
 void Append(GrBatch* origBatch,
             GrColor color,
             const SkMatrix& viewMatrix,
             const SkMatrix& localMatrix,
             const SkRect& rect,
             const SkRect& devRect) {
-    AAFillRectBatchLocalMatrix* batch = origBatch->cast<AAFillRectBatchLocalMatrix>();
+    AAFillRectLocalMatrixBatch* batch = origBatch->cast<AAFillRectLocalMatrixBatch>();
     append_to_batch(batch, color, viewMatrix, localMatrix, rect, devRect);
     batch->updateBoundsAfterAppend();
 }
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
@@ skipping 10 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