Create append methods in batch namespaces

src/gpu/batches/GrNonAAStrokeRectBatch.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 "GrNonAAStrokeRectBatch.h"
 
 #include "GrBatchTest.h"
@@ skipping 30 matching lines @@
 public:
     DEFINE_BATCH_CLASS_ID
 
     struct Geometry {
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkScalar fStrokeWidth;
         GrColor fColor;
     };
 
-    static GrDrawBatch* Create(GrColor color, const SkMatrix& viewMatrix, const SkRect& rect,
-                               SkScalar strokeWidth, bool snapToPixelCenters) {
-        return new NonAAStrokeRectBatch(color, viewMatrix, rect, strokeWidth, snapToPixelCenters);
+    static NonAAStrokeRectBatch* Create() {
+        return new NonAAStrokeRectBatch;
     }
 
     const char* name() const override { return "GrStrokeRectBatch"; }
 
     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->setKnownSingleComponent(0xff);
     }
 
+    void append(GrColor color, const SkMatrix& viewMatrix, const SkRect& rect,
+                SkScalar strokeWidth) {
+        Geometry& geometry = fGeoData.push_back();
+        geometry.fViewMatrix = viewMatrix;
+        geometry.fRect = rect;
+        geometry.fStrokeWidth = strokeWidth;
+        geometry.fColor = color;
+    }
+
+    void appendAndUpdateBounds(GrColor color, const SkMatrix& viewMatrix, const SkRect& rect,
+                               SkScalar strokeWidth, bool snapToPixelCenters) {
+        this->append(color, viewMatrix, rect, strokeWidth);
+
+        SkRect bounds;
+        this->setupBounds(&bounds, fGeoData.back(), snapToPixelCenters);
+        this->joinBounds(bounds);
+    }
+
+    void init(bool snapToPixelCenters) {
+        const Geometry& geo = fGeoData[0];
+        fBatch.fHairline = geo.fStrokeWidth == 0;
+
+        // setup bounds
+        this->setupBounds(&fBounds, geo, snapToPixelCenters);
+    }
+
 private:
+    void setupBounds(SkRect* bounds, const Geometry& geo, bool snapToPixelCenters) {
+        *bounds = geo.fRect;
+        SkScalar rad = SkScalarHalf(geo.fStrokeWidth);
+        bounds->outset(rad, rad);
+        geo.fViewMatrix.mapRect(&fBounds);
+
+        // If our caller snaps to pixel centers then we have to round out the bounds
+        if (snapToPixelCenters) {
+            bounds->roundOut();
+        }
+    }
+
     void onPrepareDraws(Target* target) override {
         SkAutoTUnref<const GrGeometryProcessor> gp;
         {
             using namespace GrDefaultGeoProcFactory;
             Color color(this->color());
             Coverage coverage(this->coverageIgnored() ? Coverage::kSolid_Type :
                                                         Coverage::kNone_Type);
             LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
                                                               LocalCoords::kUnused_Type);
             gp.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords,
@@ skipping 54 matching lines @@
         }
         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();
     }
 
-    NonAAStrokeRectBatch(GrColor color, const SkMatrix& viewMatrix, const SkRect& rect,
-                         SkScalar strokeWidth, bool snapToPixelCenters)
-        : INHERITED(ClassID()) {
-        Geometry& geometry = fGeoData.push_back();
-        geometry.fViewMatrix = viewMatrix;
-        geometry.fRect = rect;
-        geometry.fStrokeWidth = strokeWidth;
-        geometry.fColor = color;
-
-        fBatch.fHairline = geometry.fStrokeWidth == 0;
-
-        fGeoData.push_back(geometry);
-
-        // setup bounds
-        fBounds = geometry.fRect;
-        SkScalar rad = SkScalarHalf(geometry.fStrokeWidth);
-        fBounds.outset(rad, rad);
-        geometry.fViewMatrix.mapRect(&fBounds);
-
-        // If our caller snaps to pixel centers then we have to round out the bounds
-        if (snapToPixelCenters) {
-            fBounds.roundOut();
-        }
-    }
+    NonAAStrokeRectBatch() : INHERITED(ClassID()) {}
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool hairline() const { return fBatch.fHairline; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps&) override {
         // if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(),
@@ skipping 24 matching lines @@
     typedef GrVertexBatch INHERITED;
 };
 
 namespace GrNonAAStrokeRectBatch {
 
 GrDrawBatch* Create(GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkRect& rect,
                     SkScalar strokeWidth,
                     bool snapToPixelCenters) {
-    return NonAAStrokeRectBatch::Create(color, viewMatrix, rect, strokeWidth, snapToPixelCenters);
+    NonAAStrokeRectBatch* batch = NonAAStrokeRectBatch::Create();
+    batch->append(color, viewMatrix, rect, strokeWidth);
+    batch->init(snapToPixelCenters);
+    return batch;
+}
+
+void Append(GrBatch* origBatch,
+            GrColor color,
+            const SkMatrix& viewMatrix,
+            const SkRect& rect,
+            SkScalar strokeWidth,
+            bool snapToPixelCenters) {
+    NonAAStrokeRectBatch* batch = origBatch->cast<NonAAStrokeRectBatch>();
+    batch->appendAndUpdateBounds(color, viewMatrix, rect, strokeWidth, snapToPixelCenters);
 }
 
 };
 
 #ifdef GR_TEST_UTILS
 
 DRAW_BATCH_TEST_DEFINE(NonAAStrokeRectBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     SkRect rect = GrTest::TestRect(random);
     SkScalar strokeWidth = random->nextBool() ? 0.0f : 1.0f;
 
-    return NonAAStrokeRectBatch::Create(color, viewMatrix, rect, strokeWidth, random->nextBool());
+    return GrNonAAStrokeRectBatch::Create(color, viewMatrix, rect, strokeWidth, random->nextBool());
 }
 
 #endif