Make XPFragmentBuilder only Builder with access to DstCopy.

src/gpu/effects/GrCustomXfermode.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 "effects/GrCustomXfermode.h"
 #include "effects/GrCustomXfermodePriv.h"
 
@@ skipping 11 matching lines @@
 #include "gl/builders/GrGLProgramBuilder.h"
 
 bool GrCustomXfermode::IsSupportedMode(SkXfermode::Mode mode) {
     return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMode;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Static helpers
 ///////////////////////////////////////////////////////////////////////////////
 
-static void hard_light(GrGLFPFragmentBuilder* fsBuilder,
+static void hard_light(GrGLFragmentBuilder* 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(GrGLFPFragmentBuilder* fsBuilder,
+static void color_dodge_component(GrGLFragmentBuilder* 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(GrGLFPFragmentBuilder* fsBuilder,
+static void color_burn_component(GrGLFragmentBuilder* 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(GrGLFPFragmentBuilder* fsBuilder,
+static void soft_light_component_pos_dst_alpha(GrGLFragmentBuilder* 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 22 matching lines @@
                            final, component, dst, dst, component, src, src, component, dst,
                            src, component, dst, component, src, src, component, 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(GrGLFPFragmentBuilder* fsBuilder, SkString* setLumFunction) {
+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),
     };
     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(GrGLFPFragmentBuilder* fsBuilder, SkString* setSatFunction) {
+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) };
     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 52 matching lines @@
                        helpFunc, helpFunc);
     fsBuilder->emitFunction(kVec3f_GrSLType,
                             "set_saturation",
                             SK_ARRAY_COUNT(setSatArgs), setSatArgs,
                             setSatBody.c_str(),
                             setSatFunction);
 
 }
 
 static void emit_custom_xfermode_code(SkXfermode::Mode mode,
-                                      GrGLFPFragmentBuilder* fsBuilder,
+                                      GrGLFragmentBuilder* fsBuilder,
                                       const char* outputColor,
                                       const char* inputColor,
                                       const char* dstColor) {
     // We don't try to optimize for this case at all
     if (NULL == inputColor) {
         fsBuilder->codeAppendf("const vec4 ones = vec4(1);");
         inputColor = "ones";
     }
     fsBuilder->codeAppendf("// SkXfermode::Mode: %s\n", SkXfermode::ModeName(mode));
 
@@ skipping 139 matching lines @@
     GLCustomXferFP(const GrFragmentProcessor&) {}
     ~GLCustomXferFP() override {};
 
     void emitCode(GrGLFPBuilder* builder,
                   const GrFragmentProcessor& fp,
                   const char* outputColor,
                   const char* inputColor,
                   const TransformedCoordsArray& coords,
                   const TextureSamplerArray& samplers) override {
         SkXfermode::Mode mode = fp.cast<GrCustomXferFP>().mode();
-        GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+        GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
         const char* dstColor = "bgColor";
         fsBuilder->codeAppendf("vec4 %s = ", dstColor);
         fsBuilder->appendTextureLookup(samplers[0], coords[0].c_str(), coords[0].getType());
         fsBuilder->codeAppendf(";");
 
         emit_custom_xfermode_code(mode, fsBuilder, outputColor, inputColor, dstColor); 
     }
 
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override {}
 
@@ skipping 113 matching lines @@
     static void GenKey(const GrXferProcessor& proc, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
         uint32_t key = proc.numTextures();
         SkASSERT(key <= 1);
         key |= proc.cast<CustomXP>().mode() << 1;
         b->add32(key);
     }
 
 private:
     void onEmitCode(const EmitArgs& args) override {
         SkXfermode::Mode mode = args.fXP.cast<CustomXP>().mode();
-        GrGLFPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
+        GrGLXPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
         const char* dstColor = fsBuilder->dstColor();
 
         emit_custom_xfermode_code(mode, fsBuilder, args.fOutputPrimary, args.fInputColor, dstColor);
 
         fsBuilder->codeAppendf("%s = %s * %s + (vec4(1.0) - %s) * %s;",
                                args.fOutputPrimary, args.fOutputPrimary, args.fInputCoverage,
                                args.fInputCoverage, dstColor);
     }
 
     void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
@@ skipping 56 matching lines @@
 GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
 GrXPFactory* GrCustomXPFactory::TestCreate(SkRandom* rand,
                                            GrContext*,
                                            const GrDrawTargetCaps&,
                                            GrTexture*[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXPFactory, (static_cast<SkXfermode::Mode>(mode)));
 }