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.h"
9
10 #include "SkCanvas.h"
11 #include "SkGradientShader.h"
12 #include "SkGraphics.h"
13 #include "SkShader.h"
14 #include "SkString.h"
15 #include "SkTDArray.h"
16
make_shader(SkBlendMode mode)17 static sk_sp<SkShader> make_shader(SkBlendMode mode) {
18 SkPoint pts[2];
19 SkColor colors[2];
20
21 pts[0].set(0, 0);
22 pts[1].set(SkIntToScalar(100), 0);
23 colors[0] = SK_ColorRED;
24 colors[1] = SK_ColorBLUE;
25 auto shaderA = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
26
27 pts[0].set(0, 0);
28 pts[1].set(0, SkIntToScalar(100));
29 colors[0] = SK_ColorBLACK;
30 colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
31 auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
32
33 return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB), mode);
34 }
35
36 class ComposeShaderGM : public skiagm::GM {
37 public:
ComposeShaderGM()38 ComposeShaderGM() {
39 fShader = make_shader(SkBlendMode::kDstIn);
40 }
41
42 protected:
onShortName()43 SkString onShortName() override {
44 return SkString("composeshader");
45 }
46
onISize()47 SkISize onISize() override {
48 return SkISize::Make(120, 120);
49 }
50
onDraw(SkCanvas * canvas)51 void onDraw(SkCanvas* canvas) override {
52 SkPaint paint;
53 paint.setColor(SK_ColorGREEN);
54 canvas->drawRect(SkRect::MakeWH(100, 100), paint);
55 paint.setShader(fShader);
56 canvas->drawRect(SkRect::MakeWH(100, 100), paint);
57 }
58
59 protected:
60 sk_sp<SkShader> fShader;
61
62 private:
63 typedef GM INHERITED ;
64 };
65
66 class ComposeShaderAlphaGM : public skiagm::GM {
67 public:
ComposeShaderAlphaGM()68 ComposeShaderAlphaGM() {}
69
70 protected:
onShortName()71 SkString onShortName() override {
72 return SkString("composeshader_alpha");
73 }
74
onISize()75 SkISize onISize() override {
76 return SkISize::Make(750, 220);
77 }
78
onDraw(SkCanvas * canvas)79 void onDraw(SkCanvas* canvas) override {
80 sk_sp<SkShader> shaders[] = {
81 make_shader(SkBlendMode::kDstIn),
82 make_shader(SkBlendMode::kSrcOver),
83 };
84
85 SkPaint paint;
86 paint.setColor(SK_ColorGREEN);
87
88 const SkRect r = SkRect::MakeXYWH(5, 5, 100, 100);
89
90 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
91 canvas->save();
92 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
93 paint.setAlpha(0xFF);
94 paint.setShader(nullptr);
95 canvas->drawRect(r, paint);
96
97 paint.setAlpha(alpha);
98 paint.setShader(shaders[y]);
99 canvas->drawRect(r, paint);
100
101 canvas->translate(r.width() + 5, 0);
102 }
103 canvas->restore();
104 canvas->translate(0, r.height() + 5);
105 }
106 }
107
108 private:
109 typedef GM INHERITED ;
110 };
111
112
113 // creates a square bitmap with red background and a green circle in the center
draw_color_bm(SkBitmap * bm,int length)114 static void draw_color_bm(SkBitmap* bm, int length) {
115 SkPaint paint;
116 paint.setColor(SK_ColorGREEN);
117
118 bm->allocN32Pixels(length, length);
119 bm->eraseColor(SK_ColorRED);
120
121 SkCanvas canvas(*bm);
122 canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/2),
123 paint);
124 }
125
126 // creates a square alpha8 bitmap with transparent background and an opaque circle in the center
draw_alpha8_bm(SkBitmap * bm,int length)127 static void draw_alpha8_bm(SkBitmap* bm, int length) {
128 SkPaint circlePaint;
129 circlePaint.setColor(SK_ColorBLACK);
130
131 bm->allocPixels(SkImageInfo::MakeA8(length, length));
132 bm->eraseColor(SK_ColorTRANSPARENT);
133
134 SkCanvas canvas(*bm);
135 canvas.drawCircle(SkIntToScalar(length/2), SkIntToScalar(length/2), SkIntToScalar(length/4),
136 circlePaint);
137 }
138
139 // creates a linear gradient shader
make_linear_gradient_shader(int length)140 static sk_sp<SkShader> make_linear_gradient_shader(int length) {
141 SkPoint pts[2];
142 SkColor colors[2];
143 pts[0].set(0, 0);
144 pts[1].set(SkIntToScalar(length), 0);
145 colors[0] = SK_ColorBLUE;
146 colors[1] = SkColorSetARGB(0, 0, 0, 0xFF);
147 return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
148 }
149
150
151 class ComposeShaderBitmapGM : public skiagm::GM {
152 public:
ComposeShaderBitmapGM()153 ComposeShaderBitmapGM() {}
154
155 protected:
onOnceBeforeDraw()156 void onOnceBeforeDraw() override {
157 draw_color_bm(&fColorBitmap, squareLength);
158 draw_alpha8_bm(&fAlpha8Bitmap, squareLength);
159 SkMatrix s;
160 s.reset();
161 fColorBitmapShader = SkShader::MakeBitmapShader(fColorBitmap, SkShader::kRepeat_TileMode,
162 SkShader::kRepeat_TileMode, &s);
163 fAlpha8BitmapShader = SkShader::MakeBitmapShader(fAlpha8Bitmap, SkShader::kRepeat_TileMode,
164 SkShader::kRepeat_TileMode, &s);
165 fLinearGradientShader = make_linear_gradient_shader(squareLength);
166 }
167
onShortName()168 SkString onShortName() override {
169 return SkString("composeshader_bitmap");
170 }
171
onISize()172 SkISize onISize() override {
173 return SkISize::Make(7 * (squareLength + 5), 2 * (squareLength + 5));
174 }
175
onDraw(SkCanvas * canvas)176 void onDraw(SkCanvas* canvas) override {
177 SkBlendMode mode = SkBlendMode::kDstOver;
178
179 sk_sp<SkShader> shaders[] = {
180 // gradient should appear over color bitmap
181 SkShader::MakeComposeShader(fLinearGradientShader, fColorBitmapShader, mode),
182 // gradient should appear over alpha8 bitmap colorized by the paint color
183 SkShader::MakeComposeShader(fLinearGradientShader, fAlpha8BitmapShader, mode),
184 };
185
186 SkPaint paint;
187 paint.setColor(SK_ColorYELLOW);
188
189 const SkRect r = SkRect::MakeXYWH(0, 0, SkIntToScalar(squareLength),
190 SkIntToScalar(squareLength));
191
192 for (size_t y = 0; y < SK_ARRAY_COUNT(shaders); ++y) {
193 canvas->save();
194 for (int alpha = 0xFF; alpha > 0; alpha -= 0x28) {
195 paint.setAlpha(alpha);
196 paint.setShader(shaders[y]);
197 canvas->drawRect(r, paint);
198
199 canvas->translate(r.width() + 5, 0);
200 }
201 canvas->restore();
202 canvas->translate(0, r.height() + 5);
203 }
204 }
205
206 private:
207 /** This determines the length and width of the bitmaps used in the ComposeShaders. Values
208 * above 20 may cause an SkASSERT to fail in SkSmallAllocator. However, larger values will
209 * work in a release build. You can change this parameter and then compile a release build
210 * to have this GM draw larger bitmaps for easier visual inspection.
211 */
212 static constexpr int squareLength = 20;
213
214 SkBitmap fColorBitmap;
215 SkBitmap fAlpha8Bitmap;
216 sk_sp<SkShader> fColorBitmapShader;
217 sk_sp<SkShader> fAlpha8BitmapShader;
218 sk_sp<SkShader> fLinearGradientShader;
219
220 typedef GM INHERITED;
221 };
222
223 DEF_SIMPLE_GM(composeshader_bitmap2, canvas, 200, 200) {
224 int width = 255;
225 int height = 255;
226 SkTDArray<uint8_t> dst8Storage;
227 dst8Storage.setCount(width * height);
228 SkTDArray<uint32_t> dst32Storage;
229 dst32Storage.setCount(width * height * sizeof(int32_t));
230 for (int y = 0; y < height; ++y) {
231 for (int x = 0; x < width; ++x) {
232 dst8Storage[y * width + x] = (y + x) / 2;
233 dst32Storage[y * width + x] = SkPackARGB32(0xFF, x, y, 0);
234 }
235 }
236 SkPaint paint;
237 paint.setAntiAlias(true);
238 paint.setColor(SK_ColorBLUE);
239 SkRect r = {0, 0, SkIntToScalar(width), SkIntToScalar(height)};
240 canvas->drawRect(r, paint);
241 SkBitmap skBitmap, skMask;
242 SkImageInfo imageInfo = SkImageInfo::Make(width, height,
243 SkColorType::kN32_SkColorType, kPremul_SkAlphaType);
244 skBitmap.installPixels(imageInfo, dst32Storage.begin(), width * sizeof(int32_t),
245 nullptr, nullptr, nullptr);
246 imageInfo = SkImageInfo::Make(width, height,
247 SkColorType::kAlpha_8_SkColorType, kPremul_SkAlphaType);
248 skMask.installPixels(imageInfo, dst8Storage.begin(), width, nullptr, nullptr, nullptr);
249 sk_sp<SkImage> skSrc = SkImage::MakeFromBitmap(skBitmap);
250 sk_sp<SkShader> skSrcShader =
251 skSrc->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
252 sk_sp<SkImage> skMaskImage = SkImage::MakeFromBitmap(skMask);
253 sk_sp<SkShader> skMaskShader = skMaskImage->makeShader(
254 SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
255 paint.setShader(
256 SkShader::MakeComposeShader(skMaskShader, skSrcShader, SkBlendMode::kSrcIn));
257 canvas->drawRect(r, paint);
258 }
259
260 //////////////////////////////////////////////////////////////////////////////
261
262 DEF_GM( return new ComposeShaderGM; )
263 DEF_GM( return new ComposeShaderAlphaGM; )
264 DEF_GM( return new ComposeShaderBitmapGM; )
265