Step towards variable length effect keys.

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
 #include "GrAllocator.h"
 #include "GrBackendEffectFactory.h"
 #include "GrColor.h"
 #include "GrEffect.h"
 #include "SkTypes.h"
+#include "gl/GrGLProgramDesc.h"
 #include "gl/GrGLProgramEffects.h"
 #include "gl/GrGLSL.h"
 #include "gl/GrGLUniformManager.h"
 
 #include <stdarg.h>
 
 class GrGLContextInfo;
 class GrEffectStage;
 class GrGLProgramDesc;
 
@@ skipping 220 matching lines @@
     GrGpuGL* gpu() const { return fGpu; }
 
     const GrGLProgramDesc& desc() const { return fDesc; }
 
     /** Add input/output variable declarations (i.e. 'varying') to the fragment shader. */
     GrGLShaderVar& fsInputAppend() { return fFSInputs.push_back(); }
 
     // Helper for emitEffects().
     void createAndEmitEffects(GrGLProgramEffectsBuilder*,
                               const GrEffectStage* effectStages[],
-                              const EffectKey effectKeys[],
                               int effectCnt,
+                              const GrGLProgramDesc::EffectKeyProvider&,
                               GrGLSLExpr4* inOutFSColor);
 
     // Generates a name for a variable. The generated string will be name prefixed by the prefix
     // char (unless the prefix is '\0'). It also mangles the name to be stage-specific if we're
     // generating stage code.
     void nameVariable(SkString* out, char prefix, const char* name);
 
     virtual bool compileAndAttachShaders(GrGLuint programId, SkTDArray<GrGLuint>* shaderIds) const;
 
     virtual void bindProgramLocations(GrGLuint programId) const;
@@ skipping 63 matching lines @@
      * The base class will emit the fragment code that precedes the per-effect code and then call
      * this function. The subclass can use it to insert additional fragment code that should
      * execute before the effects' code and/or emit other shaders (e.g. geometry, vertex).
      *
      * The subclass can modify the initial color or coverage 
      */
     virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) = 0;
 
     /**
     * Adds code for effects and returns a GrGLProgramEffects* object. The caller is responsible for
-    * deleting it when finished. effectStages contains the effects to add. effectKeys[i] is the key
-    * generated from effectStages[i]. inOutFSColor specifies the input color to the first stage and
-    * is updated to be the output color of the last stage.
-    * The handles to texture samplers for effectStage[i] are added to
+    * deleting it when finished. effectStages contains the effects to add. The effect key provider 
+    * is used to communicate the key each effect created in its GenKey function. inOutFSColor
+    * specifies the input color to the first stage and is updated to be the output color of the
+    * last stage. The handles to texture samplers for effectStage[i] are added to
     * effectSamplerHandles[i].
     */
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
-                                                     const EffectKey effectKeys[],
                                                      int effectCnt,
+                                                     const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) = 0;
 
     /**
      * Similar to emitCodeBeforeEffects() but called after per-effect code is emitted.
      */
     virtual void emitCodeAfterEffects() = 0;
 
     /** Enables using the secondary color output and returns the name of the var in which it is
         to be stored */
     const char* enableSecondaryOutput();
@@ skipping 98 matching lines @@
      */
     bool hasExplicitLocalCoords() const { return (fLocalCoordsVar != fPositionVar); }
 
     bool addEffectAttribute(int attributeIndex, GrSLType type, const SkString& name);
     const SkString* getEffectAttributeName(int attributeIndex) const;
 
 private:
     virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) SK_OVERRIDE;
 
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
-                                                     const EffectKey effectKeys[],
                                                      int effectCnt,
+                                                     const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
     virtual void emitCodeAfterEffects() SK_OVERRIDE;
 
     virtual bool compileAndAttachShaders(GrGLuint programId,
                                          SkTDArray<GrGLuint>* shaderIds) const SK_OVERRIDE;
 
     virtual void bindProgramLocations(GrGLuint programId) const SK_OVERRIDE;
 
     VarArray                            fVSAttrs;
@@ skipping 23 matching lines @@
 class GrGLFragmentOnlyShaderBuilder : public GrGLShaderBuilder {
 public:
     GrGLFragmentOnlyShaderBuilder(GrGpuGL*, GrGLUniformManager*, const GrGLProgramDesc&);
 
     int addTexCoordSets(int count);
 
 private:
     virtual void emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) SK_OVERRIDE {}
 
     virtual GrGLProgramEffects* createAndEmitEffects(const GrEffectStage* effectStages[],
-                                                     const EffectKey effectKeys[],
                                                      int effectCnt,
+                                                     const GrGLProgramDesc::EffectKeyProvider&,
                                                      GrGLSLExpr4* inOutFSColor) SK_OVERRIDE;
 
     virtual void emitCodeAfterEffects() SK_OVERRIDE {}
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 #endif