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->drawText(SkBlendMode_Name(mode),
  75                                  strlen(SkBlendMode_Name(mode)),
  76                                  SkIntToScalar(x),
  77                                  SkIntToScalar(y + kSize + 3) + labelP.getTextSize(),
  78                                  labelP);
  79                 for (size_t c = 0; c < SK_ARRAY_COUNT(kSolidColors); ++c) {
  80                     SkPaint modePaint;
  81                     modePaint.setBlendMode(mode);
  82                     modePaint.setColor(kSolidColors[c]);
  83                     modePaint.setStyle(kStrokes[s].fStyle);
  84                     modePaint.setStrokeWidth(kStrokes[s].fWidth);
  85
  86                     this->drawMode(canvas, x, y, kSize, kSize, modePaint, tempSurface.get());
  87
  88                     ++test;
  89                     x += kSize + 10;
  90                     if (!(test % kTestsPerRow)) {
  91                         x = 0;
  92                         y += kSize + 30;
  93                     }
  94                 }
  95                 for (size_t a = 0; a < SK_ARRAY_COUNT(kBmpAlphas); ++a) {
  96                     SkPaint modePaint;
  97                     modePaint.setBlendMode(mode);
  98                     modePaint.setAlpha(kBmpAlphas[a]);
  99                     modePaint.setShader(fBmpShader);
 100                     modePaint.setStyle(kStrokes[s].fStyle);
 101                     modePaint.setStrokeWidth(kStrokes[s].fWidth);
 102
 103                     this->drawMode(canvas, x, y, kSize, kSize, modePaint, tempSurface.get());
 104
 105                     ++test;
 106                     x += kSize + 10;
 107                     if (!(test % kTestsPerRow)) {
 108                         x = 0;
 109                         y += kSize + 30;
 110                     }
 111                 }
 112             }
 113         }
 114     }
 115
 116 private:
 117     /**
 118      * GrContext has optimizations around full rendertarget draws that can be replaced with clears.
 119      * We are trying to test those. We could use saveLayer() to create small SkGpuDevices but
 120      * saveLayer() uses the texture cache. This means that the actual render target may be larger
 121      * than the layer. Because the clip will contain the layer's bounds, no draws will be full-RT.
 122      * So when running on a GPU canvas we explicitly create a temporary canvas using a texture with
 123      * dimensions exactly matching the layer size.
 124      */
 125     sk_sp<SkSurface> possiblyCreateTempSurface(SkCanvas* baseCanvas, int w, int h) {
 126 #if SK_SUPPORT_GPU
 127         GrContext* context = baseCanvas->getGrContext();
 128         SkImageInfo baseInfo = baseCanvas->imageInfo();
 129         SkImageInfo info = SkImageInfo::Make(w, h, baseInfo.colorType(), baseInfo.alphaType(),
 130                                              baseInfo.refColorSpace());
 131         SkSurfaceProps canvasProps(SkSurfaceProps::kLegacyFontHost_InitType);
 132         baseCanvas->getProps(&canvasProps);
 133         return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, &canvasProps);
 134 #else
 135         return nullptr;
 136 #endif
 137     }
 138
 139     void drawMode(SkCanvas* canvas,
 140                   int x, int y, int w, int h,
 141                   const SkPaint& modePaint, SkSurface* surface) {
 142         canvas->save();
 143         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
 144
 145         SkRect r = SkRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h));
 146
 147         SkCanvas* modeCanvas;
 148         if (nullptr == surface) {
 149             canvas->saveLayer(&r, nullptr);
 150             modeCanvas = canvas;
 151         } else {
 152             modeCanvas = surface->getCanvas();
 153         }
 154
 155         SkPaint bgPaint;
 156         bgPaint.setAntiAlias(false);
 157         bgPaint.setShader(fBGShader);
 158         modeCanvas->drawRect(r, bgPaint);
 159         modeCanvas->drawRect(r, modePaint);
 160         modeCanvas = nullptr;
 161
 162         if (nullptr == surface) {
 163             canvas->restore();
 164         } else {
 165             surface->draw(canvas, 0, 0, nullptr);
 166         }
 167
 168         r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
 169         SkPaint borderPaint;
 170         borderPaint.setStyle(SkPaint::kStroke_Style);
 171         canvas->drawRect(r, borderPaint);
 172
 173         canvas->restore();
 174     }
 175
 176     void onOnceBeforeDraw() override {
 177         const uint32_t kCheckData[] = {
 178             SkPackARGB32(0xFF, 0x42, 0x41, 0x42),
 179             SkPackARGB32(0xFF, 0xD6, 0xD3, 0xD6),
 180             SkPackARGB32(0xFF, 0xD6, 0xD3, 0xD6),
 181             SkPackARGB32(0xFF, 0x42, 0x41, 0x42)
 182         };
 183         SkBitmap bg;
 184         bg.allocN32Pixels(2, 2, true);
 185         memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
 186
 187         SkMatrix lm;
 188         lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize));
 189         fBGShader = SkShader::MakeBitmapShader(bg, SkShader::kRepeat_TileMode,
 190                                                SkShader::kRepeat_TileMode, &lm);
 191
 192         SkPaint bmpPaint;
 193         const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 };
 194         const SkColor kColors[] = {
 195             SK_ColorTRANSPARENT, 0x80800000, 0xF020F060, SK_ColorWHITE
 196         };
 197         bmpPaint.setShader(SkGradientShader::MakeRadial(kCenter, 3 * SkIntToScalar(kSize) / 4,
 198                                                         kColors, nullptr, SK_ARRAY_COUNT(kColors),
 199                                                         SkShader::kRepeat_TileMode));
 200
 201         SkBitmap bmp;
 202         bmp.allocN32Pixels(kSize, kSize);
 203         SkCanvas bmpCanvas(bmp);
 204
 205         bmpCanvas.clear(SK_ColorTRANSPARENT);
 206         SkRect rect = { SkIntToScalar(kSize) / 8, SkIntToScalar(kSize) / 8,
 207                         7 * SkIntToScalar(kSize) / 8, 7 * SkIntToScalar(kSize) / 8};
 208         bmpCanvas.drawRect(rect, bmpPaint);
 209
 210         fBmpShader = SkShader::MakeBitmapShader(bmp, SkShader::kClamp_TileMode,
 211                                                 SkShader::kClamp_TileMode);
 212     }
 213
 214     enum {
 215         kCheckSize = 8,
 216         kSize = 30,
 217         kTestsPerRow = 15,
 218     };
 219
 220     sk_sp<SkShader> fBGShader;
 221     sk_sp<SkShader> fBmpShader;
 222
 223     typedef GM INHERITED;
 224 };
 225
 226 //////////////////////////////////////////////////////////////////////////////
 227
 228 DEF_GM(return new Xfermodes3GM;)
 229
 230 }