Express (GLSL expression, possibly known value) pairs as a class

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 98 matching lines @@
                                      GrGLUniformManager& uniformManager,
                                      const GrGLProgramDesc& desc,
                                      bool needsVertexShader)
     : fUniforms(kVarsPerBlock)
     , fGpu(gpu)
     , fUniformManager(uniformManager)
     , fFSFeaturesAddedMask(0)
     , fFSInputs(kVarsPerBlock)
     , fFSOutputs(kMaxFSOutputs)
     , fSetupFragPosition(false)
-    , fKnownColorValue(kNone_GrSLConstantVec)
-    , fKnownCoverageValue(kNone_GrSLConstantVec)
     , fHasCustomColorOutput(false)
     , fHasSecondaryOutput(false)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey) {
 
     const GrGLProgramDesc::KeyHeader& header = desc.getHeader();
 
     if (needsVertexShader) {
         fVertexBuilder.reset(SkNEW_ARGS(VertexBuilder, (this, fGpu, desc)));
     }
 
@@ skipping 42 matching lines @@
             break;
         }
         case GrGLProgramDesc::kUniform_ColorInput: {
             const char* name;
             fColorUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                              kVec4f_GrSLType, "Color", &name);
             fInputColor = name;
             break;
         }
         case GrGLProgramDesc::kTransBlack_ColorInput:
-            fKnownColorValue = kZeros_GrSLConstantVec;
+            fInputColor = GrGLSLExpr<4>(0);
             break;
         case GrGLProgramDesc::kSolidWhite_ColorInput:
-            fKnownColorValue = kOnes_GrSLConstantVec;
+            fInputColor = GrGLSLExpr<4>(1);
             break;
         default:
             GrCrash("Unknown color type.");
     }
 
     switch (header.fCoverageInput) {
         case GrGLProgramDesc::kAttribute_ColorInput: {
             SkASSERT(NULL != fVertexBuilder.get());
             fVertexBuilder->addAttribute(kVec4f_GrSLType, coverage_attribute_name());
             const char *vsName, *fsName;
             fVertexBuilder->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
             fVertexBuilder->vsCodeAppendf("\t%s = %s;\n", vsName, coverage_attribute_name());
             fInputCoverage = fsName;
             break;
         }
         case GrGLProgramDesc::kUniform_ColorInput: {
             const char* name;
             fCoverageUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                                 kVec4f_GrSLType, "Coverage", &name);
             fInputCoverage = name;
             break;
         }
         case GrGLProgramDesc::kTransBlack_ColorInput:
-            fKnownCoverageValue = kZeros_GrSLConstantVec;
+            fInputCoverage = GrGLSLExpr<4>(0);
             break;
         case GrGLProgramDesc::kSolidWhite_ColorInput:
-            fKnownCoverageValue = kOnes_GrSLConstantVec;
+            fInputCoverage = GrGLSLExpr<4>(1);
             break;
         default:
             GrCrash("Unknown coverage type.");
     }
 
     if (k110_GrGLSLGeneration != fGpu->glslGeneration()) {
         fFSOutputs.push_back().set(kVec4f_GrSLType,
                                    GrGLShaderVar::kOut_TypeModifier,
                                    declared_color_output_name());
         fHasCustomColorOutput = true;
@@ skipping 113 matching lines @@
     this->appendTextureLookup(&fFSCode, sampler, coordName, varyingType);
 }
 
 void GrGLShaderBuilder::fsAppendTextureLookupAndModulate(
                                             const char* modulation,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) {
     SkString lookup;
     this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
-    GrGLSLModulatef<4>(&fFSCode, modulation, lookup.c_str());
+    fFSCode.append((GrGLSLExpr<4>(modulation) * GrGLSLExpr<4>(lookup)).c_str());
 }
 
 GrBackendEffectFactory::EffectKey GrGLShaderBuilder::KeyForTextureAccess(
                                                             const GrTextureAccess& access,
                                                             const GrGLCaps& caps) {
     uint32_t configComponentMask = GrPixelConfigComponentMask(access.getTexture()->config());
     if (swizzle_requires_alpha_remapping(caps, configComponentMask, access.swizzleMask())) {
         return 1;
     } else {
         return 0;
@@ skipping 196 matching lines @@
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
 void GrGLShaderBuilder::emitEffects(
                         const GrEffectStage* effectStages[],
                         const GrBackendEffectFactory::EffectKey effectKeys[],
                         int effectCnt,
-                        SkString* fsInOutColor,
-                        GrSLConstantVec* fsInOutColorKnownValue,
+                        GrGLSLExpr<4>* fsInOutColor,
                         SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
                         GrGLEffect* glEffects[]) {
     bool effectEmitted = false;
 
-    SkString inColor = *fsInOutColor;
-    SkString outColor;
+    GrGLSLExpr<4> inColor = *fsInOutColor;
+    GrGLSLExpr<4> outColor;
 
     for (int e = 0; e < effectCnt; ++e) {
         SkASSERT(NULL != effectStages[e] && NULL != effectStages[e]->getEffect());
         const GrEffectStage& stage = *effectStages[e];
         const GrEffectRef& effect = *stage.getEffect();
 
         CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
 
         int numTextures = effect->numTextures();
         SkSTArray<8, GrGLShaderBuilder::TextureSampler> textureSamplers;
@@ skipping 13 matching lines @@
             SkASSERT(NULL != fVertexBuilder.get());
             SkString attributeName("aAttr");
             attributeName.appendS32(attributeIndices[a]);
             fVertexBuilder->addEffectAttribute(attributeIndices[a],
                                                effect->vertexAttribType(a),
                                                attributeName);
         }
 
         glEffects[e] = effect->getFactory().createGLInstance(drawEffect);
 
-        if (kZeros_GrSLConstantVec == *fsInOutColorKnownValue) {
+        if (inColor.isZeros()) {
+            SkString inColorName;
             // Effects have no way to communicate zeros, they treat an empty string as ones.
-            this->nameVariable(&inColor, '\0', "input");
-            this->fsCodeAppendf("\tvec4 %s = %s;\n", inColor.c_str(), GrGLSLZerosVecf(4));
+            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
-        this->nameVariable(&outColor, '\0', "output");
-        this->fsCodeAppendf("\tvec4 %s;\n", outColor.c_str());
+        SkString outColorName;
+        this->nameVariable(&outColorName, '\0', "output");
+        this->fsCodeAppendf("\tvec4 %s;\n", outColorName.c_str());
+        outColor = outColorName;
 
         // Enclose custom code in a block to avoid namespace conflicts
         SkString openBrace;
         openBrace.printf("\t{ // Stage %d: %s\n", fCodeStage.stageIndex(), glEffects[e]->name());
         if (NULL != fVertexBuilder.get()) {
             fVertexBuilder->vsCodeAppend(openBrace.c_str());
         }
         this->fsCodeAppend(openBrace.c_str());
 
         glEffects[e]->emitCode(this,
                                drawEffect,
                                effectKeys[e],
                                outColor.c_str(),
-                               inColor.isEmpty() ? NULL : inColor.c_str(),
+                               inColor.isOnes() ? NULL : inColor.c_str(),
                                textureSamplers);
 
         if (NULL != fVertexBuilder.get()) {
             fVertexBuilder->vsCodeAppend("\t}\n");
         }
         this->fsCodeAppend("\t}\n");
 
         inColor = outColor;
-        *fsInOutColorKnownValue = kNone_GrSLConstantVec;
         effectEmitted = true;
     }
 
     if (effectEmitted) {
         *fsInOutColor = outColor;
     }
 }
 
 const char* GrGLShaderBuilder::getColorOutputName() const {
     return fHasCustomColorOutput ? declared_color_output_name() : "gl_FragColor";
@@ skipping 335 matching lines @@
         GL_CALL(BindAttribLocation(programId,
                                    header.fCoverageAttributeIndex,
                                    coverage_attribute_name()));
     }
 
     const AttributePair* attribEnd = fEffectAttributes.end();
     for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {
          GL_CALL(BindAttribLocation(programId, attrib->fIndex, attrib->fName.c_str()));
     }
 }