Add GrAARectBatch which can handle a local matrix

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 "GrBatch.h"
 #include "GrColor.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrResourceKey.h"
 #include "GrResourceProvider.h"
 #include "GrTypes.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);
 }
 
-static const GrGeometryProcessor* create_fill_rect_gp(bool tweakAlphaForCoverage,
-                                                      const SkMatrix& viewMatrix,
-                                                      bool usesLocalCoords,
-                                                      bool coverageIgnored) {
-    using namespace GrDefaultGeoProcFactory;
-
-    Color color(Color::kAttribute_Type);
-    Coverage::Type coverageType;
-    // TODO remove coverage if coverage is ignored
-    /*if (coverageIgnored) {
-        coverageType = Coverage::kNone_Type;
-    } else*/ if (tweakAlphaForCoverage) {
-        coverageType = Coverage::kSolid_Type;
-    } else {
-        coverageType = Coverage::kAttribute_Type;
-    }
-    Coverage coverage(coverageType);
-    LocalCoords localCoords(usesLocalCoords ? LocalCoords::kUsePosition_Type :
-                                              LocalCoords::kUnused_Type);
-    return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
-}
-
+/*
+ * 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 CanCombineLocalCoords(const SkMatrix& mine, const SkMatrix& theirs,
+ *                                bool usesLocalCoords)
+ *
+ *     GrDefaultGeoProcFactory::LocalCoords::Type LocalCoordsType()
+ *
+ *     bool StrideCheck(size_t vertexStride, bool canTweakAlphaForCoverage,
+ *                      bool usesLocalCoords)
+ *
+ *     void FillInAttributes(intptr_t startVertex, size_t vertexStride,
+ *                           SkPoint* fan0Position, const Geometry&)
+ */
+template <typename Base>
 class AAFillRectBatch : public GrBatch {
 public:
-    struct Geometry {
-        GrColor fColor;
-        SkMatrix fViewMatrix;
-        SkRect fRect;
-        SkRect fDevRect;
-    };
+    typedef typename Base::Geometry Geometry;
 
-    static GrBatch* Create(GrColor color,
-                           const SkMatrix& viewMatrix,
-                           const SkRect& rect,
-                           const SkRect& devRect) {
-        return SkNEW_ARGS(AAFillRectBatch, (color, viewMatrix, rect, devRect));
+    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 {
@@ skipping 11 matching lines @@
         fBatch.fColorIgnored = !opt.readsColor();
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = opt.readsLocalCoords();
         fBatch.fCoverageIgnored = !opt.readsCoverage();
         fBatch.fCanTweakAlphaForCoverage = opt.canTweakAlphaForCoverage();
     }
 
     void generateGeometry(GrBatchTarget* batchTarget) override {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
-        SkAutoTUnref<const GrGeometryProcessor> gp(create_fill_rect_gp(canTweakAlphaForCoverage,
-                                                                       this->viewMatrix(),
-                                                                       this->usesLocalCoords(),
-                                                                       this->coverageIgnored()));
+        SkAutoTUnref<const GrGeometryProcessor> gp(CreateFillRectGP(canTweakAlphaForCoverage,
+                                                                    this->viewMatrix(),
+                                                                    this->usesLocalCoords(),
+                                                                    Base::LocalCoordsType(),
+                                                                    this->coverageIgnored()));
         if (!gp) {
             SkDebugf("Couldn't create GrGeometryProcessor\n");
             return;
         }
 
         batchTarget->initDraw(gp, this->pipeline());
 
         size_t vertexStride = gp->getVertexStride();
-        SkASSERT(canTweakAlphaForCoverage ?
-                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
-                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
+        SkASSERT(Base::StrideCheck(vertexStride, canTweakAlphaForCoverage,
+                                   this->usesLocalCoords()));
         int instanceCount = fGeoData.count();
 
         SkAutoTUnref<const GrIndexBuffer> indexBuffer(this->getIndexBuffer(
             batchTarget->resourceProvider()));
         InstancedHelper helper;
         void* vertices = helper.init(batchTarget, kTriangles_GrPrimitiveType, vertexStride,
                                      indexBuffer, kVertsPerAAFillRect, kIndicesPerAAFillRect,
                                      instanceCount);
         if (!vertices || !indexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         for (int i = 0; i < instanceCount; i++) {
-            const Geometry& args = fGeoData[i];
             this->generateAAFillRectGeometry(vertices,
                                              i * kVertsPerAAFillRect * vertexStride,
                                              vertexStride,
-                                             args.fColor,
-                                             args.fViewMatrix,
-                                             args.fRect,
-                                             args.fDevRect,
+                                             fGeoData[i],
                                              canTweakAlphaForCoverage);
         }
         helper.issueDraw(batchTarget);
     }
 
     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(GrColor color, const SkMatrix& viewMatrix, const SkRect& rect,
-                      const SkRect& devRect) {
-        this->initClassID<AAFillRectBatch>();
-        Geometry& geometry = fGeoData.push_back();
-        geometry.fRect = rect;
-        geometry.fViewMatrix = viewMatrix;
-        geometry.fDevRect = devRect;
-        geometry.fColor = color;
+    AAFillRectBatch() {
+        this->initClassID<AAFillRectBatch<Base>>();
 
-        this->setBounds(geometry.fDevRect);
+        // Push back an initial geometry
+        fGeoData.push_back();
     }
 
     static const int kNumAAFillRectsInIndexBuffer = 256;
     static const int kVertsPerAAFillRect = 8;
     static const int kIndicesPerAAFillRect = 30;
 
     const GrIndexBuffer* getIndexBuffer(GrResourceProvider* resourceProvider) {
         GR_DEFINE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
 
         static const uint16_t gFillAARectIdx[] = {
@@ skipping 16 matching lines @@
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(), t->bounds(),
                                 caps)) {
             return false;
         }
 
         AAFillRectBatch* that = t->cast<AAFillRectBatch>();
-
-        SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
-        // 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
-        if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
+        if (!Base::CanCombineLocalCoords(this->viewMatrix(), that->viewMatrix(),
+                                         this->usesLocalCoords())) {
             return false;
         }
 
         if (this->color() != that->color()) {
             fBatch.fColor = GrColor_ILLEGAL;
         }
 
         // In the event of two batches, one who can tweak, one who cannot, we just fall back to
         // not tweaking
         if (this->canTweakAlphaForCoverage() != that->canTweakAlphaForCoverage()) {
             fBatch.fCanTweakAlphaForCoverage = false;
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
     void generateAAFillRectGeometry(void* vertices,
                                     size_t offset,
                                     size_t vertexStride,
-                                    GrColor color,
-                                    const SkMatrix& viewMatrix,
-                                    const SkRect& rect,
-                                    const SkRect& devRect,
+                                    const Geometry& args,
                                     bool tweakAlphaForCoverage) const {
         intptr_t verts = reinterpret_cast<intptr_t>(vertices) + offset;
 
         SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
         SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vertexStride);
 
-        SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1);
-        inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height());
+        SkScalar inset = SkMinScalar(args.fDevRect.width(), SK_Scalar1);
+        inset = SK_ScalarHalf * SkMinScalar(inset, args.fDevRect.height());
 
-        if (viewMatrix.rectStaysRect()) {
-            set_inset_fan(fan0Pos, vertexStride, devRect, -SK_ScalarHalf, -SK_ScalarHalf);
-            set_inset_fan(fan1Pos, vertexStride, devRect, inset,  inset);
+        if (args.fViewMatrix.rectStaysRect()) {
+            set_inset_fan(fan0Pos, vertexStride, args.fDevRect, -SK_ScalarHalf, -SK_ScalarHalf);
+            set_inset_fan(fan1Pos, vertexStride, args.fDevRect, inset,  inset);
         } else {
             // compute transformed (1, 0) and (0, 1) vectors
             SkVector vec[2] = {
-              { viewMatrix[SkMatrix::kMScaleX], viewMatrix[SkMatrix::kMSkewY] },
-              { viewMatrix[SkMatrix::kMSkewX],  viewMatrix[SkMatrix::kMScaleY] }
+              { args.fViewMatrix[SkMatrix::kMScaleX], args.fViewMatrix[SkMatrix::kMSkewY] },
+              { args.fViewMatrix[SkMatrix::kMSkewX],  args.fViewMatrix[SkMatrix::kMScaleY] }
             };
 
             vec[0].normalize();
             vec[0].scale(SK_ScalarHalf);
             vec[1].normalize();
             vec[1].scale(SK_ScalarHalf);
 
             // create the rotated rect
-            fan0Pos->setRectFan(rect.fLeft, rect.fTop,
-                                rect.fRight, rect.fBottom, vertexStride);
-            viewMatrix.mapPointsWithStride(fan0Pos, vertexStride, 4);
+            fan0Pos->setRectFan(args.fRect.fLeft, args.fRect.fTop,
+                                args.fRect.fRight, args.fRect.fBottom, vertexStride);
+            args.fViewMatrix.mapPointsWithStride(fan0Pos, vertexStride, 4);
 
             // Now create the inset points and then outset the original
             // rotated points
 
             // TL
             *((SkPoint*)((intptr_t)fan1Pos + 0 * vertexStride)) =
                 *((SkPoint*)((intptr_t)fan0Pos + 0 * vertexStride)) + vec[0] + vec[1];
             *((SkPoint*)((intptr_t)fan0Pos + 0 * vertexStride)) -= vec[0] + vec[1];
             // BL
             *((SkPoint*)((intptr_t)fan1Pos + 1 * vertexStride)) =
                 *((SkPoint*)((intptr_t)fan0Pos + 1 * vertexStride)) + vec[0] - vec[1];
             *((SkPoint*)((intptr_t)fan0Pos + 1 * vertexStride)) -= vec[0] - vec[1];
             // BR
             *((SkPoint*)((intptr_t)fan1Pos + 2 * vertexStride)) =
                 *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) - vec[0] - vec[1];
             *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) += vec[0] + vec[1];
             // TR
             *((SkPoint*)((intptr_t)fan1Pos + 3 * vertexStride)) =
                 *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) - vec[0] + vec[1];
             *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) += vec[0] - vec[1];
         }
 
+        Base::FillInAttributes(verts, vertexStride, fan0Pos, args);
+
         // Make verts point to vertex color and then set all the color and coverage vertex attrs
         // values.
         verts += sizeof(SkPoint);
         for (int i = 0; i < 4; ++i) {
             if (tweakAlphaForCoverage) {
                 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0;
             } else {
-                *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
+                *reinterpret_cast<GrColor*>(verts + i * vertexStride) = args.fColor;
                 *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = 0;
             }
         }
 
         int scale;
         if (inset < SK_ScalarHalf) {
             scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf));
             SkASSERT(scale >= 0 && scale <= 255);
         } else {
             scale = 0xff;
         }
 
         verts += 4 * vertexStride;
 
         float innerCoverage = GrNormalizeByteToFloat(scale);
