Added registerChild; transforms, textures, glKey automatically handled.

src/gpu/gl/builders/GrGLProgramBuilder.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 "GrGLProgramBuilder.h"
 
 #include "gl/GrGLGeometryProcessor.h"
@@ skipping 161 matching lines @@
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
 const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
+template <>
+void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor,

[joshualitt, 2015/08/03 14:06:02]

This should be GrFragmentProcessor& so it doesn't instantiate for GrProcessor
base class.  Also, can we make this call the general template, and then just
call itself recursively?  I think we can try upcasting to GrProcessor base
class, or something similar.

[wangyix, 2015/08/03 16:12:47]

Removed this function for the time being; Was discussed.

+                                      GrGLProcessor::TextureSamplerArray* outSamplers,
+                                      GrGLInstalledProc<GrGLFragmentProcessor>* ifp) {
+    SkDEBUGCODE(ifp->fSamplersIdx = fSamplerUniforms.count();)
+    int numTextures = processor.numTextures();
+    int samplerUniformsOffset = fSamplerUniforms.count();
+    UniformHandle* localSamplerUniforms = fSamplerUniforms.push_back_n(numTextures);
+    SkString name;
+    for (int t = 0; t < numTextures; ++t) {
+        name.printf("Sampler%d", samplerUniformsOffset + t);
+        localSamplerUniforms[t] = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                                   kSampler2D_GrSLType, kDefault_GrSLPrecision,
+                                                   name.c_str());
+        SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLProcessor::TextureSampler,
+                               (localSamplerUniforms[t], processor.textureAccess(t)));
+    }
+
+    // recursively emit the samplers of this processor's child processors
+    const GrFragmentProcessor& fp = processor.cast<GrFragmentProcessor>();
+    for (int i = 0; i < fp.numChildProcessors(); ++i) {
+        this->emitSamplers(*fp.childProcessor(i), outSamplers, ifp);
+    }
+}
+
+void appendGrFPCoordTransforms(const GrFragmentProcessor* processor,

[joshualitt, 2015/08/03 14:06:02]

static void append_gr_fp_coord_transforms

[wangyix, 2015/08/03 16:12:47]

Done.

+                              SkTArray<const GrCoordTransform*, true>* procCoords) {
+    // add the coord transforms of this processor
+    for (int i = 0; i < processor->numTransforms(); ++i) {
+        procCoords->push_back(&processor->coordTransform(i));
+    }
+    // recursively add the coord transforms of this processor's child processors
+    for (int i = 0; i < processor->numChildProcessors(); ++i) {
+        appendGrFPCoordTransforms(processor->childProcessor(i), procCoords);
+    }
+}
+
 bool GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage) {
     // First we loop over all of the installed processors and collect coord transforms.  These will
     // be sent to the GrGLPrimitiveProcessor in its emitCode function
     const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
     int totalTextures = primProc.numTextures();
     const int maxTextureUnits = fGpu->glCaps().maxFragmentTextureUnits();
     SkSTArray<8, GrGLProcessor::TransformedCoordsArray> outCoords;
     for (int i = 0; i < this->pipeline().numFragmentStages(); i++) {
         const GrFragmentProcessor* processor = this->pipeline().getFragmentStage(i).processor();
         SkSTArray<2, const GrCoordTransform*, true>& procCoords = fCoordTransforms.push_back();
-        for (int t = 0; t < processor->numTransforms(); t++) {
-            procCoords.push_back(&processor->coordTransform(t));
-        }
 
-        totalTextures += processor->numTextures();
+        appendGrFPCoordTransforms(processor, &procCoords);
+
+        totalTextures += processor->numTexturesIncludeChildProcs();
         if (totalTextures >= maxTextureUnits) {
             GrCapsDebugf(fGpu->caps(), "Program would use too many texture units\n");
             return false;
         }
     }
 
     this->emitAndInstallProc(primProc, inputColor, inputCoverage);
 
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
     int numProcs = this->pipeline().numFragmentStages();
@@ skipping 70 matching lines @@
 
 void GrGLProgramBuilder::emitAndInstallProc(const GrPendingFragmentStage& fs,
                                             int index,
                                             const char* outColor,
                                             const char* inColor) {
     GrGLInstalledFragProc* ifp = SkNEW(GrGLInstalledFragProc);
 
     const GrFragmentProcessor& fp = *fs.processor();
     ifp->fGLProc.reset(fp.createGLInstance());
 
-    SkSTArray<4, GrGLProcessor::TextureSampler> samplers(fp.numTextures());
+    SkSTArray<4, GrGLProcessor::TextureSampler> samplers(fp.numTexturesIncludeChildProcs());
     this->emitSamplers(fp, &samplers, ifp);
 
     GrGLFragmentProcessor::EmitArgs args(this, fp, outColor, inColor, fOutCoords[index], samplers);
     ifp->fGLProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(fp);
     fFragmentProcessors->fProcs.push_back(ifp);
 }
@@ skipping 63 matching lines @@
 
 void GrGLProgramBuilder::verify(const GrXferProcessor& xp) {
     SkASSERT(fFS.hasReadDstColor() == xp.willReadDstColor());
 }
 
 void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) {
     SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
 }
 
 template <class Proc>
 void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor,

[joshualitt, 2015/08/03 14:06:02]

This should be Proc& processor

[wangyix, 2015/08/03 16:12:47]

Didn't do this; Was discussed.

                                       GrGLProcessor::TextureSamplerArray* outSamplers,
                                       GrGLInstalledProc<Proc>* ip) {
     SkDEBUGCODE(ip->fSamplersIdx = fSamplerUniforms.count();)
     int numTextures = processor.numTextures();
     UniformHandle* localSamplerUniforms = fSamplerUniforms.push_back_n(numTextures);
     SkString name;
     for (int t = 0; t < numTextures; ++t) {
         name.printf("Sampler%d", t);
         localSamplerUniforms[t] = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                    kSampler2D_GrSLType, kDefault_GrSLPrecision,
@@ skipping 115 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }