src/third_party/skia/gm/xfermodes3.cpp

   1
   2 /*
   3  * Copyright 2013 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8 #include "gm.h"
   9 #include "SkBitmap.h"
  10 #include "SkGradientShader.h"
  11 #include "SkXfermode.h"
  12 #include "SkColorPriv.h"
  13
  14 #if SK_SUPPORT_GPU
  15 #include "GrContext.h"
  16 #include "SkGpuDevice.h"
  17 #endif
  18
  19 namespace skiagm {
  20
  21 /**
  22  * This tests drawing device-covering rects with solid colors and bitmap shaders over a
  23  * checkerboard background using different xfermodes.
  24  */
  25 class Xfermodes3GM : public GM {
  26 public:
  27     Xfermodes3GM() {}
  28
  29 protected:
  30     virtual SkString onShortName() SK_OVERRIDE {
  31         return SkString("xfermodes3");
  32     }
  33
  34     virtual SkISize onISize() SK_OVERRIDE {
  35         return SkISize::Make(630, 1215);
  36     }
  37
  38     virtual void onDrawBackground(SkCanvas* canvas) SK_OVERRIDE {
  39         SkPaint bgPaint;
  40         bgPaint.setColor(0xFF70D0E0);
  41         canvas->drawPaint(bgPaint);
  42     }
  43
  44     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
  45         canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
  46
  47         SkPaint labelP;
  48         labelP.setAntiAlias(true);
  49         sk_tool_utils::set_portable_typeface(&labelP);
  50
  51         static const SkColor kSolidColors[] = {
  52             SK_ColorTRANSPARENT,
  53             SK_ColorBLUE,
  54             0x80808000
  55         };
  56
  57         static const SkColor kBmpAlphas[] = {
  58             0xff,
  59             0x80,
  60         };
  61
  62         SkAutoTUnref<SkCanvas> tempCanvas(this->possiblyCreateTempCanvas(canvas, kSize, kSize));
  63
  64         int test = 0;
  65         int x = 0, y = 0;
  66         static const struct { SkPaint::Style fStyle; SkScalar fWidth; } kStrokes[] = {
  67             {SkPaint::kFill_Style, 0},
  68             {SkPaint::kStroke_Style, SkIntToScalar(kSize) / 2},
  69         };
  70         for (size_t s = 0; s < SK_ARRAY_COUNT(kStrokes); ++s) {
  71             for (size_t m = 0; m <= SkXfermode::kLastMode; ++m) {
  72                 SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(m);
  73                 canvas->drawText(SkXfermode::ModeName(mode),
  74                                  strlen(SkXfermode::ModeName(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.setXfermodeMode(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, tempCanvas.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.setXfermodeMode(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, tempCanvas.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     SkCanvas* possiblyCreateTempCanvas(SkCanvas* baseCanvas, int w, int h) {
 125         SkCanvas* tempCanvas = NULL;
 126 #if SK_SUPPORT_GPU
 127         GrContext* context = baseCanvas->getGrContext();
 128         if (context) {
 129             GrSurfaceDesc desc;
 130             desc.fWidth = w;
 131             desc.fHeight = h;
 132             desc.fConfig = SkImageInfo2GrPixelConfig(baseCanvas->imageInfo());
 133             desc.fFlags = kRenderTarget_GrSurfaceFlag;
 134             SkAutoTUnref<GrSurface> surface(context->createUncachedTexture(desc, NULL, 0));
 135             SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(surface.get(),
 136                                           SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType)));
 137             if (device.get()) {
 138                 tempCanvas = SkNEW_ARGS(SkCanvas, (device.get()));
 139             }
 140         }
 141 #endif
 142         return tempCanvas;
 143     }
 144
 145     void drawMode(SkCanvas* canvas,
 146                   int x, int y, int w, int h,
 147                   const SkPaint& modePaint, SkCanvas* layerCanvas) {
 148         canvas->save();
 149
 150         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
 151
 152         SkRect r = SkRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h));
 153
 154         SkCanvas* modeCanvas;
 155         if (NULL == layerCanvas) {
 156             canvas->saveLayer(&r, NULL);
 157             modeCanvas = canvas;
 158         } else {
 159             modeCanvas = layerCanvas;
 160         }
 161
 162         SkPaint bgPaint;
 163         bgPaint.setAntiAlias(false);
 164         bgPaint.setShader(fBGShader);
 165         modeCanvas->drawRect(r, bgPaint);
 166         modeCanvas->drawRect(r, modePaint);
 167         modeCanvas = NULL;
 168
 169         if (NULL == layerCanvas) {
 170             canvas->restore();
 171         } else {
 172             SkAutoROCanvasPixels ropixels(layerCanvas);
 173             SkBitmap bitmap;
 174             if (ropixels.asROBitmap(&bitmap)) {
 175                 canvas->drawBitmap(bitmap, 0, 0);
 176             }
 177         }
 178
 179         r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
 180         SkPaint borderPaint;
 181         borderPaint.setStyle(SkPaint::kStroke_Style);
 182         canvas->drawRect(r, borderPaint);
 183
 184         canvas->restore();
 185     }
 186
 187     virtual void onOnceBeforeDraw() SK_OVERRIDE {
 188         static const uint32_t kCheckData[] = {
 189             SkPackARGB32(0xFF, 0x40, 0x40, 0x40),
 190             SkPackARGB32(0xFF, 0xD0, 0xD0, 0xD0),
 191             SkPackARGB32(0xFF, 0xD0, 0xD0, 0xD0),
 192             SkPackARGB32(0xFF, 0x40, 0x40, 0x40)
 193         };
 194         SkBitmap bg;
 195         bg.allocN32Pixels(2, 2, true);
 196         SkAutoLockPixels bgAlp(bg);
 197         memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
 198
 199         SkMatrix lm;
 200         lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize));
 201         fBGShader.reset(SkShader::CreateBitmapShader(bg,
 202                                                      SkShader::kRepeat_TileMode,
 203                                                      SkShader::kRepeat_TileMode,
 204                                                      &lm));
 205
 206         SkPaint bmpPaint;
 207         static const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 };
 208         static const SkColor kColors[] = { SK_ColorTRANSPARENT, 0x80800000,
 209                                           0xF020F060, SK_ColorWHITE };
 210         bmpPaint.setShader(SkGradientShader::CreateRadial(kCenter,
 211                                                           3 * SkIntToScalar(kSize) / 4,
 212                                                           kColors,
 213                                                           NULL,
 214                                                           SK_ARRAY_COUNT(kColors),
 215                                                           SkShader::kRepeat_TileMode))->unref();
 216
 217         SkBitmap bmp;
 218         bmp.allocN32Pixels(kSize, kSize);
 219         SkCanvas bmpCanvas(bmp);
 220
 221         bmpCanvas.clear(SK_ColorTRANSPARENT);
 222         SkRect rect = { SkIntToScalar(kSize) / 8, SkIntToScalar(kSize) / 8,
 223                         7 * SkIntToScalar(kSize) / 8, 7 * SkIntToScalar(kSize) / 8};
 224         bmpCanvas.drawRect(rect, bmpPaint);
 225
 226         fBmpShader.reset(SkShader::CreateBitmapShader(bmp,
 227                                                       SkShader::kClamp_TileMode,
 228                                                       SkShader::kClamp_TileMode));
 229     }
 230
 231     enum {
 232         kCheckSize = 8,
 233         kSize = 30,
 234         kTestsPerRow = 15,
 235     };
 236
 237     SkAutoTUnref<SkShader> fBGShader;
 238     SkAutoTUnref<SkShader> fBmpShader;
 239
 240     typedef GM INHERITED;
 241 };
 242
 243 //////////////////////////////////////////////////////////////////////////////
 244
 245 DEF_GM(return new Xfermodes3GM;)
 246
 247 }