All child GrFragmentProcs' transforms and textures will be stored in the root GrFragmentProc in pre…

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"
+#include "GrStagedProcessor.h"
 
 class GrCoordTransform;
 class GrGLSLCaps;
 class GrGLFragmentProcessor;
 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:
     GrFragmentProcessor()
         : INHERITED()
-        , fUsesLocalCoords(false) {}
+        , fUsesLocalCoords(false) {
+        SkDEBUGCODE(fIsChild = false;)
+    }
 
     /** Returns a new instance of the appropriate *GL* implementation class
         for the given GrFragmentProcessor; caller is responsible for deleting
         the object. */
     virtual GrGLFragmentProcessor* createGLInstance() const = 0;
 
     /** Human-meaningful string to identify this GrFragmentProcessor; may be embedded
         in generated shader code. */
     virtual const char* name() const = 0;
 
     void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
         this->onGetGLProcessorKey(caps, b);
         for (int i = 0; i < fChildProcessors.count(); ++i) {
-            fChildProcessors[i]->getGLProcessorKey(caps, b);
+            fChildProcessors[i].processor()->getGLProcessorKey(caps, b);
         }
     }
 
-    int numTransforms() const { return fCoordTransforms.count(); }
+    int numTextures() const override {
+        SkASSERT(!fIsChild);
+        return fTextureAccesses.count();
+    }
 
-    int numTransformsIncludeChildProcs() const {
-        int numTransforms = fCoordTransforms.count();
-        for (int i = 0; i < fChildProcessors.count(); ++i) {
-            numTransforms += fChildProcessors[i]->numTransformsIncludeChildProcs();
-        }
-        return numTransforms;
+    const GrTextureAccess& textureAccess(int index) const override {
+        SkASSERT(!fIsChild);
+        return *fTextureAccesses[index];
+    }
+
+    int numTransforms() const {
+        SkASSERT(!fIsChild);
+        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 GrCoordTransform& coordTransform(int index) const {
+        SkASSERT(!fIsChild);
+        return *fCoordTransforms[index];
+    }
 
     const SkTArray<const GrCoordTransform*, true>& coordTransforms() const {
+        SkASSERT(!fIsChild);
         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);
+        SkASSERT(!fIsChild);
+        if (!fCoordTransforms.empty()) {
+            outTransforms->push_back_n(fCoordTransforms.count(), fCoordTransforms.begin());
         }
     }
 
     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;
+    const GrFragmentProcessor& childProcessor(int index) const {
+        return *fChildProcessors[index].processor();
     }
 
     /** 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
@@ skipping 37 matching lines @@
      * processor subclass manages the lifetime of the transformations (this function only stores a
      * pointer). The GrCoordTransform is typically a member field of the GrProcessor subclass. 
      *
      * A processor subclass that has multiple methods of construction should always add its coord
      * transforms in a consistent order. The non-virtual implementation of isEqual() automatically
      * compares transforms and will assume they line up across the two processor instances.
      */
     void addCoordTransform(const GrCoordTransform*);
 
     /**
-     * FragmentProcessor subclasses call this to register any child FragmentProcessors they have.
+     * FragmentProcessor subclasses call this from their constructor to register any child
+     * FragmentProcessors they have.
      * This is for processors whose shader code will be composed of nested processors whose output
      * colors will be combined somehow to produce its output color.  Registering these child
-     * processors will allow the ProgramBuilder to automatically add their transformed coords and
-     * texture accesses and mangle their uniform and output color names and
+     * processors will allow the ProgramBuilder to automatically handle their transformed coords and
+     * texture accesses and mangle their uniform and output color names.
      */
-    void registerChildProcessor(GrFragmentProcessor* child);
+    int registerChildProcessor(GrFragmentProcessor* child);
 
     /**
      * Subclass implements this to support getConstantColorComponents(...).
      */
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
 
 private:
     /** Implemented using GLFragmentProcessor::GenKey as described in this class's comment. */
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const = 0;
 
     /**
      * Subclass implements this to support isEqual(). It will only be called if it is known that
      * 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;
+
+    /**
+     * This 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.
+     * The same goes for fTextureAccesses with textures.
+     */
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
-    bool                                         fUsesLocalCoords;
-    SkTArray<GrFragmentProcessor*, false>        fChildProcessors;
+
+    SkTArray<GrFragmentStage, false>             fChildProcessors;
+
+    SkDEBUGCODE(bool fIsChild;)

[joshualitt, 2015/08/12 14:49:52]

I think this has the same problem as the fIsParent

[wangyix, 2015/08/12 15:09:24]

Ok. This variable is no longer necessary if the children keep a copy of their
textures and transforms since that'll allow us to call numTextures(),
numTransforms(), etc on child procs, so no SkASSERT(!fIsChild) will be necessary
anywhere.

 
     typedef GrProcessor INHERITED;
 };
 
 #endif