Added fNumTransformsExclChildren and fNumTexturesExclChildren; changed emitChild() to forward search

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)
+        , fNumTexturesExclChildren(0)
+        , fNumTransformsExclChildren(0) {}
 
     GrGLFragmentProcessor* createGLInstance() const;
 
     /** 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].processor()->getGLProcessorKey(caps, b);
         }
     }
 
+    int numTexturesExclChildren() const { return fNumTexturesExclChildren; }

[tomhudson, 2015/08/18 19:36:11]

nit: abbreviation in API smells bad - but I can understand wanting the name
shorter, and aren't coming up with better alternatives

[bsalomon, 2015/08/19 14:22:17]

Nonrecursive?

I can't come up with anything I really like.

+
+    int numTransformsExclChildren() const { return fNumTransformsExclChildren; }
+
     int numTransforms() 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;
     }
 
@@ skipping 24 matching lines @@
      * 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.
      */
     void computeInvariantOutput(GrInvariantOutput* inout) const;
 
 protected:
+    void addTextureAccess(const GrTextureAccess* textureAccess) 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.
      *
      * When the transformation has perspective, the transformed coordinates will have
      * 3 components. Otherwise they'll have 2. 
      *
      * This must only be called from the constructor because GrProcessors are immutable. The
      * 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 from their constructor to register any child
-     * FragmentProcessors they have.
+     * FragmentProcessors they have. This must be called AFTER all texture accesses and coord
+     * transforms have been added.
      * 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 handle their transformed coords and
      * texture accesses and mangle their uniform and output color names.
      */
     int registerChildProcessor(const GrFragmentProcessor* child);
 
     /**
      * Subclass implements this to support getConstantColorComponents(...).
      *
@@ skipping 42 matching lines @@
      *                        [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.
      */
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
 
+    int                                          fNumTexturesExclChildren;
+    int                                          fNumTransformsExclChildren;
+
     SkTArray<GrFragmentStage, false>             fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif