gm/xfermodes3.cpp

   1 /*
   2  * Copyright 2013 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 "SkBitmap.h"
  11 #include "SkGradientShader.h"
  12 #include "SkSurface.h"
  13 #include "SkBlendModePriv.h"
  14 #include "SkColorPriv.h"
  15
  16 #if SK_SUPPORT_GPU
  17 #include "GrContext.h"
  18 #endif
  19
  20 namespace skiagm {
  21
  22 /**
  23  * This tests drawing device-covering rects with solid colors and bitmap shaders over a
  24  * checkerboard background using different xfermodes.
  25  */
  26 class Xfermodes3GM : public GM {
  27 public:
  28     Xfermodes3GM() {}
  29
  30 protected:
  31     SkString onShortName() override {
  32         return SkString("xfermodes3");
  33     }
  34
  35     SkISize onISize() override {
  36         return SkISize::Make(630, 1215);
  37     }
  38
  39     void onDrawBackground(SkCanvas* canvas) override {
  40         SkPaint bgPaint;
  41         bgPaint.setColor(sk_tool_utils::color_to_565(0xFF70D0E0));
  42         canvas->drawPaint(bgPaint);
  43     }
  44
  45     void onDraw(SkCanvas* canvas) override {
  46         canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
  47
  48         SkPaint labelP;
  49         labelP.setAntiAlias(true);
  50         sk_tool_utils::set_portable_typeface(&labelP);
  51
  52         constexpr SkColor kSolidColors[] = {
  53             SK_ColorTRANSPARENT,
  54             SK_ColorBLUE,
  55             0x80808000
  56         };
  57
  58         constexpr SkColor kBmpAlphas[] = {
  59             0xff,
  60             0x80,
  61         };
  62
  63         auto tempSurface(this->possiblyCreateTempSurface(canvas, kSize, kSize));
  64
  65         int test = 0;
  66         int x = 0, y = 0;
  67         constexpr struct { SkPaint::Style fStyle; SkScalar fWidth; } kStrokes[] = {
  68             {SkPaint::kFill_Style, 0},
  69             {SkPaint::kStroke_Style, SkIntToScalar(kSize) / 2},
  70         };
  71         for (size_t s = 0; s < SK_ARRAY_COUNT(kStrokes); ++s) {
  72             for (size_t m = 0; m <= (size_t)SkBlendMode::kLastMode; ++m) {
  73                 SkBlendMode mode = static_cast<SkBlendMode>(m);
  74                 canvas->drawString(SkBlendMode_Name(mode),
  75                                  SkIntToScalar(x),
  76                                  SkIntToScalar(y + kSize + 3) + labelP.getTextSize(),
  77                                  labelP);
  78                 for (size_t c = 0; c < SK_ARRAY_COUNT(kSolidColors); ++c) {
  79                     SkPaint modePaint;
  80                     modePaint.setBlendMode(mode);
  81                     modePaint.setColor(kSolidColors[c]);
  82                     modePaint.setStyle(kStrokes[s].fStyle);
  83                     modePaint.setStrokeWidth(kStrokes[s].fWidth);
  84
  85                     this->drawMode(canvas, x, y, kSize, kSize, modePaint, tempSurface.get());
  86
  87                     ++test;
  88                     x += kSize + 10;
  89                     if (!(test % kTestsPerRow)) {
  90                         x = 0;
  91                         y += kSize + 30;
  92                     }
  93                 }
  94                 for (size_t a = 0; a < SK_ARRAY_COUNT(kBmpAlphas); ++a) {
  95                     SkPaint modePaint;
  96                     modePaint.setBlendMode(mode);
  97                     modePaint.setAlpha(kBmpAlphas[a]);
  98                     modePaint.setShader(fBmpShader);
  99                     modePaint.setStyle(kStrokes[s].fStyle);
 100                     modePaint.setStrokeWidth(kStrokes[s].fWidth);
 101
 102                     this->drawMode(canvas, x, y, kSize, kSize, modePaint, tempSurface.get());
 103
 104                     ++test;
 105                     x += kSize + 10;
 106                     if (!(test % kTestsPerRow)) {
 107                         x = 0;
 108                         y += kSize + 30;
 109                     }
 110                 }
 111             }
 112         }
 113     }
 114
 115 private:
 116     /**
 117      * GrContext has optimizations around full rendertarget draws that can be replaced with clears.
 118      * We are trying to test those. We could use saveLayer() to create small SkGpuDevices but
 119      * saveLayer() uses the texture cache. This means that the actual render target may be larger
 120      * than the layer. Because the clip will contain the layer's bounds, no draws will be full-RT.
 121      * So when running on a GPU canvas we explicitly create a temporary canvas using a texture with
 122      * dimensions exactly matching the layer size.
 123      */
 124     sk_sp<SkSurface> possiblyCreateTempSurface(SkCanvas* baseCanvas, int w, int h) {
 125 #if SK_SUPPORT_GPU
 126         GrContext* context = baseCanvas->getGrContext();
 127         SkImageInfo baseInfo = baseCanvas->imageInfo();
 128         SkImageInfo info = SkImageInfo::Make(w, h, baseInfo.colorType(), baseInfo.alphaType(),
 129                                              baseInfo.refColorSpace());
 130         SkSurfaceProps canvasProps(SkSurfaceProps::kLegacyFontHost_InitType);
 131         baseCanvas->getProps(&canvasProps);
 132         return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, &canvasProps);
 133 #else
 134         return nullptr;
 135 #endif
 136     }
 137
 138     void drawMode(SkCanvas* canvas,
 139                   int x, int y, int w, int h,
 140                   const SkPaint& modePaint, SkSurface* surface) {
 141         canvas->save();
 142         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
 143
 144         SkRect r = SkRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h));
 145
 146         SkCanvas* modeCanvas;
 147         if (nullptr == surface) {
 148             canvas->saveLayer(&r, nullptr);
 149             modeCanvas = canvas;
 150         } else {
 151             modeCanvas = surface->getCanvas();
 152         }
 153
 154         SkPaint bgPaint;
 155         bgPaint.setAntiAlias(false);
 156         bgPaint.setShader(fBGShader);
 157         modeCanvas->drawRect(r, bgPaint);
 158         modeCanvas->drawRect(r, modePaint);
 159         modeCanvas = nullptr;
 160
 161         if (nullptr == surface) {
 162             canvas->restore();
 163         } else {
 164             surface->draw(canvas, 0, 0, nullptr);
 165         }
 166
 167         r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
 168         SkPaint borderPaint;
 169         borderPaint.setStyle(SkPaint::kStroke_Style);
 170         canvas->drawRect(r, borderPaint);
 171
 172         canvas->restore();
 173     }
 174
 175     void onOnceBeforeDraw() override {
 176         const uint32_t kCheckData[] = {
 177             SkPackARGB32(0xFF, 0x42, 0x41, 0x42),
 178             SkPackARGB32(0xFF, 0xD6, 0xD3, 0xD6),
 179             SkPackARGB32(0xFF, 0xD6, 0xD3, 0xD6),
 180             SkPackARGB32(0xFF, 0x42, 0x41, 0x42)
 181         };
 182         SkBitmap bg;
 183         bg.allocN32Pixels(2, 2, true);
 184         memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
 185
 186         SkMatrix lm;
 187         lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize));
 188         fBGShader = SkShader::MakeBitmapShader(bg, SkShader::kRepeat_TileMode,
 189                                                SkShader::kRepeat_TileMode, &lm);
 190
 191         SkPaint bmpPaint;
 192         const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 };
 193         const SkColor kColors[] = {
 194             SK_ColorTRANSPARENT, 0x80800000, 0xF020F060, SK_ColorWHITE
 195         };
 196         bmpPaint.setShader(SkGradientShader::MakeRadial(kCenter, 3 * SkIntToScalar(kSize) / 4,
 197                                                         kColors, nullptr, SK_ARRAY_COUNT(kColors),
 198                                                         SkShader::kRepeat_TileMode));
 199
 200         SkBitmap bmp;
 201         bmp.allocN32Pixels(kSize, kSize);
 202         SkCanvas bmpCanvas(bmp);
 203
 204         bmpCanvas.clear(SK_ColorTRANSPARENT);
 205         SkRect rect = { SkIntToScalar(kSize) / 8, SkIntToScalar(kSize) / 8,
 206                         7 * SkIntToScalar(kSize) / 8, 7 * SkIntToScalar(kSize) / 8};
 207         bmpCanvas.drawRect(rect, bmpPaint);
 208
 209         fBmpShader = SkShader::MakeBitmapShader(bmp, SkShader::kClamp_TileMode,
 210                                                 SkShader::kClamp_TileMode);
 211     }
 212
 213     enum {
 214         kCheckSize = 8,
 215         kSize = 30,
 216         kTestsPerRow = 15,
 217     };
 218
 219     sk_sp<SkShader> fBGShader;
 220     sk_sp<SkShader> fBmpShader;
 221
 222     typedef GM INHERITED;
 223 };
 224
 225 //////////////////////////////////////////////////////////////////////////////
 226
 227 DEF_GM(return new Xfermodes3GM;)
 228
 229 }