New API for computing optimization invariants.

src/gpu/batches/GrAAFillRectBatch.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 "GrAAFillRectBatch.h"
 
 #include "GrColor.h"
@@ skipping 28 matching lines @@
         4, 5, 6, 6, 7, 4,
     };
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFillAARectIdx) == kIndicesPerAAFillRect);
     return resourceProvider->findOrCreateInstancedIndexBuffer(gFillAARectIdx,
         kIndicesPerAAFillRect, kNumAAFillRectsInIndexBuffer, kVertsPerAAFillRect,
         gAAFillRectIndexBufferKey);
 }
 
 static const GrGeometryProcessor* create_fill_rect_gp(
                                        const SkMatrix& viewMatrix,
-                                       const GrPipelineOptimizations& opts,
+                                       const GrXPOverridesForBatch& overrides,
                                        GrDefaultGeoProcFactory::LocalCoords::Type localCoordsType) {
     using namespace GrDefaultGeoProcFactory;
 
     Color color(Color::kAttribute_Type);
     Coverage::Type coverageType;
     // TODO remove coverage if coverage is ignored
     /*if (coverageIgnored) {
         coverageType = Coverage::kNone_Type;
-    } else*/ if (opts.canTweakAlphaForCoverage()) {
+    } else*/ if (overrides.canTweakAlphaForCoverage()) {
         coverageType = Coverage::kSolid_Type;
     } else {
         coverageType = Coverage::kAttribute_Type;
     }
     Coverage coverage(coverageType);
 
     // We assume the caller has inverted the viewmatrix
     if (LocalCoords::kHasExplicit_Type == localCoordsType) {
         LocalCoords localCoords(localCoordsType);
         return GrDefaultGeoProcFactory::Create(color, coverage, localCoords, SkMatrix::I());
     } else {
-        LocalCoords localCoords(opts.readsLocalCoords() ? localCoordsType :
-                                                          LocalCoords::kUnused_Type);
+        LocalCoords localCoords(overrides.readsLocalCoords() ? localCoordsType :
+                                                               LocalCoords::kUnused_Type);
         return CreateForDeviceSpace(color, coverage, localCoords, viewMatrix);
     }
 }
 
 static void generate_aa_fill_rect_geometry(intptr_t verts,
                                            size_t vertexStride,
                                            GrColor color,
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rect,
                                            const SkRect& devRect,
-                                           const GrPipelineOptimizations& opts,
+                                           const GrXPOverridesForBatch& overrides,
                                            const SkMatrix* localMatrix) {
     SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts);
     SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vertexStride);
 
     SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1);
     inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height());
 
     if (viewMatrix.rectStaysRect()) {
         set_inset_fan(fan0Pos, vertexStride, devRect, -SK_ScalarHalf, -SK_ScalarHalf);
         set_inset_fan(fan1Pos, vertexStride, devRect, inset,  inset);
@@ skipping 40 matching lines @@
         if (!viewMatrix.invert(&invViewMatrix)) {
             SkASSERT(false);
             invViewMatrix = SkMatrix::I();
         }
         SkMatrix localCoordMatrix;
         localCoordMatrix.setConcat(*localMatrix, invViewMatrix);
         SkPoint* fan0Loc = reinterpret_cast<SkPoint*>(verts + sizeof(SkPoint) + sizeof(GrColor));
         localCoordMatrix.mapPointsWithStride(fan0Loc, fan0Pos, vertexStride, 8);
     }
 
