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/SkBlendMode.h"
10 #include "include/core/SkCanvas.h"
11 #include "include/core/SkColor.h"
12 #include "include/core/SkColorFilter.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/SkTileMode.h"
22 #include "include/effects/SkColorMatrix.h"
23 #include "include/effects/SkGradientShader.h"
24 #include "include/effects/SkImageFilters.h"
25 #include "include/private/SkTArray.h"
26 #include "include/private/SkTDArray.h"
27 #include "tools/Resources.h"
28 
29 #include <string.h>
30 #include <utility>
31 
32 #define FILTER_WIDTH    SkIntToScalar(30)
33 #define FILTER_HEIGHT   SkIntToScalar(30)
34 #define MARGIN          SkIntToScalar(10)
35 
cf_make_brightness(float brightness)36 static sk_sp<SkColorFilter> cf_make_brightness(float brightness) {
37     float matrix[20] = {
38         1, 0, 0, 0, brightness,
39         0, 1, 0, 0, brightness,
40         0, 0, 1, 0, brightness,
41         0, 0, 0, 1, 0 };
42     return SkColorFilters::Matrix(matrix);
43 }
44 
cf_make_grayscale()45 static sk_sp<SkColorFilter> cf_make_grayscale() {
46     float matrix[20];
47     memset(matrix, 0, 20 * sizeof(float));
48     matrix[0] = matrix[5] = matrix[10] = 0.2126f;
49     matrix[1] = matrix[6] = matrix[11] = 0.7152f;
50     matrix[2] = matrix[7] = matrix[12] = 0.0722f;
51     matrix[18] = 1.0f;
52     return SkColorFilters::Matrix(matrix);
53 }
54 
cf_make_colorize(SkColor color)55 static sk_sp<SkColorFilter> cf_make_colorize(SkColor color) {
56     return SkColorFilters::Blend(color, SkBlendMode::kSrc);
57 }
58 
sk_gm_get_colorfilters(SkTArray<sk_sp<SkColorFilter>> * array)59 static void sk_gm_get_colorfilters(SkTArray<sk_sp<SkColorFilter>>* array) {
60     array->push_back(cf_make_brightness(0.5f));
61     array->push_back(cf_make_grayscale());
62     array->push_back(cf_make_colorize(SK_ColorBLUE));
63 }
64 
65 ///////////////////////////////////////////////////////////////////////////////////////////////////
66 
sh_make_lineargradient0()67 static sk_sp<SkShader> sh_make_lineargradient0() {
68     const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
69     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
70     return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkTileMode::kRepeat);
71 }
72 
sh_make_lineargradient1()73 static sk_sp<SkShader> sh_make_lineargradient1() {
74     const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
75     const SkColor colors[] = { SK_ColorRED, 0x0000FF00, SK_ColorBLUE };
76     return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkTileMode::kRepeat);
77 }
78 
sh_make_image()79 static sk_sp<SkShader> sh_make_image() {
80     sk_sp<SkImage> image(GetResourceAsImage("images/mandrill_128.png"));
81     if (!image) {
82         return nullptr;
83     }
84     return image->makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat);
85 }
86 
sk_gm_get_shaders(SkTDArray<SkShader * > * array)87 static void sk_gm_get_shaders(SkTDArray<SkShader*>* array) {
88     if (auto shader = sh_make_lineargradient0()) {
89         *array->append() = shader.release();
90     }
91     if (auto shader = sh_make_lineargradient1()) {
92         *array->append() = shader.release();
93     }
94     if (auto shader = sh_make_image()) {
95         *array->append() = shader.release();
96     }
97 }
98 
99 ///////////////////////////////////////////////////////////////////////////////////////////////////
100 
make_blur(float amount,sk_sp<SkImageFilter> input)101 static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
102     return SkImageFilters::Blur(amount, amount, std::move(input));
103 }
104 
make_brightness(float amount,sk_sp<SkImageFilter> input)105 static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> input) {
106     return SkImageFilters::ColorFilter(cf_make_brightness(amount), std::move(input));
107 }
108 
make_grayscale(sk_sp<SkImageFilter> input)109 static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
110     return SkImageFilters::ColorFilter(cf_make_grayscale(), std::move(input));
111 }
112 
make_mode_blue(sk_sp<SkImageFilter> input)113 static sk_sp<SkImageFilter> make_mode_blue(sk_sp<SkImageFilter> input) {
114     return SkImageFilters::ColorFilter(cf_make_colorize(SK_ColorBLUE), std::move(input));
115 }
116 
draw_clipped_rect(SkCanvas * canvas,const SkRect & r,const SkPaint & paint,float outset=0.0f)117 static void draw_clipped_rect(SkCanvas* canvas,
118                               const SkRect& r,
119                               const SkPaint& paint,
120                               float outset = 0.0f) {
121     canvas->save();
122     SkRect clip(r);
123     clip.outset(outset, outset);
124     canvas->clipRect(clip);
125     canvas->drawRect(r, paint);
126     canvas->restore();
127 }
128 
129 DEF_SIMPLE_GM(colorfilterimagefilter, canvas, 400, 100){
130         SkRect r = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT);
131         SkPaint paint;
132         paint.setColor(SK_ColorRED);
133         canvas->save();
134         for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.2f) {
135             sk_sp<SkImageFilter> dim(make_brightness(-brightness, nullptr));
136             sk_sp<SkImageFilter> bright(make_brightness(brightness, std::move(dim)));
137             paint.setImageFilter(std::move(bright));
138             draw_clipped_rect(canvas, r, paint);
139             canvas->translate(FILTER_WIDTH + MARGIN, 0);
140         }
141         canvas->restore();
142         canvas->translate(0, FILTER_HEIGHT + MARGIN);
143         {
144             sk_sp<SkImageFilter> brightness(make_brightness(0.9f, nullptr));
145             sk_sp<SkImageFilter> grayscale(make_grayscale(std::move(brightness)));
146             paint.setImageFilter(std::move(grayscale));
147             draw_clipped_rect(canvas, r, paint);
148             canvas->translate(FILTER_WIDTH + MARGIN, 0);
149         }
150         {
151             sk_sp<SkImageFilter> grayscale(make_grayscale(nullptr));
152             sk_sp<SkImageFilter> brightness(make_brightness(0.9f, std::move(grayscale)));
153             paint.setImageFilter(std::move(brightness));
154             draw_clipped_rect(canvas, r, paint);
155             canvas->translate(FILTER_WIDTH + MARGIN, 0);
156         }
157         {
158             sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
159             sk_sp<SkImageFilter> brightness(make_brightness(1.0f, std::move(blue)));
160             paint.setImageFilter(std::move(brightness));
161             draw_clipped_rect(canvas, r, paint);
162             canvas->translate(FILTER_WIDTH + MARGIN, 0);
163         }
164         {
165             sk_sp<SkImageFilter> brightness(make_brightness(1.0f, nullptr));
166             sk_sp<SkImageFilter> blue(make_mode_blue(std::move(brightness)));
167             paint.setImageFilter(std::move(blue));
168             draw_clipped_rect(canvas, r, paint);
169             canvas->translate(FILTER_WIDTH + MARGIN, 0);
170         }
171         {
172             sk_sp<SkImageFilter> blur(make_blur(3.0f, nullptr));
173             sk_sp<SkImageFilter> brightness(make_brightness(0.5f, std::move(blur)));
174             paint.setImageFilter(std::move(brightness));
175             draw_clipped_rect(canvas, r, paint, 3);
176             canvas->translate(FILTER_WIDTH + MARGIN, 0);
177         }
178         {
179             sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
180             paint.setImageFilter(std::move(blue));
181             draw_clipped_rect(canvas, r, paint, 5);
182             canvas->translate(FILTER_WIDTH + MARGIN, 0);
183         }
184 }
185 
186 DEF_SIMPLE_GM(colorfilterimagefilter_layer, canvas, 32, 32) {
187     SkAutoCanvasRestore autoCanvasRestore(canvas, false);
188     SkColorMatrix cm;
189     cm.setSaturation(0.0f);
190     sk_sp<SkColorFilter> cf(SkColorFilters::Matrix(cm));
191     SkPaint p;
192     p.setImageFilter(SkImageFilters::ColorFilter(std::move(cf), nullptr));
193     canvas->saveLayer(nullptr, &p);
194     canvas->clear(SK_ColorRED);
195 }
196 
197 ///////////////////////////////////////////////////////////////////////////////////////////////////
198 
199 template <typename T> class SkTRefArray : public SkTDArray<T> {
200 public:
~SkTRefArray()201     ~SkTRefArray() { this->unrefAll(); }
202 };
203 
204 DEF_SIMPLE_GM(colorfiltershader, canvas, 610, 610) {
205     SkTArray<sk_sp<SkColorFilter>> filters;
206     sk_gm_get_colorfilters(&filters);
207 
208     SkTRefArray<SkShader*> shaders;
209     sk_gm_get_shaders(&shaders);
210 
211     const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
212     *shaders.append() = SkGradientShader::MakeTwoPointConical({0, 0}, 50, {0, 0}, 150,
213                                                               colors, nullptr, 2,
214                                                               SkTileMode::kClamp).release();
215 
216     SkPaint paint;
217     SkRect r = SkRect::MakeWH(120, 120);
218 
219     canvas->translate(20, 20);
220     for (int y = 0; y < shaders.count(); ++y) {
221         SkShader* shader = shaders[y];
222 
223         canvas->save();
224         for (int x = -1; x < filters.count(); ++x) {
225             sk_sp<SkColorFilter> filter = x >= 0 ? filters[x] : nullptr;
226 
227             paint.setShader(shader->makeWithColorFilter(filter));
228             canvas->drawRect(r, paint);
229             canvas->translate(150, 0);
230         }
231         canvas->restore();
232         canvas->translate(0, 150);
233     }
234 }
235 
do_mixershader(SkCanvas * canvas,Maker && maker)236 template <typename Maker> void do_mixershader(SkCanvas* canvas, Maker&& maker) {
237     auto shaderA = GetResourceAsImage("images/mandrill_128.png")->makeShader(SkTileMode::kClamp,
238                                                                              SkTileMode::kClamp);
239     const SkColor colors[] = { SK_ColorGREEN, 0 };
240     auto shaderB = SkGradientShader::MakeRadial({60, 60}, 55, colors, nullptr, 2,
241                                                 SkTileMode::kClamp,
242                                                 SkGradientShader::kInterpolateColorsInPremul_Flag,
243                                                 nullptr);
244     const SkBlendMode modes[] = {
245         SkBlendMode::kSrc, SkBlendMode::kModulate, SkBlendMode::kColorBurn, SkBlendMode::kPlus,
246         SkBlendMode::kDstATop,
247     };
248     SkPaint paint;
249     SkRect r = SkRect::MakeWH(120, 120);
250 
251     canvas->translate(10, 10);
252     for (auto mode : modes) {
253         canvas->save();
254         const int count = 6;
255         for (int x = 0; x < count; ++x) {
256             const float t = x * 1.0f / (count - 1);
257             paint.setShader(maker(shaderA, shaderB, mode, t));
258             canvas->drawRect(r, paint);
259             canvas->translate(r.width() + 10, 0);
260         }
261         canvas->restore();
262         canvas->translate(0, r.height() + 20);
263     }
264 }
265 
266 DEF_SIMPLE_GM(mixershader, canvas, 800, 700) {
__anon36a155f70102(sk_sp<SkShader> a, sk_sp<SkShader> b, SkBlendMode mode, float t) 267     do_mixershader(canvas, [](sk_sp<SkShader> a, sk_sp<SkShader> b, SkBlendMode mode, float t) {
268         auto sh = SkShaders::Blend(mode, a, b);
269         return SkShaders::Lerp(t, a, sh);
270     });
271 }
272 
273 DEF_SIMPLE_GM(mixershader2, canvas, 800, 700) {
__anon36a155f70202(sk_sp<SkShader> a, sk_sp<SkShader> b, SkBlendMode mode, float t) 274     do_mixershader(canvas, [](sk_sp<SkShader> a, sk_sp<SkShader> b, SkBlendMode mode, float t) {
275         return SkShaders::Lerp(t, a, SkShaders::Blend(mode, a, b));
276     });
277 }
278