123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239 |
- /*
- * Copyright 2018 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #ifndef SkMaskFilterBase_DEFINED
- #define SkMaskFilterBase_DEFINED
- #include "include/core/SkBlurTypes.h"
- #include "include/core/SkFlattenable.h"
- #include "include/core/SkMaskFilter.h"
- #include "include/core/SkPaint.h"
- #include "include/core/SkStrokeRec.h"
- #include "include/private/SkNoncopyable.h"
- #include "src/core/SkMask.h"
- class GrClip;
- struct GrFPArgs;
- class GrFragmentProcessor;
- class GrPaint;
- class GrRecordingContext;
- class GrRenderTarget;
- class GrRenderTargetContext;
- class GrResourceProvider;
- class GrShape;
- class GrTexture;
- class GrTextureProxy;
- class SkBitmap;
- class SkBlitter;
- class SkCachedData;
- class SkMatrix;
- class SkPath;
- class SkRasterClip;
- class SkRRect;
- class SkMaskFilterBase : public SkMaskFilter {
- public:
- /** Returns the format of the resulting mask that this subclass will return
- when its filterMask() method is called.
- */
- virtual SkMask::Format getFormat() const = 0;
- /** Create a new mask by filter the src mask.
- If src.fImage == null, then do not allocate or create the dst image
- but do fill out the other fields in dstMask.
- If you do allocate a dst image, use SkMask::AllocImage()
- If this returns false, dst mask is ignored.
- @param dst the result of the filter. If src.fImage == null, dst should not allocate its image
- @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 = 0;
- #if SK_SUPPORT_GPU
- /**
- * Returns a processor if the filter can be expressed a single-pass GrProcessor without
- * requiring an explicit input mask. Per-pixel, the effect receives the incoming mask's
- * coverage as the input color and outputs the filtered covereage value. This means that each
- * pixel's filtered coverage must only depend on the unfiltered mask value for that pixel and
- * not on surrounding values.
- */
- std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs& args) const;
- /**
- * Returns true iff asFragmentProcessor() will return a processor
- */
- bool hasFragmentProcessor() const;
- /**
- * If asFragmentProcessor() fails the filter may be implemented on the GPU by a subclass
- * overriding filterMaskGPU (declared below). That code path requires constructing a
- * src mask as input. Since that is a potentially expensive operation, the subclass must also
- * override this function to indicate whether filterTextureMaskGPU would succeeed if the mask
- * were to be created.
- *
- * 'maskRect' returns the device space portion of the mask that 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).
- *
- * Logically, how this works is:
- * canFilterMaskGPU is called
- * if (it returns true)
- * the returned mask rect is used for quick rejecting
- * the mask rect is used to generate the mask
- * filterMaskGPU is called to filter the mask
- *
- * TODO: this should work as:
- * if (canFilterMaskGPU(devShape, ...)) // rect, rrect, drrect, path
- * filterMaskGPU(devShape, ...)
- * this would hide the RRect special case and the mask generation
- */
- virtual bool canFilterMaskGPU(const GrShape&,
- const SkIRect& devSpaceShapeBounds,
- const SkIRect& clipBounds,
- const SkMatrix& ctm,
- SkIRect* maskRect) const;
- /**
- * Try to directly render the mask filter into the target. Returns true if drawing was
- * successful. If false is returned then paint is unmodified.
- */
- virtual bool directFilterMaskGPU(GrRecordingContext*,
- GrRenderTargetContext*,
- GrPaint&& paint,
- const GrClip&,
- const SkMatrix& viewMatrix,
- const GrShape& shape) const;
- /**
- * This function is used to implement filters that require an explicit src mask. It should only
- * be called if canFilterMaskGPU returned true and the maskRect param should be the output from
- * that call.
- * Implementations are free to get the GrContext from the src texture in order to create
- * additional textures and perform multiple passes.
- */
- virtual sk_sp<GrTextureProxy> filterMaskGPU(GrRecordingContext*,
- sk_sp<GrTextureProxy> srcProxy,
- const SkMatrix& ctm,
- const SkIRect& maskRect) 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,
- * but subclasses may override this if they can compute the rect faster.
- */
- virtual void computeFastBounds(const SkRect& src, SkRect* dest) const;
- struct BlurRec {
- SkScalar fSigma;
- SkBlurStyle fStyle;
- };
- /**
- * If this filter can be represented by a BlurRec, return true and (if not null) fill in the
- * provided BlurRec parameter. If this effect cannot be represented as a BlurRec, return false
- * and ignore the BlurRec parameter.
- */
- virtual bool asABlur(BlurRec*) const;
- protected:
- SkMaskFilterBase() {}
- #if SK_SUPPORT_GPU
- virtual std::unique_ptr<GrFragmentProcessor> onAsFragmentProcessor(const GrFPArgs&) const;
- virtual bool onHasFragmentProcessor() const;
- #endif
- enum FilterReturn {
- kFalse_FilterReturn,
- kTrue_FilterReturn,
- kUnimplemented_FilterReturn
- };
- class NinePatch : ::SkNoncopyable {
- public:
- NinePatch() : fCache(nullptr) { }
- ~NinePatch();
- SkMask fMask; // fBounds must have [0,0] in its top-left
- SkIRect fOuterRect; // width/height must be >= fMask.fBounds'
- SkIPoint fCenter; // identifies center row/col for stretching
- SkCachedData* fCache;
- };
- /**
- * Override if your subclass can filter a rect, and return the answer as
- * a ninepatch mask to be stretched over the returned outerRect. On success
- * return kTrue_FilterReturn. On failure (e.g. out of memory) return
- * kFalse_FilterReturn. If the normal filterMask() entry-point should be
- * called (the default) return kUnimplemented_FilterReturn.
- *
- * By convention, the caller will take the center rol/col from the returned
- * mask as the slice it can replicate horizontally and vertically as we
- * stretch the mask to fit inside outerRect. It is an error for outerRect
- * to be smaller than the mask's bounds. This would imply that the width
- * and height of the mask should be odd. This is not required, just that
- * the caller will call mask.fBounds.centerX() and centerY() to find the
- * strips that will be replicated.
- */
- virtual FilterReturn filterRectsToNine(const SkRect[], int count,
- const SkMatrix&,
- const SkIRect& clipBounds,
- NinePatch*) const;
- /**
- * Similar to filterRectsToNine, except it performs the work on a round rect.
- */
- virtual FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&,
- const SkIRect& clipBounds,
- NinePatch*) const;
- private:
- friend class SkDraw;
- /** Helper method that, given a path in device space, will rasterize it into a kA8_Format mask
- and then call filterMask(). If this returns true, the specified blitter will be called
- to render that mask. Returns false if filterMask() returned false.
- This method is not exported to java.
- */
- bool filterPath(const SkPath& devPath, const SkMatrix& ctm, const SkRasterClip&, SkBlitter*,
- SkStrokeRec::InitStyle) const;
- /** Helper method that, given a roundRect in device space, will rasterize it into a kA8_Format
- mask and then call filterMask(). If this returns true, the specified blitter will be called
- to render that mask. Returns false if filterMask() returned false.
- */
- bool filterRRect(const SkRRect& devRRect, const SkMatrix& ctm, const SkRasterClip&,
- SkBlitter*) const;
- typedef SkFlattenable INHERITED;
- };
- inline SkMaskFilterBase* as_MFB(SkMaskFilter* mf) {
- return static_cast<SkMaskFilterBase*>(mf);
- }
- inline const SkMaskFilterBase* as_MFB(const SkMaskFilter* mf) {
- return static_cast<const SkMaskFilterBase*>(mf);
- }
- inline const SkMaskFilterBase* as_MFB(const sk_sp<SkMaskFilter>& mf) {
- return static_cast<SkMaskFilterBase*>(mf.get());
- }
- #endif
|