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