1 /* 2 * Copyright 2011 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 "SkPath.h" 12 #include "SkMakeUnique.h" 13 14 static void do_draw(SkCanvas* canvas, const SkRect& r) { 15 SkPaint paint; 16 paint.setBlendMode(SkBlendMode::kSrc); 17 paint.setColor(0x800000FF); 18 canvas->drawRect(r, paint); 19 } 20 21 /** 22 * Exercise kDontClipToLayer_Legacy_SaveLayerFlag flag, which does not limit the clip to the 23 * layer's bounds. Thus when a draw occurs, it can (depending on "where" it is) draw into the layer 24 * and/or draw onto the surrounding portions of the canvas, or both. 25 * 26 * This GM has a 100x100 rectangle (r), which its going to draw. However first it creates a layer 27 * with this flag covering 1/2 of the rectangle (upper half). Then it draws the rect in SRC mode. 28 * 29 * The portion of the draw that intersects the layer should see the SRC draw, apply it to the layer 30 * and then during restore, it will SRC_OVER that layer onto the canvas (SRC_OVER since the layer 31 * has no paint, so it gets the default xfermode during restore). 32 * 33 * Note: when we talk about drawing directly into the "canvas", in fact we are drawing into an 34 * "outer" layer we created (filled with red). This is a testing detail, so that our final 35 * output image is itself opaque, otherwise we make it harder to view the GM as a PNG. 36 * 37 * The portion of the draw below the layer draws directly into the canvas. Since it is in SRC mode, 38 * it will write 0x80 to the canvas' alpha, overwriting the "red", which then gets blended with 39 * the GM's white background. 40 * 41 * The portion in the layer, will end up SRC_OVERing the 0x80 layer pixels onto the canvas' red 42 * pixels, making magenta. 43 * 44 * Thus the expected result is the upper half to be magenta 0xFF7F0080, and the lower half to be 45 * light blue 0xFF7F7FFF. 46 */ 47 DEF_SIMPLE_GM(dont_clip_to_layer, canvas, 120, 120) { 48 const SkRect r { 10, 10, 110, 110 }; 49 50 // Wrap the entire test inside a red layer, so we don't punch the actual gm's alpha with 51 // kSrc_Mode, which makes it hard to view (we like our GMs to have opaque pixels). 52 canvas->saveLayer(&r, nullptr); 53 canvas->drawColor(SK_ColorRED); 54 55 SkRect r0 = { 20, 20, 100, 55 }; 56 SkRect r1 = { 20, 65, 100, 100 }; 57 58 SkCanvas::SaveLayerRec rec; 59 rec.fPaint = nullptr; 60 rec.fBounds = &r0; 61 rec.fBackdrop = nullptr; 62 rec.fSaveLayerFlags = 1 << 31;//SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag; 63 canvas->saveLayer(rec); 64 rec.fBounds = &r1; 65 canvas->saveLayer(rec); 66 do_draw(canvas, r); 67 canvas->restore(); 68 canvas->restore(); 69 70 canvas->restore(); // red-layer 71 } 72 73 /** Draw a 2px border around the target, then red behind the target; 74 set the clip to match the target, then draw >> the target in blue. 75 */ 76 77 static void draw(SkCanvas* canvas, SkRect& target, int x, int y) { 78 SkPaint borderPaint; 79 borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0)); 80 borderPaint.setAntiAlias(true); 81 SkPaint backgroundPaint; 82 backgroundPaint.setColor(SkColorSetRGB(0xDD, 0x0, 0x0)); 83 backgroundPaint.setAntiAlias(true); 84 SkPaint foregroundPaint; 85 foregroundPaint.setColor(SkColorSetRGB(0x0, 0x0, 0xDD)); 86 foregroundPaint.setAntiAlias(true); 87 88 canvas->save(); 89 canvas->translate(SkIntToScalar(x), SkIntToScalar(y)); 90 target.inset(SkIntToScalar(-2), SkIntToScalar(-2)); 91 canvas->drawRect(target, borderPaint); 92 target.inset(SkIntToScalar(2), SkIntToScalar(2)); 93 canvas->drawRect(target, backgroundPaint); 94 canvas->clipRect(target, true); 95 target.inset(SkIntToScalar(-4), SkIntToScalar(-4)); 96 canvas->drawRect(target, foregroundPaint); 97 canvas->restore(); 98 } 99 100 static void draw_square(SkCanvas* canvas, int x, int y) { 101 SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 10 * SK_Scalar1)); 102 draw(canvas, target, x, y); 103 } 104 105 static void draw_column(SkCanvas* canvas, int x, int y) { 106 SkRect target (SkRect::MakeWH(1 * SK_Scalar1, 10 * SK_Scalar1)); 107 draw(canvas, target, x, y); 108 } 109 110 static void draw_bar(SkCanvas* canvas, int x, int y) { 111 SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 1 * SK_Scalar1)); 112 draw(canvas, target, x, y); 113 } 114 115 static void draw_rect_tests(SkCanvas* canvas) { 116 draw_square(canvas, 10, 10); 117 draw_column(canvas, 30, 10); 118 draw_bar(canvas, 10, 30); 119 } 120 121 /** 122 Test a set of clipping problems discovered while writing blitAntiRect, 123 and test all the code paths through the clipping blitters. 124 Each region should show as a blue center surrounded by a 2px green 125 border, with no red. 126 */ 127 128 class AAClipGM : public skiagm::GM { 129 public: 130 AAClipGM() { 131 132 } 133 134 protected: 135 SkString onShortName() override { 136 return SkString("aaclip"); 137 } 138 139 SkISize onISize() override { 140 return SkISize::Make(240, 120); 141 } 142 143 void onDraw(SkCanvas* canvas) override { 144 // Initial pixel-boundary-aligned draw 145 draw_rect_tests(canvas); 146 147 // Repeat 4x with .2, .4, .6, .8 px offsets 148 canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); 149 canvas->translate(SkIntToScalar(50), 0); 150 draw_rect_tests(canvas); 151 152 canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); 153 canvas->translate(SkIntToScalar(50), 0); 154 draw_rect_tests(canvas); 155 156 canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); 157 canvas->translate(SkIntToScalar(50), 0); 158 draw_rect_tests(canvas); 159 160 canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5); 161 canvas->translate(SkIntToScalar(50), 0); 162 draw_rect_tests(canvas); 163 } 164 165 private: 166 typedef skiagm::GM INHERITED; 167 }; 168 169 DEF_GM(return new AAClipGM;) 170 171 ///////////////////////////////////////////////////////////////////////// 172 173 #ifdef SK_BUILD_FOR_MAC 174 175 static std::unique_ptr<SkCanvas> make_canvas(const SkBitmap& bm) { 176 const SkImageInfo& info = bm.info(); 177 if (info.bytesPerPixel() == 4) { 178 return SkCanvas::MakeRasterDirectN32(info.width(), info.height(), 179 (SkPMColor*)bm.getPixels(), 180 bm.rowBytes()); 181 } else { 182 return skstd::make_unique<SkCanvas>(bm); 183 } 184 } 185 186 #include "SkCGUtils.h" 187 static void test_image(SkCanvas* canvas, const SkImageInfo& info) { 188 SkBitmap bm; 189 bm.allocPixels(info); 190 191 if (info.isOpaque()) { 192 bm.eraseColor(SK_ColorGREEN); 193 } else { 194 bm.eraseColor(0); 195 } 196 197 SkPaint paint; 198 paint.setAntiAlias(true); 199 paint.setColor(SK_ColorBLUE); 200 make_canvas(bm)->drawCircle(50, 50, 49, paint); 201 canvas->drawBitmap(bm, 10, 10); 202 203 CGImageRef image = SkCreateCGImageRefWithColorspace(bm, nullptr); 204 205 SkBitmap bm2; 206 SkCreateBitmapFromCGImage(&bm2, image); 207 canvas->drawBitmap(bm2, 10, 120); 208 canvas->drawImage(SkMakeImageFromCGImage(image), 10, 120 + bm2.height() + 10); 209 210 CGImageRelease(image); 211 } 212 213 class CGImageGM : public skiagm::GM { 214 public: 215 CGImageGM() {} 216 217 protected: 218 SkString onShortName() override { 219 return SkString("cgimage"); 220 } 221 222 SkISize onISize() override { 223 return SkISize::Make(800, 250); 224 } 225 226 void onDraw(SkCanvas* canvas) override { 227 const struct { 228 SkColorType fCT; 229 SkAlphaType fAT; 230 } rec[] = { 231 { kRGB_565_SkColorType, kOpaque_SkAlphaType }, 232 233 { kRGBA_8888_SkColorType, kPremul_SkAlphaType }, 234 { kRGBA_8888_SkColorType, kUnpremul_SkAlphaType }, 235 { kRGBA_8888_SkColorType, kOpaque_SkAlphaType }, 236 237 { kBGRA_8888_SkColorType, kPremul_SkAlphaType }, 238 { kBGRA_8888_SkColorType, kUnpremul_SkAlphaType }, 239 { kBGRA_8888_SkColorType, kOpaque_SkAlphaType }, 240 }; 241 242 for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) { 243 SkImageInfo info = SkImageInfo::Make(100, 100, rec[i].fCT, rec[i].fAT); 244 test_image(canvas, info); 245 canvas->translate(info.width() + 10, 0); 246 } 247 } 248 249 private: 250 typedef skiagm::GM INHERITED; 251 }; 252 //DEF_GM( return new CGImageGM; ) 253 #endif 254 255 /////////////////////////////////////////////////////////////////////////////////////////////////// 256 257 // https://bug.skia.org/3716 258 class ClipCubicGM : public skiagm::GM { 259 const SkScalar W = 100; 260 const SkScalar H = 240; 261 262 SkPath fVPath, fHPath; 263 public: 264 ClipCubicGM() { 265 fVPath.moveTo(W, 0); 266 fVPath.cubicTo(W, H-10, 0, 10, 0, H); 267 268 SkMatrix pivot; 269 pivot.setRotate(90, W/2, H/2); 270 fVPath.transform(pivot, &fHPath); 271 } 272 273 protected: 274 SkString onShortName() override { 275 return SkString("clipcubic"); 276 } 277 278 SkISize onISize() override { 279 return SkISize::Make(400, 410); 280 } 281 282 void doDraw(SkCanvas* canvas, const SkPath& path) { 283 SkPaint paint; 284 paint.setAntiAlias(true); 285 286 paint.setColor(sk_tool_utils::color_to_565(0xFFCCCCCC)); 287 canvas->drawPath(path, paint); 288 289 paint.setColor(SK_ColorRED); 290 paint.setStyle(SkPaint::kStroke_Style); 291 canvas->drawPath(path, paint); 292 } 293 294 void drawAndClip(SkCanvas* canvas, const SkPath& path, SkScalar dx, SkScalar dy) { 295 SkAutoCanvasRestore acr(canvas, true); 296 297 SkRect r = SkRect::MakeXYWH(0, H/4, W, H/2); 298 SkPaint paint; 299 paint.setColor(sk_tool_utils::color_to_565(0xFF8888FF)); 300 301 canvas->drawRect(r, paint); 302 this->doDraw(canvas, path); 303 304 canvas->translate(dx, dy); 305 306 canvas->drawRect(r, paint); 307 canvas->clipRect(r); 308 this->doDraw(canvas, path); 309 } 310 311 void onDraw(SkCanvas* canvas) override { 312 canvas->translate(80, 10); 313 this->drawAndClip(canvas, fVPath, 200, 0); 314 canvas->translate(0, 200); 315 this->drawAndClip(canvas, fHPath, 200, 0); 316 } 317 318 private: 319 typedef skiagm::GM INHERITED; 320 }; 321 DEF_GM(return new ClipCubicGM;) 322
