gm/srcmode.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 "SkGradientShader.h"
  11 #include "SkSurface.h"
  12
  13 #if SK_SUPPORT_GPU
  14     #include "SkGpuDevice.h"
  15 #endif
  16
  17 #define W   SkIntToScalar(80)
  18 #define H   SkIntToScalar(60)
  19
  20 typedef void (*PaintProc)(SkPaint*);
  21
  22 static void identity_paintproc(SkPaint* paint) {
  23     paint->setShader(NULL);
  24 }
  25
  26 static void gradient_paintproc(SkPaint* paint) {
  27     const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
  28     const SkPoint pts[] = { { 0, 0 }, { W, H } };
  29     SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL,
  30                                                  SK_ARRAY_COUNT(colors),
  31                                                  SkShader::kClamp_TileMode);
  32     paint->setShader(s)->unref();
  33 }
  34
  35 typedef void (*Proc)(SkCanvas*, const SkPaint&);
  36
  37 static void draw_hair(SkCanvas* canvas, const SkPaint& paint) {
  38     SkPaint p(paint);
  39     p.setStrokeWidth(0);
  40     canvas->drawLine(0, 0, W, H, p);
  41 }
  42
  43 static void draw_thick(SkCanvas* canvas, const SkPaint& paint) {
  44     SkPaint p(paint);
  45     p.setStrokeWidth(H/5);
  46     canvas->drawLine(0, 0, W, H, p);
  47 }
  48
  49 static void draw_rect(SkCanvas* canvas, const SkPaint& paint) {
  50     canvas->drawRect(SkRect::MakeWH(W, H), paint);
  51 }
  52
  53 static void draw_oval(SkCanvas* canvas, const SkPaint& paint) {
  54     canvas->drawOval(SkRect::MakeWH(W, H), paint);
  55 }
  56
  57 static void draw_text(SkCanvas* canvas, const SkPaint& paint) {
  58     SkPaint p(paint);
  59     p.setTextSize(H/4);
  60     canvas->drawText("Hamburge", 8, 0, H*2/3, p);
  61 }
  62
  63 class SrcModeGM : public skiagm::GM {
  64     SkPath fPath;
  65 public:
  66     SrcModeGM() {
  67         this->setBGColor(SK_ColorBLACK);
  68     }
  69
  70 protected:
  71     virtual SkString onShortName() {
  72         return SkString("srcmode");
  73     }
  74
  75     virtual SkISize onISize() {
  76         return SkISize::Make(640, 760);
  77     }
  78
  79     void drawContent(SkCanvas* canvas) {
  80         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
  81
  82         SkPaint paint;
  83         paint.setColor(0x80FF0000);
  84
  85         const Proc procs[] = {
  86             draw_hair, draw_thick, draw_rect, draw_oval, draw_text
  87         };
  88
  89         const SkXfermode::Mode modes[] = {
  90             SkXfermode::kSrcOver_Mode, SkXfermode::kSrc_Mode, SkXfermode::kClear_Mode
  91         };
  92
  93         const PaintProc paintProcs[] = {
  94             identity_paintproc, gradient_paintproc
  95         };
  96
  97         for (int aa = 0; aa <= 1; ++aa) {
  98             paint.setAntiAlias(SkToBool(aa));
  99             canvas->save();
 100             for (size_t i = 0; i < SK_ARRAY_COUNT(paintProcs); ++i) {
 101                 paintProcs[i](&paint);
 102                 for (size_t x = 0; x < SK_ARRAY_COUNT(modes); ++x) {
 103                     paint.setXfermodeMode(modes[x]);
 104                     canvas->save();
 105                     for (size_t y = 0; y < SK_ARRAY_COUNT(procs); ++y) {
 106                         procs[y](canvas, paint);
 107                         canvas->translate(0, H * 5 / 4);
 108                     }
 109                     canvas->restore();
 110                     canvas->translate(W * 5 / 4, 0);
 111                 }
 112             }
 113             canvas->restore();
 114             canvas->translate(0, (H * 5 / 4) * SK_ARRAY_COUNT(procs));
 115         }
 116     }
 117
 118     static SkSurface* compat_surface(SkCanvas* canvas, const SkISize& size,
 119                                      bool skipGPU) {
 120         SkImageInfo info = SkImageInfo::MakeN32Premul(size);
 121 #if SK_SUPPORT_GPU
 122         SkBaseDevice* dev = canvas->getDevice();
 123         if (!skipGPU && dev->accessRenderTarget()) {
 124             SkGpuDevice* gd = (SkGpuDevice*)dev;
 125             GrContext* ctx = gd->context();
 126             return SkSurface::NewRenderTarget(ctx, info, 0);
 127         }
 128 #endif
 129         return SkSurface::NewRaster(info);
 130     }
 131
 132     virtual void onDraw(SkCanvas* canvas) {
 133         SkAutoTUnref<SkSurface> surf(compat_surface(canvas, this->getISize(),
 134                                                     this->isCanvasDeferred()));
 135         surf->getCanvas()->drawColor(SK_ColorWHITE);
 136         this->drawContent(surf->getCanvas());
 137         surf->draw(canvas, 0, 0, NULL);
 138     }
 139
 140 private:
 141     typedef skiagm::GM INHERITED;
 142 };
 143
 144 ///////////////////////////////////////////////////////////////////////////////
 145
 146 DEF_GM(return new SrcModeGM;)