Implement color filter as GrGLEffect

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 131 matching lines @@
                               "_dstTexCoord",
                               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;
+        fInputColor = GrGLSLExpr4(name);
     } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fColorInput) {
-        fInputColor = GrGLSLExpr<4>(1);
+        fInputColor = GrGLSLExpr4(1);
     } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fColorInput) {
-        fInputColor = GrGLSLExpr<4>(0);
+        fInputColor = GrGLSLExpr4(0);
     }
 
     if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
         const char* name;
         fCoverageUniform = this->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                             kVec4f_GrSLType, "Coverage", &name);
-        fInputCoverage = name;
+        fInputCoverage = GrGLSLExpr4(name);
     } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) {
-        fInputCoverage = GrGLSLExpr<4>(1);
+        fInputCoverage = GrGLSLExpr4(1);
     } else if (GrGLProgramDesc::kTransBlack_ColorInput == header.fCoverageInput) {
-        fInputCoverage = GrGLSLExpr<4>(0);
+        fInputCoverage = GrGLSLExpr4(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);
-    fFSCode.append((GrGLSLExpr<4>(modulation) * GrGLSLExpr<4>(lookup)).c_str());
+    fFSCode.append((GrGLSLExpr4(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 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,
-                                             GrGLSLExpr<4>* fsInOutColor) {
+                                             GrGLSLExpr4* fsInOutColor) {
     bool effectEmitted = false;
 
-    GrGLSLExpr<4> inColor = *fsInOutColor;
-    GrGLSLExpr<4> outColor;
+    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;
 
@@ skipping 299 matching lines @@
         }
     }
 
     return NULL;
 }
 
 GrGLProgramEffects* GrGLFullShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
         const EffectKey effectKeys[],
         int effectCnt,
-        GrGLSLExpr<4>* inOutFSColor) {
+        GrGLSLExpr4* inOutFSColor) {
 
     GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, effectCnt);
     this->INHERITED::createAndEmitEffects(&programEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
                                           inOutFSColor);
     return programEffectsBuilder.finish();
 }
 
@@ skipping 94 matching lines @@
     int firstFreeCoordSet = fNumTexCoordSets;
     fNumTexCoordSets += count;
     SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fNumTexCoordSets);
     return firstFreeCoordSet;
 }
 
 GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
         const EffectKey effectKeys[],
         int effectCnt,
-        GrGLSLExpr<4>* inOutFSColor) {
+        GrGLSLExpr4* inOutFSColor) {
 
     GrGLTexGenProgramEffectsBuilder texGenEffectsBuilder(this, effectCnt);
     this->INHERITED::createAndEmitEffects(&texGenEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
                                           inOutFSColor);
     return texGenEffectsBuilder.finish();
 }