Rename ShaderType enum to ShaderVisibility

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 120 matching lines @@
         const char* dstCopyTopLeftName;
         const char* dstCopyCoordScaleName;
         uint32_t configMask;
         if (SkToBool(kUseAlphaConfig_DstReadKeyBit & header.fDstReadKey)) {
             configMask = kA_GrColorComponentFlag;
         } else {
             configMask = kRGBA_GrColorComponentFlags;
         }
         fDstCopySampler.init(this, configMask, "rgba", 0);
 
-        fDstCopyTopLeftUniform = this->addUniform(kFragment_ShaderType,
+        fDstCopyTopLeftUniform = this->addUniform(kFragment_Visibility,
                                                   kVec2f_GrSLType,
                                                   "DstCopyUpperLeft",
                                                   &dstCopyTopLeftName);
-        fDstCopyScaleUniform     = this->addUniform(kFragment_ShaderType,
+        fDstCopyScaleUniform     = this->addUniform(kFragment_Visibility,
                                                     kVec2f_GrSLType,
                                                     "DstCopyCoordScale",
                                                     &dstCopyCoordScaleName);
         const char* fragPos = this->fragmentPosition();
         this->fsCodeAppend("\t// Read color from copy of the destination.\n");
         this->fsCodeAppendf("\tvec2 _dstTexCoord = (%s.xy - %s) * %s;\n",
                             fragPos, dstCopyTopLeftName, dstCopyCoordScaleName);
         if (!topDown) {
             this->fsCodeAppend("\t_dstTexCoord.y = 1.0 - _dstTexCoord.y;\n");
         }
         this->fsCodeAppendf("\tvec4 %s = ", kDstCopyColorName);
-        this->appendTextureLookup(kFragment_ShaderType, fDstCopySampler, "_dstTexCoord");
+        this->fsAppendTextureLookup(fDstCopySampler, "_dstTexCoord");
         this->fsCodeAppend(";\n\n");
     }
 }
 
 bool GrGLShaderBuilder::enableFeature(GLSLFeature feature) {
     switch (feature) {
         case kStandardDerivatives_GLSLFeature:
             if (!fCtxInfo.caps()->shaderDerivativeSupport()) {
                 return false;
             }
@@ skipping 78 matching lines @@
     } else if (GrGLCaps::kNV_FBFetchType == fetchType) {
         SkAssertResult(this->enablePrivateFeature(kNVShaderFramebufferFetch_GLSLPrivateFeature));
         return kFBFetchColorName;
     } else if (fDstCopySampler.isInitialized()) {
         return kDstCopyColorName;
     } else {
         return "";
     }
 }
 
-void GrGLShaderBuilder::codeAppendf(ShaderType type, const char format[], va_list args) {
-    SkString* string = NULL;
-    switch (type) {
-        case kVertex_ShaderType:
-            string = &fVSCode;
-            break;
-        case kGeometry_ShaderType:
-            string = &fGSCode;
-            break;
-        case kFragment_ShaderType:
-            string = &fFSCode;
-            break;
-        default:
-            GrCrash("Invalid shader type");
-    }
-    string->appendf(format, args);
-}
-
-void GrGLShaderBuilder::codeAppend(ShaderType type, const char* str) {
-    SkString* string = NULL;
-    switch (type) {
-        case kVertex_ShaderType:
-            string = &fVSCode;
-            break;
-        case kGeometry_ShaderType:
-            string = &fGSCode;
-            break;
-        case kFragment_ShaderType:
-            string = &fFSCode;
-            break;
-        default:
-            GrCrash("Invalid shader type");
-    }
-    string->append(str);
-}
-
 void GrGLShaderBuilder::appendTextureLookup(SkString* out,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) const {
     SkASSERT(NULL != coordName);
 
     out->appendf("%s(%s, %s)",
                  sample_function_name(varyingType, fCtxInfo.glslGeneration()),
                  this->getUniformCStr(sampler.fSamplerUniform),
                  coordName);
     append_swizzle(out, sampler, *fCtxInfo.caps());
 }
 
