Move all ShaderBuilder files to GLSL

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"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
 
 //////////////////////////////////////////////////////////////////////////////
 //  Advanced (non-coeff) blend helpers
 //////////////////////////////////////////////////////////////////////////////
 
-static void hard_light(GrGLFragmentBuilder* fsBuilder,
+static void hard_light(GrGLSLFragmentBuilder* fsBuilder,
                        const char* final,
                        const char* src,
                        const char* dst) {
     static const char kComponents[] = { 'r', 'g', 'b' };
     for (size_t i = 0; i < SK_ARRAY_COUNT(kComponents); ++i) {
         char component = kComponents[i];
         fsBuilder->codeAppendf("if (2.0 * %s.%c <= %s.a) {", src, component, src);
         fsBuilder->codeAppendf("%s.%c = 2.0 * %s.%c * %s.%c;",
                                final, component, src, component, dst, component);
         fsBuilder->codeAppend("} else {");
         fsBuilder->codeAppendf("%s.%c = %s.a * %s.a - 2.0 * (%s.a - %s.%c) * (%s.a - %s.%c);",
                                final, component, src, dst, dst, dst, component, src, src,
                                component);
         fsBuilder->codeAppend("}");
     }
     fsBuilder->codeAppendf("%s.rgb += %s.rgb * (1.0 - %s.a) + %s.rgb * (1.0 - %s.a);",
                            final, src, dst, dst, src);
 }
 
 // Does one component of color-dodge
-static void color_dodge_component(GrGLFragmentBuilder* fsBuilder,
+static void color_dodge_component(GrGLSLFragmentBuilder* fsBuilder,
                                   const char* final,
                                   const char* src,
                                   const char* dst,
                                   const char component) {
     fsBuilder->codeAppendf("if (0.0 == %s.%c) {", dst, component);
     fsBuilder->codeAppendf("%s.%c = %s.%c * (1.0 - %s.a);",
                            final, component, src, component, dst);
     fsBuilder->codeAppend("} else {");
     fsBuilder->codeAppendf("float d = %s.a - %s.%c;", src, src, component);
     fsBuilder->codeAppend("if (0.0 == d) {");
     fsBuilder->codeAppendf("%s.%c = %s.a * %s.a + %s.%c * (1.0 - %s.a) + %s.%c * (1.0 - %s.a);",
                            final, component, src, dst, src, component, dst, dst, component,
                            src);
     fsBuilder->codeAppend("} else {");
     fsBuilder->codeAppendf("d = min(%s.a, %s.%c * %s.a / d);",
                            dst, dst, component, src);
     fsBuilder->codeAppendf("%s.%c = d * %s.a + %s.%c * (1.0 - %s.a) + %s.%c * (1.0 - %s.a);",
                            final, component, src, src, component, dst, dst, component, src);
     fsBuilder->codeAppend("}");
     fsBuilder->codeAppend("}");
 }
 
 // Does one component of color-burn
-static void color_burn_component(GrGLFragmentBuilder* fsBuilder,
+static void color_burn_component(GrGLSLFragmentBuilder* fsBuilder,
                                  const char* final,
                                  const char* src,
                                  const char* dst,
                                  const char component) {
     fsBuilder->codeAppendf("if (%s.a == %s.%c) {", dst, dst, component);
     fsBuilder->codeAppendf("%s.%c = %s.a * %s.a + %s.%c * (1.0 - %s.a) + %s.%c * (1.0 - %s.a);",
                            final, component, src, dst, src, component, dst, dst, component,
                            src);
     fsBuilder->codeAppendf("} else if (0.0 == %s.%c) {", src, component);
     fsBuilder->codeAppendf("%s.%c = %s.%c * (1.0 - %s.a);",
                            final, component, dst, component, src);
     fsBuilder->codeAppend("} else {");
     fsBuilder->codeAppendf("float d = max(0.0, %s.a - (%s.a - %s.%c) * %s.a / %s.%c);",
                            dst, dst, dst, component, src, src, component);
     fsBuilder->codeAppendf("%s.%c = %s.a * d + %s.%c * (1.0 - %s.a) + %s.%c * (1.0 - %s.a);",
                            final, component, src, src, component, dst, dst, component, src);
     fsBuilder->codeAppend("}");
 }
 
 // Does one component of soft-light. Caller should have already checked that dst alpha > 0.
-static void soft_light_component_pos_dst_alpha(GrGLFragmentBuilder* fsBuilder,
+static void soft_light_component_pos_dst_alpha(GrGLSLFragmentBuilder* fsBuilder,
                                                const char* final,
                                                const char* src,
                                                const char* dst,
                                                const char component) {
     // if (2S < Sa)
     fsBuilder->codeAppendf("if (2.0 * %s.%c <= %s.a) {", src, component, src);
     // (D^2 (Sa-2 S))/Da+(1-Da) S+D (-Sa+2 S+1)
     fsBuilder->codeAppendf("%s.%c = (%s.%c*%s.%c*(%s.a - 2.0*%s.%c)) / %s.a +"
                            "(1.0 - %s.a) * %s.%c + %s.%c*(-%s.a + 2.0*%s.%c + 1.0);",
                            final, component, dst, component, dst, component, src, src,
@@ skipping 21 matching lines @@
                            " sqrt(%s.a*%s.%c)*(%s.a - 2.0*%s.%c) - %s.a*%s.%c;",
                            final, component, dst, component, src, src, component, src, component,
                            dst, dst, component, src, src, component, dst, src, component);
     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) {
+static void add_lum_function(GrGLSLFragmentBuilder* fsBuilder, SkString* setLumFunction) {
     // Emit a helper that gets the luminance of a color.
     SkString getFunction;
     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(),
@@ skipping 24 matching lines @@
     fsBuilder->emitFunction(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 add_sat_function(GrGLFragmentBuilder* fsBuilder, SkString* setSatFunction) {
+static void add_sat_function(GrGLSLFragmentBuilder* fsBuilder, SkString* setSatFunction) {
     // Emit a helper that gets the saturation of a color
     SkString getFunction;
     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(),
@@ skipping 50 matching lines @@
                        "return hueLumColor;",
                        getFunction.c_str(), helpFunc, helpFunc, helpFunc, helpFunc,
                        helpFunc, helpFunc);
     fsBuilder->emitFunction(kVec3f_GrSLType,
                             "set_saturation",
                             SK_ARRAY_COUNT(setSatArgs), setSatArgs,
                             setSatBody.c_str(),
                             setSatFunction);
 }
 
-static void emit_advanced_xfermode_code(GrGLFragmentBuilder* fsBuilder, const char* srcColor,
+static void emit_advanced_xfermode_code(GrGLSLFragmentBuilder* fsBuilder, const char* srcColor,
                                         const char* dstColor, const char* outputColor,
                                         SkXfermode::Mode mode) {
     SkASSERT(srcColor);
     SkASSERT(dstColor);
     SkASSERT(outputColor);
     // These all perform src-over on the alpha channel.
     fsBuilder->codeAppendf("%s.a = %s.a + (1.0 - %s.a) * %s.a;",
                            outputColor, srcColor, srcColor, dstColor);
 
     switch (mode) {
@@ skipping 112 matching lines @@
         default:
             SkFAIL("Unknown Custom Xfer mode.");
             break;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //  Porter-Duff blend helper
 //////////////////////////////////////////////////////////////////////////////
 
-static bool append_porterduff_term(GrGLFragmentBuilder* fsBuilder, SkXfermode::Coeff coeff,
+static bool append_porterduff_term(GrGLSLFragmentBuilder* fsBuilder, SkXfermode::Coeff coeff,
                                    const char* colorName, const char* srcColorName,
                                    const char* dstColorName, bool hasPrevious) {
     if (SkXfermode::kZero_Coeff == coeff) {
         return hasPrevious;
     } else {
         if (hasPrevious) {
             fsBuilder->codeAppend(" + ");
         }
         fsBuilder->codeAppendf("%s", colorName);
         switch (coeff) {
@@ skipping 25 matching lines @@
                 break;
             default:
                 SkFAIL("Unsupported Blend Coeff");
         }
         return true;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-void GrGLSLBlend::AppendMode(GrGLFragmentBuilder* fsBuilder, const char* srcColor,
+void GrGLSLBlend::AppendMode(GrGLSLFragmentBuilder* fsBuilder, const char* srcColor,
                              const char* dstColor, const char* outColor,
                              SkXfermode::Mode mode) {
 
     SkXfermode::Coeff srcCoeff, dstCoeff;
     if (SkXfermode::ModeAsCoeff(mode, &srcCoeff, &dstCoeff)) {
         fsBuilder->codeAppendf("%s = ", outColor);
         // append src blend
         bool didAppend = append_porterduff_term(fsBuilder, srcCoeff, srcColor, srcColor, dstColor,
                                                 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);
     }
 }