Implement color filter as GrGLEffect

src/effects/SkColorFilters.cpp

Index: src/effects/SkColorFilters.cpp
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index 41a201ef39559fc232e10319c3a9e65f20c39c8c..229e02cf63fb31a2bcfc4a50b7a3f4841ebe7a62 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -85,6 +85,9 @@ public:
     }
 #endif
 
+#if SK_SUPPORT_GPU
+    virtual GrEffectRef* asNewEffect(GrContext*) const SK_OVERRIDE;
+#endif
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
 
 protected:
@@ -117,6 +120,285 @@ private:
     typedef SkColorFilter INHERITED;
 };
 
+///////////////////////////////////////////////////////////////////////////////
+#if SK_SUPPORT_GPU
+#include "GrBlend.h"
+#include "GrEffect.h"
+#include "GrEffectUnitTest.h"
+#include "GrTBackendEffectFactory.h"
+#include "gl/GrGLEffect.h"
+#include "gl/GrGLEffectMatrix.h"
+#include "SkGr.h"
+
+namespace {
+/**
+ * A definition of blend equation for one coefficient. Generates a
+ * blend_coeff * value "expression".
+ */
+template<typename ColorExpr>
+static inline ColorExpr blend_term(SkXfermode::Coeff coeff,
+                                   const ColorExpr& src,
+                                   const ColorExpr& dst,
+                                   const ColorExpr& value) {
+    switch (coeff) {
+    default:
+        GrCrash("Unexpected xfer coeff.");
+    case SkXfermode::kZero_Coeff:    /** 0 */
+        return ColorExpr(0);
+    case SkXfermode::kOne_Coeff:     /** 1 */
+        return value;
+    case SkXfermode::kSC_Coeff:
+        return src * value;
+    case SkXfermode::kISC_Coeff:
+        return (1 - src) * dst;
+    case SkXfermode::kDC_Coeff:
+        return dst * value;
+    case SkXfermode::kIDC_Coeff:
+        return (1 - dst) * value;
+    case SkXfermode::kSA_Coeff:      /** src alpha */
+        return value * src.a();
+    case SkXfermode::kISA_Coeff:     /** inverse src alpha (i.e. 1 - sa) */
+        return value * (1 - src.a());
+    case SkXfermode::kDA_Coeff:      /** dst alpha */
+        return value * dst.a();
+    case SkXfermode::kIDA_Coeff:     /** inverse dst alpha (i.e. 1 - da) */
+        return value * (1 - dst.a());
+    }
+}
+/**
+ * Creates a color filter expression which modifies the color by
+ * the specified color filter.
+ */
+template <typename ColorExpr>
+static inline ColorExpr color_filter_expression(SkXfermode::Mode mode,
+                                                const ColorExpr& filterColor,
+                                                const ColorExpr& inColor) {
+    SkXfermode::Coeff colorCoeff;
+    SkXfermode::Coeff filterColorCoeff;
+    SkAssertResult(SkXfermode::ModeAsCoeff(mode, &filterColorCoeff, &colorCoeff));
+    return blend_term(colorCoeff, filterColor, inColor, inColor) +
+           blend_term(filterColorCoeff, filterColor, inColor, filterColor);
+}
+}
+
+class ModeColorFilterEffect : public GrEffect {
+public:
+    static GrEffectRef* Create(const GrColor& c, SkXfermode::Mode mode) {
+        AutoEffectUnref effect(SkNEW_ARGS(ModeColorFilterEffect, (c, mode)));
+        return CreateEffectRef(effect);
+    }
+
+    virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
+
+    virtual bool willUseInputColor() const {
+        SkXfermode::Coeff dstCoeff;
+        SkXfermode::Coeff srcCoeff;
+        SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff));
+        // These could be calculated from the blend equation with template trickery..
+        if (SkXfermode::kZero_Coeff == dstCoeff) {
+            return GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff));
+        }
+        return true;
+    }
+
+    bool willUseFilterColor() const {
+        SkXfermode::Coeff dstCoeff;
+        SkXfermode::Coeff srcCoeff;
+        SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff));
+        if (SkXfermode::kZero_Coeff == srcCoeff) {
+            return GrBlendCoeffRefsSrc(sk_blend_to_grblend(dstCoeff));
+        }
+        return true;
+    }
+
+    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
+        return GrTBackendEffectFactory<ModeColorFilterEffect>::getInstance();
+    }
+
+    static const char* Name() { return "ModeColorFilterEffect"; }
+
+    SkXfermode::Mode mode() const { return fMode; }
+    GrColor color() const { return fColor; }
+
+    class GLEffect : public GrGLEffect {
+    public:
+        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
+            : INHERITED(factory) {
+        }
+
+        virtual void emitCode(GrGLShaderBuilder* builder,
+                              const GrDrawEffect& drawEffect,
+                              EffectKey key,
+                              const char* outputColor,
+                              const char* inputColor,
+                              const TextureSamplerArray& samplers) SK_OVERRIDE {
+            SkXfermode::Mode mode = drawEffect.castEffect<ModeColorFilterEffect>().mode();
+
+            SkASSERT(SkXfermode::kDst_Mode != mode);
+            const char* colorFilterColorUniName = NULL;
+            if (drawEffect.castEffect<ModeColorFilterEffect>().willUseFilterColor()) {
+                fFilterColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+                                                      kVec4f_GrSLType, "FilterColor",
+                                                      &colorFilterColorUniName);
+            }
+
+            GrGLSLExpr<4> filter = color_filter_expression(mode,
+                                                           GrGLSLExpr<4>(colorFilterColorUniName),
+                                                           GrGLSLExpr<4>(inputColor));
+            builder->fsCodeAppendf("\t%s = %s;\n", outputColor, filter.c_str());
+        }
+
+        static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
+            const ModeColorFilterEffect& colorModeFilter = drawEffect.castEffect<ModeColorFilterEffect>();
+            // The SL code does not depend on filter color at the moment, so no need to represent it
+            // in the key.
+            EffectKey modeKey = colorModeFilter.mode();
+            return modeKey;
+        }
+
+        virtual void setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) SK_OVERRIDE {
+            if (fFilterColorUni.isValid()) {
+                const ModeColorFilterEffect& colorModeFilter = drawEffect.castEffect<ModeColorFilterEffect>();
+                GrGLfloat c[4];
+                GrColorToRGBAFloat(colorModeFilter.color(), c);
+                uman.set4fv(fFilterColorUni, 0, 1, c);
+            }
+        }
+
+    private:
+
+        static const GrEffect::CoordsType kCoordsType = GrEffect::kLocal_CoordsType;
+        GrGLUniformManager::UniformHandle fFilterColorUni;
+        typedef GrGLEffect INHERITED;
+    };
+
+    GR_DECLARE_EFFECT_TEST;
+
+private:
+    ModeColorFilterEffect(GrColor color, SkXfermode::Mode mode)
+        : fMode(mode),
+          fColor(color) {
+    }
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
+        const ModeColorFilterEffect& s = CastEffect<ModeColorFilterEffect>(other);
+        return fMode == s.fMode && fColor == s.fColor;
+    }
+
+    SkXfermode::Mode fMode;
+    GrColor fColor;
+
+    typedef GrEffect INHERITED;
+};
+
+namespace {
+/** MaskedColorExpr is used to evaluate the color and valid color component
+ * flags through the blending equation.
+ */
+class MaskedColorExpr {
+public:
+    MaskedColorExpr(const GrGLfloat color[], uint32_t flags)
+        : fFlags(flags) {
+        fColor[0] = color[0];
+        fColor[1] = color[1];
+        fColor[2] = color[2];
+        fColor[3] = color[3];
+    }
+    MaskedColorExpr(float v)
+        : fFlags(kRGBA_GrColorComponentFlags) {
+        fColor[0] = v;
+        fColor[1] = v;
+        fColor[2] = v;
+        fColor[3] = v;
+    }
+
+    MaskedColorExpr operator*(const MaskedColorExpr& other) const {
+        GrGLfloat tmp[4];
+        tmp[0] = GrMax(0.f, GrMin(1.f, fColor[0] * other.fColor[0]));
+        tmp[1] = GrMax(0.f, GrMin(1.f, fColor[1] * other.fColor[1]));
+        tmp[2] = GrMax(0.f, GrMin(1.f, fColor[2] * other.fColor[2]));
+        tmp[3] = GrMax(0.f, GrMin(1.f, fColor[3] * other.fColor[3]));
+
+        return MaskedColorExpr(tmp, fFlags & other.fFlags);
+    }
+
+    MaskedColorExpr operator+(const MaskedColorExpr& other) const {
+        GrGLfloat tmp[4];
+        tmp[0] = GrMax(0.f, GrMin(1.f, fColor[0] + other.fColor[0]));
+        tmp[1] = GrMax(0.f, GrMin(1.f, fColor[1] + other.fColor[1]));
+        tmp[2] = GrMax(0.f, GrMin(1.f, fColor[2] + other.fColor[2]));
+        tmp[3] = GrMax(0.f, GrMin(1.f, fColor[3] + other.fColor[3]));
+
+        return MaskedColorExpr(tmp, fFlags & other.fFlags);
+    }
+
+    MaskedColorExpr operator-(const MaskedColorExpr& other) const {
+        GrGLfloat tmp[4];
+        tmp[0] = GrMax(0.f, GrMin(1.f, fColor[0] - other.fColor[0]));
+        tmp[1] = GrMax(0.f, GrMin(1.f, fColor[1] - other.fColor[1]));
+        tmp[2] = GrMax(0.f, GrMin(1.f, fColor[2] - other.fColor[2]));
+        tmp[3] = GrMax(0.f, GrMin(1.f, fColor[3] - other.fColor[3]));
+
+        return MaskedColorExpr(tmp, fFlags & other.fFlags);
+    }
+
+    MaskedColorExpr a() const {
+        return MaskedColorExpr(fColor[3]);
+    }
+
+    GrColor getColor() const {
+        return GrColorPackRGBA(fColor[0] * 255.f, fColor[1] * 255.f,
+                               fColor[2] * 255.f, fColor[3] * 255.f);
+    }
+
+    uint32_t getValidComponents() const  { return fFlags; }
+
+private:
+    GrGLfloat fColor[4];
+    uint32_t fFlags;
+};
+
+MaskedColorExpr operator-(int v, const MaskedColorExpr& other) {
+    return MaskedColorExpr(v) - other;
+}
+}
+
+void ModeColorFilterEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {

[Kimmo Kinnunen, 2013/10/01 12:55:46]

Btw: It'd be great to be able to unit test these sort of things. There's the
problem of lack of .h file, so a new test .cpp file is not possible. Some sort
of static constructor -based test function discovery would be needed (similar to
DEFINE_EFFECT_TEST) unless the interface would be exposed in .h.

Any opinion on should this method be tested directly? Any opinion on how to
setup and run the test?

+    GrGLfloat inputColor[4];
+    GrColorToRGBAFloat(*color, inputColor);
+    GrGLfloat filterColor[4];
+    GrColorToRGBAFloat(fColor, filterColor);
+    MaskedColorExpr result =
+        color_filter_expression(fMode,
+                                MaskedColorExpr(filterColor, kRGBA_GrColorComponentFlags),
+                                MaskedColorExpr(inputColor, *validFlags));
+
+    *color = result.getColor();
+    *validFlags = result.getValidComponents();
+}
+
+GR_DEFINE_EFFECT_TEST(ModeColorFilterEffect);
+GrEffectRef* ModeColorFilterEffect::TestCreate(SkRandom* rand,
+                                    GrContext*,
+                                    const GrDrawTargetCaps&,
+                                    GrTexture*[]) {
+    int mode = rand->nextRangeU(0, SkXfermode::kLastCoeffMode);
+    GrColor color = rand->nextU();
+    static AutoEffectUnref gEffect(SkNEW_ARGS(ModeColorFilterEffect, (color, static_cast<SkXfermode::Mode>(mode))));
+    return CreateEffectRef(gEffect);
+}
+
+GrEffectRef* SkModeColorFilter::asNewEffect(GrContext*) const {
+    if (SkXfermode::kDst_Mode != fMode) {
+        return ModeColorFilterEffect::Create(SkColor2GrColor(fColor), fMode);
+    }
+    return NULL;
+}
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
 class Src_SkModeColorFilter : public SkModeColorFilter {
 public:
     Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrc_Mode) {}