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 "SkPath.h" 11 #include "SkRandom.h" 12 #include "SkDashPathEffect.h" 13 #include "SkParsePath.h" 14 15 #define W 400 16 #define H 400 17 #define N 50 18 19 constexpr SkScalar SW = SkIntToScalar(W); 20 constexpr SkScalar SH = SkIntToScalar(H); 21 22 static void rnd_rect(SkRect* r, SkPaint* paint, SkRandom& rand) { 23 SkScalar x = rand.nextUScalar1() * W; 24 SkScalar y = rand.nextUScalar1() * H; 25 SkScalar w = rand.nextUScalar1() * (W >> 2); 26 SkScalar h = rand.nextUScalar1() * (H >> 2); 27 SkScalar hoffset = rand.nextSScalar1(); 28 SkScalar woffset = rand.nextSScalar1(); 29 30 r->set(x, y, x + w, y + h); 31 r->offset(-w/2 + woffset, -h/2 + hoffset); 32 33 paint->setColor(rand.nextU()); 34 paint->setAlpha(0xFF); 35 } 36 37 38 class StrokesGM : public skiagm::GM { 39 public: 40 StrokesGM() {} 41 42 protected: 43 44 SkString onShortName() override { 45 return SkString("strokes_round"); 46 } 47 48 SkISize onISize() override { 49 return SkISize::Make(W, H*2); 50 } 51 52 void onDraw(SkCanvas* canvas) override { 53 SkPaint paint; 54 paint.setStyle(SkPaint::kStroke_Style); 55 paint.setStrokeWidth(SkIntToScalar(9)/2); 56 57 for (int y = 0; y < 2; y++) { 58 paint.setAntiAlias(!!y); 59 SkAutoCanvasRestore acr(canvas, true); 60 canvas->translate(0, SH * y); 61 canvas->clipRect(SkRect::MakeLTRB( 62 SkIntToScalar(2), SkIntToScalar(2) 63 , SW - SkIntToScalar(2), SH - SkIntToScalar(2) 64 )); 65 66 SkRandom rand; 67 for (int i = 0; i < N; i++) { 68 SkRect r; 69 rnd_rect(&r, &paint, rand); 70 canvas->drawOval(r, paint); 71 rnd_rect(&r, &paint, rand); 72 canvas->drawRoundRect(r, r.width()/4, r.height()/4, paint); 73 rnd_rect(&r, &paint, rand); 74 } 75 } 76 } 77 78 private: 79 typedef skiagm::GM INHERITED; 80 }; 81 82 /* See 83 https://code.google.com/p/chromium/issues/detail?id=422974 and 84 http://jsfiddle.net/1xnku3sg/2/ 85 */ 86 class ZeroLenStrokesGM : public skiagm::GM { 87 SkPath fMoveHfPath, fMoveZfPath, fDashedfPath, fRefPath[4]; 88 SkPath fCubicPath, fQuadPath, fLinePath; 89 protected: 90 void onOnceBeforeDraw() override { 91 92 SkAssertResult(SkParsePath::FromSVGString("M0,0h0M10,0h0M20,0h0", &fMoveHfPath)); 93 SkAssertResult(SkParsePath::FromSVGString("M0,0zM10,0zM20,0z", &fMoveZfPath)); 94 SkAssertResult(SkParsePath::FromSVGString("M0,0h25", &fDashedfPath)); 95 SkAssertResult(SkParsePath::FromSVGString("M 0 0 C 0 0 0 0 0 0", &fCubicPath)); 96 SkAssertResult(SkParsePath::FromSVGString("M 0 0 Q 0 0 0 0", &fQuadPath)); 97 SkAssertResult(SkParsePath::FromSVGString("M 0 0 L 0 0", &fLinePath)); 98 99 for (int i = 0; i < 3; ++i) { 100 fRefPath[0].addCircle(i * 10.f, 0, 5); 101 fRefPath[1].addCircle(i * 10.f, 0, 10); 102 fRefPath[2].addRect(i * 10.f - 4, -2, i * 10.f + 4, 6); 103 fRefPath[3].addRect(i * 10.f - 10, -10, i * 10.f + 10, 10); 104 } 105 } 106 107 SkString onShortName() override { 108 return SkString("zeroPath"); 109 } 110 111 SkISize onISize() override { 112 return SkISize::Make(W, H*2); 113 } 114 115 void onDraw(SkCanvas* canvas) override { 116 SkPaint fillPaint, strokePaint, dashPaint; 117 fillPaint.setAntiAlias(true); 118 strokePaint = fillPaint; 119 strokePaint.setStyle(SkPaint::kStroke_Style); 120 for (int i = 0; i < 2; ++i) { 121 fillPaint.setAlpha(255); 122 strokePaint.setAlpha(255); 123 strokePaint.setStrokeWidth(i ? 8.f : 10.f); 124 strokePaint.setStrokeCap(i ? SkPaint::kSquare_Cap : SkPaint::kRound_Cap); 125 canvas->save(); 126 canvas->translate(10 + i * 100.f, 10); 127 canvas->drawPath(fMoveHfPath, strokePaint); 128 canvas->translate(0, 20); 129 canvas->drawPath(fMoveZfPath, strokePaint); 130 dashPaint = strokePaint; 131 const SkScalar intervals[] = { 0, 10 }; 132 dashPaint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 0)); 133 SkPath fillPath; 134 dashPaint.getFillPath(fDashedfPath, &fillPath); 135 canvas->translate(0, 20); 136 canvas->drawPath(fDashedfPath, dashPaint); 137 canvas->translate(0, 20); 138 canvas->drawPath(fRefPath[i * 2], fillPaint); 139 strokePaint.setStrokeWidth(20); 140 strokePaint.setAlpha(127); 141 canvas->translate(0, 50); 142 canvas->drawPath(fMoveHfPath, strokePaint); 143 canvas->translate(0, 30); 144 canvas->drawPath(fMoveZfPath, strokePaint); 145 canvas->translate(0, 30); 146 fillPaint.setAlpha(127); 147 canvas->drawPath(fRefPath[1 + i * 2], fillPaint); 148 canvas->translate(0, 30); 149 canvas->drawPath(fCubicPath, strokePaint); 150 canvas->translate(0, 30); 151 canvas->drawPath(fQuadPath, strokePaint); 152 canvas->translate(0, 30); 153 canvas->drawPath(fLinePath, strokePaint); 154 canvas->restore(); 155 } 156 } 157 158 private: 159 typedef skiagm::GM INHERITED; 160 }; 161 162 class TeenyStrokesGM : public skiagm::GM { 163 164 SkString onShortName() override { 165 return SkString("teenyStrokes"); 166 } 167 168 SkISize onISize() override { 169 return SkISize::Make(W, H*2); 170 } 171 172 static void line(SkScalar scale, SkCanvas* canvas, SkColor color) { 173 SkPaint p; 174 p.setAntiAlias(true); 175 p.setStyle(SkPaint::kStroke_Style); 176 p.setColor(color); 177 canvas->translate(50, 0); 178 canvas->save(); 179 p.setStrokeWidth(scale * 5); 180 canvas->scale(1 / scale, 1 / scale); 181 canvas->drawLine(20 * scale, 20 * scale, 20 * scale, 100 * scale, p); 182 canvas->drawLine(20 * scale, 20 * scale, 100 * scale, 100 * scale, p); 183 canvas->restore(); 184 } 185 186 void onDraw(SkCanvas* canvas) override { 187 line(0.00005f, canvas, SK_ColorBLACK); 188 line(0.000045f, canvas, SK_ColorRED); 189 line(0.0000035f, canvas, SK_ColorGREEN); 190 line(0.000003f, canvas, SK_ColorBLUE); 191 line(0.000002f, canvas, SK_ColorBLACK); 192 } 193 private: 194 typedef skiagm::GM INHERITED; 195 }; 196 197 DEF_SIMPLE_GM(CubicStroke, canvas, 384, 384) { 198 SkPaint p; 199 p.setAntiAlias(true); 200 p.setStyle(SkPaint::kStroke_Style); 201 p.setStrokeWidth(1.0720f); 202 SkPath path; 203 path.moveTo(-6000,-6000); 204 path.cubicTo(-3500,5500,-500,5500,2500,-6500); 205 canvas->drawPath(path, p); 206 p.setStrokeWidth(1.0721f); 207 canvas->translate(10, 10); 208 canvas->drawPath(path, p); 209 p.setStrokeWidth(1.0722f); 210 canvas->translate(10, 10); 211 canvas->drawPath(path, p); 212 } 213 214 DEF_SIMPLE_GM(zerolinestroke, canvas, 90, 120) { 215 SkPaint paint; 216 paint.setStyle(SkPaint::kStroke_Style); 217 paint.setStrokeWidth(20); 218 paint.setAntiAlias(true); 219 paint.setStrokeCap(SkPaint::kRound_Cap); 220 221 SkPath path; 222 path.moveTo(30, 90); 223 path.lineTo(30, 90); 224 path.lineTo(60, 90); 225 path.lineTo(60, 90); 226 canvas->drawPath(path, paint); 227 228 path.reset(); 229 path.moveTo(30, 30); 230 path.lineTo(60, 30); 231 canvas->drawPath(path, paint); 232 233 path.reset(); 234 path.moveTo(30, 60); 235 path.lineTo(30, 60); 236 path.lineTo(60, 60); 237 canvas->drawPath(path, paint); 238 } 239 240 DEF_SIMPLE_GM(quadcap, canvas, 200, 200) { 241 SkPaint p; 242 p.setAntiAlias(true); 243 p.setStyle(SkPaint::kStroke_Style); 244 p.setStrokeWidth(0); 245 SkPath path; 246 SkPoint pts[] = {{105.738571f,13.126318f}, 247 {105.738571f,13.126318f}, 248 {123.753784f,1.f}}; 249 SkVector tangent = pts[1] - pts[2]; 250 tangent.normalize(); 251 SkPoint pts2[3]; 252 memcpy(pts2, pts, sizeof(pts)); 253 const SkScalar capOutset = SK_ScalarPI / 8; 254 pts2[0].fX += tangent.fX * capOutset; 255 pts2[0].fY += tangent.fY * capOutset; 256 pts2[1].fX += tangent.fX * capOutset; 257 pts2[1].fY += tangent.fY * capOutset; 258 pts2[2].fX += -tangent.fX * capOutset; 259 pts2[2].fY += -tangent.fY * capOutset; 260 path.moveTo(pts2[0]); 261 path.quadTo(pts2[1], pts2[2]); 262 canvas->drawPath(path, p); 263 264 path.reset(); 265 path.moveTo(pts[0]); 266 path.quadTo(pts[1], pts[2]); 267 p.setStrokeCap(SkPaint::kRound_Cap); 268 canvas->translate(30, 0); 269 canvas->drawPath(path, p); 270 } 271 272 class Strokes2GM : public skiagm::GM { 273 SkPath fPath; 274 protected: 275 void onOnceBeforeDraw() override { 276 SkRandom rand; 277 fPath.moveTo(0, 0); 278 for (int i = 0; i < 13; i++) { 279 SkScalar x = rand.nextUScalar1() * (W >> 1); 280 SkScalar y = rand.nextUScalar1() * (H >> 1); 281 fPath.lineTo(x, y); 282 } 283 } 284 285 286 SkString onShortName() override { 287 return SkString("strokes_poly"); 288 } 289 290 SkISize onISize() override { 291 return SkISize::Make(W, H*2); 292 } 293 294 void onDraw(SkCanvas* canvas) override { 295 canvas->drawColor(SK_ColorWHITE); 296 297 SkPaint paint; 298 paint.setStyle(SkPaint::kStroke_Style); 299 paint.setStrokeWidth(SkIntToScalar(9)/2); 300 301 for (int y = 0; y < 2; y++) { 302 paint.setAntiAlias(!!y); 303 SkAutoCanvasRestore acr(canvas, true); 304 canvas->translate(0, SH * y); 305 canvas->clipRect(SkRect::MakeLTRB(SkIntToScalar(2), 306 SkIntToScalar(2), 307 SW - SkIntToScalar(2), 308 SH - SkIntToScalar(2))); 309 310 SkRandom rand; 311 for (int i = 0; i < N/2; i++) { 312 SkRect r; 313 rnd_rect(&r, &paint, rand); 314 canvas->rotate(SkIntToScalar(15), SW/2, SH/2); 315 canvas->drawPath(fPath, paint); 316 } 317 } 318 } 319 320 private: 321 typedef skiagm::GM INHERITED; 322 }; 323 324 ////////////////////////////////////////////////////////////////////////////// 325 326 static SkRect inset(const SkRect& r) { 327 SkRect rr(r); 328 rr.inset(r.width()/10, r.height()/10); 329 return rr; 330 } 331 332 class Strokes3GM : public skiagm::GM { 333 static void make0(SkPath* path, const SkRect& bounds, SkString* title) { 334 path->addRect(bounds, SkPath::kCW_Direction); 335 path->addRect(inset(bounds), SkPath::kCW_Direction); 336 title->set("CW CW"); 337 } 338 339 static void make1(SkPath* path, const SkRect& bounds, SkString* title) { 340 path->addRect(bounds, SkPath::kCW_Direction); 341 path->addRect(inset(bounds), SkPath::kCCW_Direction); 342 title->set("CW CCW"); 343 } 344 345 static void make2(SkPath* path, const SkRect& bounds, SkString* title) { 346 path->addOval(bounds, SkPath::kCW_Direction); 347 path->addOval(inset(bounds), SkPath::kCW_Direction); 348 title->set("CW CW"); 349 } 350 351 static void make3(SkPath* path, const SkRect& bounds, SkString* title) { 352 path->addOval(bounds, SkPath::kCW_Direction); 353 path->addOval(inset(bounds), SkPath::kCCW_Direction); 354 title->set("CW CCW"); 355 } 356 357 static void make4(SkPath* path, const SkRect& bounds, SkString* title) { 358 path->addRect(bounds, SkPath::kCW_Direction); 359 SkRect r = bounds; 360 r.inset(bounds.width() / 10, -bounds.height() / 10); 361 path->addOval(r, SkPath::kCW_Direction); 362 title->set("CW CW"); 363 } 364 365 static void make5(SkPath* path, const SkRect& bounds, SkString* title) { 366 path->addRect(bounds, SkPath::kCW_Direction); 367 SkRect r = bounds; 368 r.inset(bounds.width() / 10, -bounds.height() / 10); 369 path->addOval(r, SkPath::kCCW_Direction); 370 title->set("CW CCW"); 371 } 372 373 public: 374 Strokes3GM() {} 375 376 protected: 377 378 SkString onShortName() override { 379 return SkString("strokes3"); 380 } 381 382 SkISize onISize() override { 383 return SkISize::Make(1500, 1500); 384 } 385 386 void onDraw(SkCanvas* canvas) override { 387 SkPaint origPaint; 388 origPaint.setAntiAlias(true); 389 origPaint.setStyle(SkPaint::kStroke_Style); 390 SkPaint fillPaint(origPaint); 391 fillPaint.setColor(SK_ColorRED); 392 SkPaint strokePaint(origPaint); 393 strokePaint.setColor(sk_tool_utils::color_to_565(0xFF4444FF)); 394 395 void (*procs[])(SkPath*, const SkRect&, SkString*) = { 396 make0, make1, make2, make3, make4, make5 397 }; 398 399 canvas->translate(SkIntToScalar(20), SkIntToScalar(80)); 400 401 SkRect bounds = SkRect::MakeWH(SkIntToScalar(50), SkIntToScalar(50)); 402 SkScalar dx = bounds.width() * 4/3; 403 SkScalar dy = bounds.height() * 5; 404 405 for (size_t i = 0; i < SK_ARRAY_COUNT(procs); ++i) { 406 SkPath orig; 407 SkString str; 408 procs[i](&orig, bounds, &str); 409 410 canvas->save(); 411 for (int j = 0; j < 13; ++j) { 412 strokePaint.setStrokeWidth(SK_Scalar1 * j * j); 413 canvas->drawPath(orig, strokePaint); 414 canvas->drawPath(orig, origPaint); 415 SkPath fill; 416 strokePaint.getFillPath(orig, &fill); 417 canvas->drawPath(fill, fillPaint); 418 canvas->translate(dx + strokePaint.getStrokeWidth(), 0); 419 } 420 canvas->restore(); 421 canvas->translate(0, dy); 422 } 423 } 424 425 private: 426 typedef skiagm::GM INHERITED; 427 }; 428 429 class Strokes4GM : public skiagm::GM { 430 public: 431 Strokes4GM() {} 432 433 protected: 434 435 SkString onShortName() override { 436 return SkString("strokes_zoomed"); 437 } 438 439 SkISize onISize() override { 440 return SkISize::Make(W, H*2); 441 } 442 443 void onDraw(SkCanvas* canvas) override { 444 SkPaint paint; 445 paint.setStyle(SkPaint::kStroke_Style); 446 paint.setStrokeWidth(0.055f); 447 448 canvas->scale(1000, 1000); 449 canvas->drawCircle(0, 2, 1.97f, paint); 450 } 451 452 private: 453 typedef skiagm::GM INHERITED; 454 }; 455 456 // Test stroking for curves that produce degenerate tangents when t is 0 or 1 (see bug 4191) 457 class Strokes5GM : public skiagm::GM { 458 public: 459 Strokes5GM() {} 460 461 protected: 462 463 SkString onShortName() override { 464 return SkString("zero_control_stroke"); 465 } 466 467 SkISize onISize() override { 468 return SkISize::Make(W, H*2); 469 } 470 471 void onDraw(SkCanvas* canvas) override { 472 SkPaint p; 473 p.setColor(SK_ColorRED); 474 p.setAntiAlias(true); 475 p.setStyle(SkPaint::kStroke_Style); 476 p.setStrokeWidth(40); 477 p.setStrokeCap(SkPaint::kButt_Cap); 478 479 SkPath path; 480 path.moveTo(157.474f,111.753f); 481 path.cubicTo(128.5f,111.5f,35.5f,29.5f,35.5f,29.5f); 482 canvas->drawPath(path, p); 483 path.reset(); 484 path.moveTo(250, 50); 485 path.quadTo(280, 80, 280, 80); 486 canvas->drawPath(path, p); 487 path.reset(); 488 path.moveTo(150, 50); 489 path.conicTo(180, 80, 180, 80, 0.707f); 490 canvas->drawPath(path, p); 491 492 path.reset(); 493 path.moveTo(157.474f,311.753f); 494 path.cubicTo(157.474f,311.753f,85.5f,229.5f,35.5f,229.5f); 495 canvas->drawPath(path, p); 496 path.reset(); 497 path.moveTo(280, 250); 498 path.quadTo(280, 250, 310, 280); 499 canvas->drawPath(path, p); 500 path.reset(); 501 path.moveTo(180, 250); 502 path.conicTo(180, 250, 210, 280, 0.707f); 503 canvas->drawPath(path, p); 504 } 505 506 private: 507 typedef skiagm::GM INHERITED; 508 }; 509 510 511 ////////////////////////////////////////////////////////////////////////////// 512 513 DEF_GM( return new StrokesGM; ) 514 DEF_GM( return new Strokes2GM; ) 515 DEF_GM( return new Strokes3GM; ) 516 DEF_GM( return new Strokes4GM; ) 517 DEF_GM( return new Strokes5GM; ) 518 519 DEF_GM( return new ZeroLenStrokesGM; ) 520 DEF_GM( return new TeenyStrokesGM; ) 521 522 DEF_SIMPLE_GM(zerolinedash, canvas, 256, 256) { 523 canvas->clear(SK_ColorWHITE); 524 525 SkPaint paint; 526 paint.setColor(SkColorSetARGB(255, 0, 0, 0)); 527 paint.setStrokeWidth(11); 528 paint.setStrokeCap(SkPaint::kRound_Cap); 529 paint.setStrokeJoin(SkPaint::kBevel_Join); 530 531 SkScalar dash_pattern[] = {1, 5}; 532 paint.setPathEffect(SkDashPathEffect::Make(dash_pattern, 2, 0)); 533 534 canvas->drawLine(100, 100, 100, 100, paint); 535 } 536 537 #ifdef PDF_IS_FIXED_SO_THIS_DOESNT_BREAK_IT 538 DEF_SIMPLE_GM(longrect_dash, canvas, 250, 250) { 539 canvas->clear(SK_ColorWHITE); 540 541 SkPaint paint; 542 paint.setColor(SkColorSetARGB(255, 0, 0, 0)); 543 paint.setStrokeWidth(5); 544 paint.setStrokeCap(SkPaint::kRound_Cap); 545 paint.setStrokeJoin(SkPaint::kBevel_Join); 546 paint.setStyle(SkPaint::kStroke_Style); 547 SkScalar dash_pattern[] = {1, 5}; 548 paint.setPathEffect(SkDashPathEffect::Make(dash_pattern, 2, 0)); 549 // try all combinations of stretching bounds 550 for (auto left : { 20.f, -100001.f } ) { 551 for (auto top : { 20.f, -100001.f } ) { 552 for (auto right : { 40.f, 100001.f } ) { 553 for (auto bottom : { 40.f, 100001.f } ) { 554 canvas->save(); 555 canvas->clipRect({10, 10, 50, 50}); 556 canvas->drawRect({left, top, right, bottom}, paint); 557 canvas->restore(); 558 canvas->translate(60, 0); 559 } 560 } 561 canvas->translate(-60 * 4, 60); 562 } 563 } 564 } 565 #endif 566
