Move GrGLShaderVar to GrGLSL

src/gpu/gl/GrGLSLBlend.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "GrGLSLBlend.h"
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 104 matching lines @@
     fsBuilder->codeAppendf("}");
 }
 
 // Adds a function that takes two colors and an alpha as input. It produces a color with the
 // 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 add_lum_function(GrGLFragmentBuilder* fsBuilder, SkString* setLumFunction) {
     // Emit a helper that gets the luminance of a color.
     SkString getFunction;
-    GrGLShaderVar getLumArgs[] = {
-        GrGLShaderVar("color", kVec3f_GrSLType),
+    GrGLSLShaderVar getLumArgs[] = {
+        GrGLSLShaderVar("color", kVec3f_GrSLType),
     };
     SkString getLumBody("return dot(vec3(0.3, 0.59, 0.11), color);");
     fsBuilder->emitFunction(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),
+    GrGLSLShaderVar setLumArgs[] = {
+        GrGLSLShaderVar("hueSat", kVec3f_GrSLType),
+        GrGLSLShaderVar("alpha", kFloat_GrSLType),
+        GrGLSLShaderVar("lumColor", kVec3f_GrSLType),
     };
     SkString setLumBody;
     setLumBody.printf("float diff = %s(lumColor - hueSat);", getFunction.c_str());
     setLumBody.append("vec3 outColor = hueSat + diff;");
     setLumBody.appendf("float outLum = %s(outColor);", getFunction.c_str());
     setLumBody.append("float minComp = min(min(outColor.r, outColor.g), outColor.b);"
                       "float maxComp = max(max(outColor.r, outColor.g), outColor.b);"
                       "if (minComp < 0.0 && outLum != minComp) {"
                       "outColor = outLum + ((outColor - vec3(outLum, outLum, outLum)) * outLum) /"
                       "(outLum - minComp);"
@@ skipping 10 matching lines @@
                             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 add_sat_function(GrGLFragmentBuilder* fsBuilder, SkString* setSatFunction) {
     // Emit a helper that gets the saturation of a color
     SkString getFunction;
-    GrGLShaderVar getSatArgs[] = { GrGLShaderVar("color", kVec3f_GrSLType) };
+    GrGLSLShaderVar getSatArgs[] = { GrGLSLShaderVar("color", kVec3f_GrSLType) };
     SkString getSatBody;
     getSatBody.printf("return max(max(color.r, color.g), color.b) - "
                       "min(min(color.r, color.g), color.b);");
     fsBuilder->emitFunction(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),
+    GrGLSLShaderVar helperArgs[] = {
+        GrGLSLShaderVar("minComp", kFloat_GrSLType),
+        GrGLSLShaderVar("midComp", kFloat_GrSLType),
+        GrGLSLShaderVar("maxComp", kFloat_GrSLType),
+        GrGLSLShaderVar("sat", kFloat_GrSLType),
     };
     static const char kHelperBody[] = "if (minComp < maxComp) {"
         "vec3 result;"
         "result.r = 0.0;"
         "result.g = sat * (midComp - minComp) / (maxComp - minComp);"
         "result.b = sat;"
         "return result;"
         "} else {"
         "return vec3(0, 0, 0);"
         "}";
     fsBuilder->emitFunction(kVec3f_GrSLType,
                             "set_saturation_helper",
                             SK_ARRAY_COUNT(helperArgs), helperArgs,
                             kHelperBody,
                             &helperFunction);
 
-    GrGLShaderVar setSatArgs[] = {
-        GrGLShaderVar("hueLumColor", kVec3f_GrSLType),
-        GrGLShaderVar("satColor", kVec3f_GrSLType),
+    GrGLSLShaderVar setSatArgs[] = {
+        GrGLSLShaderVar("hueLumColor", kVec3f_GrSLType),
+        GrGLSLShaderVar("satColor", kVec3f_GrSLType),
     };
     const char* helpFunc = helperFunction.c_str();
     SkString setSatBody;
     setSatBody.appendf("float sat = %s(satColor);"
                        "if (hueLumColor.r <= hueLumColor.g) {"
                        "if (hueLumColor.g <= hueLumColor.b) {"
                        "hueLumColor.rgb = %s(hueLumColor.r, hueLumColor.g, hueLumColor.b, sat);"
                        "} else if (hueLumColor.r <= hueLumColor.b) {"
                        "hueLumColor.rbg = %s(hueLumColor.r, hueLumColor.b, hueLumColor.g, sat);"
                        "} else {"
@@ skipping 207 matching lines @@
                                                 false);
         // append dst blend
         if(!append_porterduff_term(fsBuilder, dstCoeff, dstColor, srcColor, dstColor, didAppend)) {
             fsBuilder->codeAppend("vec4(0, 0, 0, 0)");
         }
         fsBuilder->codeAppend(";");
     } else {
         emit_advanced_xfermode_code(fsBuilder, srcColor, dstColor, outColor, mode);
     }
 }