Initial change to move 2D kernel to its own file

src/gpu/effects/GrMatrixConvolutionEffect.h

Index: src/gpu/effects/GrMatrixConvolutionEffect.h
diff --git a/src/gpu/effects/GrMatrixConvolutionEffect.h b/src/gpu/effects/GrMatrixConvolutionEffect.h
new file mode 100644
index 0000000000000000000000000000000000000000..49c1c6a9a0cf1311e19d3f9d5bd6bddb4a85fe0b
--- /dev/null
+++ b/src/gpu/effects/GrMatrixConvolutionEffect.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrMatrixConvolutionEffect_DEFINED
+#define GrMatrixConvolutionEffect_DEFINED
+
+#include "GrSingleTextureEffect.h"
+#include "../effects/SkMatrixConvolutionImageFilter.h"

[bsalomon, 2014/07/11 13:07:41]

Hmm... we like the effects code to be optional so clients can only build the
subset of it that they require.

We might have to duplicate the enum and have a translation in SkCMIF.cpp (it
could just cast and statically assert that the enum values match).

Also, it might be worth looking at whether GrMCE should be using the
GrTextureDomain helper. It doesn't currently support mirroring, though it could
be extended fairly easily, I believe. (If that is something to pursue I'd argue
for doing it in a separate change).

+
+class GrGLMatrixConvolutionEffect;
+
+// A little bit less than the minimum # uniforms required by DX9SM2 (32).
+// Allows for a 5x5 kernel (or 25x1, for that matter).
+#define MAX_KERNEL_SIZE 25
+
+class GrMatrixConvolutionEffect : public GrSingleTextureEffect {
+public:
+    typedef SkMatrixConvolutionImageFilter::TileMode TileMode;
+    static GrEffect* Create(GrTexture* texture,
+                            const SkIRect& bounds,
+                            const SkISize& kernelSize,
+                            const SkScalar* kernel,
+                            SkScalar gain,
+                            SkScalar bias,
+                            const SkIPoint& kernelOffset,
+                            TileMode tileMode,
+                            bool convolveAlpha) {
+        return SkNEW_ARGS(GrMatrixConvolutionEffect, (texture,
+                                                      bounds,
+                                                      kernelSize,
+                                                      kernel,
+                                                      gain,
+                                                      bias,
+                                                      kernelOffset,
+                                                      tileMode,
+                                                      convolveAlpha));
+    }
+    virtual ~GrMatrixConvolutionEffect();
+
+    virtual void getConstantColorComponents(GrColor* color,
+                                            uint32_t* validFlags) const SK_OVERRIDE {
+        // TODO: Try to do better?
+        *validFlags = 0;
+    }
+
+    static const char* Name() { return "MatrixConvolution"; }
+    const SkIRect& bounds() const { return fBounds; }
+    const SkISize& kernelSize() const { return fKernelSize; }
+    const float* kernelOffset() const { return fKernelOffset; }
+    const float* kernel() const { return fKernel; }
+    float gain() const { return fGain; }
+    float bias() const { return fBias; }
+    TileMode tileMode() const { return fTileMode; }
+    bool convolveAlpha() const { return fConvolveAlpha; }
+
+    typedef GrGLMatrixConvolutionEffect GLEffect;
+
+    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
+
+private:
+    GrMatrixConvolutionEffect(GrTexture*,
+                              const SkIRect& bounds,
+                              const SkISize& kernelSize,
+                              const SkScalar* kernel,
+                              SkScalar gain,
+                              SkScalar bias,
+                              const SkIPoint& kernelOffset,
+                              TileMode tileMode,
+                              bool convolveAlpha);
+
+    virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+
+    SkIRect  fBounds;
+    SkISize  fKernelSize;
+    float   *fKernel;
+    float    fGain;
+    float    fBias;
+    float    fKernelOffset[2];
+    TileMode fTileMode;
+    bool     fConvolveAlpha;
+
+    GR_DECLARE_EFFECT_TEST;
+
+    typedef GrSingleTextureEffect INHERITED;
+};
+
+#endif