Stop flattening GrCoordTransforms in parent GrFragmentProcessors.

src/gpu/batches/GrPLSPathRenderer.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 "GrPLSPathRenderer.h"
 
 #include "SkChunkAlloc.h"
@@ skipping 315 matching lines @@
             vsBuilder->codeAppendf("%s = vec2(%s.x - %s.x, %s.y - %s.y) * 0.5;",
                                    delta3.vsOut(), v3.vsOut(), v1.vsOut(), v1.vsOut(), v3.vsOut());
 
             GrGLSLVertToFrag windings(kInt_GrSLType);
             varyingHandler->addFlatVarying("windings", &windings, kLow_GrSLPrecision);
             vsBuilder->codeAppendf("%s = %s;",
                                    windings.vsOut(), te.inWindings()->fName);
 
             // emit transforms
             this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
-                                 te.inPosition()->fName, te.localMatrix(), args.fTransformsIn,
-                                 args.fTransformsOut);
+                                 te.inPosition()->fName, te.localMatrix(),
+                                 args.fFPCoordTransformHandler);
 
             GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
             SkAssertResult(fsBuilder->enableFeature(
                            GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
             SkAssertResult(fsBuilder->enableFeature(
                     GrGLSLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
             // Compute four subsamples, each shifted a quarter pixel along x and y from
             // gl_FragCoord. The oriented box positioning of the subsamples is of course not
             // optimal, but it greatly simplifies the math and this simplification is necessary for
@@ skipping 36 matching lines @@
 
         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrGLSLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const PLSAATriangleEffect& te = gp.cast<PLSAATriangleEffect>();
             uint32_t key = 0;
             key |= te.localMatrix().hasPerspective() ? 0x1 : 0x0;
             b->add32(key);
         }
 
-        virtual void setData(const GrGLSLProgramDataManager& pdman,
-                             const GrPrimitiveProcessor& gp) override {
-        }
-
-        void setTransformData(const GrPrimitiveProcessor& primProc,
-                              const GrGLSLProgramDataManager& pdman,
-                              int index,
-                              const SkTArray<const GrCoordTransform*, true>& transforms) override {
-            this->setTransformDataHelper(primProc.cast<PLSAATriangleEffect>().fLocalMatrix, pdman,
-                                         index, transforms);
+        void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& gp,
+                     FPCoordTransformIter&& transformIter) override {
+            this->setTransformDataHelper(gp.cast<PLSAATriangleEffect>().fLocalMatrix, pdman,
+                                         &transformIter);
         }
 
     private:
         typedef GrGLSLGeometryProcessor INHERITED;
     };
 
     virtual void getGLSLProcessorKey(const GrGLSLCaps& caps,
                                    GrProcessorKeyBuilder* b) const override {
         GLSLProcessor::GenKey(*this, caps, b);
     }
@@ skipping 101 matching lines @@
             GrGLSLVertToFrag windings(kInt_GrSLType);
             varyingHandler->addFlatVarying("windings", &windings, kLow_GrSLPrecision);
             vsBuilder->codeAppendf("%s = %s;",
                                    windings.vsOut(), qe.inWindings()->fName);
 
             // Setup position
             this->setupPosition(vsBuilder, gpArgs, qe.inPosition()->fName);
 
             // emit transforms
             this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
-                                 qe.inPosition()->fName, qe.localMatrix(), args.fTransformsIn,
-                                 args.fTransformsOut);
+                                 qe.inPosition()->fName, qe.localMatrix(),
+                                 args.fFPCoordTransformHandler);
 
             GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
             SkAssertResult(fsBuilder->enableFeature(
                            GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
             SkAssertResult(fsBuilder->enableFeature(
                     GrGLSLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             static const int QUAD_ARGS = 2;
             GrGLSLShaderVar inQuadArgs[QUAD_ARGS] = {
                 GrGLSLShaderVar("dot", kFloat_GrSLType, 0, kHigh_GrSLPrecision),
                 GrGLSLShaderVar("uv", kVec2f_GrSLType, 0, kHigh_GrSLPrecision)
@@ skipping 37 matching lines @@
 
         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrGLSLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const PLSQuadEdgeEffect& qee = gp.cast<PLSQuadEdgeEffect>();
             uint32_t key = 0;
             key |= qee.usesLocalCoords() && qee.localMatrix().hasPerspective() ? 0x1 : 0x0;
             b->add32(key);
         }
 
-        virtual void setData(const GrGLSLProgramDataManager& pdman,
-                             const GrPrimitiveProcessor& gp) override {
-        }
-
-        void setTransformData(const GrPrimitiveProcessor& primProc,
-                              const GrGLSLProgramDataManager& pdman,
-                              int index,
-                              const SkTArray<const GrCoordTransform*, true>& transforms) override {
-            this->setTransformDataHelper(primProc.cast<PLSQuadEdgeEffect>().fLocalMatrix, pdman,
-                                         index, transforms);
+        void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& gp,
+                             FPCoordTransformIter&& transformIter) override {
+            this->setTransformDataHelper(gp.cast<PLSQuadEdgeEffect>().fLocalMatrix, pdman,
+                                         &transformIter);
         }
 
     private:
         typedef GrGLSLGeometryProcessor INHERITED;
     };
 
     virtual void getGLSLProcessorKey(const GrGLSLCaps& caps,
                                    GrProcessorKeyBuilder* b) const override {
         GLSLProcessor::GenKey(*this, caps, b);
     }
@@ skipping 69 matching lines @@
             GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
             fUseEvenOdd = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                     kFloat_GrSLType, kLow_GrSLPrecision,
                                                     "useEvenOdd");
             const char* useEvenOdd = uniformHandler->getUniformCStr(fUseEvenOdd);
 
             varyingHandler->emitAttributes(fe);
             this->setupPosition(vsBuilder, gpArgs, fe.inPosition()->fName);
             this->emitTransforms(vsBuilder, varyingHandler, uniformHandler, gpArgs->fPositionVar,
-                                 fe.inPosition()->fName, fe.localMatrix(), args.fTransformsIn,
-                                 args.fTransformsOut);
+                                 fe.inPosition()->fName, fe.localMatrix(),
+                                 args.fFPCoordTransformHandler);
 
             GrGLSLPPFragmentBuilder* fsBuilder = args.fFragBuilder;
             SkAssertResult(fsBuilder->enableFeature(
                            GrGLSLFragmentShaderBuilder::kPixelLocalStorage_GLSLFeature));
             fsBuilder->declAppendf(GR_GL_PLS_PATH_DATA_DECL);
             fsBuilder->codeAppend("float coverage;");
             fsBuilder->codeAppendf("if (%s != 0.0) {", useEvenOdd);
             fsBuilder->codeAppend("coverage = float(abs(pls.windings[0]) % 2) * 0.25;");
             fsBuilder->codeAppend("coverage += float(abs(pls.windings[1]) % 2) * 0.25;");
             fsBuilder->codeAppend("coverage += float(abs(pls.windings[2]) % 2) * 0.25;");
@@ skipping 14 matching lines @@
 
         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrGLSLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const PLSFinishEffect& fe = gp.cast<PLSFinishEffect>();
             uint32_t key = 0;
             key |= fe.usesLocalCoords() && fe.localMatrix().hasPerspective() ? 0x1 : 0x0;
             b->add32(key);
         }
 