-        GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
+        GrColor scaledColor = (0xff == scale) ? args.fColor : SkAlphaMulQ(args.fColor, scale);
 
         for (int i = 0; i < 4; ++i) {
             if (tweakAlphaForCoverage) {
                 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
             } else {
-                *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
+                *reinterpret_cast<GrColor*>(verts + i * vertexStride) = args.fColor;
                 *reinterpret_cast<float*>(verts + i * vertexStride +
                                           sizeof(GrColor)) = innerCoverage;
             }
         }
     }
 
+    static const GrGeometryProcessor* CreateFillRectGP(
+                                         bool tweakAlphaForCoverage,
+                                         const SkMatrix& viewMatrix,
+                                         bool usesLocalCoords,
+                                         GrDefaultGeoProcFactory::LocalCoords::Type localCoordsType,
+                                         bool coverageIgnored) {
+        using namespace GrDefaultGeoProcFactory;
+
+        Color color(Color::kAttribute_Type);
+        Coverage::Type coverageType;
+        // TODO remove coverage if coverage is ignored
+        /*if (coverageIgnored) {
+            coverageType = Coverage::kNone_Type;
+        } else*/ if (tweakAlphaForCoverage) {
+            coverageType = Coverage::kSolid_Type;
+        } else {
+            coverageType = Coverage::kAttribute_Type;
+        }
+        Coverage coverage(coverageType);
+
+        // We assume the caller has inverted the viewmatrix
+        LocalCoords localCoords(usesLocalCoords ? localCoordsType : LocalCoords::kUnused_Type);
+        if (LocalCoords::kHasExplicit_Type == localCoordsType) {
+            return GrDefaultGeoProcFactory::Create(color, coverage, localCoords, SkMatrix::I());
+        } else {
+            return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
+        }
+    }
+
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         bool fCanTweakAlphaForCoverage;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
+class AAFillRectBatchNoLocalMatrixImp {
+public:
+    struct Geometry {
+        SkMatrix fViewMatrix;
+        SkRect fRect;
+        SkRect fDevRect;
+        GrColor fColor;
+    };
+
+    inline static bool CanCombineLocalCoords(const SkMatrix& mine, const SkMatrix& theirs,
+                                             bool usesLocalCoords) {
+        // 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 !usesLocalCoords || mine.cheapEqualTo(theirs);
+    }
+
+    inline static GrDefaultGeoProcFactory::LocalCoords::Type LocalCoordsType() {
+        return GrDefaultGeoProcFactory::LocalCoords::kUsePosition_Type;
+    }
+
+    inline static bool StrideCheck(size_t vertexStride, bool canTweakAlphaForCoverage,
+                                   bool usesLocalCoords) {
+        return canTweakAlphaForCoverage ?
+                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
+                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr);
+    }
+
+    inline static void FillInAttributes(intptr_t, size_t, SkPoint*, const Geometry&) {}
+};
+
+class AAFillRectBatchLocalMatrixImp {
+public:
+    struct Geometry {
+        SkMatrix fViewMatrix;
+        SkMatrix fLocalMatrix;
+        SkRect fRect;
+        SkRect fDevRect;
+        GrColor fColor;
+    };
+
+    inline static bool CanCombineLocalCoords(const SkMatrix& mine, const SkMatrix& theirs,
+                                             bool usesLocalCoords) {
+        return true;
+    }
+
+    inline static GrDefaultGeoProcFactory::LocalCoords::Type LocalCoordsType() {
+        return GrDefaultGeoProcFactory::LocalCoords::kHasExplicit_Type;
+    }
+
+    inline static bool StrideCheck(size_t vertexStride, bool canTweakAlphaForCoverage,
+                                   bool usesLocalCoords) {
+        // Whomever created us should not have done so if there are no local coords
+        SkASSERT(usesLocalCoords);
+        return canTweakAlphaForCoverage ?
+                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
+                 vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordCoverage);
+    }
+
+    inline static void FillInAttributes(intptr_t vertices, size_t vertexStride,
+                                        SkPoint* fan0Pos, const Geometry& args) {
+        SkMatrix invViewMatrix;
+        if (!args.fViewMatrix.invert(&invViewMatrix)) {
+            SkASSERT(false);
+            invViewMatrix = SkMatrix::I();
+        }
+        SkMatrix localCoordMatrix;
+        localCoordMatrix.setConcat(args.fLocalMatrix, invViewMatrix);
+        SkPoint* fan0Loc = reinterpret_cast<SkPoint*>(vertices + vertexStride - sizeof(SkPoint));
+        localCoordMatrix.mapPointsWithStride(fan0Loc, fan0Pos, vertexStride, 8);
+    }
+};
+
+typedef AAFillRectBatch<AAFillRectBatchNoLocalMatrixImp> AAFillRectBatchNoLocalMatrix;
+typedef AAFillRectBatch<AAFillRectBatchLocalMatrixImp> AAFillRectBatchLocalMatrix;
+
 namespace GrAAFillRectBatch {
 
 GrBatch* Create(GrColor color,
                 const SkMatrix& viewMatrix,
                 const SkRect& rect,
                 const SkRect& devRect) {
-    return AAFillRectBatch::Create(color, viewMatrix, rect, devRect);
+    AAFillRectBatchNoLocalMatrix* batch = AAFillRectBatchNoLocalMatrix::Create();
+    AAFillRectBatchNoLocalMatrix::Geometry& geo = *batch->geometry();
+    geo.fColor = color;
+    geo.fViewMatrix = viewMatrix;
+    geo.fRect = rect;
+    geo.fDevRect = devRect;
+    batch->init();
+    return batch;
+}
+
+GrBatch* Create(GrColor color,
+                const SkMatrix& viewMatrix,
+                const SkMatrix& localMatrix,
+                const SkRect& rect,
+                const SkRect& devRect) {
+    AAFillRectBatchLocalMatrix* batch = AAFillRectBatchLocalMatrix::Create();
+    AAFillRectBatchLocalMatrix::Geometry& geo = *batch->geometry();
+    geo.fColor = color;
+    geo.fViewMatrix = viewMatrix;
+    geo.fLocalMatrix = localMatrix;
+    geo.fRect = rect;
+    geo.fDevRect = devRect;
+    batch->init();
+    return batch;
 }
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 #include "GrBatchTest.h"
 
 BATCH_TEST_DEFINE(AAFillRectBatch) {
-    GrColor color = GrRandomColor(random);
-    SkMatrix viewMatrix = GrTest::TestMatrix(random);
-    SkRect rect = GrTest::TestRect(random);
-    SkRect devRect = GrTest::TestRect(random);
-    return AAFillRectBatch::Create(color, viewMatrix, rect, devRect);
+    AAFillRectBatchNoLocalMatrix* batch = AAFillRectBatchNoLocalMatrix::Create();
+    AAFillRectBatchNoLocalMatrix::Geometry& geo = *batch->geometry();
+    geo.fColor = GrRandomColor(random);
+    geo.fViewMatrix = GrTest::TestMatrix(random);
+    geo.fRect = GrTest::TestRect(random);
+    geo.fDevRect = GrTest::TestRect(random);
+    batch->init();
+    return batch;
+}
+
+BATCH_TEST_DEFINE(AAFillRectBatchLocalMatrix) {
+    AAFillRectBatchLocalMatrix* batch = AAFillRectBatchLocalMatrix::Create();
+    AAFillRectBatchLocalMatrix::Geometry& geo = *batch->geometry();
+    geo.fColor = GrRandomColor(random);
+    geo.fViewMatrix = GrTest::TestMatrix(random);
+    geo.fLocalMatrix = GrTest::TestMatrix(random);
+    geo.fRect = GrTest::TestRect(random);
+    geo.fDevRect = GrTest::TestRect(random);
+    batch->init();
+    return batch;
 }
 
 #endif