Move StrokeRectBatches into .cpp files

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 25 matching lines @@
         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);
 }
 
-void GrAAStrokeRectBatch::initBatchTracker(const GrPipelineOptimizations& opt) {
+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);
+    }
+
+    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;
+
+    AAStrokeRectBatch(GrColor color, const SkMatrix& viewMatrix, const SkRect& devOutside,
+                      const SkRect& devOutsideAssist, const SkRect& devInside, bool miterStroke)
+        : INHERITED(ClassID()) {
+        fBatch.fViewMatrix = viewMatrix;
+        Geometry& geometry = fGeoData.push_back();
+        geometry.fColor = color;
+        geometry.fDevOutside = devOutside;
+        geometry.fDevOutsideAssist = devOutsideAssist;
+        geometry.fDevInside = devInside;
+        geometry.fMiterStroke = miterStroke;
+
+        // 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);
+    }
+
+
+    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; }
+
+    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;
+
+    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 GrAAStrokeRectBatch::onPrepareDraws(Target* target) {
+void AAStrokeRectBatch::onPrepareDraws(Target* target) {
     bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
     SkAutoTUnref<const GrGeometryProcessor> gp(create_stroke_rect_gp(canTweakAlphaForCoverage,
                                                                      this->viewMatrix(),
                                                                      this->usesLocalCoords(),
                                                                      this->coverageIgnored()));
     if (!gp) {
         SkDebugf("Couldn't create GrGeometryProcessor\n");
         return;
     }
@@ skipping 32 matching lines @@
                                            args.fColor,
                                            args.fDevOutside,
                                            args.fDevOutsideAssist,
                                            args.fDevInside,
                                            args.fMiterStroke,
                                            canTweakAlphaForCoverage);
     }
     helper.recordDraw(target);
 }
 
-const GrIndexBuffer* GrAAStrokeRectBatch::GetIndexBuffer(GrResourceProvider* resourceProvider,
-                                                         bool miterStroke) {
+const GrIndexBuffer* AAStrokeRectBatch::GetIndexBuffer(GrResourceProvider* resourceProvider,
+                                                       bool miterStroke) {
 
     if (miterStroke) {
         static const uint16_t gMiterIndices[] = {
             0 + 0, 1 + 0, 5 + 0, 5 + 0, 4 + 0, 0 + 0,
             1 + 0, 2 + 0, 6 + 0, 6 + 0, 5 + 0, 1 + 0,
             2 + 0, 3 + 0, 7 + 0, 7 + 0, 6 + 0, 2 + 0,
             3 + 0, 0 + 0, 4 + 0, 4 + 0, 7 + 0, 3 + 0,
 
             0 + 4, 1 + 4, 5 + 4, 5 + 4, 4 + 4, 0 + 4,
             1 + 4, 2 + 4, 6 + 4, 6 + 4, 5 + 4, 1 + 4,
@@ skipping 69 matching lines @@
         };
         GR_STATIC_ASSERT(SK_ARRAY_COUNT(gBevelIndices) == kBevelIndexCnt);
 
         GR_DEFINE_STATIC_UNIQUE_KEY(gBevelIndexBufferKey);
         return resourceProvider->findOrCreateInstancedIndexBuffer(gBevelIndices,
             kBevelIndexCnt, kNumBevelRectsInIndexBuffer, kBevelVertexCnt,
             gBevelIndexBufferKey);
     }
 }
 
-bool GrAAStrokeRectBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
-    GrAAStrokeRectBatch* that = t->cast<GrAAStrokeRectBatch>();
+bool AAStrokeRectBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
+    AAStrokeRectBatch* that = t->cast<AAStrokeRectBatch>();
 
     if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                 that->bounds(), caps)) {
         return false;
     }
 
     // TODO batch across miterstroke changes
     if (this->miterStroke() != that->miterStroke()) {
         return false;
     }
@@ skipping 12 matching lines @@
     }
 
     if (this->color() != that->color()) {
         fBatch.fColor = GrColor_ILLEGAL;
     }
     fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
     this->joinBounds(that->bounds());
     return true;
 }
 
-void GrAAStrokeRectBatch::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 {
+void AAStrokeRectBatch::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 {
     intptr_t verts = reinterpret_cast<intptr_t>(vertices) + offset;
 
     // We create vertices for four nested rectangles. There are two ramps from 0 to full
     // coverage, one on the exterior of the stroke and the other on the interior.
     // The following pointers refer to the four rects, from outermost to innermost.
     SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
     SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + outerVertexNum * vertexStride);
     SkPoint* fan2Pos = reinterpret_cast<SkPoint*>(verts + 2 * outerVertexNum * vertexStride);
     SkPoint* fan3Pos = reinterpret_cast<SkPoint*>(verts +
                                                   (2 * outerVertexNum + innerVertexNum) *
@@ skipping 82 matching lines @@
     for (int i = 0; i < innerVertexNum; ++i) {
         if (tweakAlphaForCoverage) {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
             *reinterpret_cast<GrColor*>(verts + i * vertexStride + sizeof(GrColor)) = 0;
         }
     }
 }
 
+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);
+}
+
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #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);
 
-    GrAAStrokeRectBatch::Geometry geo;
-    geo.fColor = GrRandomColor(random);
-    geo.fDevOutside = outside;
-    geo.fDevOutsideAssist = outsideAssist;
-    geo.fDevInside = inside;
-    geo.fMiterStroke = miterStroke;
+    GrColor color = GrRandomColor(random);
 
-    return GrAAStrokeRectBatch::Create(geo, GrTest::TestMatrix(random));
+    return GrAAStrokeRectBatch::Create(color, GrTest::TestMatrix(random), outside, outsideAssist,
+                                       inside, miterStroke);
 }
 
 #endif