Add a requiresVertexShader method to GrGLEffect

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
 
@@ skipping 89 matching lines @@
 
     enum ShaderVisibility {
         kVertex_Visibility   = 0x1,
         kGeometry_Visibility = 0x2,
         kFragment_Visibility = 0x4,
     };
 
     GrGLShaderBuilder(const GrGLContextInfo&,
                       GrGLUniformManager&,
                       const GrGLProgramDesc&,
-                      bool needsVertexShader);
+                      bool requiresVertexShader);
 
     /**
      * Use of these features may require a GLSL extension to be enabled. Shaders may not compile
      * if code is added that uses one of these features without calling enableFeature()
      */
     enum GLSLFeature {
         kStandardDerivatives_GLSLFeature = 0,
 
         kLastGLSLFeature = kStandardDerivatives_GLSLFeature
     };
@@ skipping 128 matching lines @@
      * Adds code for effects. effectStages contains the effects to add. effectKeys[i] is the key
      * generated from effectStages[i]. An entry in effectStages can be NULL, in which case it is
      * skipped. Moreover, if the corresponding key is GrGLEffect::NoEffectKey then it is skipped.
      * inOutFSColor specifies the input color to the first stage and is updated to be the
      * output color of the last stage. fsInOutColorKnownValue specifies whether the input color
      * has a known constant value and is updated to refer to the status of the output color.
      * The handles to texture samplers for effectStage[i] are added to effectSamplerHandles[i]. The
      * glEffects array is updated to contain the GrGLEffect generated for each entry in
      * effectStages.
      */
-    void emitEffects(const GrEffectStage* effectStages[],
-                     const GrBackendEffectFactory::EffectKey effectKeys[],
+    void emitEffects(GrGLEffect* const glEffects[],
+                     GrDrawEffect const drawEffects[],
+                     GrBackendEffectFactory::EffectKey const effectKeys[],

[bsalomon, 2013/09/06 14:10:03]

what's with the const placement?

[Chris Dalton, 2013/09/06 17:17:24]

For GrDrawEffect and GrBackendEffectFactory, it means the same thing on either
side of the type name. I just moved it to match GrGLEffect* (I'm going to move
it back tough).

For GrGLEffect*, this means the GrGLEffects (2 levels deep) are const:

  const GrGLEffect* glEffects[]

And this means the GrGLEffect* pointers (1 level deep) are const:

  GrGLEffect* const glEffects[]

We can't do the first way because it turns out C++ makes it illegal to promote a
'T**' to a 'const T**' (it creates a back door to modify const values). Thanks
for pointing it out though. We should really make both levels const:

  const GrGLEffect* const glEffects[]

[Chris Dalton, 2013/09/06 17:31:37]

Oh yeah, I forgot. The GrGLEffects can't be const because emitCode is non-const.
So we do need just make the GrGLEffects* pointers const:

GrGLEffect* const glEffects[]

But I'll still move the other consts back.

[bsalomon, 2013/09/06 17:37:17]

Gotcha

                      int effectCnt,
                      SkString*  inOutFSColor,
                      GrSLConstantVec* fsInOutColorKnownValue,
-                     SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
-                     GrGLEffect* glEffects[]);
+                     SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[]);
 
     GrGLUniformManager::UniformHandle getRTHeightUniform() const { return fRTHeightUniform; }
     GrGLUniformManager::UniformHandle getDstCopyTopLeftUniform() const {
         return fDstCopyTopLeftUniform;
     }
     GrGLUniformManager::UniformHandle getDstCopyScaleUniform() const {
         return fDstCopyScaleUniform;
     }
     GrGLUniformManager::UniformHandle getDstCopySamplerUniform() const {
         return fDstCopySampler.fSamplerUniform;
@@ skipping 105 matching lines @@
 private:
     void appendDecls(const VarArray&, SkString*) const;
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
     typedef GrGLUniformManager::BuilderUniform BuilderUniform;
     GrGLUniformManager::BuilderUniformArray fUniforms;
 
 private:
     class CodeStage : GrNoncopyable {
     public:
-        CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
+        CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffect(NULL) {}
 
         bool inStageCode() const {
             this->validate();
-            return NULL != fEffectStage;
+            return NULL != fEffect;
         }
 
-        const GrEffectStage* effectStage() const {
+        const GrEffectRef* effect() const {
             this->validate();
-            return fEffectStage;
+            return fEffect;
         }
 
         int stageIndex() const {
             this->validate();
             return fCurrentIndex;
         }
 
         class AutoStageRestore : GrNoncopyable {
         public:
-            AutoStageRestore(CodeStage* codeStage, const GrEffectStage* newStage) {
+            AutoStageRestore(CodeStage* codeStage, const GrEffectRef* effect) {
                 SkASSERT(NULL != codeStage);
                 fSavedIndex = codeStage->fCurrentIndex;
-                fSavedEffectStage = codeStage->fEffectStage;
+                fSavedEffect = codeStage->fEffect;
 
-                if (NULL == newStage) {
+                if (NULL == effect) {
                     codeStage->fCurrentIndex = -1;
                 } else {
                     codeStage->fCurrentIndex = codeStage->fNextIndex++;
                 }
-                codeStage->fEffectStage = newStage;
+                codeStage->fEffect = effect;
 
                 fCodeStage = codeStage;
             }
             ~AutoStageRestore() {
                 fCodeStage->fCurrentIndex = fSavedIndex;
-                fCodeStage->fEffectStage = fSavedEffectStage;
+                fCodeStage->fEffect = fSavedEffect;
             }
         private:
-            CodeStage*              fCodeStage;
-            int                     fSavedIndex;
-            const GrEffectStage*    fSavedEffectStage;
+            CodeStage*            fCodeStage;
+            int                   fSavedIndex;
+            const GrEffectRef*    fSavedEffect;
         };
     private:
-        void validate() const { SkASSERT((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
-        int                     fNextIndex;
-        int                     fCurrentIndex;
-        const GrEffectStage*    fEffectStage;
+        void validate() const { SkASSERT((NULL == fEffect) == (-1 == fCurrentIndex)); }
+        int                   fNextIndex;
+        int                   fCurrentIndex;
+        const GrEffectRef*    fEffect;
     } fCodeStage;
 
     /**
      * Features that should only be enabled by GrGLShaderBuilder itself.
      */
     enum GLSLPrivateFeature {
         kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
         kEXTShaderFramebufferFetch_GLSLPrivateFeature,
         kNVShaderFramebufferFetch_GLSLPrivateFeature,
     };
@@ skipping 38 matching lines @@
     GrGLUniformManager::UniformHandle   fRTHeightUniform;
     GrGLUniformManager::UniformHandle   fDstCopyTopLeftUniform;
     GrGLUniformManager::UniformHandle   fDstCopyScaleUniform;
 
     bool                                fTopLeftFragPosRead;
 
     SkAutoTDelete<VertexBuilder> fVertexBuilder;
 };
 
 #endif