1 2 /* 3 * Copyright 2006 The Android Open Source Project 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10 #ifndef SkMaskFilter_DEFINED 11 #define SkMaskFilter_DEFINED 12 13 #include "SkBlurTypes.h" 14 #include "SkFlattenable.h" 15 #include "SkMask.h" 16 #include "SkPaint.h" 17 #include "SkStrokeRec.h" 18 19 class GrClip; 20 class GrContext; 21 class GrRenderTargetContext; 22 class GrPaint; 23 class GrFragmentProcessor; 24 class GrRenderTarget; 25 class GrResourceProvider; 26 class GrTexture; 27 class GrTextureProxy; 28 class SkBitmap; 29 class SkBlitter; 30 class SkCachedData; 31 class SkMatrix; 32 class SkPath; 33 class SkRasterClip; 34 class SkRRect; 35 36 /** \class SkMaskFilter 37 38 SkMaskFilter is the base class for object that perform transformations on 39 an alpha-channel mask before drawing it. A subclass of SkMaskFilter may be 40 installed into a SkPaint. Once there, each time a primitive is drawn, it 41 is first scan converted into a SkMask::kA8_Format mask, and handed to the 42 filter, calling its filterMask() method. If this returns true, then the 43 new mask is used to render into the device. 44 45 Blur and emboss are implemented as subclasses of SkMaskFilter. 46 */ 47 class SK_API SkMaskFilter : public SkFlattenable { 48 public: 49 /** Returns the format of the resulting mask that this subclass will return 50 when its filterMask() method is called. 51 */ 52 virtual SkMask::Format getFormat() const = 0; 53 54 /** Create a new mask by filter the src mask. 55 If src.fImage == null, then do not allocate or create the dst image 56 but do fill out the other fields in dstMask. 57 If you do allocate a dst image, use SkMask::AllocImage() 58 If this returns false, dst mask is ignored. 59 @param dst the result of the filter. If src.fImage == null, dst should not allocate its image 60 @param src the original image to be filtered. 61 @param matrix the CTM 62 @param margin if not null, return the buffer dx/dy need when calculating the effect. Used when 63 drawing a clipped object to know how much larger to allocate the src before 64 applying the filter. If returning false, ignore this parameter. 65 @return true if the dst mask was correctly created. 66 */ 67 virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&, 68 SkIPoint* margin) const; 69 70 #if SK_SUPPORT_GPU 71 /** 72 * Returns true if the filter can be expressed a single-pass GrProcessor without requiring an 73 * explicit input mask. Per-pixel, the effect receives the incoming mask's coverage as 74 * the input color and outputs the filtered covereage value. This means that each pixel's 75 * filtered coverage must only depend on the unfiltered mask value for that pixel and not on 76 * surrounding values. 77 * 78 * If effect is non-NULL, a new GrProcessor instance is stored in it. The caller assumes 79 * ownership of the effect and must unref it. 80 */ 81 virtual bool asFragmentProcessor(GrFragmentProcessor**) const { return false; } 82 83 /** 84 * If asFragmentProcessor() fails the filter may be implemented on the GPU by a subclass 85 * overriding filterMaskGPU (declared below). That code path requires constructing a 86 * src mask as input. Since that is a potentially expensive operation, the subclass must also 87 * override this function to indicate whether filterTextureMaskGPU would succeeed if the mask 88 * were to be created. 89 * 90 * 'maskRect' returns the device space portion of the mask that the filter needs. The mask 91 * passed into 'filterMaskGPU' should have the same extent as 'maskRect' but be 92 * translated to the upper-left corner of the mask (i.e., (maskRect.fLeft, maskRect.fTop) 93 * appears at (0, 0) in the mask). 94 * 95 * Logically, how this works is: 96 * canFilterMaskGPU is called 97 * if (it returns true) 98 * the returned mask rect is used for quick rejecting 99 * either directFilterMaskGPU or directFilterRRectMaskGPU is then called 100 * if (neither of them handle the blur) 101 * the mask rect is used to generate the mask 102 * filterMaskGPU is called to filter the mask 103 * 104 * TODO: this should work as: 105 * if (canFilterMaskGPU(devShape, ...)) // rect, rrect, drrect, path 106 * filterMaskGPU(devShape, ...) 107 * this would hide the RRect special case and the mask generation 108 */ 109 virtual bool canFilterMaskGPU(const SkRRect& devRRect, 110 const SkIRect& clipBounds, 111 const SkMatrix& ctm, 112 SkRect* maskRect) const; 113 114 /** 115 * Try to directly render the mask filter into the target. Returns true if drawing was 116 * successful. If false is returned then paint is unmodified. 117 */ 118 virtual bool directFilterMaskGPU(GrContext*, 119 GrRenderTargetContext* renderTargetContext, 120 GrPaint&& paint, 121 const GrClip&, 122 const SkMatrix& viewMatrix, 123 const SkStrokeRec& strokeRec, 124 const SkPath& path) const; 125 /** 126 * Try to directly render a rounded rect mask filter into the target. Returns 127 * true if drawing was successful. If false is returned then paint is unmodified. 128 */ 129 virtual bool directFilterRRectMaskGPU(GrContext*, 130 GrRenderTargetContext* renderTargetContext, 131 GrPaint&& paint, 132 const GrClip&, 133 const SkMatrix& viewMatrix, 134 const SkStrokeRec& strokeRec, 135 const SkRRect& rrect, 136 const SkRRect& devRRect) const; 137 138 /** 139 * This function is used to implement filters that require an explicit src mask. It should only 140 * be called if canFilterMaskGPU returned true and the maskRect param should be the output from 141 * that call. 142 * Implementations are free to get the GrContext from the src texture in order to create 143 * additional textures and perform multiple passes. 144 */ 145 virtual sk_sp<GrTextureProxy> filterMaskGPU(GrContext*, 146 sk_sp<GrTextureProxy> srcProxy, 147 const SkMatrix& ctm, 148 const SkIRect& maskRect) const; 149 #endif 150 151 /** 152 * The fast bounds function is used to enable the paint to be culled early 153 * in the drawing pipeline. This function accepts the current bounds of the 154 * paint as its src param and the filter adjust those bounds using its 155 * current mask and returns the result using the dest param. Callers are 156 * allowed to provide the same struct for both src and dest so each 157 * implementation must accomodate that behavior. 158 * 159 * The default impl calls filterMask with the src mask having no image, 160 * but subclasses may override this if they can compute the rect faster. 161 */ 162 virtual void computeFastBounds(const SkRect& src, SkRect* dest) const; 163 164 struct BlurRec { 165 SkScalar fSigma; 166 SkBlurStyle fStyle; 167 SkBlurQuality fQuality; 168 }; 169 /** 170 * If this filter can be represented by a BlurRec, return true and (if not null) fill in the 171 * provided BlurRec parameter. If this effect cannot be represented as a BlurRec, return false 172 * and ignore the BlurRec parameter. 173 */ 174 virtual bool asABlur(BlurRec*) const; 175 176 SK_TO_STRING_PUREVIRT() 177 SK_DEFINE_FLATTENABLE_TYPE(SkMaskFilter) 178 179 protected: 180 SkMaskFilter() {} 181 182 enum FilterReturn { 183 kFalse_FilterReturn, 184 kTrue_FilterReturn, 185 kUnimplemented_FilterReturn 186 }; 187 188 class NinePatch : ::SkNoncopyable { 189 public: 190 NinePatch() : fCache(nullptr) { } 191 ~NinePatch(); 192 193 SkMask fMask; // fBounds must have [0,0] in its top-left 194 SkIRect fOuterRect; // width/height must be >= fMask.fBounds' 195 SkIPoint fCenter; // identifies center row/col for stretching 196 SkCachedData* fCache; 197 }; 198 199 /** 200 * Override if your subclass can filter a rect, and return the answer as 201 * a ninepatch mask to be stretched over the returned outerRect. On success 202 * return kTrue_FilterReturn. On failure (e.g. out of memory) return 203 * kFalse_FilterReturn. If the normal filterMask() entry-point should be 204 * called (the default) return kUnimplemented_FilterReturn. 205 * 206 * By convention, the caller will take the center rol/col from the returned 207 * mask as the slice it can replicate horizontally and vertically as we 208 * stretch the mask to fit inside outerRect. It is an error for outerRect 209 * to be smaller than the mask's bounds. This would imply that the width 210 * and height of the mask should be odd. This is not required, just that 211 * the caller will call mask.fBounds.centerX() and centerY() to find the 212 * strips that will be replicated. 213 */ 214 virtual FilterReturn filterRectsToNine(const SkRect[], int count, 215 const SkMatrix&, 216 const SkIRect& clipBounds, 217 NinePatch*) const; 218 /** 219 * Similar to filterRectsToNine, except it performs the work on a round rect. 220 */ 221 virtual FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&, 222 const SkIRect& clipBounds, 223 NinePatch*) const; 224 225 private: 226 friend class SkDraw; 227 228 /** Helper method that, given a path in device space, will rasterize it into a kA8_Format mask 229 and then call filterMask(). If this returns true, the specified blitter will be called 230 to render that mask. Returns false if filterMask() returned false. 231 This method is not exported to java. 232 */ 233 bool filterPath(const SkPath& devPath, const SkMatrix& ctm, const SkRasterClip&, SkBlitter*, 234 SkStrokeRec::InitStyle) const; 235 236 /** Helper method that, given a roundRect in device space, will rasterize it into a kA8_Format 237 mask and then call filterMask(). If this returns true, the specified blitter will be called 238 to render that mask. Returns false if filterMask() returned false. 239 */ 240 bool filterRRect(const SkRRect& devRRect, const SkMatrix& ctm, const SkRasterClip&, 241 SkBlitter*) const; 242 243 typedef SkFlattenable INHERITED; 244 }; 245 246 #endif 247
