Rename ShaderType enum to ShaderVisibility

src/effects/SkPerlinNoiseShader.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDither.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkFlattenableBuffers.h"
@@ skipping 734 matching lines @@
                                 const GrDrawEffect&,
                                 EffectKey key,
                                 const char* outputColor,
                                 const char* inputColor,
                                 const TextureSamplerArray&) {
     sk_ignore_unused_variable(inputColor);
 
     SkString vCoords;
     fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, &vCoords);
 
-    fSeedUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+    fSeedUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                    kFloat_GrSLType, "seed");
     const char* seedUni = builder->getUniformCStr(fSeedUni);
-    fInvMatrixUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+    fInvMatrixUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                         kMat33f_GrSLType, "invMatrix");
     const char* invMatrixUni = builder->getUniformCStr(fInvMatrixUni);
-    fBaseFrequencyUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+    fBaseFrequencyUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                             kVec2f_GrSLType, "baseFrequency");
     const char* baseFrequencyUni = builder->getUniformCStr(fBaseFrequencyUni);
-    fAlphaUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+    fAlphaUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                     kFloat_GrSLType, "alpha");
     const char* alphaUni = builder->getUniformCStr(fAlphaUni);
 
     // Add vec3 modulo 289 function
     static const GrGLShaderVar gVec3Args[] =  {
         GrGLShaderVar("x", kVec3f_GrSLType)
     };
 
     SkString mod289_3_funcName;
-    builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType, kVec3f_GrSLType,
-                          "mod289", SK_ARRAY_COUNT(gVec3Args), gVec3Args,
-                          "const vec2 C = vec2(1.0 / 289.0, 289.0);\n"
-                          "return x - floor(x * C.xxx) * C.yyy;", &mod289_3_funcName);
+    builder->fsEmitFunction(kVec3f_GrSLType,
+                            "mod289", SK_ARRAY_COUNT(gVec3Args), gVec3Args,
+                            "const vec2 C = vec2(1.0 / 289.0, 289.0);\n"
+                            "return x - floor(x * C.xxx) * C.yyy;", &mod289_3_funcName);
 
     // Add vec4 modulo 289 function
     static const GrGLShaderVar gVec4Args[] =  {
         GrGLShaderVar("x", kVec4f_GrSLType)
     };
 
     SkString mod289_4_funcName;
-    builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType, kVec4f_GrSLType,
-                          "mod289", SK_ARRAY_COUNT(gVec4Args), gVec4Args,
-                          "const vec2 C = vec2(1.0 / 289.0, 289.0);\n"
-                          "return x - floor(x * C.xxxx) * C.yyyy;", &mod289_4_funcName);
+    builder->fsEmitFunction(kVec4f_GrSLType,
+                            "mod289", SK_ARRAY_COUNT(gVec4Args), gVec4Args,
+                            "const vec2 C = vec2(1.0 / 289.0, 289.0);\n"
+                            "return x - floor(x * C.xxxx) * C.yyyy;", &mod289_4_funcName);
 
     // Add vec4 permute function
     SkString permuteCode;
     permuteCode.appendf("const vec2 C = vec2(34.0, 1.0);\n"
                         "return %s(((x * C.xxxx) + C.yyyy) * x);", mod289_4_funcName.c_str());
     SkString permuteFuncName;
-    builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType, kVec4f_GrSLType,
-                          "permute", SK_ARRAY_COUNT(gVec4Args), gVec4Args,
-                          permuteCode.c_str(), &permuteFuncName);
+    builder->fsEmitFunction(kVec4f_GrSLType,
+                            "permute", SK_ARRAY_COUNT(gVec4Args), gVec4Args,
+                            permuteCode.c_str(), &permuteFuncName);
 
     // Add vec4 taylorInvSqrt function
     SkString taylorInvSqrtFuncName;
-    builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType, kVec4f_GrSLType,
-                          "taylorInvSqrt", SK_ARRAY_COUNT(gVec4Args), gVec4Args,
-                          "const vec2 C = vec2(-0.85373472095314, 1.79284291400159);\n"
-                          "return x * C.xxxx + C.yyyy;", &taylorInvSqrtFuncName);
+    builder->fsEmitFunction(kVec4f_GrSLType,
+                            "taylorInvSqrt", SK_ARRAY_COUNT(gVec4Args), gVec4Args,
+                            "const vec2 C = vec2(-0.85373472095314, 1.79284291400159);\n"
+                            "return x * C.xxxx + C.yyyy;", &taylorInvSqrtFuncName);
 
     // Add vec3 noise function
     static const GrGLShaderVar gNoiseVec3Args[] =  {
         GrGLShaderVar("v", kVec3f_GrSLType)
     };
 
     SkString noiseCode;
     noiseCode.append(
         "const vec2 C = vec2(1.0/6.0, 1.0/3.0);\n"
         "const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);\n"
@@ skipping 64 matching lines @@
         "p2 *= norm.z;\n"
         "p3 *= norm.w;\n"
 
         // Mix final noise value
         "vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);\n"
         "m = m * m;\n"
         "return 42.0 * dot(m*m, vec4(dot(p0,x0), dot(p1,x1), dot(p2,x2), dot(p3,x3)));",
         taylorInvSqrtFuncName.c_str());
 
     SkString noiseFuncName;
-    builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType, kFloat_GrSLType,
-                          "snoise", SK_ARRAY_COUNT(gNoiseVec3Args), gNoiseVec3Args,
-                          noiseCode.c_str(), &noiseFuncName);
+    builder->fsEmitFunction(kFloat_GrSLType,
+                            "snoise", SK_ARRAY_COUNT(gNoiseVec3Args), gNoiseVec3Args,
+                            noiseCode.c_str(), &noiseFuncName);
 
     const char* noiseVecIni = "noiseVecIni";
     const char* factors     = "factors";
     const char* sum         = "sum";
     const char* xOffsets    = "xOffsets";
     const char* yOffsets    = "yOffsets";
     const char* channel     = "channel";
 
     // Fill with some prime numbers
     builder->fsCodeAppendf("\t\tconst vec4 %s = vec4(13.0, 53.0, 101.0, 151.0);\n", xOffsets);
@@ skipping 59 matching lines @@
                                const GrDrawEffect&,
                                EffectKey key,
                                const char* outputColor,
                                const char* inputColor,
                                const TextureSamplerArray& samplers) {
     sk_ignore_unused_variable(inputColor);
 
     SkString vCoords;
     fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, &vCoords);
 
-    fInvMatrixUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+    fInvMatrixUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                         kMat33f_GrSLType, "invMatrix");
     const char* invMatrixUni = builder->getUniformCStr(fInvMatrixUni);
-    fBaseFrequencyUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+    fBaseFrequencyUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                             kVec2f_GrSLType, "baseFrequency");
     const char* baseFrequencyUni = builder->getUniformCStr(fBaseFrequencyUni);
-    fAlphaUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+    fAlphaUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                     kFloat_GrSLType, "alpha");
     const char* alphaUni = builder->getUniformCStr(fAlphaUni);
 
     const char* stitchDataUni = NULL;
     if (fStitchTiles) {
-        fStitchDataUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
+        fStitchDataUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
                                              kVec2f_GrSLType, "stitchData");
         stitchDataUni = builder->getUniformCStr(fStitchDataUni);
     }
 
     // There are 4 lines, so the center of each line is 1/8, 3/8, 5/8 and 7/8
     const char* chanCoordR  = "0.125";
     const char* chanCoordG  = "0.375";
     const char* chanCoordB  = "0.625";
     const char* chanCoordA  = "0.875";
     const char* chanCoord   = "chanCoord";
@@ skipping 136 matching lines @@
         noiseCode.appendf(dotLattice, lattice, lattice, inc8bit, fractVal);
     }
 
     // Compute 'b' as a linear interpolation of 'u' and 'v'
     noiseCode.appendf("\n\t%s.y = mix(%s.x, %s.y, %s.x);", ab, uv, uv, noiseSmooth);
     // Compute the noise as a linear interpolation of 'a' and 'b'
     noiseCode.appendf("\n\treturn mix(%s.x, %s.y, %s.y);\n", ab, ab, noiseSmooth);
 
     SkString noiseFuncName;
     if (fStitchTiles) {
-        builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType, kFloat_GrSLType,
-                              "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseStitchArgs),
-                              gPerlinNoiseStitchArgs, noiseCode.c_str(), &noiseFuncName);
+        builder->fsEmitFunction(kFloat_GrSLType,
+                                "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseStitchArgs),
+                                gPerlinNoiseStitchArgs, noiseCode.c_str(), &noiseFuncName);
     } else {
-        builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType, kFloat_GrSLType,
-                              "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseArgs),
-                              gPerlinNoiseArgs, noiseCode.c_str(), &noiseFuncName);
+        builder->fsEmitFunction(kFloat_GrSLType,
+                                "perlinnoise", SK_ARRAY_COUNT(gPerlinNoiseArgs),
+                                gPerlinNoiseArgs, noiseCode.c_str(), &noiseFuncName);
     }
 
     // There are rounding errors if the floor operation is not performed here
     builder->fsCodeAppendf("\n\t\tvec2 %s = floor((%s * vec3(%s, 1.0)).xy) * %s;",
                            noiseVec, invMatrixUni, vCoords.c_str(), baseFrequencyUni);
 
     // Clear the color accumulator
     builder->fsCodeAppendf("\n\t\t%s = vec4(0.0);", outputColor);
 
     if (fStitchTiles) {
@@ skipping 212 matching lines @@
     str->append(" seed: ");
     str->appendScalar(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif