Added class AutoFragmentChildProcAdvance to be constructed before a child emitCode and destructed a…

src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLFragmentShaderBuilder.h"
 #include "GrGLProgramBuilder.h"
 #include "gl/GrGLGpu.h"
@@ skipping 294 matching lines @@
     fSubstageIndices.back()++;
     fSubstageIndices.push_back(0);
     fMangleString.append(this->getMangleStringThisLevel());
 }
 
 void GrGLFragmentBuilder::onAfterChildProcEmitCode() {
     fSubstageIndices.pop_back();
     int removeAt = fMangleString.findLastOf('_');
     fMangleString.remove(removeAt, fMangleString.size() - removeAt);
 }
+
+GrGLFragmentBuilder::AutoFragmentChildProcAdvance::AutoFragmentChildProcAdvance(
+                                                    int childProcIndex,
+                                                    GrGLFPBuilder* builder,
+                                                    const GrFragmentProcessor& fp,
+                                                    const char* outputColor,
+                                                    const TransformedCoordsArray& coords,
+                                                    const TextureSamplerArray& samplers,
+                                                    const GrFragmentProcessor** childFp,
+                                                    SkString* childOutputColor,
+                                                    TransformedCoordsArray* childCoords,
+                                                    TextureSamplerArray* childSamplers
+                                                    ) {
+    fFsb = builder->getFragmentShaderBuilder();
+    fFsb->onBeforeChildProcEmitCode();  // call first so mangleString is updated
+
+    const GrFragmentProcessor& childProc = fp.childProcessor(childProcIndex);
+    *childFp = &childProc;
+
+    // Mangle the name of the outputColor
+    childOutputColor->set(outputColor);
+    childOutputColor->append(fFsb->getMangleStringThisLevel());
+
+    /*
+     * We now want to find the subset of coords and samplers that belong to the child and its
+     * descendants and put that into childCoords and childSamplers. To do so, we must do a
+     * backwards linear search on coords and samplers.
+     *
+     * Explanation:
+     * Each GrFragmentProcessor has a copy of all the transforms and textures of itself and
+     * all procs in its subtree. For 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. Each frag proc's transforms array
+     * contains its own transforms, followed by the transforms of all its descendants (i.e. preorder
+     * traversal). Suppose procs A, B, C, D, E, F have 1, 2, 1, 1, 3, 2 transforms respectively.
+     *
+     *                                   (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]
+     *
+     * So if we're inside proc A's emitCode, and A is about to call emitCode on proc B, we want the
+     * EmitArgs that's passed onto B to only contain its and its descendants' coords. The
+     * EmitArgs given to A would contain the transforms [a1,b1,b2,c1,d1,e1,e2,e3,f1,f2], and we want
+     * to extract the subset [b1,b2,c1] to pass on to B. We can do this with a backwards linear
+     * search since we know that D's subtree has 6 transforms and B's subtree has 3 transforms (by
+     * calling D.numTextures() and B.numTextures()), so we know the start of B's transforms is 9
+     * from the end of A's transforms.  We cannot do this with a forwards linear search since we
+     * don't know how many transforms belong to A (A.numTextures() will return 10, not 1), so
+     * we wouldn't know how many transforms to initially skip in A's array if using a forward linear
+     * search.
+     * Textures work the same way as transforms.
+     */
+    SkASSERT(childCoords->empty());
+    SkASSERT(childSamplers->empty());
+    int firstCoordAt = fp.numTransforms();
+    int firstSamplerAt = fp.numTextures();
+    for (int i = fp.numChildProcessors() - 1; i >= childProcIndex; --i) {
+        firstCoordAt -= fp.childProcessor(i).numTransforms();
+        firstSamplerAt -= fp.childProcessor(i).numTextures();
+    }
+    if (!coords.empty()) {
+        childCoords->push_back_n(childProc.numTransforms(), &coords[firstCoordAt]);
+    }
+    if (!samplers.empty()) {
+        childSamplers->push_back_n(childProc.numTextures(), &samplers[firstSamplerAt]);
+    }
+
+    fFsb->codeAppendf("vec4 %s;\n", childOutputColor->c_str());
+    fFsb->codeAppend("{\n");
+    fFsb->codeAppendf("// Child %d: %s\n", fFsb->getChildNumberThisLevel(), childProc.name());
+}
+
+GrGLFragmentBuilder::AutoFragmentChildProcAdvance::~AutoFragmentChildProcAdvance() {
+    fFsb->codeAppend("}\n");
+    fFsb->onAfterChildProcEmitCode();
+}