Stop flattening GrCoordTransforms in parent GrFragmentProcessors.

include/gpu/GrFragmentProcessor.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrFragmentProcessor_DEFINED
 #define GrFragmentProcessor_DEFINED
 
 #include "GrProcessor.h"
 
 class GrCoordTransform;
 class GrGLSLCaps;
 class GrGLSLFragmentProcessor;
 class GrInvariantOutput;
+class GrPipeline;
 class GrProcessorKeyBuilder;
 
 /** Provides custom fragment shader code. Fragment processors receive an input color (vec4f) and
     produce an output color. They may reference textures and uniforms. They may use
     GrCoordTransforms to receive a transformation of the local coordinates that map from local space
     to the fragment being processed.
  */
 class GrFragmentProcessor : public GrProcessor {
 public:
     /**
@@ skipping 34 matching lines @@
      *
      * The array elements with be moved.
      */
     static sk_sp<GrFragmentProcessor> RunInSeries(sk_sp<GrFragmentProcessor>*, int cnt);
 
     GrFragmentProcessor()
         : INHERITED()
         , fUsesDistanceVectorField(false)
         , fUsesLocalCoords(false)
         , fNumTexturesExclChildren(0)
-        , fNumBuffersExclChildren(0)
-        , fNumTransformsExclChildren(0) {}
+        , fNumBuffersExclChildren(0) {}
 
     ~GrFragmentProcessor() override;
 
     GrGLSLFragmentProcessor* createGLSLInstance() const;
 
     void getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
         this->onGetGLSLProcessorKey(caps, b);
         for (int i = 0; i < fChildProcessors.count(); ++i) {
             fChildProcessors[i]->getGLSLProcessorKey(caps, b);
         }
     }
 
     int numTexturesExclChildren() const { return fNumTexturesExclChildren; }
 
     int numBuffersExclChildren() const { return fNumBuffersExclChildren; }
 
-    int numTransformsExclChildren() const { return fNumTransformsExclChildren; }
-
-    int numTransforms() const { return fCoordTransforms.count(); }
+    int numCoordTransforms() const { return fCoordTransforms.count(); }
 
     /** Returns the coordinate transformation at index. index must be valid according to
         numTransforms(). */
     const GrCoordTransform& coordTransform(int index) const { return *fCoordTransforms[index]; }
 
     const SkTArray<const GrCoordTransform*, true>& coordTransforms() const {
         return fCoordTransforms;
     }
 
     void gatherCoordTransforms(SkTArray<const GrCoordTransform*, true>* outTransforms) const {
@@ skipping 26 matching lines @@
      * indicate whether the input components to this processor in the FS will have known values.
      * In inout the validFlags member is a bitfield of GrColorComponentFlags. The isSingleComponent
      * member indicates whether the input will be 1 or 4 bytes. The function updates the members of
      * inout to indicate known values of its output. A component of the color member only has
      * meaning if the corresponding bit in validFlags is set.
      */
     void computeInvariantOutput(GrInvariantOutput* inout) const {
         this->onComputeInvariantOutput(inout);
     }
 
+    /**

[robertphillips, 2016/09/15 20:44:30]

or a the ?

[bsalomon, 2016/09/15 20:55:52]

should be "or of the forest of FPs..."

+     * Pre-order traversal of a FP hierarchy, or a the forest of FPs in a GrPipeline. In the latter
+     * case the tree rooted at each FP in the GrPipeline is visited successively.
+     * */
+    class Iter : public SkNoncopyable {
+    public:
+        explicit Iter(const GrFragmentProcessor* fp) { fFPStack.push_back(fp); }
+        explicit Iter(const GrPipeline& pipeline);
+        const GrFragmentProcessor* next();
+
+    private:
+        SkSTArray<4, const GrFragmentProcessor*, true> fFPStack;
+    };
+
+    /**
+     * Iterates over all the GrCoordTransforms in a GrPipeline's GrFragmentProcessors. FPs are
+     * visited in the same order as Iter and each of an FP's coord transforms are visited linearly.
+     */
+    class CoordTransformIter : public SkNoncopyable {
+    public:
+        explicit CoordTransformIter(const GrPipeline& pipeline)
+                : fCurrFP(nullptr)
+                , fCTIdx(0)
+                , fFPIter(pipeline) {
+            fCurrFP = fFPIter.next();
+        }
+        const GrCoordTransform* next();
+
+    private:
+        const GrFragmentProcessor*  fCurrFP;
+        int                         fCTIdx;
+        GrFragmentProcessor::Iter   fFPIter;
+    };
+
 protected:
     void addTextureAccess(const GrTextureAccess* textureAccess) override;
     void addBufferAccess(const GrBufferAccess*) override;
 
     /**
      * Fragment Processor subclasses call this from their constructor to register coordinate
      * transformations. Coord transforms provide a mechanism for a processor to receive coordinates
      * in their FS code. The matrix expresses a transformation from local space. For a given
      * fragment the matrix will be applied to the local coordinate that maps to the fragment.
      *
@@ skipping 51 matching lines @@
      * the two processors are of the same subclass (i.e. they return the same object from
      * getFactory()). The processor subclass should not compare its coord transforms as that will
      * be performed automatically in the non-virtual isEqual().
      */
     virtual bool onIsEqual(const GrFragmentProcessor&) const = 0;
 
     bool hasSameTransforms(const GrFragmentProcessor&) const;
 
     bool                                       fUsesLocalCoords;
 
+    SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
+
     /**
-     * fCoordTransforms stores the transforms of this proc, followed by all the transforms of this
-     * proc's children. In other words, each proc stores all the transforms of its subtree as if
+     * A processor stores the texture accesses of this proc, followed by all the accesses of this
+     * proc's children. In other words, each proc stores all the accesses of its subtree as if
      * they were collected using preorder traversal.
      *
      * Example:
      * Suppose we have frag proc A, who has two children B and D. B has a child C, and D has
-     * two children E and F. Suppose procs A, B, C, D, E, F have 1, 2, 1, 1, 3, 2 transforms
-     * respectively. The following shows what the fCoordTransforms array of each proc would contain:
+     * two children E and F. Suppose procs A, B, C, D, E, F have 1, 2, 1, 1, 3, 2 accesses
+     * respectively. The following shows what the array of each proc's texture accesses would
+     * contain:
      *
      *                                   (A)
      *                        [a1,b1,b2,c1,d1,e1,e2,e3,f1,f2]
      *                                  /    \
      *                                /        \
      *                            (B)           (D)
      *                        [b1,b2,c1]   [d1,e1,e2,e3,f1,f2]
      *                          /             /    \
      *                        /             /        \
      *                      (C)          (E)          (F)
      *                     [c1]      [e1,e2,e3]      [f1,f2]
      *
-     * The same goes for fTextureAccesses with textures.
+     * The same goes for buffer accesses.
      */
-    SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
     int                                         fNumTexturesExclChildren;
     int                                         fNumBuffersExclChildren;
-    int                                         fNumTransformsExclChildren;
 
     /**
      * This is not SkSTArray<1, sk_sp<GrFragmentProcessor>> because this class holds strong
      * references until notifyRefCntIsZero and then it holds pending executions.
      */
     SkSTArray<1, GrFragmentProcessor*, true>    fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif