Home | History | Annotate | Download | only in gm
      1 /*
      2  * Copyright 2011 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 "SkColorMatrixFilter.h"
     10 #include "SkGradientShader.h"
     11 
     12 #define WIDTH 500
     13 #define HEIGHT 500
     14 
     15 class SkOnce {
     16 public:
     17     SkOnce() : fOnce(false) {};
     18 
     19     bool once() const {
     20         if (fOnce) {
     21             return false;
     22         }
     23         fOnce = true;
     24         return true;
     25     }
     26 
     27 private:
     28     mutable bool fOnce;
     29 };
     30 
     31 static void setColorMatrix(SkPaint* paint, const SkColorMatrix& matrix) {
     32     paint->setColorFilter(SkNEW_ARGS(SkColorMatrixFilter, (matrix)))->unref();
     33 }
     34 
     35 static void setArray(SkPaint* paint, const SkScalar array[]) {
     36     paint->setColorFilter(SkNEW_ARGS(SkColorMatrixFilter, (array)))->unref();
     37 }
     38 
     39 namespace skiagm {
     40 
     41 class ColorMatrixGM : public GM {
     42     SkOnce fOnce;
     43     void init() {
     44         if (fOnce.once()) {
     45             fSolidBitmap = this->createSolidBitmap(64, 64);
     46             fTransparentBitmap = this->createTransparentBitmap(64, 64);
     47         }
     48     }
     49 
     50 public:
     51     ColorMatrixGM() {
     52         this->setBGColor(0xFF808080);
     53     }
     54 
     55 protected:
     56     virtual SkString onShortName() {
     57         return SkString("colormatrix");
     58     }
     59 
     60     virtual SkISize onISize() {
     61         return make_isize(WIDTH, HEIGHT);
     62     }
     63 
     64     SkBitmap createSolidBitmap(int width, int height) {
     65         SkBitmap bm;
     66         bm.setConfig(SkBitmap::kARGB_8888_Config, width, height);
     67         bm.allocPixels();
     68         SkCanvas canvas(bm);
     69         canvas.clear(0x0);
     70         for (int y = 0; y < height; ++y) {
     71             for (int x = 0; x < width; ++x) {
     72                 SkPaint paint;
     73                 paint.setColor(SkColorSetARGB(255, x * 255 / width, y * 255 / height, 0));
     74                 canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(x),
     75                     SkIntToScalar(y), SK_Scalar1, SK_Scalar1), paint);
     76             }
     77         }
     78         return bm;
     79     }
     80 
     81     // creates a bitmap with shades of transparent gray.
     82     SkBitmap createTransparentBitmap(int width, int height) {
     83         SkBitmap bm;
     84         bm.setConfig(SkBitmap::kARGB_8888_Config, width, height);
     85         bm.allocPixels();
     86         SkCanvas canvas(bm);
     87         canvas.clear(0x0);
     88 
     89         SkPoint pts[] = {{0, 0}, {SkIntToScalar(width), SkIntToScalar(height)}};
     90         SkColor colors[] = {0x00000000, 0xFFFFFFFF};
     91         SkPaint paint;
     92         paint.setShader(SkGradientShader::CreateLinear(pts, colors, NULL, 2,
     93                                                        SkShader::kClamp_TileMode))->unref();
     94         canvas.drawRect(SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)), paint);
     95         return bm;
     96     }
     97 
     98     virtual void onDraw(SkCanvas* canvas) {
     99         this->init();
    100 
    101         SkPaint paint;
    102         SkColorMatrix matrix;
    103 
    104         paint.setXfermodeMode(SkXfermode::kSrc_Mode);
    105         const SkBitmap bmps[] = { fSolidBitmap, fTransparentBitmap };
    106 
    107         for (size_t i = 0; i < SK_ARRAY_COUNT(bmps); ++i) {
    108 
    109             matrix.setIdentity();
    110             setColorMatrix(&paint, matrix);
    111             canvas->drawBitmap(bmps[i], 0, 0, &paint);
    112 
    113             matrix.setRotate(SkColorMatrix::kR_Axis, 90);
    114             setColorMatrix(&paint, matrix);
    115             canvas->drawBitmap(bmps[i], 80, 0, &paint);
    116 
    117             matrix.setRotate(SkColorMatrix::kG_Axis, 90);
    118             setColorMatrix(&paint, matrix);
    119             canvas->drawBitmap(bmps[i], 160, 0, &paint);
    120 
    121             matrix.setRotate(SkColorMatrix::kB_Axis, 90);
    122             setColorMatrix(&paint, matrix);
    123             canvas->drawBitmap(bmps[i], 240, 0, &paint);
    124 
    125             matrix.setSaturation(SkFloatToScalar(0.0f));
    126             setColorMatrix(&paint, matrix);
    127             canvas->drawBitmap(bmps[i], 0, 80, &paint);
    128 
    129             matrix.setSaturation(SkFloatToScalar(0.5f));
    130             setColorMatrix(&paint, matrix);
    131             canvas->drawBitmap(bmps[i], 80, 80, &paint);
    132 
    133             matrix.setSaturation(SkFloatToScalar(1.0f));
    134             setColorMatrix(&paint, matrix);
    135             canvas->drawBitmap(bmps[i], 160, 80, &paint);
    136 
    137             matrix.setSaturation(SkFloatToScalar(2.0f));
    138             setColorMatrix(&paint, matrix);
    139             canvas->drawBitmap(bmps[i], 240, 80, &paint);
    140 
    141             matrix.setRGB2YUV();
    142             setColorMatrix(&paint, matrix);
    143             canvas->drawBitmap(bmps[i], 0, 160, &paint);
    144 
    145             matrix.setYUV2RGB();
    146             setColorMatrix(&paint, matrix);
    147             canvas->drawBitmap(bmps[i], 80, 160, &paint);
    148 
    149             SkScalar s1 = SK_Scalar1;
    150             SkScalar s255 = SkIntToScalar(255);
    151             // Move red into alpha, set color to white
    152             SkScalar data[20] = {
    153                 0,  0, 0, 0, s255,
    154                 0,  0, 0, 0, s255,
    155                 0,  0, 0, 0, s255,
    156                 s1, 0, 0, 0, 0,
    157             };
    158 
    159             setArray(&paint, data);
    160             canvas->drawBitmap(bmps[i], 160, 160, &paint);
    161 
    162             canvas->translate(0, 240);
    163         }
    164     }
    165 
    166 private:
    167     SkBitmap fSolidBitmap;
    168     SkBitmap fTransparentBitmap;
    169     typedef GM INHERITED;
    170 };
    171 
    172 //////////////////////////////////////////////////////////////////////////////
    173 
    174 static GM* MyFactory(void*) { return new ColorMatrixGM; }
    175 static GMRegistry reg(MyFactory);
    176 
    177 }
    178