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 "SkColor.h"
     10 #include "SkMatrixConvolutionImageFilter.h"
     11 #include "SkGradientShader.h"
     12 
     13 namespace skiagm {
     14 
     15 class MatrixConvolutionGM : public GM {
     16 public:
     17     MatrixConvolutionGM() : fInitialized(false) {
     18         this->setBGColor(0x00000000);
     19     }
     20 
     21 protected:
     22     virtual SkString onShortName() {
     23         return SkString("matrixconvolution");
     24     }
     25 
     26     void make_bitmap() {
     27         fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
     28         fBitmap.allocPixels();
     29         SkBitmapDevice device(fBitmap);
     30         SkCanvas canvas(&device);
     31         canvas.clear(0x00000000);
     32         SkPaint paint;
     33         paint.setAntiAlias(true);
     34         paint.setColor(0xFFFFFFFF);
     35         paint.setTextSize(SkIntToScalar(180));
     36         SkPoint pts[2] = { SkPoint::Make(0, 0),
     37                            SkPoint::Make(0, SkIntToScalar(80)) };
     38         SkColor colors[2] = { 0xFFFFFFFF, 0x40404040 };
     39         SkScalar pos[2] = { 0, SkIntToScalar(80) };
     40         paint.setShader(SkGradientShader::CreateLinear(
     41             pts, colors, pos, 2, SkShader::kClamp_TileMode))->unref();
     42         const char* str = "e";
     43         canvas.drawText(str, strlen(str), SkIntToScalar(-10), SkIntToScalar(80), paint);
     44     }
     45 
     46     virtual SkISize onISize() {
     47         return make_isize(500, 300);
     48     }
     49 
     50     void draw(SkCanvas* canvas, int x, int y, const SkIPoint& target,
     51               SkMatrixConvolutionImageFilter::TileMode tileMode, bool convolveAlpha,
     52               const SkImageFilter::CropRect* cropRect = NULL) {
     53         SkScalar kernel[9] = {
     54             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     55             SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
     56             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     57         };
     58         SkISize kernelSize = SkISize::Make(3, 3);
     59         SkScalar gain = 0.3f, bias = SkIntToScalar(100);
     60         SkPaint paint;
     61         SkAutoTUnref<SkImageFilter> filter(
     62             SkNEW_ARGS(SkMatrixConvolutionImageFilter, (kernelSize,
     63                                                         kernel,
     64                                                         gain,
     65                                                         bias,
     66                                                         target,
     67                                                         tileMode,
     68                                                         convolveAlpha,
     69                                                         NULL,
     70                                                         cropRect)));
     71         paint.setImageFilter(filter);
     72         canvas->save();
     73         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
     74         canvas->clipRect(SkRect::MakeWH(SkIntToScalar(fBitmap.width()),
     75                                         SkIntToScalar(fBitmap.height())));
     76         canvas->drawBitmap(fBitmap, 0, 0, &paint);
     77         canvas->restore();
     78     }
     79 
     80     typedef SkMatrixConvolutionImageFilter MCIF;
     81 
     82     virtual void onDraw(SkCanvas* canvas) {
     83         if (!fInitialized) {
     84             make_bitmap();
     85             fInitialized = true;
     86         }
     87         canvas->clear(0x00000000);
     88         SkIPoint target = SkIPoint::Make(1, 0);
     89         for (int x = 10; x < 310; x += 100) {
     90             this->draw(canvas, x, 10, target, MCIF::kClamp_TileMode, true);
     91             this->draw(canvas, x, 110, target, MCIF::kClampToBlack_TileMode, true);
     92             this->draw(canvas, x, 210, target, MCIF::kRepeat_TileMode, true);
     93             target.fY++;
     94         }
     95         target.fY = 1;
     96         SkImageFilter::CropRect rect(SkRect::MakeXYWH(10, 5, 60, 60));
     97         this->draw(canvas, 310, 10, target, MCIF::kClamp_TileMode, true, &rect);
     98         this->draw(canvas, 310, 110, target, MCIF::kClampToBlack_TileMode, true, &rect);
     99         this->draw(canvas, 310, 210, target, MCIF::kRepeat_TileMode, true, &rect);
    100 
    101         this->draw(canvas, 410, 10, target, MCIF::kClamp_TileMode, false);
    102         this->draw(canvas, 410, 110, target, MCIF::kClampToBlack_TileMode, false);
    103         this->draw(canvas, 410, 210, target, MCIF::kRepeat_TileMode, false);
    104     }
    105 
    106 private:
    107     typedef GM INHERITED;
    108     SkBitmap fBitmap;
    109     bool fInitialized;
    110 };
    111 
    112 //////////////////////////////////////////////////////////////////////////////
    113 
    114 static GM* MyFactory(void*) { return new MatrixConvolutionGM; }
    115 static GMRegistry reg(MyFactory);
    116 
    117 }
    118