-        virtual void setData(const GrGLSLProgramDataManager& pdman,
-                             const GrPrimitiveProcessor& gp) override {
+        void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& gp,
+                     FPCoordTransformIter&& transformIter) override {
             const PLSFinishEffect& fe = gp.cast<PLSFinishEffect>();
             pdman.set1f(fUseEvenOdd, fe.fUseEvenOdd);
             if (fe.color() != fColor && !fe.colorIgnored()) {
                 GrGLfloat c[4];
                 GrColorToRGBAFloat(fe.color(), c);
                 pdman.set4fv(fColorUniform, 1, c);
                 fColor = fe.color();
             }
-        }
-
-        void setTransformData(const GrPrimitiveProcessor& primProc,
-                              const GrGLSLProgramDataManager& pdman,
-                              int index,
-                              const SkTArray<const GrCoordTransform*, true>& transforms) override {
-            this->setTransformDataHelper(primProc.cast<PLSFinishEffect>().fLocalMatrix, pdman,
-                                         index, transforms);
+            this->setTransformDataHelper(fe.fLocalMatrix, pdman, &transformIter);
         }
 
     private:
         GrColor fColor;
         UniformHandle fColorUniform;
         UniformHandle fUseEvenOdd;
 
         typedef GrGLSLGeometryProcessor INHERITED;
     };
 
@@ skipping 222 matching lines @@
 
 DRAW_BATCH_TEST_DEFINE(PLSPathBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix vm = GrTest::TestMatrixInvertible(random);
     SkPath path = GrTest::TestPathConvex(random);
 
     return new PLSPathBatch(color, path, vm);
 }
 
 #endif