Step towards variable length effect keys.

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 176 matching lines @@
                                    GrGLShaderVar::kOut_TypeModifier,
                                    declared_color_output_name());
         fHasCustomColorOutput = true;
     }
 
     this->emitCodeBeforeEffects(&inputColor, &inputCoverage);
 
     ///////////////////////////////////////////////////////////////////////////
     // emit the per-effect code for both color and coverage effects
 
+    GrGLProgramDesc::EffectKeyProvider colorKeyProvider(
+        &this->desc(), GrGLProgramDesc::EffectKeyProvider::kColor_EffectType);
     fOutput.fColorEffects.reset(this->createAndEmitEffects(colorStages,
-                                                           this->desc().getEffectKeys(),
                                                            this->desc().numColorEffects(),
+                                                           colorKeyProvider,
                                                            &inputColor));
 
+    GrGLProgramDesc::EffectKeyProvider coverageKeyProvider(
+        &this->desc(), GrGLProgramDesc::EffectKeyProvider::kCoverage_EffectType);
     fOutput.fCoverageEffects.reset(this->createAndEmitEffects(coverageStages,
-                                    this->desc().getEffectKeys() + this->desc().numColorEffects(),
-                                    this->desc().numCoverageEffects(),
-                                    &inputCoverage));
+                                   this->desc().numCoverageEffects(),
+                                   coverageKeyProvider,
+                                   &inputCoverage));
 
     this->emitCodeAfterEffects();
 
     ///////////////////////////////////////////////////////////////////////////
     // write the secondary color output if necessary
     if (GrGLProgramDesc::CoverageOutputUsesSecondaryOutput(header.fCoverageOutput)) {
         const char* secondaryOutputName = this->enableSecondaryOutput();
 
         // default coeff to ones for kCoverage_DualSrcOutput
         GrGLSLExpr4 coeff(1);
@@ skipping 378 matching lines @@
     for (int i = 0; i < fUniforms.count(); ++i) {
         if (fUniforms[i].fVisibility & visibility) {
             fUniforms[i].fVariable.appendDecl(this->ctxInfo(), out);
             out->append(";\n");
         }
     }
 }
 
 void GrGLShaderBuilder::createAndEmitEffects(GrGLProgramEffectsBuilder* programEffectsBuilder,
                                              const GrEffectStage* effectStages[],
-                                             const EffectKey effectKeys[],
                                              int effectCnt,
+                                             const GrGLProgramDesc::EffectKeyProvider& keyProvider,
                                              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],
+                                          keyProvider.get(e),
                                           outColor.c_str(),
                                           inColor.isOnes() ? NULL : inColor.c_str(),
                                           fCodeStage.stageIndex());
 
         inColor = outColor;
         effectEmitted = true;
     }
 
     if (effectEmitted) {
         *fsInOutColor = outColor;
@@ skipping 323 matching lines @@
         if (attrib->fIndex == attributeIndex) {
             return &attrib->fName;
         }
     }
 
     return NULL;
 }
 
 GrGLProgramEffects* GrGLFullShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
-        const EffectKey effectKeys[],
         int effectCnt,
+        const GrGLProgramDesc::EffectKeyProvider& keyProvider,
         GrGLSLExpr4* inOutFSColor) {
 
     GrGLVertexProgramEffectsBuilder programEffectsBuilder(this, effectCnt);
     this->INHERITED::createAndEmitEffects(&programEffectsBuilder,
                                           effectStages,
-                                          effectKeys,
                                           effectCnt,
+                                          keyProvider,
                                           inOutFSColor);
     return programEffectsBuilder.finish();
 }
 
 bool GrGLFullShaderBuilder::compileAndAttachShaders(GrGLuint programId,
                                                     SkTDArray<GrGLuint>* shaderIds) const {
     const GrGLContext& glCtx = this->gpu()->glContext();
     SkString vertShaderSrc(GrGetGLSLVersionDecl(this->ctxInfo()));
     this->appendUniformDecls(kVertex_Visibility, &vertShaderSrc);
     this->appendDecls(fVSAttrs, &vertShaderSrc);
@@ skipping 88 matching lines @@
 
 int GrGLFragmentOnlyShaderBuilder::addTexCoordSets(int count) {
     int firstFreeCoordSet = fOutput.fTexCoordSetCnt;
     fOutput.fTexCoordSetCnt += count;
     SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fOutput.fTexCoordSetCnt);
     return firstFreeCoordSet;
 }
 
 GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
-        const EffectKey effectKeys[],
         int effectCnt,
+        const GrGLProgramDesc::EffectKeyProvider& keyProvider,
         GrGLSLExpr4* inOutFSColor) {
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
-                                          effectKeys,
                                           effectCnt,
+                                          keyProvider,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }