Expose coord transforms from GrPipeline

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
 
@@ skipping 42 matching lines @@
     }
 
     /** 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;
     }
 
+    /** Gather the coord transforms into an array. We use preorder traversal */
+    void gatherCoordTransforms(SkTArray<const GrCoordTransform*, true>* outTransforms) const {
+        SkASSERT(outTransforms);
+        outTransforms->push_back_n(fCoordTransforms.count(), fCoordTransforms.begin());
+        for (int i = 0; i < fChildProcessors.count(); ++i) {
+            fChildProcessors[i]->gatherCoordTransforms(outTransforms);
+        }
+    }
+
     int numChildProcessors() const { return fChildProcessors.count(); }
 
     GrFragmentProcessor* childProcessor(int index) const { return fChildProcessors[index]; }
 
     const SkTArray<GrFragmentProcessor*, false>& childProcessors() const {
         return fChildProcessors;
     }
 
     int numTexturesIncludeChildProcs() const {
         int numTextures = this->numTextures();
         for (int i = 0; i < fChildProcessors.count(); ++i) {
             numTextures += fChildProcessors[i]->numTexturesIncludeChildProcs();
         }
         return numTextures;
     }
 
     /** Do any of the coordtransforms for this processor require local coords? */
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
     /** Returns true if this and other processor conservatively draw identically. It can only return
         true when the two processor are of the same subclass (i.e. they return the same object from
         from getFactory()).
 
         A return value of true from isEqual() should not be used to test whether the processor would
         generate the same shader code. To test for identical code generation use getGLProcessorKey*/
-    bool isEqual(const GrFragmentProcessor& that) const {
+    bool isEqual(const GrFragmentProcessor& that, bool ignoreCoordTransforms) const {
         if (this->classID() != that.classID() ||
-            !this->hasSameTransforms(that) ||
             !this->hasSameTextureAccesses(that)) {
             return false;
         }
+        if (ignoreCoordTransforms) {
+            if (this->numTransforms() != that.numTransforms()) {
+                return false;
+            }
+        } else if (!this->hasSameTransforms(that)) {
+            return false;
+        }
         return this->onIsEqual(that);
     }
 
     /**
      * This function is used to perform optimizations. When called the invarientOuput param
      * 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.
@@ skipping 50 matching lines @@
     bool hasSameTransforms(const GrFragmentProcessor&) const;
 
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
     bool                                         fUsesLocalCoords;
     SkTArray<GrFragmentProcessor*, false>        fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif