Rename ShaderType enum to ShaderVisibility

src/core/SkXfermode.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkXfermode.h"
@@ skipping 934 matching lines @@
                               const char* inputColor,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             SkXfermode::Mode mode = drawEffect.castEffect<XferEffect>().mode();
             const GrTexture* backgroundTex = drawEffect.castEffect<XferEffect>().backgroundAccess().getTexture();
             const char* dstColor;
             if (backgroundTex) {
                 SkString bgCoords;
                 GrSLType bgCoordsType = fBackgroundEffectMatrix.emitCode(builder, key, &bgCoords, NULL, "BG");
                 dstColor = "bgColor";
                 builder->fsCodeAppendf("\t\tvec4 %s = ", dstColor);
-                builder->appendTextureLookup(GrGLShaderBuilder::kFragment_ShaderType,
-                                             samplers[0],
-                                             bgCoords.c_str(),
-                                             bgCoordsType);
+                builder->fsAppendTextureLookup(samplers[0], bgCoords.c_str(), bgCoordsType);
                 builder->fsCodeAppendf(";\n");
             } else {
                 dstColor = builder->dstColor();
             }
             SkASSERT(NULL != dstColor);
 
             // We don't try to optimize for this case at all
             if (NULL == inputColor) {
                 builder->fsCodeAppendf("\t\tconst vec4 ones = %s;\n", GrGLSLOnesVecf(4));
                 inputColor = "ones";
@@ skipping 249 matching lines @@
         // hue and saturation of the first color, the luminosity of the second color, and the input
         // alpha. It has this signature:
         //      vec3 set_luminance(vec3 hueSatColor, float alpha, vec3 lumColor).
         static void AddLumFunction(GrGLShaderBuilder* builder, SkString* setLumFunction) {
             // Emit a helper that gets the luminance of a color.
             SkString getFunction;
             GrGLShaderVar getLumArgs[] = {
                 GrGLShaderVar("color", kVec3f_GrSLType),
             };
             SkString getLumBody("\treturn dot(vec3(0.3, 0.59, 0.11), color);\n");
-            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
-                                  kFloat_GrSLType,
-                                  "luminance",
-                                   SK_ARRAY_COUNT(getLumArgs), getLumArgs,
-                                   getLumBody.c_str(),
-                                   &getFunction);
+            builder->fsEmitFunction(kFloat_GrSLType,
+                                    "luminance",
+                                    SK_ARRAY_COUNT(getLumArgs), getLumArgs,
+                                    getLumBody.c_str(),
+                                    &getFunction);
 
             // Emit the set luminance function.
             GrGLShaderVar setLumArgs[] = {
                 GrGLShaderVar("hueSat", kVec3f_GrSLType),
                 GrGLShaderVar("alpha", kFloat_GrSLType),
                 GrGLShaderVar("lumColor", kVec3f_GrSLType),
             };
             SkString setLumBody;
             setLumBody.printf("\tfloat diff = %s(lumColor - hueSat);\n", getFunction.c_str());
             setLumBody.append("\tvec3 outColor = hueSat + diff;\n");
             setLumBody.appendf("\tfloat outLum = %s(outColor);\n", getFunction.c_str());
             setLumBody.append("\tfloat minComp = min(min(outColor.r, outColor.g), outColor.b);\n"
                               "\tfloat maxComp = max(max(outColor.r, outColor.g), outColor.b);\n"
                               "\tif (minComp < 0.0) {\n"
                               "\t\toutColor = outLum + ((outColor - vec3(outLum, outLum, outLum)) * outLum) / (outLum - minComp);\n"
                               "\t}\n"
                               "\tif (maxComp > alpha) {\n"
                               "\t\toutColor = outLum + ((outColor - vec3(outLum, outLum, outLum)) * (alpha - outLum)) / (maxComp - outLum);\n"
                               "\t}\n"
                               "\treturn outColor;\n");
-            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
-                        kVec3f_GrSLType,
-                        "set_luminance",
-                        SK_ARRAY_COUNT(setLumArgs), setLumArgs,
-                        setLumBody.c_str(),
-                        setLumFunction);
+            builder->fsEmitFunction(kVec3f_GrSLType,
+                                    "set_luminance",
+                                    SK_ARRAY_COUNT(setLumArgs), setLumArgs,
+                                    setLumBody.c_str(),
+                                    setLumFunction);
         }
 
         // Adds a function that creates a color with the hue and luminosity of one input color and
         // the saturation of another color. It will have this signature:
         //      float set_saturation(vec3 hueLumColor, vec3 satColor)
         static void AddSatFunction(GrGLShaderBuilder* builder, SkString* setSatFunction) {
             // Emit a helper that gets the saturation of a color
             SkString getFunction;
             GrGLShaderVar getSatArgs[] = { GrGLShaderVar("color", kVec3f_GrSLType) };
             SkString getSatBody;
             getSatBody.printf("\treturn max(max(color.r, color.g), color.b) - "
                               "min(min(color.r, color.g), color.b);\n");
-            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
-                                  kFloat_GrSLType,
-                                  "saturation",
-                                  SK_ARRAY_COUNT(getSatArgs), getSatArgs,
-                                  getSatBody.c_str(),
-                                  &getFunction);
+            builder->fsEmitFunction(kFloat_GrSLType,
+                                    "saturation",
+                                    SK_ARRAY_COUNT(getSatArgs), getSatArgs,
+                                    getSatBody.c_str(),
+                                    &getFunction);
 
             // Emit a helper that sets the saturation given sorted input channels. This used
             // to use inout params for min, mid, and max components but that seems to cause
             // problems on PowerVR drivers. So instead it returns a vec3 where r, g ,b are the
             // adjusted min, mid, and max inputs, respectively.
             SkString helperFunction;
             GrGLShaderVar helperArgs[] = {
                 GrGLShaderVar("minComp", kFloat_GrSLType),
                 GrGLShaderVar("midComp", kFloat_GrSLType),
                 GrGLShaderVar("maxComp", kFloat_GrSLType),
                 GrGLShaderVar("sat", kFloat_GrSLType),
             };
             static const char kHelperBody[] = "\tif (minComp < maxComp) {\n"
                                               "\t\tvec3 result;\n"
                                               "\t\tresult.r = 0.0;\n"
                                               "\t\tresult.g = sat * (midComp - minComp) / (maxComp - minComp);\n"
                                               "\t\tresult.b = sat;\n"
                                               "\t\treturn result;\n"
                                               "\t} else {\n"
                                               "\t\treturn vec3(0, 0, 0);\n"
                                               "\t}\n";
-            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
-                                  kVec3f_GrSLType,
-                                  "set_saturation_helper",
-                                  SK_ARRAY_COUNT(helperArgs), helperArgs,
-                                  kHelperBody,
-                                  &helperFunction);
+            builder->fsEmitFunction(kVec3f_GrSLType,
+                                    "set_saturation_helper",
+                                    SK_ARRAY_COUNT(helperArgs), helperArgs,
+                                    kHelperBody,
+                                    &helperFunction);
 
             GrGLShaderVar setSatArgs[] = {
                 GrGLShaderVar("hueLumColor", kVec3f_GrSLType),
                 GrGLShaderVar("satColor", kVec3f_GrSLType),
             };
             const char* helpFunc = helperFunction.c_str();
             SkString setSatBody;
             setSatBody.appendf("\tfloat sat = %s(satColor);\n"
                                "\tif (hueLumColor.r <= hueLumColor.g) {\n"
                                "\t\tif (hueLumColor.g <= hueLumColor.b) {\n"
                                "\t\t\thueLumColor.rgb = %s(hueLumColor.r, hueLumColor.g, hueLumColor.b, sat);\n"
                                "\t\t} else if (hueLumColor.r <= hueLumColor.b) {\n"
                                "\t\t\thueLumColor.rbg = %s(hueLumColor.r, hueLumColor.b, hueLumColor.g, sat);\n"
                                "\t\t} else {\n"
                                "\t\t\thueLumColor.brg = %s(hueLumColor.b, hueLumColor.r, hueLumColor.g, sat);\n"
                                "\t\t}\n"
                                "\t} else if (hueLumColor.r <= hueLumColor.b) {\n"
                                "\t\thueLumColor.grb = %s(hueLumColor.g, hueLumColor.r, hueLumColor.b, sat);\n"
                                "\t} else if (hueLumColor.g <= hueLumColor.b) {\n"
                                "\t\thueLumColor.gbr = %s(hueLumColor.g, hueLumColor.b, hueLumColor.r, sat);\n"
                                "\t} else {\n"
                                "\t\thueLumColor.bgr = %s(hueLumColor.b, hueLumColor.g, hueLumColor.r, sat);\n"
                                "\t}\n"
                                "\treturn hueLumColor;\n",
                                getFunction.c_str(), helpFunc, helpFunc, helpFunc, helpFunc,
                                helpFunc, helpFunc);
-            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
-                                  kVec3f_GrSLType,
-                                  "set_saturation",
-                                  SK_ARRAY_COUNT(setSatArgs), setSatArgs,
-                                  setSatBody.c_str(),
-                                  setSatFunction);
+            builder->fsEmitFunction(kVec3f_GrSLType,
+                                    "set_saturation",
+                                    SK_ARRAY_COUNT(setSatArgs), setSatArgs,
+                                    setSatBody.c_str(),
+                                    setSatFunction);
 
         }
 
         static const GrEffect::CoordsType kCoordsType = GrEffect::kLocal_CoordsType;
         GrGLEffectMatrix   fBackgroundEffectMatrix;
         typedef GrGLEffect INHERITED;
     };
 
     GR_DECLARE_EFFECT_TEST;
 
@@ skipping 624 matching lines @@
     return proc16;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkClearXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSrcXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstInXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstOutXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END