Create append methods in batch namespaces

src/gpu/batches/GrAAStrokeRectBatch.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 "GrAAStrokeRectBatch.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 35 matching lines @@
 class AAStrokeRectBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     // TODO support AA rotated stroke rects by copying around view matrices
     struct Geometry {
         SkRect fDevOutside;
         SkRect fDevOutsideAssist;
         SkRect fDevInside;
         GrColor fColor;
-        bool fMiterStroke;
     };
 
-    static GrDrawBatch* Create(GrColor color, const SkMatrix& viewMatrix, const SkRect& devOutside,
-                               const SkRect& devOutsideAssist, const SkRect& devInside,
-                               bool miterStroke) {
-        return new AAStrokeRectBatch(color, viewMatrix, devOutside, devOutsideAssist, devInside,
-                                     miterStroke);
+    static AAStrokeRectBatch* Create(const SkMatrix& viewMatrix, bool miterStroke) {
+        return new AAStrokeRectBatch(viewMatrix, miterStroke);
     }
 
     const char* name() const override { return "AAStrokeRect"; }
 
     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();
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
-private:
-    void onPrepareDraws(Target*) override;
-    void initBatchTracker(const GrPipelineOptimizations&) override;
+    bool canAppend(const SkMatrix& viewMatrix, bool miterStroke) {
+        return fViewMatrix.cheapEqualTo(viewMatrix) && fMiterStroke == miterStroke;
+    }
 
-    AAStrokeRectBatch(GrColor color, const SkMatrix& viewMatrix, const SkRect& devOutside,
-                      const SkRect& devOutsideAssist, const SkRect& devInside, bool miterStroke)
-        : INHERITED(ClassID()) {
-        fBatch.fViewMatrix = viewMatrix;
+    void append(GrColor color, const SkRect& devOutside, const SkRect& devOutsideAssist,
+                const SkRect& devInside) {
         Geometry& geometry = fGeoData.push_back();
         geometry.fColor = color;
         geometry.fDevOutside = devOutside;
         geometry.fDevOutsideAssist = devOutsideAssist;
         geometry.fDevInside = devInside;
-        geometry.fMiterStroke = miterStroke;
+    }
 
+    void appendAndUpdateBounds(GrColor color, const SkRect& devOutside,
+                               const SkRect& devOutsideAssist, const SkRect& devInside) {
+        this->append(color, devOutside, devOutsideAssist, devInside);
+
+        SkRect bounds;
+        this->updateBounds(&bounds, fGeoData.back());
+        this->joinBounds(bounds);
+    }
+
+    void init() { this->updateBounds(&fBounds, fGeoData[0]); }
+
+private:
+    void updateBounds(SkRect* bounds, const Geometry& geo) {
         // If we have miterstroke then we inset devOutside and outset devOutsideAssist, so we need
         // the join for proper bounds
-        fBounds = geometry.fDevOutside;
-        fBounds.join(geometry.fDevOutsideAssist);
+        *bounds = geo.fDevOutside;
+        bounds->join(geo.fDevOutsideAssist);
     }
 
+    void onPrepareDraws(Target*) override;
+    void initBatchTracker(const GrPipelineOptimizations&) override;
+
+    AAStrokeRectBatch(const SkMatrix& viewMatrix,bool miterStroke)
+        : INHERITED(ClassID()) {
+        fViewMatrix = viewMatrix;
+        fMiterStroke = miterStroke;
+    }
 
     static const int kMiterIndexCnt = 3 * 24;
     static const int kMiterVertexCnt = 16;
     static const int kNumMiterRectsInIndexBuffer = 256;
 
     static const int kBevelIndexCnt = 48 + 36 + 24;
     static const int kBevelVertexCnt = 24;
     static const int kNumBevelRectsInIndexBuffer = 256;
 
     static const GrIndexBuffer* GetIndexBuffer(GrResourceProvider* resourceProvider,
                                                bool miterStroke);
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool canTweakAlphaForCoverage() const { return fBatch.fCanTweakAlphaForCoverage; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
-    const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
-    bool miterStroke() const { return fBatch.fMiterStroke; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
+    const Geometry& geometry() const { return fGeoData[0]; }
+    const SkMatrix& viewMatrix() const { return fViewMatrix; }
+    bool miterStroke() const { return fMiterStroke; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps&) override;
 
     void generateAAStrokeRectGeometry(void* vertices,
                                       size_t offset,
                                       size_t vertexStride,
                                       int outerVertexNum,
                                       int innerVertexNum,
                                       GrColor color,
                                       const SkRect& devOutside,
                                       const SkRect& devOutsideAssist,
                                       const SkRect& devInside,
                                       bool miterStroke,
                                       bool tweakAlphaForCoverage) const;
 
     struct BatchTracker {
-        SkMatrix fViewMatrix;
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
-        bool fMiterStroke;
         bool fCanTweakAlphaForCoverage;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
+    SkMatrix fViewMatrix;
+    bool fMiterStroke;
 
     typedef GrVertexBatch INHERITED;
 };
 
 void AAStrokeRectBatch::initBatchTracker(const GrPipelineOptimizations& opt) {
     // Handle any color overrides
     if (!opt.readsColor()) {
         fGeoData[0].fColor = GrColor_ILLEGAL;
     }
     opt.getOverrideColorIfSet(&fGeoData[0].fColor);
 
     // setup batch properties
     fBatch.fColorIgnored = !opt.readsColor();
     fBatch.fColor = fGeoData[0].fColor;
     fBatch.fUsesLocalCoords = opt.readsLocalCoords();
     fBatch.fCoverageIgnored = !opt.readsCoverage();
-    fBatch.fMiterStroke = fGeoData[0].fMiterStroke;
     fBatch.fCanTweakAlphaForCoverage = opt.canTweakAlphaForCoverage();
 }
 
 void AAStrokeRectBatch::onPrepareDraws(Target* target) {
     bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
     SkAutoTUnref<const GrGeometryProcessor> gp(create_stroke_rect_gp(canTweakAlphaForCoverage,
                                                                      this->viewMatrix(),
                                                                      this->usesLocalCoords(),
                                                                      this->coverageIgnored()));
@@ skipping 30 matching lines @@
         const Geometry& args = fGeoData[i];
         this->generateAAStrokeRectGeometry(vertices,
                                            i * verticesPerInstance * vertexStride,
                                            vertexStride,
                                            outerVertexNum,
                                            innerVertexNum,
                                            args.fColor,
                                            args.fDevOutside,
                                            args.fDevOutsideAssist,
                                            args.fDevInside,
-                                           args.fMiterStroke,
+                                           fMiterStroke,
                                            canTweakAlphaForCoverage);
     }
     helper.recordDraw(target);
 }
 
 const GrIndexBuffer* AAStrokeRectBatch::GetIndexBuffer(GrResourceProvider* resourceProvider,
                                                        bool miterStroke) {
 
     if (miterStroke) {
         static const uint16_t gMiterIndices[] = {
@@ skipping 231 matching lines @@
 }
 
 namespace GrAAStrokeRectBatch {
 
 GrDrawBatch* Create(GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkRect& devOutside,
                     const SkRect& devOutsideAssist,
                     const SkRect& devInside,
                     bool miterStroke) {
-    return AAStrokeRectBatch::Create(color, viewMatrix, devOutside, devOutsideAssist, devInside,
-                                     miterStroke);
+    AAStrokeRectBatch* batch = AAStrokeRectBatch::Create(viewMatrix, miterStroke);
+    batch->append(color, devOutside, devOutsideAssist, devInside);
+    batch->init();
+    return batch;
+}
+
+bool Append(GrBatch* origBatch,
+            GrColor color,
+            const SkMatrix& viewMatrix,
+            const SkRect& devOutside,
+            const SkRect& devOutsideAssist,
+            const SkRect& devInside,
+            bool miterStroke) {
+    AAStrokeRectBatch* batch = origBatch->cast<AAStrokeRectBatch>();
+
+    // we can't batch across vm changes
+    if (!batch->canAppend(viewMatrix, miterStroke)) {
+        return false;
+    }
+
+    batch->appendAndUpdateBounds(color, devOutside, devOutsideAssist, devInside);
+    return true;
 }
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 #include "GrBatchTest.h"
 
 DRAW_BATCH_TEST_DEFINE(AAStrokeRectBatch) {
     bool miterStroke = random->nextBool();
 
     // Create mock stroke rect
     SkRect outside = GrTest::TestRect(random);
     SkScalar minDim = SkMinScalar(outside.width(), outside.height());
     SkScalar strokeWidth = minDim * 0.1f;
     SkRect outsideAssist = outside;
     outsideAssist.outset(strokeWidth, strokeWidth);
     SkRect inside = outside;
     inside.inset(strokeWidth, strokeWidth);
 
     GrColor color = GrRandomColor(random);
 
     return GrAAStrokeRectBatch::Create(color, GrTest::TestMatrix(random), outside, outsideAssist,
                                        inside, miterStroke);
 }
 
 #endif