-void GrGLShaderBuilder::appendTextureLookup(ShaderType type,
-                                            const GrGLShaderBuilder::TextureSampler& sampler,
-                                            const char* coordName,
-                                            GrSLType varyingType) {
-    SkASSERT(kFragment_ShaderType == type);
+void GrGLShaderBuilder::fsAppendTextureLookup(const GrGLShaderBuilder::TextureSampler& sampler,
+                                              const char* coordName,
+                                              GrSLType varyingType) {
     this->appendTextureLookup(&fFSCode, sampler, coordName, varyingType);
 }
 
-void GrGLShaderBuilder::appendTextureLookupAndModulate(
-                                            ShaderType type,
+void GrGLShaderBuilder::fsAppendTextureLookupAndModulate(
                                             const char* modulation,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) {
-    SkASSERT(kFragment_ShaderType == type);
     SkString lookup;
     this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
     GrGLSLModulatef<4>(&fFSCode, modulation, lookup.c_str());
 }
 
 GrBackendEffectFactory::EffectKey GrGLShaderBuilder::KeyForTextureAccess(
                                                             const GrTextureAccess& access,
                                                             const GrGLCaps& caps) {
     uint32_t configComponentMask = GrPixelConfigComponentMask(access.getTexture()->config());
     if (swizzle_requires_alpha_remapping(caps, configComponentMask, access.swizzleMask())) {
@@ skipping 46 matching lines @@
         return gStraight;
     }
 }
 
 GrGLUniformManager::UniformHandle GrGLShaderBuilder::addUniformArray(uint32_t visibility,
                                                                      GrSLType type,
                                                                      const char* name,
                                                                      int count,
                                                                      const char** outName) {
     SkASSERT(name && strlen(name));
-    SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_ShaderType | kFragment_ShaderType);
+    SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_Visibility | kFragment_Visibility);
     SkASSERT(0 == (~kVisibilityMask & visibility));
     SkASSERT(0 != visibility);
 
     BuilderUniform& uni = fUniforms.push_back();
     UniformHandle h = GrGLUniformManager::UniformHandle::CreateFromUniformIndex(fUniforms.count() - 1);
     GR_DEBUGCODE(UniformHandle h2 =)
     fUniformManager.appendUniform(type, count);
     // We expect the uniform manager to initially have no uniforms and that all uniforms are added
     // by this function. Therefore, the handles should match.
     SkASSERT(h2 == h);
     uni.fVariable.setType(type);
     uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
     this->nameVariable(uni.fVariable.accessName(), 'u', name);
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
 
     // If it is visible in both the VS and FS, the precision must match.
     // We declare a default FS precision, but not a default VS. So set the var
     // to use the default FS precision.
-    if ((kVertex_ShaderType | kFragment_ShaderType) == visibility) {
+    if ((kVertex_Visibility | kFragment_Visibility) == visibility) {
         // the fragment and vertex precisions must match
         uni.fVariable.setPrecision(kDefaultFragmentPrecision);
     }
 
     if (NULL != outName) {
         *outName = uni.fVariable.c_str();
     }
 
     return h;
 }
@@ skipping 84 matching lines @@
         return "gl_FragCoord";
     } else {
         static const char* kCoordName = "fragCoordYDown";
         if (!fSetupFragPosition) {
             // temporarily change the stage index because we're inserting non-stage code.
             CodeStage::AutoStageRestore csar(&fCodeStage, NULL);
 
             SkASSERT(!fRTHeightUniform.isValid());
             const char* rtHeightName;
 
-            fRTHeightUniform = this->addUniform(kFragment_ShaderType,
+            fRTHeightUniform = this->addUniform(kFragment_Visibility,
                                                 kFloat_GrSLType,
                                                 "RTHeight",
                                                 &rtHeightName);
 
             this->fFSCode.prependf("\tvec4 %s = vec4(gl_FragCoord.x, %s - gl_FragCoord.y, gl_FragCoord.zw);\n",
                                    kCoordName, rtHeightName);
             fSetupFragPosition = true;
         }
         SkASSERT(fRTHeightUniform.isValid());
         return kCoordName;
     }
 }
 
 
-void GrGLShaderBuilder::emitFunction(ShaderType shader,
-                                     GrSLType returnType,
-                                     const char* name,
-                                     int argCnt,
-                                     const GrGLShaderVar* args,
-                                     const char* body,
-                                     SkString* outName) {
-    SkASSERT(kFragment_ShaderType == shader);
+void GrGLShaderBuilder::fsEmitFunction(GrSLType returnType,
+                                       const char* name,
+                                       int argCnt,
+                                       const GrGLShaderVar* args,
+                                       const char* body,
+                                       SkString* outName) {
     fFSFunctions.append(GrGLSLTypeString(returnType));
     this->nameVariable(outName, '\0', name);
     fFSFunctions.appendf(" %s", outName->c_str());
     fFSFunctions.append("(");
     for (int i = 0; i < argCnt; ++i) {
         args[i].appendDecl(fCtxInfo, &fFSFunctions);
         if (i < argCnt - 1) {
             fFSFunctions.append(", ");
         }
     }
@@ skipping 28 matching lines @@
 }
 }
 
 void GrGLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const {
     for (int i = 0; i < vars.count(); ++i) {
         vars[i].appendDecl(fCtxInfo, out);
         out->append(";\n");
     }
 }
 
-void GrGLShaderBuilder::appendUniformDecls(ShaderType stype, SkString* out) const {
+void GrGLShaderBuilder::appendUniformDecls(ShaderVisibility visibility,
+                                           SkString* out) const {
     for (int i = 0; i < fUniforms.count(); ++i) {
-        if (fUniforms[i].fVisibility & stype) {
+        if (fUniforms[i].fVisibility & visibility) {
             fUniforms[i].fVariable.appendDecl(fCtxInfo, out);
             out->append(";\n");
         }
     }
 }
 
-void GrGLShaderBuilder::getShader(ShaderType type, SkString* shaderStr) const {
-    const char* version = GrGetGLSLVersionDecl(fCtxInfo);
+void GrGLShaderBuilder::vsGetShader(SkString* shaderStr) const {
+    *shaderStr = GrGetGLSLVersionDecl(fCtxInfo);
+    this->appendUniformDecls(kVertex_Visibility, shaderStr);
+    this->appendDecls(fVSAttrs, shaderStr);
+    this->appendDecls(fVSOutputs, shaderStr);
+    shaderStr->append("void main() {\n");
+    shaderStr->append(fVSCode);
+    shaderStr->append("}\n");
+}
 
-    switch (type) {
-        case kVertex_ShaderType:
-            *shaderStr = version;
-            this->appendUniformDecls(kVertex_ShaderType, shaderStr);
-            this->appendDecls(fVSAttrs, shaderStr);
-            this->appendDecls(fVSOutputs, shaderStr);
-            shaderStr->append("void main() {\n");
-            shaderStr->append(fVSCode);
-            shaderStr->append("}\n");
-            break;
-        case kGeometry_ShaderType:
-            if (fUsesGS) {
-                *shaderStr = version;
-                shaderStr->append(fGSHeader);
-                this->appendDecls(fGSInputs, shaderStr);
-                this->appendDecls(fGSOutputs, shaderStr);
-                shaderStr->append("void main() {\n");
-                shaderStr->append(fGSCode);
-                shaderStr->append("}\n");
-            } else {
-                shaderStr->reset();
-            }
-            break;
-        case kFragment_ShaderType:
-            *shaderStr = version;
-            shaderStr->append(fFSExtensions);
-            append_default_precision_qualifier(kDefaultFragmentPrecision,
-                                               fCtxInfo.binding(),
-                                               shaderStr);
-            this->appendUniformDecls(kFragment_ShaderType, shaderStr);
-            this->appendDecls(fFSInputs, shaderStr);
-            // We shouldn't have declared outputs on 1.10
-            SkASSERT(k110_GrGLSLGeneration != fCtxInfo.glslGeneration() || fFSOutputs.empty());
-            this->appendDecls(fFSOutputs, shaderStr);
-            shaderStr->append(fFSFunctions);
-            shaderStr->append("void main() {\n");
-            shaderStr->append(fFSCode);
-            shaderStr->append("}\n");
-            break;
+void GrGLShaderBuilder::gsGetShader(SkString* shaderStr) const {
+    if (!fUsesGS) {
+        shaderStr->reset();
+        return;
     }
- }
+
+    *shaderStr = GrGetGLSLVersionDecl(fCtxInfo);
+    shaderStr->append(fGSHeader);
+    this->appendDecls(fGSInputs, shaderStr);
+    this->appendDecls(fGSOutputs, shaderStr);
+    shaderStr->append("void main() {\n");
+    shaderStr->append(fGSCode);
+    shaderStr->append("}\n");
+}
+
+void GrGLShaderBuilder::fsGetShader(SkString* shaderStr) const {
+    *shaderStr = GrGetGLSLVersionDecl(fCtxInfo);
+    shaderStr->append(fFSExtensions);
+    append_default_precision_qualifier(kDefaultFragmentPrecision,
+                                       fCtxInfo.binding(),
+                                       shaderStr);
+    this->appendUniformDecls(kFragment_Visibility, shaderStr);
+    this->appendDecls(fFSInputs, shaderStr);
+    // We shouldn't have declared outputs on 1.10
+    SkASSERT(k110_GrGLSLGeneration != fCtxInfo.glslGeneration() || fFSOutputs.empty());
+    this->appendDecls(fFSOutputs, shaderStr);
+    shaderStr->append(fFSFunctions);
+    shaderStr->append("void main() {\n");
+    shaderStr->append(fFSCode);
+    shaderStr->append("}\n");
+}
 
 void GrGLShaderBuilder::finished(GrGLuint programID) {
     fUniformManager.getUniformLocations(programID, fUniforms);
 }
 
 void GrGLShaderBuilder::emitEffects(
                         const GrEffectStage* effectStages[],
                         const GrBackendEffectFactory::EffectKey effectKeys[],
                         int effectCnt,
                         SkString* fsInOutColor,
@@ skipping 75 matching lines @@
     for (const AttributePair* attrib = this->getEffectAttributes().begin();
          attrib != attribEnd;
          ++attrib) {
         if (attrib->fIndex == attributeIndex) {
             return &attrib->fName;
         }
     }
 
     return NULL;
 }