gm/modecolorfilters.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 "SkColorFilter.h"
  10 #include "SkGradientShader.h"
  11
  12 #define WIDTH 512
  13 #define HEIGHT 1024
  14
  15 namespace skiagm {
  16
  17 // Using gradients because GPU doesn't currently have an implementation of SkColorShader (duh!)
  18 static sk_sp<SkShader> make_color_shader(SkColor color) {
  19     constexpr SkPoint kPts[] = {{0, 0}, {1, 1}};
  20     SkColor colors[] = {color, color};
  21
  22     return SkGradientShader::MakeLinear(kPts, colors, nullptr, 2, SkShader::kClamp_TileMode);
  23 }
  24
  25 static sk_sp<SkShader> make_solid_shader() {
  26     return make_color_shader(SkColorSetARGB(0xFF, 0x42, 0x82, 0x21));
  27 }
  28
  29 static sk_sp<SkShader> make_transparent_shader() {
  30     return make_color_shader(SkColorSetARGB(0x80, 0x10, 0x70, 0x20));
  31 }
  32
  33 static sk_sp<SkShader> make_trans_black_shader() {
  34     return make_color_shader(0x0);
  35 }
  36
  37 // draws a background behind each test rect to see transparency
  38 static sk_sp<SkShader> make_bg_shader(int checkSize) {
  39     SkBitmap bmp;
  40     bmp.allocN32Pixels(2 * checkSize, 2 * checkSize);
  41     SkCanvas canvas(bmp);
  42     canvas.clear(sk_tool_utils::color_to_565(0xFF800000));
  43     SkPaint paint;
  44     paint.setColor(sk_tool_utils::color_to_565(0xFF000080));
  45     SkRect rect0 = SkRect::MakeXYWH(0, 0,
  46                                     SkIntToScalar(checkSize), SkIntToScalar(checkSize));
  47     SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(checkSize), SkIntToScalar(checkSize),
  48                                     SkIntToScalar(checkSize), SkIntToScalar(checkSize));
  49     canvas.drawRect(rect1, paint);
  50     canvas.drawRect(rect0, paint);
  51     return SkShader::MakeBitmapShader(bmp, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode);
  52 }
  53
  54 class ModeColorFilterGM : public GM {
  55 public:
  56     ModeColorFilterGM() {
  57         this->setBGColor(sk_tool_utils::color_to_565(0xFF303030));
  58     }
  59
  60 protected:
  61     SkString onShortName() override  {
  62         return SkString("modecolorfilters");
  63     }
  64
  65     SkISize onISize() override  {
  66         return SkISize::Make(WIDTH, HEIGHT);
  67     }
  68
  69     void onDraw(SkCanvas* canvas) override {
  70         // size of rect for each test case
  71         constexpr int kRectWidth  = 20;
  72         constexpr int kRectHeight = 20;
  73
  74         constexpr int kCheckSize  = 10;
  75
  76         if (!fBmpShader) {
  77             fBmpShader = make_bg_shader(kCheckSize);
  78         }
  79         SkPaint bgPaint;
  80         bgPaint.setShader(fBmpShader);
  81         bgPaint.setBlendMode(SkBlendMode::kSrc);
  82
  83         sk_sp<SkShader> shaders[] = {
  84             nullptr,                                   // use a paint color instead of a shader
  85             make_solid_shader(),
  86             make_transparent_shader(),
  87             make_trans_black_shader(),
  88         };
  89
  90         // used without shader
  91         SkColor colors[] = {
  92             SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF),
  93             SkColorSetARGB(0xFF, 0x00, 0x00, 0x00),
  94             SkColorSetARGB(0x00, 0x00, 0x00, 0x00),
  95             SkColorSetARGB(0xFF, 0x10, 0x20, 0x42),
  96             SkColorSetARGB(0xA0, 0x20, 0x30, 0x90),
  97         };
  98
  99         // used with shaders
 100         SkColor alphas[] = {0xFFFFFFFF, 0x80808080};
 101
 102         SkXfermode::Mode modes[]  = { // currently just doing the Modes expressible as Coeffs
 103             SkXfermode::kClear_Mode,
 104             SkXfermode::kSrc_Mode,
 105             SkXfermode::kDst_Mode,
 106             SkXfermode::kSrcOver_Mode,
 107             SkXfermode::kDstOver_Mode,
 108             SkXfermode::kSrcIn_Mode,
 109             SkXfermode::kDstIn_Mode,
 110             SkXfermode::kSrcOut_Mode,
 111             SkXfermode::kDstOut_Mode,
 112             SkXfermode::kSrcATop_Mode,
 113             SkXfermode::kDstATop_Mode,
 114             SkXfermode::kXor_Mode,
 115             SkXfermode::kPlus_Mode,
 116             SkXfermode::kModulate_Mode,
 117         };
 118
 119         SkPaint paint;
 120         int idx = 0;
 121         const int kRectsPerRow = SkMax32(this->getISize().fWidth / kRectWidth, 1);
 122         for (size_t cfm = 0; cfm < SK_ARRAY_COUNT(modes); ++cfm) {
 123             for (size_t cfc = 0; cfc < SK_ARRAY_COUNT(colors); ++cfc) {
 124                 paint.setColorFilter(SkColorFilter::MakeModeFilter(colors[cfc], modes[cfm]));
 125                 for (size_t s = 0; s < SK_ARRAY_COUNT(shaders); ++s) {
 126                     paint.setShader(shaders[s]);
 127                     bool hasShader = nullptr == paint.getShader();
 128                     int paintColorCnt = hasShader ? SK_ARRAY_COUNT(alphas) : SK_ARRAY_COUNT(colors);
 129                     SkColor* paintColors = hasShader ? alphas : colors;
 130                     for (int pc = 0; pc < paintColorCnt; ++pc) {
 131                         paint.setColor(paintColors[pc]);
 132                         SkScalar x = SkIntToScalar(idx % kRectsPerRow);
 133                         SkScalar y = SkIntToScalar(idx / kRectsPerRow);
 134                         SkRect rect = SkRect::MakeXYWH(x * kRectWidth, y * kRectHeight,
 135                                                        SkIntToScalar(kRectWidth),
 136                                                        SkIntToScalar(kRectHeight));
 137                         canvas->saveLayer(&rect, nullptr);
 138                         canvas->drawRect(rect, bgPaint);
 139                         canvas->drawRect(rect, paint);
 140                         canvas->restore();
 141                         ++idx;
 142                     }
 143                 }
 144             }
 145         }
 146     }
 147
 148 private:
 149     sk_sp<SkShader> fBmpShader;
 150     typedef GM INHERITED;
 151 };
 152
 153 //////////////////////////////////////////////////////////////////////////////
 154
 155 static GM* MyFactory(void*) { return new ModeColorFilterGM; }
 156 static GMRegistry reg(MyFactory);
 157
 158 }