Add non-separable xfer modes to GPU backend.

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 937 matching lines @@
 #include "GrEffectUnitTest.h"
 #include "GrTBackendEffectFactory.h"
 #include "gl/GrGLEffect.h"
 
 /**
  * GrEffect that implements the all the separable xfer modes that cannot be expressed as Coeffs.
  */
 class XferEffect : public GrEffect {
 public:
     static bool IsSupportedMode(SkXfermode::Mode mode) {
-        return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastSeparableMode;
+        return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMode;
     }
 
     static GrEffectRef* Create(SkXfermode::Mode mode) {
         if (!IsSupportedMode(mode)) {
             return NULL;
         } else {
             AutoEffectUnref effect(SkNEW_ARGS(XferEffect, (mode)));
             return CreateEffectRef(effect);
         }
     }
@@ skipping 24 matching lines @@
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             const char* dstColor = builder->dstColor();
             GrAssert(NULL != dstColor);
 
             // We don't try to optimize for this case at all
             if (NULL == inputColor) {
                 builder->fsCodeAppendf("\tconst vec4 ones = %s;\n", GrGLSLOnesVecf(4));
                 inputColor = "ones";
             }
 
+            SkXfermode::Mode mode = drawEffect.castEffect<XferEffect>().mode();
+            builder->fsCodeAppendf("\t\t// SkXfermode::Mode: %s\n", SkXfermode::ModeName(mode));
+
             // These all perform src-over on the alpha channel.
             builder->fsCodeAppendf("\t\t%s.a = %s.a + (1.0 - %s.a) * %s.a;\n",
                                     outputColor, inputColor, inputColor, dstColor);
 
-            switch (drawEffect.castEffect<XferEffect>().mode()) {
+            switch (mode) {
                 case SkXfermode::kOverlay_Mode:
                     // Overlay is Hard-Light with the src and dst reversed
                     HardLight(builder, outputColor, dstColor, inputColor);
                     break;
                 case SkXfermode::kDarken_Mode:
                     builder->fsCodeAppendf("\t\t%s.rgb = min((1.0 - %s.a) * %s.rgb + %s.rgb, "
                                                             "(1.0 - %s.a) * %s.rgb + %s.rgb);\n",
                                             outputColor,
                                             inputColor, dstColor, inputColor,
                                             dstColor, inputColor, dstColor);
@@ skipping 38 matching lines @@
                                                         "2.0 * %s.rgb * %s.rgb;\n",
                                            outputColor, dstColor, inputColor, dstColor, inputColor);
                     break;
                 case SkXfermode::kMultiply_Mode:
                     builder->fsCodeAppendf("\t\t%s.rgb = (1.0 - %s.a) * %s.rgb + "
                                                         "(1.0 - %s.a) * %s.rgb + "
                                                          "%s.rgb * %s.rgb;\n",
                                            outputColor, inputColor, dstColor, dstColor, inputColor,
                                            inputColor, dstColor);
                     break;
-                case SkXfermode::kHue_Mode:
-                case SkXfermode::kSaturation_Mode:
-                case SkXfermode::kColor_Mode:
-                case SkXfermode::kLuminosity_Mode:
-                    GrCrash("Unimplemented XferEffect mode.");
+                case SkXfermode::kHue_Mode: {
+                    //  SetLum(SetSat(S * Da, Sat(D * Sa)), Sa*Da, D*Sa) + (1 - Sa) * D + (1 - Da) * S
+                    SkString setSat, setLum;
+                    AddSatFunction(builder, &setSat);
+                    AddLumFunction(builder, &setLum);

[robertphillips, 2013/04/22 15:46:31]

\n before dstColor?

[bsalomon, 2013/04/22 17:36:17]

Done.

+                    builder->fsCodeAppendf("\t\tvec4 dstSrcAlpha = %s * %s.a;\n", dstColor, inputColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb = %s(%s(%s.rgb * %s.a, dstSrcAlpha.rgb), dstSrcAlpha.a, dstSrcAlpha.rgb);\n",

[robertphillips, 2013/04/22 15:46:31]

\n before inputColor?

[bsalomon, 2013/04/22 17:36:17]

Done.

+                                           outputColor, setLum.c_str(), setSat.c_str(), inputColor, dstColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb += (1.0 - %s.a) * %s.rgb + (1.0 - %s.a) * %s.rgb;\n",
+                                           outputColor, inputColor, dstColor, dstColor, inputColor);
                     break;
+                }
+                case SkXfermode::kSaturation_Mode: {
+                    // SetLum(SetSat(D * Sa, Sat(S * Da)), Sa*Da, D*Sa)) + (1 - Sa) * D + (1 - Da) * S
+                    SkString setSat, setLum;
+                    AddSatFunction(builder, &setSat);
+                    AddLumFunction(builder, &setLum);

[robertphillips, 2013/04/22 15:46:31]

\n

[bsalomon, 2013/04/22 17:36:17]

Done.

+                    builder->fsCodeAppendf("\t\tvec4 dstSrcAlpha = %s * %s.a;\n", dstColor, inputColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb = %s(%s(dstSrcAlpha.rgb, %s.rgb * %s.a), dstSrcAlpha.a, dstSrcAlpha.rgb);\n",

[robertphillips, 2013/04/22 15:46:31]

/n

[bsalomon, 2013/04/22 17:36:17]

Done.

+                                           outputColor, setLum.c_str(), setSat.c_str(), inputColor, dstColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb += (1.0 - %s.a) * %s.rgb + (1.0 - %s.a) * %s.rgb;\n",
+                                           outputColor, inputColor, dstColor, dstColor, inputColor);
+                    break;
+                }
+                case SkXfermode::kColor_Mode: {
+                    //  SetLum(S * Da, Sa* Da, D * Sa) + (1 - Sa) * D + (1 - Da) * S
+                    SkString setLum;
+                    AddLumFunction(builder, &setLum);

[robertphillips, 2013/04/22 15:46:31]

\n

[bsalomon, 2013/04/22 17:36:17]

Done.

+                    builder->fsCodeAppendf("\t\tvec4 srcDstAlpha = %s * %s.a;\n", inputColor, dstColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb = %s(srcDstAlpha.rgb, srcDstAlpha.a, %s.rgb * %s.a);\n",
+                                           outputColor, setLum.c_str(), dstColor, inputColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb += (1.0 - %s.a) * %s.rgb + (1.0 - %s.a) * %s.rgb;\n",
+                                           outputColor, inputColor, dstColor, dstColor, inputColor);
+                    break;
+                }
+                case SkXfermode::kLuminosity_Mode: {
+                    //  SetLum(D * Sa, Sa* Da, S * Da) + (1 - Sa) * D + (1 - Da) * S
+                    SkString setLum;
+                    AddLumFunction(builder, &setLum);

[robertphillips, 2013/04/22 15:46:31]

\n

[bsalomon, 2013/04/22 17:36:17]

Done.

+                    builder->fsCodeAppendf("\t\tvec4 srcDstAlpha = %s * %s.a;\n", inputColor, dstColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb = %s(%s.rgb * %s.a, srcDstAlpha.a, srcDstAlpha.rgb);\n",
+                                           outputColor, setLum.c_str(), dstColor, inputColor);
+                    builder->fsCodeAppendf("\t\t%s.rgb += (1.0 - %s.a) * %s.rgb + (1.0 - %s.a) * %s.rgb;\n",
+                                           outputColor, inputColor, dstColor, dstColor, inputColor);
+                    break;
+                }
                 default:
                     GrCrash("Unknown XferEffect mode.");
                     break;
             }
         }
 
         static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
             return drawEffect.castEffect<XferEffect>().mode();
         }
 
@@ skipping 88 matching lines @@
                                    src, src, component, dst, src, src, component, src, src,
                                    component);
             builder->fsCodeAppendf("\t\t\t} else {\n");
             // -sqrt(Da * D) (Sa-2 S)-Da S+D (Sa-2 S+1)+S
             builder->fsCodeAppendf("\t\t\t\t%s.%c = -sqrt(%s.a*%s.%c)*(%s.a - 2.0*%s.%c) - %s.a*%s.%c + %s.%c*(%s.a - 2.0*%s.%c + 1.0) + %s.%c;\n",
                                     final, component, dst, dst, component, src, src, component, dst,
                                     src, component, dst, component, src, src, component, src,
                                     component);
             builder->fsCodeAppendf("\t\t\t}\n");
         }
 

[robertphillips, 2013/04/22 15:46:31]

It also emits "luminance" method

[bsalomon, 2013/04/22 17:36:17]

But it doesn't return the name of it, so it isn't visible to the caller. It's
used from the set function.

+        // 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 AddLumFunction(GrGLShaderBuilder* builder, SkString* setLumFunction) {
+            SkString getFunction;

[robertphillips, 2013/04/22 15:46:31]

Is the indent right after this {?

[bsalomon, 2013/04/22 17:36:17]

I removed the blocks.

+            {

[robertphillips, 2013/04/22 15:46:31]

one line?

[bsalomon, 2013/04/22 17:36:17]

Done.

+            GrGLShaderVar args[] = {
+                GrGLShaderVar("color", kVec3f_GrSLType),
+            };
+            SkString body("\treturn dot(vec3(0.3, 0.59, 0.11), color);\n");
+            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
+                                  kFloat_GrSLType,
+                                  "luminance",
+                                   SK_ARRAY_COUNT(args), args,
+                                   body.c_str(),
+                                   &getFunction);
+            }
+
+            {
+            GrGLShaderVar args[] = {
+                GrGLShaderVar("hueSat", kVec3f_GrSLType),
+                GrGLShaderVar("alpha", kFloat_GrSLType),
+                GrGLShaderVar("lumColor", kVec3f_GrSLType),
+            };
+            SkString body;
+            body.printf("\tfloat diff = %s(lumColor - hueSat);\n", getFunction.c_str());
+            body.append("\tvec3 outColor = hueSat + diff;\n");
+            body.appendf("\tfloat outLum = %s(outColor);\n", getFunction.c_str());

[robertphillips, 2013/04/22 15:46:31]

Is this code happy with black?

[bsalomon, 2013/04/22 17:36:17]

yup

+            body.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(args), args,
+                        body.c_str(),
+                        setLumFunction);
+            }
+        }
+

