Rename ShaderType enum to ShaderVisibility

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 53 matching lines @@
                   uint32_t configComponentMask,
                   const char* swizzle,
                   int idx) {
             SkASSERT(!this->isInitialized());
             SkASSERT(0 != configComponentMask);
             SkASSERT(!fSamplerUniform.isValid());
 
             SkASSERT(NULL != builder);
             SkString name;
             name.printf("Sampler%d", idx);
-            fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+            fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                                   kSampler2D_GrSLType,
                                                   name.c_str());
             SkASSERT(fSamplerUniform.isValid());
 
             fConfigComponentMask = configComponentMask;
             memcpy(fSwizzle, swizzle, 4);
         }
 
         void init(GrGLShaderBuilder* builder, const GrTextureAccess* access, int idx) {
             SkASSERT(NULL != access);
             this->init(builder,
                        GrPixelConfigComponentMask(access->getTexture()->config()),
                        access->getSwizzle(),
                        idx);
         }
 
         uint32_t                          fConfigComponentMask;
         char                              fSwizzle[5];
         GrGLUniformManager::UniformHandle fSamplerUniform;
 
         friend class GrGLShaderBuilder; // to call init().
     };
 
     typedef SkTArray<TextureSampler> TextureSamplerArray;
 
-    enum ShaderType {
-        kVertex_ShaderType   = 0x1,
-        kGeometry_ShaderType = 0x2,
-        kFragment_ShaderType = 0x4,
+    enum ShaderVisibility {
+        kVertex_Visibility   = 0x1,
+        kGeometry_Visibility = 0x2,
+        kFragment_Visibility = 0x4,
     };
 
     GrGLShaderBuilder(const GrGLContextInfo&, GrGLUniformManager&, const GrGLProgramDesc&);
 
     /**
      * 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
     };
 
     /**
      * If the feature is supported then true is returned and any necessary #extension declarations
      * are added to the shaders. If the feature is not supported then false will be returned.
      */
     bool enableFeature(GLSLFeature);
 
     /**
      * Called by GrGLEffects to add code to one of the shaders.
      */
     void vsCodeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
         va_list args;
         va_start(args, format);
-        this->codeAppendf(kVertex_ShaderType, format, args);
+        fVSCode.appendf(format, args);
         va_end(args);
     }
 
     void gsCodeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
         va_list args;
         va_start(args, format);
-        this->codeAppendf(kGeometry_ShaderType, format, args);
+        fGSCode.appendf(format, args);
         va_end(args);
     }
 
     void fsCodeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
         va_list args;
         va_start(args, format);
-        this->codeAppendf(kFragment_ShaderType, format, args);
+        fFSCode.appendf(format, args);
         va_end(args);
     }
 
-    void vsCodeAppend(const char* str) { this->codeAppend(kVertex_ShaderType, str); }
-    void gsCodeAppend(const char* str) { this->codeAppend(kGeometry_ShaderType, str); }
-    void fsCodeAppend(const char* str) { this->codeAppend(kFragment_ShaderType, str); }
+    void vsCodeAppend(const char* str) { fVSCode.append(str); }
+    void gsCodeAppend(const char* str) { fGSCode.append(str); }
+    void fsCodeAppend(const char* str) { fFSCode.append(str); }
 
     /** Appends a 2D texture sample with projection if necessary. coordType must either be Vec2f or
         Vec3f. The latter is interpreted as projective texture coords. The vec length and swizzle
         order of the result depends on the GrTextureAccess associated with the TextureSampler. */
     void appendTextureLookup(SkString* out,
                              const TextureSampler&,
                              const char* coordName,
                              GrSLType coordType = kVec2f_GrSLType) const;
 
-    /** Version of above that appends the result to the shader code rather than an SkString.
-        Currently the shader type must be kFragment */
-    void appendTextureLookup(ShaderType,
-                             const TextureSampler&,
-                             const char* coordName,
-                             GrSLType coordType = kVec2f_GrSLType);
+    /** Version of above that appends the result to the fragment shader code instead.*/
+    void fsAppendTextureLookup(const TextureSampler&,
+                               const char* coordName,
+                               GrSLType coordType = kVec2f_GrSLType);
 
 
     /** Does the work of appendTextureLookup and modulates the result by modulation. The result is
         always a vec4. modulation and the swizzle specified by TextureSampler must both be vec4 or
         float. If modulation is "" or NULL it this function acts as though appendTextureLookup were
         called. */
-    void appendTextureLookupAndModulate(ShaderType,
-                                        const char* modulation,
-                                        const TextureSampler&,
-                                        const char* coordName,
-                                        GrSLType coordType = kVec2f_GrSLType);
+    void fsAppendTextureLookupAndModulate(const char* modulation,
+                                          const TextureSampler&,
+                                          const char* coordName,
+                                          GrSLType coordType = kVec2f_GrSLType);
 