-    bool tweakAlphaForCoverage = opts.canTweakAlphaForCoverage();
+    bool tweakAlphaForCoverage = overrides.canTweakAlphaForCoverage();
 
     // Make verts point to vertex color and then set all the color and coverage vertex attrs
     // values.
     verts += sizeof(SkPoint);
 
     // The coverage offset is always the last vertex attribute
     intptr_t coverageOffset = vertexStride - sizeof(GrColor) - sizeof(SkPoint);
     for (int i = 0; i < 4; ++i) {
         if (tweakAlphaForCoverage) {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0;
@@ skipping 66 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) {
         // We apply the viewmatrix to the rect points on the cpu.  However, if the pipeline uses
         // local coords then we won't be able to batch.  We could actually upload the viewmatrix
         // using vertex attributes in these cases, but haven't investigated that
-        return !opts.readsLocalCoords() || mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix);
+        return !overrides.readsLocalCoords() || mine.fViewMatrix.cheapEqualTo(theirs.fViewMatrix);
     }
 
     static const GrGeometryProcessor* CreateGP(const Geometry& geo,
-                                               const GrPipelineOptimizations& opts) {
+                                               const GrXPOverridesForBatch& overrides) {
         const GrGeometryProcessor* gp =
-                create_fill_rect_gp(geo.fViewMatrix, opts,
+                create_fill_rect_gp(geo.fViewMatrix, overrides,
                                     GrDefaultGeoProcFactory::LocalCoords::kUsePosition_Type);
 
-        SkASSERT(opts.canTweakAlphaForCoverage() ?
+        SkASSERT(overrides.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         return gp;
     }
 
     static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
-                          const GrPipelineOptimizations& opts) {
+                          const GrXPOverridesForBatch& overrides) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
-                                       geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, opts,
-                                       nullptr);
+                                       geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, 
+                                       overrides, nullptr);
     }
 };
 
 class AAFillRectBatchLocalMatrixImp : public AAFillRectBatchBase {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkMatrix fLocalMatrix;
         SkRect fRect;
         SkRect fDevRect;
         GrColor fColor;
     };
 
     static const char* Name() { return "AAFillRectBatchLocalMatrix"; }
 
     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&) {
+                           const GrXPOverridesForBatch& overrides) {
         return true;
     }
 
     static const GrGeometryProcessor* CreateGP(const Geometry& geo,
-                                               const GrPipelineOptimizations& opts) {
+                                               const GrXPOverridesForBatch& overrides) {
         const GrGeometryProcessor* gp =
-                create_fill_rect_gp(geo.fViewMatrix, opts,
+                create_fill_rect_gp(geo.fViewMatrix, overrides,
                                     GrDefaultGeoProcFactory::LocalCoords::kHasExplicit_Type);
 
-        SkASSERT(opts.canTweakAlphaForCoverage() ?
+        SkASSERT(overrides.canTweakAlphaForCoverage() ?
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  gp->getVertexStride() ==
                          sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordCoverage));
         return gp;
     }
 
     static void Tesselate(intptr_t vertices, size_t vertexStride, const Geometry& geo,
-                          const GrPipelineOptimizations& opts) {
+                          const GrXPOverridesForBatch& overrides) {
         generate_aa_fill_rect_geometry(vertices, vertexStride,
-                                       geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, opts,
-                                       &geo.fLocalMatrix);
+                                       geo.fColor, geo.fViewMatrix, geo.fRect, geo.fDevRect, 
+                                       overrides, &geo.fLocalMatrix);
     }
 };
 
 typedef GrTInstanceBatch<AAFillRectBatchNoLocalMatrixImp> AAFillRectBatchNoLocalMatrix;
 typedef GrTInstanceBatch<AAFillRectBatchLocalMatrixImp> AAFillRectBatchLocalMatrix;
 
 inline static void append_to_batch(AAFillRectBatchNoLocalMatrix* batch, GrColor color,
                                    const SkMatrix& viewMatrix, const SkRect& rect,
                                    const SkRect& devRect) {
     AAFillRectBatchNoLocalMatrix::Geometry& geo = batch->geoData()->push_back();
@@ skipping 99 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAFillRectBatchLocalMatrix) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkMatrix localMatrix = GrTest::TestMatrix(random);
     SkRect rect = GrTest::TestRect(random);
     SkRect devRect = GrTest::TestRect(random);
     return GrAAFillRectBatch::Create(color, viewMatrix, localMatrix, rect, devRect);
 }
 
 #endif