New API for computing optimization invariants.

src/gpu/batches/GrNonAAFillRectBatch.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 "GrNonAAFillRectBatch.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 116 matching lines @@
     static SkString DumpInfo(const Geometry& geo, int index) {
         SkString str;
         str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
                     index,
                     geo.fColor,
                     geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
         return str;
     }
 
     static bool CanCombine(const Geometry& mine, const Geometry& theirs,
-                           const GrPipelineOptimizations& opts) {
+                           const GrXPOverridesForBatch& overrides) {
         return true;
     }
 
     static const GrGeometryProcessor* CreateGP(const Geometry& geo,
-                                               const GrPipelineOptimizations& opts) {
-        const GrGeometryProcessor* gp = create_gp(geo.fViewMatrix, opts.readsCoverage(), true,
+                                               const GrXPOverridesForBatch& overrides) {
+        const GrGeometryProcessor* gp = create_gp(geo.fViewMatrix, overrides.readsCoverage(), true,
                                                   nullptr);
 
         SkASSERT(gp->getVertexStride() ==
                 sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr));
         return gp;
     }
 
     static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
-                          const GrPipelineOptimizations& opts) {
+                          const GrXPOverridesForBatch& overrides) {
         tesselate(vertices, vertexStride, geo.fColor, geo.fViewMatrix, geo.fRect, &geo.fLocalQuad);
     }
 };
 
 // We handle perspective in the local matrix or viewmatrix with special batches
 class NonAAFillRectBatchPerspectiveImp : public NonAAFillRectBatchBase {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkMatrix fLocalMatrix;
         SkRect fRect;
         SkRect fLocalRect;
         GrColor fColor;
         bool fHasLocalMatrix;
         bool fHasLocalRect;
     };
 
     static const char* Name() { return "NonAAFillRectBatchPerspective"; }
 
     static SkString DumpInfo(const Geometry& geo, int index) {
         SkString str;
         str.appendf("%d: Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f]\n",
                     index,
                     geo.fColor,
                     geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
         return str;
     }
 
     static bool CanCombine(const Geometry& mine, const Geometry& theirs,
-                           const GrPipelineOptimizations& opts) {
+                           const GrXPOverridesForBatch& overrides) {
         // We could batch across perspective vm changes if we really wanted to
         return mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix) &&
                mine.fHasLocalRect == theirs.fHasLocalRect &&
                (!mine.fHasLocalMatrix || mine.fLocalMatrix.cheapEqualTo(theirs.fLocalMatrix));
     }
 
     static const GrGeometryProcessor* CreateGP(const Geometry& geo,
-                                               const GrPipelineOptimizations& opts) {
-        const GrGeometryProcessor* gp = create_gp(geo.fViewMatrix, opts.readsCoverage(),
+                                               const GrXPOverridesForBatch& overrides) {
+        const GrGeometryProcessor* gp = create_gp(geo.fViewMatrix, overrides.readsCoverage(),
                                                   geo.fHasLocalRect,
                                                   geo.fHasLocalMatrix ? &geo.fLocalMatrix :
                                                                         nullptr);
 
         SkASSERT(geo.fHasLocalRect ?
              gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
              gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
         return gp;
     }
 
     static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
-                          const GrPipelineOptimizations& opts) {
+                          const GrXPOverridesForBatch& overrides) {
         if (geo.fHasLocalRect) {
             GrQuad quad(geo.fLocalRect);
             tesselate(vertices, vertexStride, geo.fColor, geo.fViewMatrix, geo.fRect, &quad);
         } else {
             tesselate(vertices, vertexStride, geo.fColor, geo.fViewMatrix, geo.fRect, nullptr);
         }
     }
 };
 
 typedef GrTInstanceBatch<NonAAFillRectBatchImp> NonAAFillRectBatchSimple;
@@ skipping 115 matching lines @@
     SkMatrix localMatrix = GrTest::TestMatrix(random);
 
     bool hasLocalRect = random->nextBool();
     bool hasLocalMatrix = random->nextBool();
     return GrNonAAFillRectBatch::Create(color, viewMatrix, rect,
                                         hasLocalRect ? &localRect : nullptr,
                                         hasLocalMatrix ? &localMatrix : nullptr);
 }
 
 #endif