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 81 matching lines @@
 GrGLShaderBuilder::GrGLShaderBuilder(GrGpuGL* gpu,
                                      GrGLUniformManager& uniformManager,
                                      const GrGLProgramDesc& desc)
     : fGpu(gpu)
     , fUniformManager(uniformManager)
     , fFSFeaturesAddedMask(0)
     , fFSInputs(kVarsPerBlock)
     , fFSOutputs(kMaxFSOutputs)
     , fUniforms(kVarsPerBlock)
     , fSetupFragPosition(false)
-    , fKnownColorValue(GrGLProgramDesc::KnownColorInputValue(desc.getHeader().fColorInput))
-    , fKnownCoverageValue(GrGLProgramDesc::KnownColorInputValue(desc.getHeader().fCoverageInput))
     , fHasCustomColorOutput(false)
     , fHasSecondaryOutput(false)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey) {
 
     const GrGLProgramDesc::KeyHeader& header = desc.getHeader();
 
     // Emit code to read the dst copy textue if necessary.
     if (kNoDstRead_DstReadKey != header.fDstReadKey &&
         GrGLCaps::kNone_FBFetchType == fGpu->glCaps().fbFetchType()) {
         bool topDown = SkToBool(kTopLeftOrigin_DstReadKeyBit & header.fDstReadKey);
@@ skipping 31 matching lines @@
                               configMask,
                               "rgba");
         this->fsCodeAppend(";\n\n");
     }
 
     if (GrGLProgramDesc::kUniform_ColorInput == header.fColorInput) {
         const char* name;
         fColorUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                          kVec4f_GrSLType, "Color", &name);
         fInputColor = name;
+    } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fColorInput) {
+        fInputColor = GrGLSLExpr<4>(1);
+    } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fColorInput) {
+        fInputColor = GrGLSLExpr<4>(0);
     }
 
     if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
         const char* name;
         fCoverageUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType, "Coverage", &name);
         fInputCoverage = name;
+    } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) {
+        fInputCoverage = GrGLSLExpr<4>(1);
+    } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fCoverageInput) {
+        fInputCoverage = GrGLSLExpr<4>(0);
     }
 
     if (k110_GrGLSLGeneration != fGpu->glslGeneration()) {
         fFSOutputs.push_back().set(kVec4f_GrSLType,
                                    GrGLShaderVar::kOut_TypeModifier,
                                    declared_color_output_name());
         fHasCustomColorOutput = true;
     }
 }
 
@@ skipping 110 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());
 }
 
 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 199 matching lines @@
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
 void GrGLShaderBuilder::createAndEmitEffects(GrGLProgramEffectsBuilder* programEffectsBuilder,
                                              const GrEffectStage* effectStages[],
                                              const EffectKey effectKeys[],
                                              int effectCnt,
-                                             SkString* fsInOutColor,
-                                             GrSLConstantVec* fsInOutColorKnownValue) {
+                                             GrGLSLExpr<4>* fsInOutColor) {
     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];
 
         CodeStage::AutoStageRestore csar(&fCodeStage, &stage);
 
-        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;
+
 
         programEffectsBuilder->emitEffect(stage,
                                           effectKeys[e],
                                           outColor.c_str(),
-                                          inColor.isEmpty() ? NULL : inColor.c_str(),
+                                          inColor.isOnes() ? NULL : inColor.c_str(),
                                           fCodeStage.stageIndex());
 
         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 269 matching lines @@
         }
     }
 
     return NULL;
 }
 
 GrGLProgramEffects* GrGLFullShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
         const EffectKey effectKeys[],
         int effectCnt,
-        SkString* inOutFSColor,
-        GrSLConstantVec* fsInOutColorKnownValue) {
+        GrGLSLExpr<4>* inOutFSColor) {
 
     GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, effectCnt);
     this->INHERITED::createAndEmitEffects(&programEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
-                                          inOutFSColor,
-                                          fsInOutColorKnownValue);
+                                          inOutFSColor);
     return programEffectsBuilder.finish();
 }
 
 bool GrGLFullShaderBuilder::compileAndAttachShaders(GrGLuint programId) const {
     const GrGLInterface* glInterface = this->gpu()->glInterface();
     SkString vertShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
     this->appendUniformDecls(kVertex_Visibility, &vertShaderSrc);
     this->appendDecls(fVSAttrs, &vertShaderSrc);
     this->appendDecls(fVSOutputs, &vertShaderSrc);
     vertShaderSrc.append("void main() {\n");
@@ skipping 80 matching lines @@
     SkASSERT(gpu->glCaps().fixedFunctionSupport());
     SkASSERT(gpu->glCaps().pathRenderingSupport());
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);
 }
 
 GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
         const EffectKey effectKeys[],
         int effectCnt,
-        SkString* inOutFSColor,
-        GrSLConstantVec* fsInOutColorKnownValue) {
+        GrGLSLExpr<4>* inOutFSColor) {
 
     GrGLTexGenProgramEffectsBuilder texGenEffectsBuilder(this, effectCnt);
     this->INHERITED::createAndEmitEffects(&texGenEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
-                                          inOutFSColor,
-                                          fsInOutColorKnownValue);
+                                          inOutFSColor);
     return texGenEffectsBuilder.finish();
 }