1 /*
2 * Copyright 2011 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 "gm/gm.h"
9 #include "include/core/SkCanvas.h"
10 #include "include/core/SkColor.h"
11 #include "include/core/SkFont.h"
12 #include "include/core/SkFontTypes.h"
13 #include "include/core/SkImage.h"
14 #include "include/core/SkImageFilter.h"
15 #include "include/core/SkPaint.h"
16 #include "include/core/SkPoint.h"
17 #include "include/core/SkRect.h"
18 #include "include/core/SkRefCnt.h"
19 #include "include/core/SkScalar.h"
20 #include "include/core/SkShader.h"
21 #include "include/core/SkSize.h"
22 #include "include/core/SkString.h"
23 #include "include/core/SkSurface.h"
24 #include "include/core/SkTileMode.h"
25 #include "include/core/SkTypeface.h"
26 #include "include/core/SkTypes.h"
27 #include "include/effects/SkGradientShader.h"
28 #include "include/effects/SkImageFilters.h"
29 #include "include/effects/SkRuntimeEffect.h"
30 #include "tools/ToolUtils.h"
31 #include "tools/fonts/FontToolUtils.h"
32
33 #include <utility>
34
make_src(int w,int h)35 static sk_sp<SkImage> make_src(int w, int h) {
36 sk_sp<SkSurface> surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(w, h)));
37 SkCanvas* canvas = surface->getCanvas();
38
39 SkPaint paint;
40 SkPoint pts[] = { {0, 0}, {SkIntToScalar(w), SkIntToScalar(h)} };
41 SkColor colors[] = {
42 SK_ColorTRANSPARENT, SK_ColorGREEN, SK_ColorCYAN,
43 SK_ColorRED, SK_ColorMAGENTA, SK_ColorWHITE,
44 };
45 paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, std::size(colors),
46 SkTileMode::kClamp));
47 canvas->drawPaint(paint);
48 return surface->makeImageSnapshot();
49 }
50
make_dst(int w,int h)51 static sk_sp<SkImage> make_dst(int w, int h) {
52 sk_sp<SkSurface> surface(SkSurfaces::Raster(SkImageInfo::MakeN32Premul(w, h)));
53 SkCanvas* canvas = surface->getCanvas();
54
55 SkPaint paint;
56 SkPoint pts[] = { {0, SkIntToScalar(h)}, {SkIntToScalar(w), 0} };
57 SkColor colors[] = {
58 SK_ColorBLUE, SK_ColorYELLOW, SK_ColorBLACK, SK_ColorGREEN,
59 SK_ColorGRAY,
60 };
61 paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, std::size(colors),
62 SkTileMode::kClamp));
63 canvas->drawPaint(paint);
64 return surface->makeImageSnapshot();
65 }
66
show_k_text(SkCanvas * canvas,SkScalar x,SkScalar y,const SkScalar k[])67 static void show_k_text(SkCanvas* canvas, SkScalar x, SkScalar y, const SkScalar k[]) {
68 SkFont font(ToolUtils::DefaultPortableTypeface(), 24);
69 font.setEdging(SkFont::Edging::kAntiAlias);
70 SkPaint paint;
71 paint.setAntiAlias(true);
72 for (int i = 0; i < 4; ++i) {
73 SkString str;
74 str.appendScalar(k[i]);
75 SkScalar width = font.measureText(str.c_str(), str.size(), SkTextEncoding::kUTF8);
76 canvas->drawString(str, x, y + font.getSize(), font, paint);
77 x += width + SkIntToScalar(10);
78 }
79 }
80
81 class ArithmodeGM : public skiagm::GM {
getName() const82 SkString getName() const override { return SkString("arithmode"); }
83
getISize()84 SkISize getISize() override { return {640, 572}; }
85
onDraw(SkCanvas * canvas)86 void onDraw(SkCanvas* canvas) override {
87 constexpr int WW = 100,
88 HH = 32;
89
90 sk_sp<SkImage> src = make_src(WW, HH);
91 sk_sp<SkImage> dst = make_dst(WW, HH);
92 sk_sp<SkImageFilter> srcFilter = SkImageFilters::Image(src, {SkFilterMode::kLinear});
93 sk_sp<SkImageFilter> dstFilter = SkImageFilters::Image(dst, {SkFilterMode::kLinear});
94
95 constexpr SkScalar one = SK_Scalar1;
96 constexpr SkScalar K[] = {
97 0, 0, 0, 0,
98 0, 0, 0, one,
99 0, one, 0, 0,
100 0, 0, one, 0,
101 0, one, one, 0,
102 0, one, -one, 0,
103 0, one/2, one/2, 0,
104 0, one/2, one/2, one/4,
105 0, one/2, one/2, -one/4,
106 one/4, one/2, one/2, 0,
107 -one/4, one/2, one/2, 0,
108 };
109
110 const SkScalar* k = K;
111 const SkScalar* stop = k + std::size(K);
112 // Many of the Arithmetic filters have a 4th coefficient that's not zero, which means they
113 // affect transparent black. 'rect' is used as a crop filter to make sure they don't
114 // overwrite each other.
115 const SkRect rect = SkRect::MakeWH(WW, HH);
116 SkScalar gap = SkIntToScalar(WW + 20);
117 while (k < stop) {
118 {
119 SkAutoCanvasRestore acr(canvas, true);
120 canvas->drawImage(src, 0, 0);
121 canvas->translate(gap, 0);
122 canvas->drawImage(dst, 0, 0);
123 canvas->translate(gap, 0);
124 SkPaint paint;
125 paint.setImageFilter(SkImageFilters::Arithmetic(k[0], k[1], k[2], k[3], true,
126 dstFilter, srcFilter, rect));
127 canvas->saveLayer(nullptr, &paint);
128 canvas->restore();
129
130 canvas->translate(gap, 0);
131 show_k_text(canvas, 0, 0, k);
132 }
133
134 k += 4;
135 canvas->translate(0, HH + 12);
136 }
137
138 // Draw two special cases to test enforcePMColor. In these cases, we
139 // draw the dst bitmap twice, the first time it is halved and inverted,
140 // leading to invalid premultiplied colors. If we enforcePMColor, these
141 // invalid values should be clamped, and will not contribute to the
142 // second draw.
143 for (int i = 0; i < 2; i++) {
144 const bool enforcePMColor = (i == 0);
145
146 {
147 SkAutoCanvasRestore acr(canvas, true);
148 canvas->translate(gap, 0);
149 canvas->drawImage(dst, 0, 0);
150 canvas->translate(gap, 0);
151
152 sk_sp<SkImageFilter> bg =
153 SkImageFilters::Arithmetic(0, 0, -one / 2, 1, enforcePMColor, dstFilter,
154 nullptr, nullptr);
155 SkPaint p;
156 p.setImageFilter(SkImageFilters::Arithmetic(0, one / 2, -one, 1, true,
157 std::move(bg), dstFilter, rect));
158 canvas->saveLayer(nullptr, &p);
159 canvas->restore();
160 canvas->translate(gap, 0);
161
162 // Label
163 SkFont font(ToolUtils::DefaultPortableTypeface(), 24);
164 SkString str(enforcePMColor ? "enforcePM" : "no enforcePM");
165 canvas->drawString(str, 0, font.getSize(), font, SkPaint());
166 }
167 canvas->translate(0, HH + 12);
168 }
169 }
170
171 private:
172 using INHERITED = GM;
173 };
174 DEF_GM( return new ArithmodeGM; )
175
176 ///////////////////////////////////////////////////////////////////////////////
177
178 #include "include/effects/SkBlenders.h"
179
180 class ArithmodeBlenderGM : public skiagm::GM {
181 float fK1, fK2, fK3, fK4;
182 sk_sp<SkImage> fSrc, fDst, fChecker;
183 sk_sp<SkShader> fSrcShader, fDstShader;
184 sk_sp<SkRuntimeEffect> fRuntimeEffect;
185
getName() const186 SkString getName() const override { return SkString("arithmode_blender"); }
187
188 static constexpr int W = 200;
189 static constexpr int H = 200;
190
getISize()191 SkISize getISize() override { return {(W + 30) * 2, (H + 30) * 4}; }
192
onOnceBeforeDraw()193 void onOnceBeforeDraw() override {
194 // Prepare a runtime effect for this blend.
195 static constexpr char kShader[] = R"(
196 uniform shader srcImage;
197 uniform shader dstImage;
198 uniform blender arithBlend;
199 half4 main(float2 xy) {
200 return arithBlend.eval(srcImage.eval(xy), dstImage.eval(xy));
201 }
202 )";
203 auto [effect, error] = SkRuntimeEffect::MakeForShader(SkString(kShader));
204 SkASSERT(effect);
205 fRuntimeEffect = effect;
206
207 // Start with interesting K-values, in case we're drawn without calling onAnimate().
208 fK1 = -0.25f;
209 fK2 = 0.25f;
210 fK3 = 0.25f;
211 fK4 = 0;
212
213 fSrc = make_src(W, H);
214 fDst = make_dst(W, H);
215 fSrcShader = fSrc->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, SkSamplingOptions());
216 fDstShader = fDst->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, SkSamplingOptions());
217
218 fChecker = ToolUtils::create_checkerboard_image(W, H, 0xFFBBBBBB, 0xFFEEEEEE, 8);
219 }
220
onAnimate(double nanos)221 bool onAnimate(double nanos) override {
222 double theta = nanos * 1e-6 * 0.001;
223 fK1 = sin(theta + 0) * 0.25;
224 fK2 = cos(theta + 1) * 0.25;
225 fK3 = sin(theta + 2) * 0.25;
226 fK4 = 0.5;
227 return true;
228 }
229
onDraw(SkCanvas * canvas)230 void onDraw(SkCanvas* canvas) override {
231 const SkRect rect = SkRect::MakeWH(W, H);
232
233 canvas->drawImage(fSrc, 10, 10);
234 canvas->drawImage(fDst, 10, 10 + H + 10);
235
236 SkSamplingOptions sampling;
237 sk_sp<SkBlender> blender = SkBlenders::Arithmetic(fK1, fK2, fK3, fK4,
238 /*enforcePremul=*/true);
239 canvas->translate(10 + W + 10, 10);
240
241 // All three images drawn below should appear identical.
242 // Draw via blend step
243 SkPaint blenderPaint;
244 canvas->drawImage(fChecker, 0, 0);
245 canvas->saveLayer(&rect, nullptr);
246 canvas->drawImage(fDst, 0, 0);
247 blenderPaint.setBlender(blender);
248 canvas->drawImage(fSrc, 0, 0, sampling, &blenderPaint);
249 canvas->restore();
250
251 canvas->translate(0, 10 + H);
252
253 // Draw via SkImageFilters::Blend (should appear the same as above)
254 SkPaint imageFilterPaint;
255 canvas->drawImage(fChecker, 0, 0);
256 imageFilterPaint.setImageFilter(
257 SkImageFilters::Blend(blender,
258 /*background=*/nullptr,
259 /*foreground=*/SkImageFilters::Image(fSrc, sampling)));
260 canvas->drawImage(fDst, 0, 0, sampling, &imageFilterPaint);
261
262 canvas->translate(0, 10 + H);
263
264 // Draw via SkShaders::Blend (should still appear the same as above)
265 SkPaint shaderBlendPaint;
266 canvas->drawImage(fChecker, 0, 0);
267 shaderBlendPaint.setShader(SkShaders::Blend(blender, fDstShader, fSrcShader));
268 canvas->drawRect(rect, shaderBlendPaint);
269
270 canvas->translate(0, 10 + H);
271
272 // Draw via runtime effect (should still appear the same as above)
273 SkPaint runtimePaint;
274 canvas->drawImage(fChecker, 0, 0);
275 SkRuntimeEffect::ChildPtr children[] = {fSrcShader, fDstShader, blender};
276 runtimePaint.setShader(fRuntimeEffect->makeShader(/*uniforms=*/{}, children));
277 canvas->drawRect(rect, runtimePaint);
278 }
279
280 private:
281 using INHERITED = GM;
282 };
283 DEF_GM( return new ArithmodeBlenderGM; )
284