Move loops that chain together effects into GrGLShaderBuilder from GrGLProgram.

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 467 matching lines @@
     // Get the coeffs for the Mode-based color filter, determine if color is needed.
     SkXfermode::Coeff colorCoeff;
     SkXfermode::Coeff filterColorCoeff;
     SkAssertResult(
         SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>(fDesc.fColorFilterXfermode),
                                 &filterColorCoeff,
                                 &colorCoeff));
     bool needColor, needFilterColor;
     need_blend_inputs(filterColorCoeff, colorCoeff, &needFilterColor, &needColor);
 
+    // used in order for builder to return the per-stage uniform handles.
+    SkTArray<GrGLUniformManager::UniformHandle, true>* stageUniformArrays[GrDrawState::kNumStages];
+
     if (needColor) {
-        ///////////////////////////////////////////////////////////////////////////
-        // compute the color
-        // if we have color stages string them together, feeding the output color
-        // of each to the next and generating code for each stage.
-        SkString outColor;
         for (int s = 0; s < fDesc.fFirstCoverageStage; ++s) {
-            if (GrGLEffect::kNoEffectKey != fDesc.fEffectKeys[s]) {
-                if (kZeros_GrSLConstantVec == knownColorValue) {
-                    // Effects have no way to communicate zeros, they treat an empty string as ones.
-                    inColor = "initialColor";
-                    builder.fsCodeAppendf("\tvec4 %s = %s;\n", inColor.c_str(), GrGLSLZerosVecf(4));
-                }
-                // create var to hold stage result
-                outColor = "color";
-                outColor.appendS32(s);
-                builder.fsCodeAppendf("\tvec4 %s;\n", outColor.c_str());
+            stageUniformArrays[s] = &fUniformHandles.fEffectSamplerUnis[s];
+        }
 
-                builder.setCurrentStage(s);
-                fEffects[s] = builder.createAndEmitGLEffect(*stages[s],
-                                                            fDesc.fEffectKeys[s],
-                                                            inColor.size() ? inColor.c_str() : NULL,
-                                                            outColor.c_str(),
-                                                            &fUniformHandles.fEffectSamplerUnis[s]);
-                builder.setNonStage();
-                inColor = outColor;
-                knownColorValue = kNone_GrSLConstantVec;
-            }
-        }
+        builder.emitEffects(stages,
+                            fDesc.fEffectKeys,
+                            fDesc.fFirstCoverageStage,
+                            &inColor,
+                            &knownColorValue,
+                            stageUniformArrays,
+                            fEffects);
     }
 
     // Insert the color filter. This will soon be replaced by a color effect.
     if (SkXfermode::kDst_Mode != fDesc.fColorFilterXfermode) {
         const char* colorFilterColorUniName = NULL;
         fUniformHandles.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                              kVec4f_GrSLType, "FilterColor",
                                                              &colorFilterColorUniName);
 
         builder.fsCodeAppend("\tvec4 filteredColor;\n");
         const char* color;
         // add_color_filter requires a real input string.
         if (knownColorValue == kOnes_GrSLConstantVec) {
             color = GrGLSLOnesVecf(4);
         } else if (knownColorValue == kZeros_GrSLConstantVec) {
             color = GrGLSLZerosVecf(4);
         } else {
             color = inColor.c_str();
         }
         add_color_filter(&builder, "filteredColor", filterColorCoeff,
                          colorCoeff, colorFilterColorUniName, color);
         inColor = "filteredColor";
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // compute the partial coverage
-
-    // incoming coverage to current stage being processed.
     SkString inCoverage;
     GrSLConstantVec knownCoverageValue = this->genInputCoverage(&builder, &inCoverage);
 
-    SkString outCoverage;
-    for (int s = fDesc.fFirstCoverageStage; s < GrDrawState::kNumStages; ++s) {
-        if (fDesc.fEffectKeys[s]) {
-            if (kZeros_GrSLConstantVec == knownCoverageValue) {
-                // Effects have no way to communicate zeros, they treat an empty string as ones.
-                inCoverage = "initialCoverage";
-                builder.fsCodeAppendf("\tvec4 %s = %s;\n", inCoverage.c_str(), GrGLSLZerosVecf(4));
-            }
-            // create var to hold stage output
-            outCoverage = "coverage";
-            outCoverage.appendS32(s);
-            builder.fsCodeAppendf("\tvec4 %s;\n", outCoverage.c_str());
+    for (int s = fDesc.fFirstCoverageStage, i = 0; s < GrDrawState::kNumStages; ++s, ++i) {
+        stageUniformArrays[i] = &fUniformHandles.fEffectSamplerUnis[s];
+    }
 
-            builder.setCurrentStage(s);
-            fEffects[s] = builder.createAndEmitGLEffect(
-                                            *stages[s],
-                                            fDesc.fEffectKeys[s],
-                                            inCoverage.size() ? inCoverage.c_str() : NULL,
-                                            outCoverage.c_str(),
-                                            &fUniformHandles.fEffectSamplerUnis[s]);
-            builder.setNonStage();
-            inCoverage = outCoverage;
-            knownCoverageValue = kNone_GrSLConstantVec;
-        }
-    }
+    builder.emitEffects(stages + fDesc.fFirstCoverageStage,
+                        fDesc.fEffectKeys + fDesc.fFirstCoverageStage,
+                        GrDrawState::kNumStages - fDesc.fFirstCoverageStage,
+                        &inCoverage,
+                        &knownCoverageValue,
+                        stageUniformArrays,
+                        fEffects + fDesc.fFirstCoverageStage);
 
     // discard if coverage is zero
     if (fDesc.fDiscardIfZeroCoverage && kOnes_GrSLConstantVec != knownCoverageValue) {
         if (kZeros_GrSLConstantVec == knownCoverageValue) {
             // This is unfortunate.
             builder.fsCodeAppend("\tdiscard;\n");
         } else {
             builder.fsCodeAppendf("\tif (all(lessThanEqual(%s, vec4(0.0)))) {\n\t\tdiscard;\n\t}\n",
                                   inCoverage.c_str());
         }
@@ skipping 399 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }