Add canFilterMaskGPU & filterMaskGPU to SkMaskFilter

include/core/SkMaskFilter.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkMaskFilter_DEFINED
 #define SkMaskFilter_DEFINED
 
 #include "SkFlattenable.h"
 #include "SkMask.h"
 #include "SkPaint.h"
 
+class SkBitmap;
 class SkBlitter;
 class SkBounder;
 class SkMatrix;
 class SkPath;
 class SkRasterClip;
 
 /** \class SkMaskFilter
 
     SkMaskFilter is the base class for object that perform transformations on
     an alpha-channel mask before drawing it. A subclass of SkMaskFilter may be
@@ skipping 24 matching lines @@
         @param src the original image to be filtered.
         @param matrix the CTM
         @param margin   if not null, return the buffer dx/dy need when calculating the effect. Used when
                         drawing a clipped object to know how much larger to allocate the src before
                         applying the filter. If returning false, ignore this parameter.
         @return true if the dst mask was correctly created.
     */
     virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
                             SkIPoint* margin) const;
 
-    enum BlurType {
-        kNone_BlurType,    //!< this maskfilter is not a blur
-        kNormal_BlurType,  //!< fuzzy inside and outside
-        kSolid_BlurType,   //!< solid inside, fuzzy outside
-        kOuter_BlurType,   //!< nothing inside, fuzzy outside
-        kInner_BlurType    //!< fuzzy inside, nothing outside
-    };
-
-    struct BlurInfo {
-        SkScalar fRadius;
-        bool     fIgnoreTransform;
-        bool     fHighQuality;
-    };
+#if SK_SUPPORT_GPU
+    /**
+     *  Returns true if the filter can be expressed a single-pass
+     *  GrEffect, used to process this filter on the GPU, or false if
+     *  not.
+     *
+     *  If effect is non-NULL, a new GrEffect instance is stored
+     *  in it.  The caller assumes ownership of the stage, and it is up to the
+     *  caller to unref it.
+     */
+    virtual bool asNewEffect(GrEffectRef** effect, GrTexture*) const;
 
     /**
-     *  Optional method for maskfilters that can be described as a blur. If so,
-     *  they return the corresponding BlurType and set the fields in BlurInfo
-     *  (if not null). If they cannot be described as a blur, they return
-     *  kNone_BlurType and ignore the info parameter.
+     *  Returns true if the filter can be processed on the GPU.  This is most
+     *  often used for multi-pass effects, where intermediate results must be
+     *  rendered to textures.  For single-pass effects, use asNewEffect().
+     *
+     *  'maskRect' returns the device space portion of the mask the the filter
+     *  needs. The mask passed into 'filterMaskGPU' should have the same extent
+     *  as 'maskRect' but be translated to the upper-left corner of the mask
+     *  (i.e., (maskRect.fLeft, maskRect.fTop) appears at (0, 0) in the mask).
      */
-    virtual BlurType asABlur(BlurInfo*) const;
+    virtual bool canFilterMaskGPU(const SkRect& devBounds, 
+                                  const SkIRect& clipBounds,
+                                  const SkMatrix& ctm,
+                                  SkRect* maskRect) const;
+
+    /**
+     *  Perform this mask filter on the GPU.  This is most often used for
+     *  multi-pass effects, where intermediate results must be rendered to
+     *  textures.  For single-pass effects, use asNewEffect().  'src' is the
+     *  source image for processing, as a texture-backed bitmap.  'result' is
+     *  the destination bitmap, which should contain a texture-backed pixelref
+     *  on success. 'maskRect' should be the rect returned from canFilterMaskGPU.
+     */
+    bool filterMaskGPU(GrContext* context,
+                       const SkBitmap& src, 
+                       const SkRect& maskRect, 
+                       SkBitmap* result) const;
+
+    /**
+     *  This flavor of 'filterMaskGPU' provides a more direct means of accessing
+     *  the filtering capabilities. Setting 'canOverwriteSrc' can allow some
+     *  filters to skip the allocation of an additional texture.
+     */
+    virtual bool filterMaskGPU(GrTexture* src, 
+                               const SkRect& maskRect, 
+                               GrTexture** result,
+                               bool canOverwriteSrc) const;
+#endif
 
     /**
      * The fast bounds function is used to enable the paint to be culled early
      * in the drawing pipeline. This function accepts the current bounds of the
      * paint as its src param and the filter adjust those bounds using its
      * current mask and returns the result using the dest param. Callers are
      * allowed to provide the same struct for both src and dest so each
      * implementation must accomodate that behavior.
      *
      *  The default impl calls filterMask with the src mask having no image,
@@ skipping 48 matching lines @@
      This method is not exported to java.
      */
     bool filterPath(const SkPath& devPath, const SkMatrix& devMatrix,
                     const SkRasterClip&, SkBounder*, SkBlitter* blitter,
                     SkPaint::Style style) const;
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif