Potentially optimize some GrGLEffects for known input color values

src/gpu/gl/GrGLShaderBuilder.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLUniformHandle.h"
@@ skipping 271 matching lines @@
                           varyingType);
 }
 
 void GrGLShaderBuilder::fsAppendTextureLookup(const GrGLShaderBuilder::TextureSampler& sampler,
                                               const char* coordName,
                                               GrSLType varyingType) {
     this->appendTextureLookup(&fFSCode, sampler, coordName, varyingType);
 }
 
 void GrGLShaderBuilder::fsAppendTextureLookupAndModulate(
-                                            const char* modulation,
+                                            const GrGLSLExpr4& modulation,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) {
     SkString lookup;
     this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
-    fFSCode.append((GrGLSLExpr4(modulation) * GrGLSLExpr4(lookup)).c_str());
+    fFSCode.append((modulation * GrGLSLExpr4(lookup)).c_str());
 }
 
 GrGLShaderBuilder::DstReadKey GrGLShaderBuilder::KeyForDstRead(const GrTexture* dstCopy,
                                                                const GrGLCaps& caps) {
     uint32_t key = kYesDstRead_DstReadKeyBit;
     if (GrGLCaps::kNone_FBFetchType != caps.fbFetchType()) {
         return key;
     }
     SkASSERT(NULL != dstCopy);
     if (!caps.textureSwizzleSupport() && GrPixelConfigIsAlphaOnly(dstCopy->config())) {
@@ skipping 200 matching lines @@
             out->append(";\n");
         }
     }
 }
 
 void GrGLShaderBuilder::createAndEmitEffects(GrGLProgramEffectsBuilder* programEffectsBuilder,
                                              const GrEffectStage* effectStages[],
                                              const EffectKey effectKeys[],
                                              int effectCnt,
                                              GrGLSLExpr4* fsInOutColor) {
-    bool effectEmitted = false;
-
-    GrGLSLExpr4 inColor = *fsInOutColor;
-    GrGLSLExpr4 outColor;
-
     for (int e = 0; e < effectCnt; ++e) {
         SkASSERT(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());
         const GrEffectStage& stage = *effectStages[e];
 
         CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
 
-        if (inColor.isZeros()) {
-            SkString inColorName;
-
-            // Effects have no way to communicate zeros, they treat an empty string as ones.
-            this->nameVariable(&inColorName, '\0', "input");
-            this->fsCodeAppendf("\tvec4 %s = %s;\n", inColorName.c_str(), inColor.c_str());
-            inColor = inColorName;
-        }
-
         // create var to hold stage result
         SkString outColorName;
         this->nameVariable(&outColorName, '\0', "output");
         this->fsCodeAppendf("\tvec4 %s;\n", outColorName.c_str());
-        outColor = outColorName;
-
 
         programEffectsBuilder->emitEffect(stage,
                                           effectKeys[e],
-                                          outColor.c_str(),
-                                          inColor.isOnes() ? NULL : inColor.c_str(),
+                                          outColorName.c_str(),
+                                          *fsInOutColor,
                                           fCodeStage.stageIndex());
 
-        inColor = outColor;
-        effectEmitted = true;
-    }
-
-    if (effectEmitted) {
-        *fsInOutColor = outColor;
+        *fsInOutColor = GrGLSLExpr4(outColorName);
     }
 }
 
 const char* GrGLShaderBuilder::getColorOutputName() const {
     return fHasCustomColorOutput ? declared_color_output_name() : "gl_FragColor";
 }
 
 const char* GrGLShaderBuilder::enableSecondaryOutput() {
     if (!fHasSecondaryOutput) {
         fFSOutputs.push_back().set(kVec4f_GrSLType,
@@ skipping 172 matching lines @@
 #endif
         ) {
         this->vsCodeAppend("\tgl_PointSize = 1.0;\n");
     }
 
     if (GrGLProgramDesc::kAttribute_ColorInput == header.fColorInput) {
         this->addAttribute(kVec4f_GrSLType, color_attribute_name());
         const char *vsName, *fsName;
         this->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
         this->vsCodeAppendf("\t%s = %s;\n", vsName, color_attribute_name());
-        this->setInputColor(fsName);
+        this->setInputColor(GrGLSLExpr4(fsName));
     }
 
     if (GrGLProgramDesc::kAttribute_ColorInput == header.fCoverageInput) {
         this->addAttribute(kVec4f_GrSLType, coverage_attribute_name());
         const char *vsName, *fsName;
         this->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
         this->vsCodeAppendf("\t%s = %s;\n", vsName, coverage_attribute_name());
-        this->setInputCoverage(fsName);
+        this->setInputCoverage(GrGLSLExpr4(fsName));
     }
 }
 
 bool GrGLFullShaderBuilder::addAttribute(GrSLType type, const char* name) {
     for (int i = 0; i < fVSAttrs.count(); ++i) {
         const GrGLShaderVar& attr = fVSAttrs[i];
         // if attribute already added, don't add it again
         if (attr.getName().equals(name)) {
             SkASSERT(attr.getType() == type);
             return false;
@@ skipping 181 matching lines @@
         GrGLSLExpr4* inOutFSColor) {
 
     GrGLTexGenProgramEffectsBuilder texGenEffectsBuilder(this, effectCnt);
     this->INHERITED::createAndEmitEffects(&texGenEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
                                           inOutFSColor);
     return texGenEffectsBuilder.finish();
 }