Hide more GrBatch Geometry structs.

src/gpu/batches/GrAADistanceFieldPathRenderer.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 110 matching lines @@
 static const SkScalar kAntiAliasPad = 1.0f;
 
 class AADistanceFieldPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
     typedef GrAADistanceFieldPathRenderer::ShapeData ShapeData;
     typedef SkTDynamicHash<ShapeData, ShapeData::Key> ShapeCache;
     typedef GrAADistanceFieldPathRenderer::ShapeDataList ShapeDataList;
 
-    struct Geometry {
-        GrShape fShape;
-        GrColor fColor;
-        bool fAntiAlias;
-    };
+    AADistanceFieldPathBatch(GrColor color,
+                             const GrShape& shape,
+                             bool antiAlias,
+                             const SkMatrix& viewMatrix,
+                             GrBatchAtlas* atlas,
+                             ShapeCache* shapeCache, ShapeDataList* shapeList,
+                             bool gammaCorrect)
+            : INHERITED(ClassID()) {
+        SkASSERT(shape.hasUnstyledKey());
+        fBatch.fViewMatrix = viewMatrix;
+        fGeoData.emplace_back(Geometry{color, shape, antiAlias});
+        SkASSERT(fGeoData[0].fShape.hasUnstyledKey());
 
-    static GrDrawBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix,
-                               GrBatchAtlas* atlas, ShapeCache* shapeCache,
-                               ShapeDataList* shapeList, bool gammaCorrect) {
-        return new AADistanceFieldPathBatch(geometry, viewMatrix, atlas, shapeCache, shapeList,
-                                            gammaCorrect);
+        fAtlas = atlas;
+        fShapeCache = shapeCache;
+        fShapeList = shapeList;
+        fGammaCorrect = gammaCorrect;
+
+        // Compute bounds
+        fBounds = shape.bounds();
+        viewMatrix.mapRect(&fBounds);
     }
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
     }
@@ skipping 119 matching lines @@
                                     vertexStride,
                                     this->viewMatrix(),
                                     args.fShape,
                                     shapeData);
             flushInfo.fInstancesToFlush++;
         }
 
         this->flush(target, &flushInfo);
     }
 
-    AADistanceFieldPathBatch(const Geometry& geometry,
-                             const SkMatrix& viewMatrix,
-                             GrBatchAtlas* atlas,
-                             ShapeCache* shapeCache, ShapeDataList* shapeList,
-                             bool gammaCorrect)
-        : INHERITED(ClassID()) {
-        SkASSERT(geometry.fShape.hasUnstyledKey());
-        fBatch.fViewMatrix = viewMatrix;
-        fGeoData.push_back(geometry);
-        SkASSERT(fGeoData[0].fShape.hasUnstyledKey());
-
-        fAtlas = atlas;
-        fShapeCache = shapeCache;
-        fShapeList = shapeList;
-        fGammaCorrect = gammaCorrect;
-
-        // Compute bounds
-        fBounds = geometry.fShape.bounds();
-        viewMatrix.mapRect(&fBounds);
-    }
-
     bool addPathToAtlas(GrVertexBatch::Target* target,
                         FlushInfo* flushInfo,
                         GrBatchAtlas* atlas,
                         ShapeData* shapeData,
                         const GrShape& shape,
                         bool antiAlias,
                         uint32_t dimension,
                         SkScalar scale) const {
         const SkRect& bounds = shape.bounds();
 
@@ skipping 188 matching lines @@
         return true;
     }
 
     struct BatchTracker {
         SkMatrix fViewMatrix;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
+    struct Geometry {
+        GrColor fColor;
+        GrShape fShape;
+        bool fAntiAlias;
+    };
+
     BatchTracker fBatch;
     SkSTArray<1, Geometry> fGeoData;
     GrBatchAtlas* fAtlas;
     ShapeCache* fShapeCache;
     ShapeDataList* fShapeList;
     bool fGammaCorrect;
 
     typedef GrVertexBatch INHERITED;
 };
 
@@ skipping 10 matching lines @@
         fAtlas = args.fResourceProvider->createAtlas(kAlpha_8_GrPixelConfig,
                                                      ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT,
                                                      NUM_PLOTS_X, NUM_PLOTS_Y,
                                                      &GrAADistanceFieldPathRenderer::HandleEviction,
                                                      (void*)this);
         if (!fAtlas) {
             return false;
         }
     }
 
-    AADistanceFieldPathBatch::Geometry geometry;
-    geometry.fShape = *args.fShape;
-    geometry.fColor = args.fColor;
-    geometry.fAntiAlias = args.fAntiAlias;
-
-    SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry,
-                                                                     *args.fViewMatrix, fAtlas,
-                                                                     &fShapeCache, &fShapeList,
-                                                                     args.fGammaCorrect));
+    SkAutoTUnref<GrDrawBatch> batch(new AADistanceFieldPathBatch(args.fColor, *args.fShape,
+                                                                 args.fAntiAlias, *args.fViewMatrix,
+                                                                 fAtlas, &fShapeCache, &fShapeList,
+                                                                 args.fGammaCorrect));
 
     GrPipelineBuilder pipelineBuilder(*args.fPaint);
     pipelineBuilder.setUserStencil(args.fUserStencilSettings);
 
     args.fDrawContext->drawBatch(pipelineBuilder, *args.fClip, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 53 matching lines @@
                                                      ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT,
                                                      NUM_PLOTS_X, NUM_PLOTS_Y,
                                                      &PathTestStruct::HandleEviction,
                                                      (void*)&gTestStruct);
     }
 
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     bool gammaCorrect = random->nextBool();
 
-    AADistanceFieldPathBatch::Geometry geometry;
     // This path renderer only allows fill styles.
     GrShape shape(GrTest::TestPath(random), GrStyle::SimpleFill());
-    geometry.fShape = shape;
-    geometry.fColor = color;
-    geometry.fAntiAlias = random->nextBool();
+    bool antiAlias = random->nextBool();
 
-    return AADistanceFieldPathBatch::Create(geometry, viewMatrix,
-                                            gTestStruct.fAtlas,
-                                            &gTestStruct.fShapeCache,
-                                            &gTestStruct.fShapeList,
-                                            gammaCorrect);
+    return new AADistanceFieldPathBatch(color,
+                                        shape,
+                                        antiAlias,
+                                        viewMatrix,
+                                        gTestStruct.fAtlas,
+                                        &gTestStruct.fShapeCache,
+                                        &gTestStruct.fShapeList,
+                                        gammaCorrect);
 }
 
 #endif