[robertphillips, 2013/04/22 15:46:31]

functions that create?

[bsalomon, 2013/04/22 17:36:17]

Changed to "Adds a function that creates"

+        // Adds functions 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) {
+            SkString getFunction;

[robertphillips, 2013/04/22 15:46:31]

// emit 'saturation' function?

[bsalomon, 2013/04/22 17:36:17]

Done.

+            {
+            GrGLShaderVar args[] = {
+                GrGLShaderVar("color", kVec3f_GrSLType),
+            };
+            SkString body;
+            body.appendf("\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(args), args,
+                                  body.c_str(),
+                                  &getFunction);
+            }
+
+            SkString helper;

[robertphillips, 2013/04/22 15:46:31]

emit "set_saturation_helper" method?

[bsalomon, 2013/04/22 17:36:17]

Done.

+            {
+            GrGLShaderVar args[] = {
+                GrGLShaderVar("minComp", kFloat_GrSLType),
+                GrGLShaderVar("midComp", kFloat_GrSLType),
+                GrGLShaderVar("maxComp", kFloat_GrSLType),
+                GrGLShaderVar("sat", kFloat_GrSLType),
+            };
+            args[0].setTypeModifier(GrGLShaderVar::kInOut_TypeModifier);
+            args[1].setTypeModifier(GrGLShaderVar::kInOut_TypeModifier);
+            args[2].setTypeModifier(GrGLShaderVar::kInOut_TypeModifier);
+            SkString body;
+            body.append("\tif (minComp < maxComp) {\n"
+                        "\t\tmidComp = sat * (midComp - minComp) / (maxComp - minComp);\n"
+                        "\t\tmaxComp = sat;\n"
+                        "\t} else {\n"
+                        "\t\tmidComp = midComp = 0.0;\n"
+                        "\t}\n"
+                        "\tminComp = 0.0;\n");
+            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
+                                  kVoid_GrSLType,
+                                  "set_saturation_helper",
+                                  SK_ARRAY_COUNT(args), args,
+                                  body.c_str(),
+                                  &helper);
+            }
+            {
+            GrGLShaderVar args[] = {
+                GrGLShaderVar("hueLumColor", kVec3f_GrSLType),
+                GrGLShaderVar("satColor", kVec3f_GrSLType),
+            };
+            SkString body;
+            const char* helpFunc = helper.c_str();
+            body.appendf("\tfloat sat = %s(satColor);\n"
+                         "\tif (hueLumColor.r <= hueLumColor.g) {\n"
+                         "\t\tif (hueLumColor.g <= hueLumColor.b) {\n"
+                         "\t\t\t%s(hueLumColor.r, hueLumColor.g, hueLumColor.b, sat);\n"
+                         "\t\t} else {\n"
+                         "\t\t\t%s(hueLumColor.r, hueLumColor.b, hueLumColor.g, sat);\n"
+                         "\t\t}\n"
+                         "\t} else if (hueLumColor.r <= hueLumColor.b) {\n"
+                         "\t\t%s(hueLumColor.g, hueLumColor.r, hueLumColor.b, sat);\n"
+                         "\t} else if (hueLumColor.g <= hueLumColor.b) {\n"
+                         "\t\t%s(hueLumColor.g, hueLumColor.b, hueLumColor.r, sat);\n"
+                         "\t} else {\n"
+                         "\t\t%s(hueLumColor.b, hueLumColor.g, hueLumColor.r, sat);\n"
+                         "\t}\n"
+                         "\treturn hueLumColor;",
+                         getFunction.c_str(), helpFunc, helpFunc, helpFunc, helpFunc, helpFunc);
+            builder->emitFunction(GrGLShaderBuilder::kFragment_ShaderType,
+                                  kVec3f_GrSLType,
+                                  "set_saturation",
+                                  SK_ARRAY_COUNT(args), args,
+                                  body.c_str(),
+                                  setSatFunction);
+            }
+
+        }
+
         typedef GrGLEffect INHERITED;
     };
 
     GR_DECLARE_EFFECT_TEST;
 
 private:
     XferEffect(SkXfermode::Mode mode) : fMode(mode) { this->setWillReadDst(); }
     virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { return true; }
 
     SkXfermode::Mode fMode;
@@ skipping 604 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