gm/colorfilterimagefilter.cpp

   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 #include "SkCanvas.h"
  10 #include "SkColorMatrixFilter.h"
  11 #include "SkColorPriv.h"
  12 #include "SkShader.h"
  13
  14 #include "SkBlurImageFilter.h"
  15 #include "SkColorFilterImageFilter.h"
  16 #include "SkTDArray.h"
  17
  18 #define FILTER_WIDTH    SkIntToScalar(30)
  19 #define FILTER_HEIGHT   SkIntToScalar(30)
  20 #define MARGIN          SkIntToScalar(10)
  21
  22 static sk_sp<SkColorFilter> cf_make_brightness(float brightness) {
  23     SkScalar amount255 = brightness * 255;
  24     SkScalar matrix[20] = {
  25         1, 0, 0, 0, amount255,
  26         0, 1, 0, 0, amount255,
  27         0, 0, 1, 0, amount255,
  28         0, 0, 0, 1, 0 };
  29     return SkColorFilter::MakeMatrixFilterRowMajor255(matrix);
  30 }
  31
  32 static sk_sp<SkColorFilter> cf_make_grayscale() {
  33     SkScalar matrix[20];
  34     memset(matrix, 0, 20 * sizeof(SkScalar));
  35     matrix[0] = matrix[5] = matrix[10] = 0.2126f;
  36     matrix[1] = matrix[6] = matrix[11] = 0.7152f;
  37     matrix[2] = matrix[7] = matrix[12] = 0.0722f;
  38     matrix[18] = 1.0f;
  39     return SkColorFilter::MakeMatrixFilterRowMajor255(matrix);
  40 }
  41
  42 static sk_sp<SkColorFilter> cf_make_colorize(SkColor color) {
  43     return SkColorFilter::MakeModeFilter(color, SkBlendMode::kSrc);
  44 }
  45
  46 static void sk_gm_get_colorfilters(SkTArray<sk_sp<SkColorFilter>>* array) {
  47     array->push_back(cf_make_brightness(0.5f));
  48     array->push_back(cf_make_grayscale());
  49     array->push_back(cf_make_colorize(SK_ColorBLUE));
  50 }
  51
  52 ///////////////////////////////////////////////////////////////////////////////////////////////////
  53 #include "SkGradientShader.h"
  54 #include "SkImage.h"
  55 #include "Resources.h"
  56
  57 static sk_sp<SkShader> sh_make_lineargradient0() {
  58     const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
  59     const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
  60     return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkShader::kRepeat_TileMode);
  61 }
  62
  63 static sk_sp<SkShader> sh_make_lineargradient1() {
  64     const SkPoint pts[] = { { 0, 0 }, { 100, 100 } };
  65     const SkColor colors[] = { SK_ColorRED, 0x0000FF00, SK_ColorBLUE };
  66     return SkGradientShader::MakeLinear(pts, colors, nullptr, 3, SkShader::kRepeat_TileMode);
  67 }
  68
  69 static sk_sp<SkShader> sh_make_image() {
  70     sk_sp<SkImage> image(GetResourceAsImage("mandrill_128.png"));
  71     if (!image) {
  72         return nullptr;
  73     }
  74     return image->makeShader(SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
  75 }
  76
  77 static void sk_gm_get_shaders(SkTDArray<SkShader*>* array) {
  78     if (auto shader = sh_make_lineargradient0()) {
  79         *array->append() = shader.release();
  80     }
  81     if (auto shader = sh_make_lineargradient1()) {
  82         *array->append() = shader.release();
  83     }
  84     if (auto shader = sh_make_image()) {
  85         *array->append() = shader.release();
  86     }
  87 }
  88
  89 ///////////////////////////////////////////////////////////////////////////////////////////////////
  90
  91 static sk_sp<SkImageFilter> make_blur(float amount, sk_sp<SkImageFilter> input) {
  92     return SkBlurImageFilter::Make(amount, amount, std::move(input));
  93 }
  94
  95 static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> input) {
  96     return SkColorFilterImageFilter::Make(cf_make_brightness(amount), std::move(input));
  97 }
  98
  99 static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) {
 100     return SkColorFilterImageFilter::Make(cf_make_grayscale(), std::move(input));
 101 }
 102
 103 static sk_sp<SkImageFilter> make_mode_blue(sk_sp<SkImageFilter> input) {
 104     return SkColorFilterImageFilter::Make(cf_make_colorize(SK_ColorBLUE), std::move(input));
 105 }
 106
 107 static void draw_clipped_rect(SkCanvas* canvas,
 108                               const SkRect& r,
 109                               const SkPaint& paint,
 110                               float outset = 0.0f) {
 111     canvas->save();
 112     SkRect clip(r);
 113     clip.outset(outset, outset);
 114     canvas->clipRect(clip);
 115     canvas->drawRect(r, paint);
 116     canvas->restore();
 117 }
 118
 119 DEF_SIMPLE_GM(colorfilterimagefilter, canvas, 400, 100){
 120         SkRect r = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT);
 121         SkPaint paint;
 122         paint.setColor(SK_ColorRED);
 123         canvas->save();
 124         for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.2f) {
 125             sk_sp<SkImageFilter> dim(make_brightness(-brightness, nullptr));
 126             sk_sp<SkImageFilter> bright(make_brightness(brightness, std::move(dim)));
 127             paint.setImageFilter(std::move(bright));
 128             draw_clipped_rect(canvas, r, paint);
 129             canvas->translate(FILTER_WIDTH + MARGIN, 0);
 130         }
 131         canvas->restore();
 132         canvas->translate(0, FILTER_HEIGHT + MARGIN);
 133         {
 134             sk_sp<SkImageFilter> brightness(make_brightness(0.9f, nullptr));
 135             sk_sp<SkImageFilter> grayscale(make_grayscale(std::move(brightness)));
 136             paint.setImageFilter(std::move(grayscale));
 137             draw_clipped_rect(canvas, r, paint);
 138             canvas->translate(FILTER_WIDTH + MARGIN, 0);
 139         }
 140         {
 141             sk_sp<SkImageFilter> grayscale(make_grayscale(nullptr));
 142             sk_sp<SkImageFilter> brightness(make_brightness(0.9f, std::move(grayscale)));
 143             paint.setImageFilter(std::move(brightness));
 144             draw_clipped_rect(canvas, r, paint);
 145             canvas->translate(FILTER_WIDTH + MARGIN, 0);
 146         }
 147         {
 148             sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
 149             sk_sp<SkImageFilter> brightness(make_brightness(1.0f, std::move(blue)));
 150             paint.setImageFilter(std::move(brightness));
 151             draw_clipped_rect(canvas, r, paint);
 152             canvas->translate(FILTER_WIDTH + MARGIN, 0);
 153         }
 154         {
 155             sk_sp<SkImageFilter> brightness(make_brightness(1.0f, nullptr));
 156             sk_sp<SkImageFilter> blue(make_mode_blue(std::move(brightness)));
 157             paint.setImageFilter(std::move(blue));
 158             draw_clipped_rect(canvas, r, paint);
 159             canvas->translate(FILTER_WIDTH + MARGIN, 0);
 160         }
 161         {
 162             sk_sp<SkImageFilter> blur(make_blur(3.0f, nullptr));
 163             sk_sp<SkImageFilter> brightness(make_brightness(0.5f, std::move(blur)));
 164             paint.setImageFilter(std::move(brightness));
 165             draw_clipped_rect(canvas, r, paint, 3);
 166             canvas->translate(FILTER_WIDTH + MARGIN, 0);
 167         }
 168         {
 169             sk_sp<SkImageFilter> blue(make_mode_blue(nullptr));
 170             paint.setImageFilter(std::move(blue));
 171             draw_clipped_rect(canvas, r, paint, 5);
 172             canvas->translate(FILTER_WIDTH + MARGIN, 0);
 173         }
 174 }
 175
 176 DEF_SIMPLE_GM(colorfilterimagefilter_layer, canvas, 32, 32) {
 177     SkAutoCanvasRestore autoCanvasRestore(canvas, false);
 178     SkColorMatrix cm;
 179     cm.setSaturation(0.0f);
 180     sk_sp<SkColorFilter> cf(SkColorFilter::MakeMatrixFilterRowMajor255(cm.fMat));
 181     SkPaint p;
 182     p.setImageFilter(SkColorFilterImageFilter::Make(std::move(cf), nullptr));
 183     canvas->saveLayer(NULL, &p);
 184     canvas->clear(SK_ColorRED);
 185 }
 186
 187 ///////////////////////////////////////////////////////////////////////////////////////////////////
 188
 189 template <typename T> class SkTRefArray : public SkTDArray<T> {
 190 public:
 191     ~SkTRefArray() { this->unrefAll(); }
 192 };
 193
 194 DEF_SIMPLE_GM(colorfiltershader, canvas, 610, 450) {
 195     SkTArray<sk_sp<SkColorFilter>> filters;
 196     sk_gm_get_colorfilters(&filters);
 197
 198     SkTRefArray<SkShader*> shaders;
 199     sk_gm_get_shaders(&shaders);
 200
 201     SkPaint paint;
 202     SkRect r = SkRect::MakeWH(120, 120);
 203
 204     canvas->translate(20, 20);
 205     for (int y = 0; y < shaders.count(); ++y) {
 206         SkShader* shader = shaders[y];
 207
 208         canvas->save();
 209         for (int x = -1; x < filters.count(); ++x) {
 210             sk_sp<SkColorFilter> filter = x >= 0 ? filters[x] : nullptr;
 211
 212             paint.setShader(shader->makeWithColorFilter(filter));
 213             canvas->drawRect(r, paint);
 214             canvas->translate(150, 0);
 215         }
 216         canvas->restore();
 217         canvas->translate(0, 150);
 218     }
 219 }