OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
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 "SkDropShadowImageFilter.h" | 8 #include "SkDropShadowImageFilter.h" |
9 | 9 |
10 #include "SkBitmap.h" | 10 #include "SkBitmap.h" |
11 #include "SkBlurImageFilter.h" | 11 #include "SkBlurImageFilter.h" |
12 #include "SkCanvas.h" | 12 #include "SkCanvas.h" |
13 #include "SkColorMatrixFilter.h" | 13 #include "SkColorMatrixFilter.h" |
14 #include "SkDevice.h" | 14 #include "SkDevice.h" |
15 #include "SkReadBuffer.h" | 15 #include "SkReadBuffer.h" |
16 #include "SkWriteBuffer.h" | 16 #include "SkWriteBuffer.h" |
17 | 17 |
18 SkDropShadowImageFilter::SkDropShadowImageFilter(SkScalar dx, SkScalar dy, | 18 SkDropShadowImageFilter::SkDropShadowImageFilter(SkScalar dx, SkScalar dy, |
19 SkScalar sigmaX, SkScalar sigma
Y, SkColor color, | 19 SkScalar sigmaX, SkScalar sigma
Y, SkColor color, |
20 SkImageFilter* input, const Cro
pRect* cropRect, | 20 ShadowMode shadowMode, SkImageF
ilter* input, |
21 uint32_t uniqueID) | 21 const CropRect* cropRect, uint3
2_t uniqueID) |
22 : INHERITED(1, &input, cropRect, uniqueID) | 22 : INHERITED(1, &input, cropRect, uniqueID) |
23 , fDx(dx) | 23 , fDx(dx) |
24 , fDy(dy) | 24 , fDy(dy) |
25 , fSigmaX(sigmaX) | 25 , fSigmaX(sigmaX) |
26 , fSigmaY(sigmaY) | 26 , fSigmaY(sigmaY) |
27 , fColor(color) | 27 , fColor(color) |
| 28 , fShadowMode(shadowMode) |
28 { | 29 { |
29 } | 30 } |
30 | 31 |
31 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING | 32 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING |
32 SkDropShadowImageFilter::SkDropShadowImageFilter(SkReadBuffer& buffer) | 33 SkDropShadowImageFilter::SkDropShadowImageFilter(SkReadBuffer& buffer) |
33 : INHERITED(1, buffer) { | 34 : INHERITED(1, buffer) { |
34 fDx = buffer.readScalar(); | 35 fDx = buffer.readScalar(); |
35 fDy = buffer.readScalar(); | 36 fDy = buffer.readScalar(); |
36 fSigmaX = buffer.readScalar(); | 37 fSigmaX = buffer.readScalar(); |
37 fSigmaY = buffer.readScalar(); | 38 fSigmaY = buffer.readScalar(); |
38 fColor = buffer.readColor(); | 39 fColor = buffer.readColor(); |
| 40 fShadowMode = buffer.isVersionLT(SkReadBuffer::kDropShadowMode_Version) ? |
| 41 kDrawShadowAndForeground_ShadowMode : |
| 42 static_cast<ShadowMode>(buffer.readInt()); |
39 buffer.validate(SkScalarIsFinite(fDx) && | 43 buffer.validate(SkScalarIsFinite(fDx) && |
40 SkScalarIsFinite(fDy) && | 44 SkScalarIsFinite(fDy) && |
41 SkScalarIsFinite(fSigmaX) && | 45 SkScalarIsFinite(fSigmaX) && |
42 SkScalarIsFinite(fSigmaY)); | 46 SkScalarIsFinite(fSigmaY)); |
43 } | 47 } |
44 #endif | 48 #endif |
45 | 49 |
46 SkFlattenable* SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) { | 50 SkFlattenable* SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) { |
47 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); | 51 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); |
48 SkScalar dx = buffer.readScalar(); | 52 SkScalar dx = buffer.readScalar(); |
49 SkScalar dy = buffer.readScalar(); | 53 SkScalar dy = buffer.readScalar(); |
50 SkScalar sigmaX = buffer.readScalar(); | 54 SkScalar sigmaX = buffer.readScalar(); |
51 SkScalar sigmaY = buffer.readScalar(); | 55 SkScalar sigmaY = buffer.readScalar(); |
52 SkColor color = buffer.readColor(); | 56 SkColor color = buffer.readColor(); |
53 return Create(dx, dy, sigmaX, sigmaY, color, common.getInput(0), &common.cro
pRect(), common.uniqueID()); | 57 ShadowMode shadowMode = buffer.isVersionLT(SkReadBuffer::kDropShadowMode_Ver
sion) ? |
| 58 kDrawShadowAndForeground_ShadowMode : |
| 59 static_cast<ShadowMode>(buffer.readInt()); |
| 60 return Create(dx, dy, sigmaX, sigmaY, color, shadowMode, common.getInput(0), |
| 61 &common.cropRect(), common.uniqueID()); |
54 } | 62 } |
55 | 63 |
56 void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const { | 64 void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const { |
57 this->INHERITED::flatten(buffer); | 65 this->INHERITED::flatten(buffer); |
58 buffer.writeScalar(fDx); | 66 buffer.writeScalar(fDx); |
59 buffer.writeScalar(fDy); | 67 buffer.writeScalar(fDy); |
60 buffer.writeScalar(fSigmaX); | 68 buffer.writeScalar(fSigmaX); |
61 buffer.writeScalar(fSigmaY); | 69 buffer.writeScalar(fSigmaY); |
62 buffer.writeColor(fColor); | 70 buffer.writeColor(fColor); |
| 71 buffer.writeInt(static_cast<int>(fShadowMode)); |
63 } | 72 } |
64 | 73 |
65 bool SkDropShadowImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source
, | 74 bool SkDropShadowImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source
, |
66 const Context& ctx, | 75 const Context& ctx, |
67 SkBitmap* result, SkIPoint* offset)
const | 76 SkBitmap* result, SkIPoint* offset)
const |
68 { | 77 { |
69 SkBitmap src = source; | 78 SkBitmap src = source; |
70 SkIPoint srcOffset = SkIPoint::Make(0, 0); | 79 SkIPoint srcOffset = SkIPoint::Make(0, 0); |
71 if (getInput(0) && !getInput(0)->filterImage(proxy, source, ctx, &src, &srcO
ffset)) | 80 if (getInput(0) && !getInput(0)->filterImage(proxy, source, ctx, &src, &srcO
ffset)) |
72 return false; | 81 return false; |
(...skipping 18 matching lines...) Expand all Loading... |
91 SkColorFilter::CreateModeFilter(fColor, SkXfermode::kSrcIn_Mode)); | 100 SkColorFilter::CreateModeFilter(fColor, SkXfermode::kSrcIn_Mode)); |
92 SkPaint paint; | 101 SkPaint paint; |
93 paint.setImageFilter(blurFilter.get()); | 102 paint.setImageFilter(blurFilter.get()); |
94 paint.setColorFilter(colorFilter.get()); | 103 paint.setColorFilter(colorFilter.get()); |
95 paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); | 104 paint.setXfermodeMode(SkXfermode::kSrcOver_Mode); |
96 SkVector offsetVec = SkVector::Make(fDx, fDy); | 105 SkVector offsetVec = SkVector::Make(fDx, fDy); |
97 ctx.ctm().mapVectors(&offsetVec, 1); | 106 ctx.ctm().mapVectors(&offsetVec, 1); |
98 canvas.translate(SkIntToScalar(srcOffset.fX - bounds.fLeft), | 107 canvas.translate(SkIntToScalar(srcOffset.fX - bounds.fLeft), |
99 SkIntToScalar(srcOffset.fY - bounds.fTop)); | 108 SkIntToScalar(srcOffset.fY - bounds.fTop)); |
100 canvas.drawBitmap(src, offsetVec.fX, offsetVec.fY, &paint); | 109 canvas.drawBitmap(src, offsetVec.fX, offsetVec.fY, &paint); |
101 canvas.drawBitmap(src, 0, 0); | 110 if (fShadowMode == kDrawShadowAndForeground_ShadowMode) { |
| 111 canvas.drawBitmap(src, 0, 0); |
| 112 } |
102 *result = device->accessBitmap(false); | 113 *result = device->accessBitmap(false); |
103 offset->fX = bounds.fLeft; | 114 offset->fX = bounds.fLeft; |
104 offset->fY = bounds.fTop; | 115 offset->fY = bounds.fTop; |
105 return true; | 116 return true; |
106 } | 117 } |
107 | 118 |
108 void SkDropShadowImageFilter::computeFastBounds(const SkRect& src, SkRect* dst)
const { | 119 void SkDropShadowImageFilter::computeFastBounds(const SkRect& src, SkRect* dst)
const { |
109 if (getInput(0)) { | 120 if (getInput(0)) { |
110 getInput(0)->computeFastBounds(src, dst); | 121 getInput(0)->computeFastBounds(src, dst); |
111 } else { | 122 } else { |
112 *dst = src; | 123 *dst = src; |
113 } | 124 } |
114 | 125 |
115 SkRect shadowBounds = *dst; | 126 SkRect shadowBounds = *dst; |
116 shadowBounds.offset(fDx, fDy); | 127 shadowBounds.offset(fDx, fDy); |
117 shadowBounds.outset(SkScalarMul(fSigmaX, SkIntToScalar(3)), | 128 shadowBounds.outset(SkScalarMul(fSigmaX, SkIntToScalar(3)), |
118 SkScalarMul(fSigmaY, SkIntToScalar(3))); | 129 SkScalarMul(fSigmaY, SkIntToScalar(3))); |
119 dst->join(shadowBounds); | 130 if (fShadowMode == kDrawShadowAndForeground_ShadowMode) { |
| 131 dst->join(shadowBounds); |
| 132 } else { |
| 133 *dst = shadowBounds; |
| 134 } |
120 } | 135 } |
121 | 136 |
122 bool SkDropShadowImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix&
ctm, | 137 bool SkDropShadowImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix&
ctm, |
123 SkIRect* dst) const { | 138 SkIRect* dst) const { |
124 SkIRect bounds = src; | 139 SkIRect bounds = src; |
125 SkVector offsetVec = SkVector::Make(fDx, fDy); | 140 SkVector offsetVec = SkVector::Make(fDx, fDy); |
126 ctm.mapVectors(&offsetVec, 1); | 141 ctm.mapVectors(&offsetVec, 1); |
127 bounds.offset(-SkScalarCeilToInt(offsetVec.x()), | 142 bounds.offset(-SkScalarCeilToInt(offsetVec.x()), |
128 -SkScalarCeilToInt(offsetVec.y())); | 143 -SkScalarCeilToInt(offsetVec.y())); |
129 SkVector sigma = SkVector::Make(fSigmaX, fSigmaY); | 144 SkVector sigma = SkVector::Make(fSigmaX, fSigmaY); |
130 ctm.mapVectors(&sigma, 1); | 145 ctm.mapVectors(&sigma, 1); |
131 bounds.outset(SkScalarCeilToInt(SkScalarMul(sigma.x(), SkIntToScalar(3))), | 146 bounds.outset(SkScalarCeilToInt(SkScalarMul(sigma.x(), SkIntToScalar(3))), |
132 SkScalarCeilToInt(SkScalarMul(sigma.y(), SkIntToScalar(3)))); | 147 SkScalarCeilToInt(SkScalarMul(sigma.y(), SkIntToScalar(3)))); |
133 bounds.join(src); | 148 if (fShadowMode == kDrawShadowAndForeground_ShadowMode) { |
| 149 bounds.join(src); |
| 150 } |
134 if (getInput(0) && !getInput(0)->filterBounds(bounds, ctm, &bounds)) { | 151 if (getInput(0) && !getInput(0)->filterBounds(bounds, ctm, &bounds)) { |
135 return false; | 152 return false; |
136 } | 153 } |
137 *dst = bounds; | 154 *dst = bounds; |
138 return true; | 155 return true; |
139 } | 156 } |
OLD | NEW |