1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "include/core/SkCanvas.h"
9 #include "include/effects/SkImageFilters.h"
10 #include "src/core/SkImageFilter_Base.h"
11 #include "src/core/SkReadBuffer.h"
12 #include "src/core/SkSpecialImage.h"
13 #include "src/core/SkSpecialSurface.h"
14 #include "src/core/SkWriteBuffer.h"
15
16 namespace {
17
18 class SkDropShadowImageFilter final : public SkImageFilter_Base {
19 public:
SkDropShadowImageFilter(SkScalar dx,SkScalar dy,SkScalar sigmaX,SkScalar sigmaY,SkColor color,bool shadowOnly,sk_sp<SkImageFilter> input,const SkRect * cropRect)20 SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY,
21 SkColor color, bool shadowOnly, sk_sp<SkImageFilter> input,
22 const SkRect* cropRect)
23 : INHERITED(&input, 1, cropRect)
24 , fDx(dx)
25 , fDy(dy)
26 , fSigmaX(sigmaX)
27 , fSigmaY(sigmaY)
28 , fColor(color)
29 , fShadowOnly(shadowOnly) {}
30
Make(SkScalar dx,SkScalar dy,SkScalar sigmaX,SkScalar sigmaY,SkColor color,bool shadowOnly,sk_sp<SkImageFilter> input,const SkRect * cropRect)31 static sk_sp<SkImageFilter> Make(SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY,
32 SkColor color, bool shadowOnly, sk_sp<SkImageFilter> input,
33 const SkRect* cropRect) {
34 return sk_sp<SkImageFilter>(new SkDropShadowImageFilter(
35 dx, dy, sigmaX, sigmaY, color, shadowOnly, std::move(input), cropRect));
36 }
37
38 SkRect computeFastBounds(const SkRect&) const override;
39
40 protected:
41 void flatten(SkWriteBuffer&) const override;
42 sk_sp<SkSpecialImage> onFilterImage(const Context&, SkIPoint* offset) const override;
43 SkIRect onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
44 MapDirection, const SkIRect* inputRect) const override;
45
46 private:
47 friend void ::SkRegisterDropShadowImageFilterFlattenable();
48 SK_FLATTENABLE_HOOKS(SkDropShadowImageFilter)
49
50 SkScalar fDx, fDy, fSigmaX, fSigmaY;
51 SkColor fColor;
52 bool fShadowOnly;
53
54 using INHERITED = SkImageFilter_Base;
55 };
56
57 } // end namespace
58
DropShadow(SkScalar dx,SkScalar dy,SkScalar sigmaX,SkScalar sigmaY,SkColor color,sk_sp<SkImageFilter> input,const CropRect & cropRect)59 sk_sp<SkImageFilter> SkImageFilters::DropShadow(
60 SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, SkColor color,
61 sk_sp<SkImageFilter> input, const CropRect& cropRect) {
62 return SkDropShadowImageFilter::Make(dx, dy, sigmaX, sigmaY, color, /* shadowOnly */ false,
63 std::move(input), cropRect);
64 }
65
DropShadowOnly(SkScalar dx,SkScalar dy,SkScalar sigmaX,SkScalar sigmaY,SkColor color,sk_sp<SkImageFilter> input,const CropRect & cropRect)66 sk_sp<SkImageFilter> SkImageFilters::DropShadowOnly(
67 SkScalar dx, SkScalar dy, SkScalar sigmaX, SkScalar sigmaY, SkColor color,
68 sk_sp<SkImageFilter> input, const CropRect& cropRect) {
69 return SkDropShadowImageFilter::Make(dx, dy, sigmaX, sigmaY, color, /* shadowOnly */ true,
70 std::move(input), cropRect);
71 }
72
SkRegisterDropShadowImageFilterFlattenable()73 void SkRegisterDropShadowImageFilterFlattenable() {
74 SK_REGISTER_FLATTENABLE(SkDropShadowImageFilter);
75 // TODO (michaelludwig) - Remove after grace period for SKPs to stop using old name
76 SkFlattenable::Register("SkDropShadowImageFilterImpl", SkDropShadowImageFilter::CreateProc);
77 }
78
CreateProc(SkReadBuffer & buffer)79 sk_sp<SkFlattenable> SkDropShadowImageFilter::CreateProc(SkReadBuffer& buffer) {
80 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
81 SkScalar dx = buffer.readScalar();
82 SkScalar dy = buffer.readScalar();
83 SkScalar sigmaX = buffer.readScalar();
84 SkScalar sigmaY = buffer.readScalar();
85 SkColor color = buffer.readColor();
86
87 // For backwards compatibility, the shadow mode had been saved as an enum cast to a 32LE int,
88 // where shadow-and-foreground was 0 and shadow-only was 1. Other than the number of bits, this
89 // is equivalent to the bool that SkDropShadowImageFilter now uses.
90 bool shadowOnly = SkToBool(buffer.read32LE(1));
91 return SkDropShadowImageFilter::Make(dx, dy, sigmaX, sigmaY, color, shadowOnly,
92 common.getInput(0), common.cropRect());
93 }
94
flatten(SkWriteBuffer & buffer) const95 void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const {
96 this->INHERITED::flatten(buffer);
97 buffer.writeScalar(fDx);
98 buffer.writeScalar(fDy);
99 buffer.writeScalar(fSigmaX);
100 buffer.writeScalar(fSigmaY);
101 buffer.writeColor(fColor);
102 // See CreateProc, but we save the bool as an int to match previous enum serialization.
103 buffer.writeInt(fShadowOnly);
104 }
105
106 ///////////////////////////////////////////////////////////////////////////////////////////////////
107
onFilterImage(const Context & ctx,SkIPoint * offset) const108 sk_sp<SkSpecialImage> SkDropShadowImageFilter::onFilterImage(const Context& ctx,
109 SkIPoint* offset) const {
110 SkIPoint inputOffset = SkIPoint::Make(0, 0);
111 sk_sp<SkSpecialImage> input(this->filterInput(0, ctx, &inputOffset));
112 if (!input) {
113 return nullptr;
114 }
115
116 const SkIRect inputBounds = SkIRect::MakeXYWH(inputOffset.x(), inputOffset.y(),
117 input->width(), input->height());
118 SkIRect bounds;
119 if (!this->applyCropRect(ctx, inputBounds, &bounds)) {
120 return nullptr;
121 }
122
123 sk_sp<SkSpecialSurface> surf(ctx.makeSurface(bounds.size()));
124 if (!surf) {
125 return nullptr;
126 }
127
128 SkCanvas* canvas = surf->getCanvas();
129 SkASSERT(canvas);
130
131 canvas->clear(0x0);
132
133 SkVector sigma = SkVector::Make(fSigmaX, fSigmaY);
134 ctx.ctm().mapVectors(&sigma, 1);
135 sigma.fX = SkScalarAbs(sigma.fX);
136 sigma.fY = SkScalarAbs(sigma.fY);
137
138 SkPaint paint;
139 paint.setAntiAlias(true);
140 paint.setImageFilter(SkImageFilters::Blur(sigma.fX, sigma.fY, nullptr));
141 paint.setColorFilter(SkColorFilters::Blend(fColor, SkBlendMode::kSrcIn));
142
143 SkVector offsetVec = SkVector::Make(fDx, fDy);
144 ctx.ctm().mapVectors(&offsetVec, 1);
145
146 canvas->translate(SkIntToScalar(inputOffset.fX) - SkIntToScalar(bounds.fLeft),
147 SkIntToScalar(inputOffset.fY) - SkIntToScalar(bounds.fTop));
148 input->draw(canvas, offsetVec.fX, offsetVec.fY, SkSamplingOptions(), &paint);
149
150 if (!fShadowOnly) {
151 input->draw(canvas, 0, 0);
152 }
153 offset->fX = bounds.fLeft;
154 offset->fY = bounds.fTop;
155 return surf->makeImageSnapshot();
156 }
157
computeFastBounds(const SkRect & src) const158 SkRect SkDropShadowImageFilter::computeFastBounds(const SkRect& src) const {
159 SkRect bounds = this->getInput(0) ? this->getInput(0)->computeFastBounds(src) : src;
160 SkRect shadowBounds = bounds;
161 shadowBounds.offset(fDx, fDy);
162 shadowBounds.outset(fSigmaX * 3, fSigmaY * 3);
163 if (!fShadowOnly) {
164 bounds.join(shadowBounds);
165 } else {
166 bounds = shadowBounds;
167 }
168 return bounds;
169 }
170
onFilterNodeBounds(const SkIRect & src,const SkMatrix & ctm,MapDirection dir,const SkIRect * inputRect) const171 SkIRect SkDropShadowImageFilter::onFilterNodeBounds(
172 const SkIRect& src, const SkMatrix& ctm, MapDirection dir, const SkIRect* inputRect) const {
173 SkVector offsetVec = SkVector::Make(fDx, fDy);
174 if (kReverse_MapDirection == dir) {
175 offsetVec.negate();
176 }
177 ctm.mapVectors(&offsetVec, 1);
178 SkIRect dst = src.makeOffset(SkScalarCeilToInt(offsetVec.x()),
179 SkScalarCeilToInt(offsetVec.y()));
180 SkVector sigma = SkVector::Make(fSigmaX, fSigmaY);
181 ctm.mapVectors(&sigma, 1);
182 dst.outset(
183 SkScalarCeilToInt(SkScalarAbs(sigma.x() * 3)),
184 SkScalarCeilToInt(SkScalarAbs(sigma.y() * 3)));
185 if (!fShadowOnly) {
186 dst.join(src);
187 }
188 return dst;
189 }
190