-    /** Emits a helper function outside of main(). Currently ShaderType must be
-        kFragment_ShaderType. */
-    void emitFunction(ShaderType shader,
-                      GrSLType returnType,
-                      const char* name,
-                      int argCnt,
-                      const GrGLShaderVar* args,
-                      const char* body,
-                      SkString* outName);
+    /** Emits a helper function outside of main() in the fragment shader. */
+    void fsEmitFunction(GrSLType returnType,
+                        const char* name,
+                        int argCnt,
+                        const GrGLShaderVar* args,
+                        const char* body,
+                        SkString* outName);
 
     /** Generates a EffectKey for the shader code based on the texture access parameters and the
         capabilities of the GL context.  This is useful for keying the shader programs that may
         have multiple representations, based on the type/format of textures used. */
     static GrBackendEffectFactory::EffectKey KeyForTextureAccess(const GrTextureAccess&,
                                                                  const GrGLCaps&);
 
     typedef uint8_t DstReadKey;
     typedef uint8_t FragPosKey;
 
     /**  Returns a key for adding code to read the copy-of-dst color in service of effects that
          require reading the dst. It must not return 0 because 0 indicates that there is no dst
          copy read at all (in which case this function should not be called). */
     static DstReadKey KeyForDstRead(const GrTexture* dstCopy, const GrGLCaps&);
 
     /** Returns a key for reading the fragment location. This should only be called if there is an
         effect that will requires the fragment position. If the fragment position is not required,
         the key is 0. */
     static FragPosKey KeyForFragmentPosition(const GrRenderTarget* dst, const GrGLCaps&);
 
     /** If texture swizzling is available using tex parameters then it is preferred over mangling
         the generated shader code. This potentially allows greater reuse of cached shaders. */
     static const GrGLenum* GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps);
 
     /** Add a uniform variable to the current program, that has visibility in one or more shaders.
-        visibility is a bitfield of ShaderType values indicating from which shaders the uniform
-        should be accessible. At least one bit must be set. Geometry shader uniforms are not
+        visibility is a bitfield of ShaderVisibility values indicating from which shaders the
+        uniform should be accessible. At least one bit must be set. Geometry shader uniforms are not
         supported at this time. The actual uniform name will be mangled. If outName is not NULL then
         it will refer to the final uniform name after return. Use the addUniformArray variant to add
         an array of uniforms.
     */
     GrGLUniformManager::UniformHandle addUniform(uint32_t visibility,
                                                  GrSLType type,
                                                  const char* name,
                                                  const char** outName = NULL) {
         return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
     }
@@ skipping 49 matching lines @@
      */
     bool hasExplicitLocalCoords() const { return (fLocalCoordsVar != fPositionVar); }
 
     /**
      * Interfaces used by GrGLProgram.
      * TODO: Hide these from the GrEffects using friend or splitting this into two related classes.
      * Also, GrGLProgram's shader string construction should be moved to this class.
      */
 
     /** Called after building is complete to get the final shader string. */
-    void getShader(ShaderType, SkString*) const;
+    void vsGetShader(SkString*) const;
+    void gsGetShader(SkString*) const;
+    void fsGetShader(SkString*) const;
 
     /**
      * 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
@@ skipping 29 matching lines @@
         return fEffectAttributes;
     }
     const SkString* getEffectAttributeName(int attributeIndex) const;
 
     // TODO: Make this do all the compiling, linking, etc.
     void finished(GrGLuint programID);
 
     const GrGLContextInfo& ctxInfo() const { return fCtxInfo; }
 
 private:
-    void codeAppendf(ShaderType type, const char format[], va_list args);
-    void codeAppend(ShaderType type, const char* str);
-
     typedef GrTAllocator<GrGLShaderVar> VarArray;
 
     void appendDecls(const VarArray&, SkString*) const;
-    void appendUniformDecls(ShaderType, SkString*) const;
+    void appendUniformDecls(ShaderVisibility, SkString*) const;
 
     typedef GrGLUniformManager::BuilderUniform BuilderUniform;
     GrGLUniformManager::BuilderUniformArray fUniforms;
 
     // TODO: Everything below here private.
 public:
 
     VarArray    fVSAttrs;
     VarArray    fVSOutputs;
     VarArray    fGSInputs;
@@ skipping 57 matching lines @@
     /**
      * Features that should only be enabled by GrGLShaderBuilder itself.
      */
     enum GLSLPrivateFeature {
         kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
         kEXTShaderFramebufferFetch_GLSLPrivateFeature,
         kNVShaderFramebufferFetch_GLSLPrivateFeature,
     };
     bool enablePrivateFeature(GLSLPrivateFeature);
 
-    // If we ever have VS/GS features we can expand this to take a bitmask of ShaderType and track
-    // the enables separately for each shader.
+    // If we ever have VS/GS features we can expand this to take a bitmask of ShaderVisibility and
+    // track the enables separately for each shader.
     void addFSFeature(uint32_t featureBit, const char* extensionName);
 
     // 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);
 
     // Interpretation of DstReadKey when generating code
     enum {
         kNoDstRead_DstReadKey         = 0,
@@ skipping 30 matching lines @@
     bool                                fTopLeftFragPosRead;
 
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
 };
 
 #endif