OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2006 The Android Open Source Project | 2 * Copyright 2006 The Android Open Source Project |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkBlurMaskFilter.h" | 8 #include "SkBlurMaskFilter.h" |
9 #include "SkBlurMask.h" | 9 #include "SkBlurMask.h" |
10 #include "SkGpuBlurUtils.h" | 10 #include "SkGpuBlurUtils.h" |
(...skipping 20 matching lines...) Expand all Loading... |
31 #include "glsl/GrGLSLSampler.h" | 31 #include "glsl/GrGLSLSampler.h" |
32 #include "glsl/GrGLSLUniformHandler.h" | 32 #include "glsl/GrGLSLUniformHandler.h" |
33 #endif | 33 #endif |
34 | 34 |
35 SkScalar SkBlurMaskFilter::ConvertRadiusToSigma(SkScalar radius) { | 35 SkScalar SkBlurMaskFilter::ConvertRadiusToSigma(SkScalar radius) { |
36 return SkBlurMask::ConvertRadiusToSigma(radius); | 36 return SkBlurMask::ConvertRadiusToSigma(radius); |
37 } | 37 } |
38 | 38 |
39 class SkBlurMaskFilterImpl : public SkMaskFilter { | 39 class SkBlurMaskFilterImpl : public SkMaskFilter { |
40 public: | 40 public: |
41 SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, uint32_t flags); | 41 SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, const SkRect& occluder, ui
nt32_t flags); |
42 | 42 |
43 // overrides from SkMaskFilter | 43 // overrides from SkMaskFilter |
44 SkMask::Format getFormat() const override; | 44 SkMask::Format getFormat() const override; |
45 bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&, | 45 bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&, |
46 SkIPoint* margin) const override; | 46 SkIPoint* margin) const override; |
47 | 47 |
48 #if SK_SUPPORT_GPU | 48 #if SK_SUPPORT_GPU |
49 bool canFilterMaskGPU(const SkRRect& devRRect, | 49 bool canFilterMaskGPU(const SkRRect& devRRect, |
50 const SkIRect& clipBounds, | 50 const SkIRect& clipBounds, |
51 const SkMatrix& ctm, | 51 const SkMatrix& ctm, |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
89 SkIPoint* margin, SkMask::CreateMode createMode) const; | 89 SkIPoint* margin, SkMask::CreateMode createMode) const; |
90 bool filterRRectMask(SkMask* dstM, const SkRRect& r, const SkMatrix& matrix, | 90 bool filterRRectMask(SkMask* dstM, const SkRRect& r, const SkMatrix& matrix, |
91 SkIPoint* margin, SkMask::CreateMode createMode) const; | 91 SkIPoint* margin, SkMask::CreateMode createMode) const; |
92 | 92 |
93 private: | 93 private: |
94 // To avoid unseemly allocation requests (esp. for finite platforms like | 94 // To avoid unseemly allocation requests (esp. for finite platforms like |
95 // handset) we limit the radius so something manageable. (as opposed to | 95 // handset) we limit the radius so something manageable. (as opposed to |
96 // a request like 10,000) | 96 // a request like 10,000) |
97 static const SkScalar kMAX_BLUR_SIGMA; | 97 static const SkScalar kMAX_BLUR_SIGMA; |
98 | 98 |
| 99 // This flag should never escape from serialization |
| 100 static const int kInternalFlag_HasOccluder = 0x08; |
| 101 |
99 SkScalar fSigma; | 102 SkScalar fSigma; |
100 SkBlurStyle fBlurStyle; | 103 SkBlurStyle fBlurStyle; |
| 104 SkRect fOccluder; |
101 uint32_t fBlurFlags; | 105 uint32_t fBlurFlags; |
102 | 106 |
103 SkBlurQuality getQuality() const { | 107 SkBlurQuality getQuality() const { |
104 return (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? | 108 return (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? |
105 kHigh_SkBlurQuality : kLow_SkBlurQuality; | 109 kHigh_SkBlurQuality : kLow_SkBlurQuality; |
106 } | 110 } |
107 | 111 |
108 SkBlurMaskFilterImpl(SkReadBuffer&); | 112 SkBlurMaskFilterImpl(SkReadBuffer&); |
109 void flatten(SkWriteBuffer&) const override; | 113 void flatten(SkWriteBuffer&) const override; |
110 | 114 |
111 SkScalar computeXformedSigma(const SkMatrix& ctm) const { | 115 SkScalar computeXformedSigma(const SkMatrix& ctm) const { |
112 bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTr
ansform_BlurFlag); | 116 bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTr
ansform_BlurFlag); |
113 | 117 |
114 SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma)
; | 118 SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma)
; |
115 return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA); | 119 return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA); |
116 } | 120 } |
117 | 121 |
118 friend class SkBlurMaskFilter; | 122 friend class SkBlurMaskFilter; |
119 | 123 |
120 typedef SkMaskFilter INHERITED; | 124 typedef SkMaskFilter INHERITED; |
121 }; | 125 }; |
122 | 126 |
123 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128); | 127 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128); |
124 | 128 |
125 sk_sp<SkMaskFilter> SkBlurMaskFilter::Make(SkBlurStyle style, SkScalar sigma, ui
nt32_t flags) { | 129 sk_sp<SkMaskFilter> SkBlurMaskFilter::Make(SkBlurStyle style, SkScalar sigma, |
| 130 const SkRect& occluder, uint32_t flag
s) { |
126 if (!SkScalarIsFinite(sigma) || sigma <= 0) { | 131 if (!SkScalarIsFinite(sigma) || sigma <= 0) { |
127 return nullptr; | 132 return nullptr; |
128 } | 133 } |
129 if ((unsigned)style > (unsigned)kLastEnum_SkBlurStyle) { | 134 if ((unsigned)style > (unsigned)kLastEnum_SkBlurStyle) { |
130 return nullptr; | 135 return nullptr; |
131 } | 136 } |
132 if (flags > SkBlurMaskFilter::kAll_BlurFlag) { | 137 SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag); |
133 return nullptr; | 138 flags &= SkBlurMaskFilter::kAll_BlurFlag; |
134 } | 139 |
135 return sk_sp<SkMaskFilter>(new SkBlurMaskFilterImpl(sigma, style, flags)); | 140 return sk_sp<SkMaskFilter>(new SkBlurMaskFilterImpl(sigma, style, occluder,
flags)); |
136 } | 141 } |
137 | 142 |
138 /////////////////////////////////////////////////////////////////////////////// | 143 /////////////////////////////////////////////////////////////////////////////// |
139 | 144 |
140 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle style, ui
nt32_t flags) | 145 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle style, |
| 146 const SkRect& occluder, uint32_t flag
s) |
141 : fSigma(sigma) | 147 : fSigma(sigma) |
142 , fBlurStyle(style) | 148 , fBlurStyle(style) |
| 149 , fOccluder(occluder) |
143 , fBlurFlags(flags) { | 150 , fBlurFlags(flags) { |
144 SkASSERT(fSigma > 0); | 151 SkASSERT(fSigma > 0); |
145 SkASSERT((unsigned)style <= kLastEnum_SkBlurStyle); | 152 SkASSERT((unsigned)style <= kLastEnum_SkBlurStyle); |
| 153 fOccluder.sort(); |
146 SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag); | 154 SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag); |
147 } | 155 } |
148 | 156 |
149 SkMask::Format SkBlurMaskFilterImpl::getFormat() const { | 157 SkMask::Format SkBlurMaskFilterImpl::getFormat() const { |
150 return SkMask::kA8_Format; | 158 return SkMask::kA8_Format; |
151 } | 159 } |
152 | 160 |
153 bool SkBlurMaskFilterImpl::asABlur(BlurRec* rec) const { | 161 bool SkBlurMaskFilterImpl::asABlur(BlurRec* rec) const { |
154 if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) { | 162 if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) { |
155 return false; | 163 return false; |
(...skipping 421 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
577 SkScalar pad = 3.0f * fSigma; | 585 SkScalar pad = 3.0f * fSigma; |
578 | 586 |
579 dst->set(src.fLeft - pad, src.fTop - pad, | 587 dst->set(src.fLeft - pad, src.fTop - pad, |
580 src.fRight + pad, src.fBottom + pad); | 588 src.fRight + pad, src.fBottom + pad); |
581 } | 589 } |
582 | 590 |
583 sk_sp<SkFlattenable> SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) { | 591 sk_sp<SkFlattenable> SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) { |
584 const SkScalar sigma = buffer.readScalar(); | 592 const SkScalar sigma = buffer.readScalar(); |
585 const unsigned style = buffer.readUInt(); | 593 const unsigned style = buffer.readUInt(); |
586 const unsigned flags = buffer.readUInt(); | 594 const unsigned flags = buffer.readUInt(); |
| 595 |
| 596 SkRect occluder; |
| 597 if (flags & kInternalFlag_HasOccluder) { |
| 598 buffer.readRect(&occluder); |
| 599 } else { |
| 600 occluder.setEmpty(); |
| 601 } |
| 602 |
587 if (style <= kLastEnum_SkBlurStyle) { | 603 if (style <= kLastEnum_SkBlurStyle) { |
588 return SkBlurMaskFilter::Make((SkBlurStyle)style, sigma, flags); | 604 return SkBlurMaskFilter::Make((SkBlurStyle)style, sigma, occluder, |
| 605 flags & ~kInternalFlag_HasOccluder); |
589 } | 606 } |
590 return nullptr; | 607 return nullptr; |
591 } | 608 } |
592 | 609 |
593 void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const { | 610 void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const { |
594 buffer.writeScalar(fSigma); | 611 buffer.writeScalar(fSigma); |
595 buffer.writeUInt(fBlurStyle); | 612 buffer.writeUInt(fBlurStyle); |
596 buffer.writeUInt(fBlurFlags); | 613 |
| 614 SkASSERT(!(fBlurFlags & kInternalFlag_HasOccluder)); |
| 615 buffer.writeUInt(fBlurFlags | kInternalFlag_HasOccluder); |
| 616 |
| 617 buffer.writeRect(fOccluder); |
597 } | 618 } |
598 | 619 |
599 #if SK_SUPPORT_GPU | 620 #if SK_SUPPORT_GPU |
600 | 621 |
601 class GrGLRectBlurEffect; | 622 class GrGLRectBlurEffect; |
602 | 623 |
603 class GrRectBlurEffect : public GrFragmentProcessor { | 624 class GrRectBlurEffect : public GrFragmentProcessor { |
604 public: | 625 public: |
605 ~GrRectBlurEffect() override { } | 626 ~GrRectBlurEffect() override { } |
606 | 627 |
(...skipping 702 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1309 } else { | 1330 } else { |
1310 str->append("None"); | 1331 str->append("None"); |
1311 } | 1332 } |
1312 str->append("))"); | 1333 str->append("))"); |
1313 } | 1334 } |
1314 #endif | 1335 #endif |
1315 | 1336 |
1316 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter) | 1337 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter) |
1317 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl) | 1338 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl) |
1318 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 1339 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |