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