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: Xfermodes3GM()28 Xfermodes3GM() {} 29 30 protected: onShortName()31 SkString onShortName() override { 32 return SkString("xfermodes3"); 33 } 34 onISize()35 SkISize onISize() override { 36 return SkISize::Make(630, 1215); 37 } 38 onDrawBackground(SkCanvas * canvas)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 onDraw(SkCanvas * canvas)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 */ possiblyCreateTempSurface(SkCanvas * baseCanvas,int w,int h)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 drawMode(SkCanvas * canvas,int x,int y,int w,int h,const SkPaint & modePaint,SkSurface * surface)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 onOnceBeforeDraw()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 SkAutoLockPixels bgAlp(bg); 186 memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData)); 187 188 SkMatrix lm; 189 lm.setScale(SkIntToScalar(kCheckSize), SkIntToScalar(kCheckSize)); 190 fBGShader = SkShader::MakeBitmapShader(bg, SkShader::kRepeat_TileMode, 191 SkShader::kRepeat_TileMode, &lm); 192 193 SkPaint bmpPaint; 194 const SkPoint kCenter = { SkIntToScalar(kSize) / 2, SkIntToScalar(kSize) / 2 }; 195 const SkColor kColors[] = { 196 SK_ColorTRANSPARENT, 0x80800000, 0xF020F060, SK_ColorWHITE 197 }; 198 bmpPaint.setShader(SkGradientShader::MakeRadial(kCenter, 3 * SkIntToScalar(kSize) / 4, 199 kColors, nullptr, SK_ARRAY_COUNT(kColors), 200 SkShader::kRepeat_TileMode)); 201 202 SkBitmap bmp; 203 bmp.allocN32Pixels(kSize, kSize); 204 SkCanvas bmpCanvas(bmp); 205 206 bmpCanvas.clear(SK_ColorTRANSPARENT); 207 SkRect rect = { SkIntToScalar(kSize) / 8, SkIntToScalar(kSize) / 8, 208 7 * SkIntToScalar(kSize) / 8, 7 * SkIntToScalar(kSize) / 8}; 209 bmpCanvas.drawRect(rect, bmpPaint); 210 211 fBmpShader = SkShader::MakeBitmapShader(bmp, SkShader::kClamp_TileMode, 212 SkShader::kClamp_TileMode); 213 } 214 215 enum { 216 kCheckSize = 8, 217 kSize = 30, 218 kTestsPerRow = 15, 219 }; 220 221 sk_sp<SkShader> fBGShader; 222 sk_sp<SkShader> fBmpShader; 223 224 typedef GM INHERITED; 225 }; 226 227 ////////////////////////////////////////////////////////////////////////////// 228 229 DEF_GM(return new Xfermodes3GM;) 230 231 } 232