1 /*
2 * Copyright 2012 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/SkBitmap.h"
10 #include "include/core/SkBlendMode.h"
11 #include "include/core/SkCanvas.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkColorPriv.h"
14 #include "include/core/SkImage.h"
15 #include "include/core/SkImageInfo.h"
16 #include "include/core/SkMatrix.h"
17 #include "include/core/SkPaint.h"
18 #include "include/core/SkPoint.h"
19 #include "include/core/SkRect.h"
20 #include "include/core/SkRefCnt.h"
21 #include "include/core/SkScalar.h"
22 #include "include/core/SkShader.h"
23 #include "include/core/SkSize.h"
24 #include "include/core/SkString.h"
25 #include "include/core/SkTileMode.h"
26 #include "include/core/SkTypes.h"
27 #include "include/effects/SkGradientShader.h"
28 #include "include/private/SkTDArray.h"
29 #include "src/core/SkTLazy.h"
30
31 #include <utility>
32
make_shader(SkBlendMode mode)33 static sk_sp<SkShader> make_shader(SkBlendMode mode) {
34 SkPoint pts[2];
35 SkColor colors[2];
36
37 pts[0].set(0, 0);
38 pts[1].set(SkIntToScalar(100), 0);
39 colors[0] = SK_ColorRED;
40 colors[1] = SK_ColorBLUE;
41 auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
42
43 pts[0].set(0, 0);
44 pts[1].set(0, SkIntToScalar(100));
45 colors[0] = SK_ColorBLACK;
46 colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
47 auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
48
49 return SkShaders::Blend(mode, std::move(shaderA), std::move(shaderB));
50 }
51
52 class ComposeShaderGM : public skiagm::GM {
53 public:
ComposeShaderGM()54 ComposeShaderGM() {
55 fShader = make_shader(SkBlendMode::kDstIn);
56 }
57
58 protected:
onShortName()59 SkString onShortName() override {
60 return SkString("composeshader");
61 }
62
onISize()63 SkISize onISize() override {
64 return SkISize::Make(120, 120);
65 }
66
onDraw(SkCanvas * canvas)67 void onDraw(SkCanvas* canvas) override {
68 SkPaint paint;
69 paint.setColor(SK_ColorGREEN);
70 canvas->drawRect(SkRect::MakeWH(100, 100), paint);
71 paint.setShader(fShader);
72 canvas->drawRect(SkRect::MakeWH(100, 100), paint);
73 }
74
75 protected:
76 sk_sp<SkShader> fShader;
77
78 private:
79 typedef GM INHERITED ;
80 };
81 DEF_GM( return new ComposeShaderGM; )
82
83 class ComposeShaderAlphaGM : public skiagm::GM {
84 public:
ComposeShaderAlphaGM()85 ComposeShaderAlphaGM() {}
86
87 protected:
onShortName()88 SkString onShortName() override {
89 return SkString("composeshader_alpha");
90 }
91
onISize()92 SkISize onISize() override {
93 return SkISize::Make(750, 220);
94 }
95
onDraw(SkCanvas * canvas)96 void onDraw(SkCanvas* canvas) override {
97 sk_sp<SkShader> shaders[] = {
98 make_shader(SkBlendMode::kDstIn),
99 make_shader(SkBlendMode::kSrcOver),
100 };
101
102 SkPaint paint;
103 paint.setColor(SK_ColorGREEN);
104
105 const SkRect r = SkRect::MakeXYWH(5, 5, 100, 100);
106
107 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
108 canvas->save();
109 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
110 paint.setAlphaf(1.0f);
111 paint.setShader(nullptr);
112 canvas->drawRect(r, paint);
113
114 paint.setAlpha(alpha);
115 paint.setShader(shaders[y]);
116 canvas->drawRect(r, paint);
117
118 canvas->translate(r.width() + 5, 0);
119 }
120 canvas->restore();
121 canvas->translate(0, r.height() + 5);
122 }
123 }
124
125 private:
126 typedef GM INHERITED ;
127 };
DEF_GM(return new ComposeShaderAlphaGM;)128 DEF_GM( return new ComposeShaderAlphaGM; )
129
130 // creates a square bitmap with red background and a green circle in the center
131 static void draw_color_bm(SkBitmap* bm, int length) {
132 SkPaint paint;
133 paint.setColor(SK_ColorGREEN);
134
135 bm->allocN32Pixels(length, length);
136 bm->eraseColor(SK_ColorRED);
137
138 SkCanvas canvas(*bm);
139 canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/2),
140 paint);
141 }
142
143 // creates a square alpha8 bitmap with transparent background and an opaque circle in the center
draw_alpha8_bm(SkBitmap * bm,int length)144 static void draw_alpha8_bm(SkBitmap* bm, int length) {
145 SkPaint circlePaint;
146 circlePaint.setColor(SK_ColorBLACK);
147
148 bm->allocPixels(SkImageInfo::MakeA8(length, length));
149 bm->eraseColor(SK_ColorTRANSPARENT);
150
151 SkCanvas canvas(*bm);
152 canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/4),
153 circlePaint);
154 }
155
156 // creates a linear gradient shader
make_linear_gradient_shader(int length)157 static sk_sp<SkShader> make_linear_gradient_shader(int length) {
158 SkPoint pts[2];
159 SkColor colors[2];
160 pts[0].set(0, 0);
161 pts[1].set(SkIntToScalar(length), 0);
162 colors[0] = SK_ColorBLUE;
163 colors[1] = SkColorSetARGB(0, 0, 0, 0xFF);
164 return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
165 }
166
167
168 class ComposeShaderBitmapGM : public skiagm::GM {
169 public:
ComposeShaderBitmapGM(bool use_lm)170 ComposeShaderBitmapGM(bool use_lm) : fUseLocalMatrix(use_lm) {}
171
172 protected:
onOnceBeforeDraw()173 void onOnceBeforeDraw() override {
174 draw_color_bm(&fColorBitmap, squareLength);
175 draw_alpha8_bm(&fAlpha8Bitmap, squareLength);
176 SkMatrix s;
177 s.reset();
178 fColorBitmapShader = fColorBitmap.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, &s);
179 fAlpha8BitmapShader = fAlpha8Bitmap.makeShader(SkTileMode::kRepeat,
180 SkTileMode::kRepeat, &s);
181 fLinearGradientShader = make_linear_gradient_shader(squareLength);
182 }
183
onShortName()184 SkString onShortName() override {
185 return SkStringPrintf("composeshader_bitmap%s", fUseLocalMatrix ? "_lm" : "");
186 }
187
onISize()188 SkISize onISize() override {
189 return SkISize::Make(7 * (squareLength + 5), 2 * (squareLength + 5));
190 }
191
onDraw(SkCanvas * canvas)192 void onDraw(SkCanvas* canvas) override {
193 SkBlendMode mode = SkBlendMode::kDstOver;
194
195 SkMatrix lm = SkMatrix::MakeTrans(0, squareLength * 0.5f);
196
197 sk_sp<SkShader> shaders[] = {
198 // gradient should appear over color bitmap
199 SkShaders::Blend(mode, fLinearGradientShader, fColorBitmapShader),
200 // gradient should appear over alpha8 bitmap colorized by the paint color
201 SkShaders::Blend(mode, fLinearGradientShader, fAlpha8BitmapShader),
202 };
203 if (fUseLocalMatrix) {
204 for (unsigned i = 0; i < SK_ARRAY_COUNT(shaders); ++i) {
205 shaders[i] = shaders[i]->makeWithLocalMatrix(lm);
206 }
207 }
208
209 SkPaint paint;
210 paint.setColor(SK_ColorYELLOW);
211
212 const SkRect r = SkRect::MakeIWH(squareLength, squareLength);
213
214 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
215 canvas->save();
216 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
217 paint.setAlpha(alpha);
218 paint.setShader(shaders[y]);
219 canvas->drawRect(r, paint);
220
221 canvas->translate(r.width() + 5, 0);
222 }
223 canvas->restore();
224 canvas->translate(0, r.height() + 5);
225 }
226 }
227
228 private:
229 /** This determines the length and width of the bitmaps used in the ComposeShaders. Values
230 * above 20 may cause an SkASSERT to fail in SkSmallAllocator. However, larger values will
231 * work in a release build. You can change this parameter and then compile a release build
232 * to have this GM draw larger bitmaps for easier visual inspection.
233 */
234 static constexpr int squareLength = 20;
235
236 const bool fUseLocalMatrix;
237
238 SkBitmap fColorBitmap;
239 SkBitmap fAlpha8Bitmap;
240 sk_sp<SkShader> fColorBitmapShader;
241 sk_sp<SkShader> fAlpha8BitmapShader;
242 sk_sp<SkShader> fLinearGradientShader;
243
244 typedef GM INHERITED;
245 };
246 DEF_GM( return new ComposeShaderBitmapGM(false); )
DEF_GM(return new ComposeShaderBitmapGM (true);)247 DEF_GM( return new ComposeShaderBitmapGM(true); )
248
249 DEF_SIMPLE_GM(composeshader_bitmap2, canvas, 200, 200) {
250 int width = 255;
251 int height = 255;
252 SkTDArray<uint8_t> dst8Storage;
253 dst8Storage.setCount(width * height);
254 SkTDArray<uint32_t> dst32Storage;
255 dst32Storage.setCount(width * height * sizeof(int32_t));
256 for (int y = 0; y < height; ++y) {
257 for (int x = 0; x < width; ++x) {
258 dst8Storage[y * width + x] = (y + x) / 2;
259 dst32Storage[y * width + x] = SkPackARGB32(0xFF, x, y, 0);
260 }
261 }
262 SkPaint paint;
263 paint.setAntiAlias(true);
264 paint.setColor(SK_ColorBLUE);
265 SkRect r = {0, 0, SkIntToScalar(width), SkIntToScalar(height)};
266 canvas->drawRect(r, paint);
267 SkBitmap skBitmap, skMask;
268 SkImageInfo imageInfo = SkImageInfo::Make(width, height,
269 SkColorType::kN32_SkColorType, kPremul_SkAlphaType);
270 skBitmap.installPixels(imageInfo, dst32Storage.begin(), width * sizeof(int32_t),
271 nullptr, nullptr);
272 imageInfo = SkImageInfo::Make(width, height,
273 SkColorType::kAlpha_8_SkColorType, kPremul_SkAlphaType);
274 skMask.installPixels(imageInfo, dst8Storage.begin(), width, nullptr, nullptr);
275 sk_sp<SkImage> skSrc = SkImage::MakeFromBitmap(skBitmap);
276 sk_sp<SkImage> skMaskImage = SkImage::MakeFromBitmap(skMask);
277 paint.setShader(
278 SkShaders::Blend(SkBlendMode::kSrcIn, skMaskImage->makeShader(), skSrc->makeShader()));
279 canvas->drawRect(r, paint);
280 }
281
282 ///////////////////////////////////////////////////////////////////////////////////////////////////
283
make_src_shader(SkScalar size)284 static sk_sp<SkShader> make_src_shader(SkScalar size) {
285 const SkPoint pts[] = { { 0, 0 }, { 0, size } };
286 const SkColor colors[] = { 0xFF0000FF, 0x000000FF };
287 return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
288 }
289
make_dst_shader(SkScalar size)290 static sk_sp<SkShader> make_dst_shader(SkScalar size) {
291 const SkPoint pts[] = { { 0, 0 }, { size, 0 } };
292 const SkColor colors[] = { SK_ColorRED, 0x00FF0000 };
293 return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkTileMode::kClamp);
294 }
295
296 const SkScalar gCellSize = 100;
297
draw_cell(SkCanvas * canvas,sk_sp<SkShader> src,sk_sp<SkShader> dst,SkBlendMode mode,SkAlpha alpha)298 static void draw_cell(SkCanvas* canvas, sk_sp<SkShader> src, sk_sp<SkShader> dst,
299 SkBlendMode mode, SkAlpha alpha) {
300 const SkRect r = SkRect::MakeWH(gCellSize, gCellSize);
301 SkPaint p;
302 p.setAlpha(alpha);
303
304 SkAutoCanvasRestore acr(canvas, false);
305 canvas->saveLayer(&r, &p);
306 p.setAlpha(0xFF);
307
308 p.setShader(dst);
309 p.setBlendMode(SkBlendMode::kSrc);
310 canvas->drawRect(r, p);
311
312 p.setShader(src);
313 p.setBlendMode(mode);
314 canvas->drawRect(r, p);
315 }
316
draw_composed(SkCanvas * canvas,sk_sp<SkShader> src,sk_sp<SkShader> dst,SkBlendMode mode,SkAlpha alpha)317 static void draw_composed(SkCanvas* canvas, sk_sp<SkShader> src, sk_sp<SkShader> dst,
318 SkBlendMode mode, SkAlpha alpha) {
319 SkPaint p;
320 p.setAlpha(alpha);
321 p.setShader(SkShaders::Blend(mode, dst, src));
322 canvas->drawRect(SkRect::MakeWH(gCellSize, gCellSize), p);
323 }
324
draw_pair(SkCanvas * canvas,sk_sp<SkShader> src,sk_sp<SkShader> dst,SkBlendMode mode)325 static void draw_pair(SkCanvas* canvas, sk_sp<SkShader> src, sk_sp<SkShader> dst,
326 SkBlendMode mode) {
327 SkAutoCanvasRestore acr(canvas, true);
328
329 const SkScalar gap = 4;
330 SkRect r = SkRect::MakeWH(2 * gCellSize + gap, 2 * gCellSize + gap);
331 r.outset(gap + 1.5f, gap + 1.5f);
332 SkPaint p;
333 p.setStyle(SkPaint::kStroke_Style);
334 canvas->drawRect(r, p); // border
335
336 SkAlpha alpha = 0xFF;
337 for (int y = 0; y < 2; ++y) {
338 draw_cell(canvas, src, dst, mode, alpha);
339 canvas->save();
340 canvas->translate(gCellSize + gap, 0);
341 draw_composed(canvas, src, dst, mode, alpha);
342 canvas->restore();
343
344 canvas->translate(0, gCellSize + gap);
345 alpha = 0x80;
346 }
347 }
348
349 DEF_SIMPLE_GM(composeshader_grid, canvas, 882, 882) {
350 auto src = make_src_shader(gCellSize);
351 auto dst = make_dst_shader(gCellSize);
352
353 const SkScalar margin = 15;
354 const SkScalar dx = 2*gCellSize + margin;
355 const SkScalar dy = 2*gCellSize + margin;
356
357 canvas->translate(margin, margin);
358 canvas->save();
359 for (int m = 0; m < 16; ++m) {
360 SkBlendMode mode = static_cast<SkBlendMode>(m);
361 draw_pair(canvas, src, dst, mode);
362 if ((m % 4) == 3) {
363 canvas->restore();
364 canvas->translate(0, dy);
365 canvas->save();
366 } else {
367 canvas->translate(dx, 0);
368 }
369 }
370 canvas->restore();
371 }
372