Add luminance mask transfer modes.

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 614 matching lines @@
     }
 
     int a = srcover_byte(sa, da);
     int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr);
     int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg);
     int b = blendfunc_nonsep_byte(sb, db, sa, da, Db);
     return SkPackARGB32(a, r, g, b);
 }
 
 
+static SkPMColor srcinlum_modeproc(SkPMColor src, SkPMColor dst) {
+    int luma = SkComputeLuminance(SkGetPackedR32(dst),
+                                  SkGetPackedG32(dst),
+                                  SkGetPackedB32(dst));
+    return SkAlphaMulQ(src, SkAlpha255To256(luma));
+}
+
+static SkPMColor dstinlum_modeproc(SkPMColor src, SkPMColor dst) {
+    int luma = SkComputeLuminance(SkGetPackedR32(src),
+                                  SkGetPackedG32(src),
+                                  SkGetPackedB32(src));
+    return SkAlphaMulQ(dst, SkAlpha255To256(luma));
+}
+
 struct ProcCoeff {
     SkXfermodeProc      fProc;
     SkXfermode::Coeff   fSC;
     SkXfermode::Coeff   fDC;
 };
 
 #define CANNOT_USE_COEFF    SkXfermode::Coeff(-1)
 
 static const ProcCoeff gProcCoeffs[] = {
     { clear_modeproc,   SkXfermode::kZero_Coeff,    SkXfermode::kZero_Coeff },
@@ skipping 19 matching lines @@
     { colorburn_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { hardlight_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { softlight_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { difference_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { exclusion_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { multiply_modeproc,    CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { hue_modeproc,         CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { saturation_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { color_modeproc,       CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
     { luminosity_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { srcinlum_modeproc,    CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { dstinlum_modeproc,    CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkXfermode::asCoeff(Coeff* src, Coeff* dst) const {
     return false;
 }
 
 bool SkXfermode::asMode(Mode* mode) const {
     return false;
@@ skipping 393 matching lines @@
                     SkString setLum;
                     AddLumFunction(builder, &setLum);
                     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;
                 }
+                case SkXfermode::kSrcInLum_Mode: {
+                    builder->fsCodeAppendf("\t\tfloat luma = dot(vec3(%f, %f, %f), %s.rgb);\n",
+                                           SK_ITU_BT709_LUM_COEFF_R,
+                                           SK_ITU_BT709_LUM_COEFF_G,
+                                           SK_ITU_BT709_LUM_COEFF_B,
+                                           dstColor);
+                    builder->fsCodeAppendf("\t\t%s = %s * luma;\n", outputColor, inputColor);
+                    break;
+                }
+                case SkXfermode::kDstInLum_Mode: {
+                    builder->fsCodeAppendf("\t\tfloat luma = dot(vec3(%f, %f, %f), %s.rgb);\n",
+                                       SK_ITU_BT709_LUM_COEFF_R,
+                                       SK_ITU_BT709_LUM_COEFF_G,
+                                       SK_ITU_BT709_LUM_COEFF_B,
+                                       inputColor);
+                    builder->fsCodeAppendf("\t\t%s = %s * luma;\n", outputColor, dstColor);
+                    break;
+                }
                 default:
                     GrCrash("Unknown XferEffect mode.");
                     break;
             }
         }
 
         static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
             const XferEffect& xfer = drawEffect.castEffect<XferEffect>();
             GrTexture* bgTex = xfer.backgroundAccess().getTexture();
             EffectKey bgKey = 0;
@@ skipping 363 matching lines @@
     typedef SkProcXfermode INHERITED;
 };
 
 const char* SkXfermode::ModeName(Mode mode) {
     SkASSERT((unsigned) mode <= (unsigned)kLastMode);
     const char* gModeStrings[] = {
         "Clear", "Src", "Dst", "SrcOver", "DstOver", "SrcIn", "DstIn",
         "SrcOut", "DstOut", "SrcATop", "DstATop", "Xor", "Plus",
         "Modulate", "Screen", "Overlay", "Darken", "Lighten", "ColorDodge",
         "ColorBurn", "HardLight", "SoftLight", "Difference", "Exclusion",
-        "Multiply", "Hue", "Saturation", "Color",  "Luminosity"
+        "Multiply", "Hue", "Saturation", "Color",  "Luminosity", "SrcInLum",
+        "DstInLum"
     };
     return gModeStrings[mode];
     SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gModeStrings) == kLastMode + 1, mode_count);
 }
 
 #ifdef SK_DEVELOPER
 void SkProcCoeffXfermode::toString(SkString* str) const {
     str->append("SkProcCoeffXfermode: ");
 
     str->append("mode: ");
@@ skipping 490 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