OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2011 Google Inc. | 3 * Copyright 2011 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 #include "SkBenchmark.h" | 8 #include "SkBenchmark.h" |
9 #include "SkBitmap.h" | 9 #include "SkBitmap.h" |
10 #include "SkCanvas.h" | 10 #include "SkCanvas.h" |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
43 | 43 |
44 protected: | 44 protected: |
45 virtual const char* onGetName() SK_OVERRIDE { | 45 virtual const char* onGetName() SK_OVERRIDE { |
46 fName.printf("path_%s_%s_", | 46 fName.printf("path_%s_%s_", |
47 fFlags & kStroke_Flag ? "stroke" : "fill", | 47 fFlags & kStroke_Flag ? "stroke" : "fill", |
48 fFlags & kBig_Flag ? "big" : "small"); | 48 fFlags & kBig_Flag ? "big" : "small"); |
49 this->appendName(&fName); | 49 this->appendName(&fName); |
50 return fName.c_str(); | 50 return fName.c_str(); |
51 } | 51 } |
52 | 52 |
53 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 53 virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { |
54 SkPaint paint(fPaint); | 54 SkPaint paint(fPaint); |
55 this->setupPaint(&paint); | 55 this->setupPaint(&paint); |
56 | 56 |
57 SkPath path; | 57 SkPath path; |
58 this->makePath(&path); | 58 this->makePath(&path); |
59 if (fFlags & kBig_Flag) { | 59 if (fFlags & kBig_Flag) { |
60 SkMatrix m; | 60 SkMatrix m; |
61 m.setScale(SkIntToScalar(10), SkIntToScalar(10)); | 61 m.setScale(SkIntToScalar(10), SkIntToScalar(10)); |
62 path.transform(m); | 62 path.transform(m); |
63 } | 63 } |
64 | 64 |
65 int count = this->getLoops(); | 65 int count = loops; |
66 if (fFlags & kBig_Flag) { | 66 if (fFlags & kBig_Flag) { |
67 count >>= 2; | 67 count >>= 2; |
68 } | 68 } |
69 count >>= (3 * complexity()); | 69 count >>= (3 * complexity()); |
70 | 70 |
71 for (int i = 0; i < count; i++) { | 71 for (int i = 0; i < count; i++) { |
72 canvas->drawPath(path, paint); | 72 canvas->drawPath(path, paint); |
73 } | 73 } |
74 } | 74 } |
75 | 75 |
(...skipping 247 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
323 protected: | 323 protected: |
324 virtual const char* onGetName() SK_OVERRIDE { | 324 virtual const char* onGetName() SK_OVERRIDE { |
325 return "path_create"; | 325 return "path_create"; |
326 } | 326 } |
327 | 327 |
328 virtual void onPreDraw() SK_OVERRIDE { | 328 virtual void onPreDraw() SK_OVERRIDE { |
329 this->createData(10, 100); | 329 this->createData(10, 100); |
330 fPaths.reset(kPathCnt); | 330 fPaths.reset(kPathCnt); |
331 } | 331 } |
332 | 332 |
333 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 333 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
334 for (int i = 0; i < this->getLoops(); ++i) { | 334 for (int i = 0; i < loops; ++i) { |
335 this->makePath(&fPaths[i & (kPathCnt - 1)]); | 335 this->makePath(&fPaths[i & (kPathCnt - 1)]); |
336 } | 336 } |
337 this->restartMakingPaths(); | 337 this->restartMakingPaths(); |
338 } | 338 } |
339 | 339 |
340 virtual void onPostDraw() SK_OVERRIDE { | 340 virtual void onPostDraw() SK_OVERRIDE { |
341 this->finishedMakingPaths(); | 341 this->finishedMakingPaths(); |
342 fPaths.reset(0); | 342 fPaths.reset(0); |
343 } | 343 } |
344 | 344 |
(...skipping 18 matching lines...) Expand all Loading... |
363 } | 363 } |
364 virtual void onPreDraw() SK_OVERRIDE { | 364 virtual void onPreDraw() SK_OVERRIDE { |
365 this->createData(10, 100); | 365 this->createData(10, 100); |
366 fPaths.reset(kPathCnt); | 366 fPaths.reset(kPathCnt); |
367 fCopies.reset(kPathCnt); | 367 fCopies.reset(kPathCnt); |
368 for (int i = 0; i < kPathCnt; ++i) { | 368 for (int i = 0; i < kPathCnt; ++i) { |
369 this->makePath(&fPaths[i]); | 369 this->makePath(&fPaths[i]); |
370 } | 370 } |
371 this->finishedMakingPaths(); | 371 this->finishedMakingPaths(); |
372 } | 372 } |
373 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 373 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
374 for (int i = 0; i < this->getLoops(); ++i) { | 374 for (int i = 0; i < loops; ++i) { |
375 int idx = i & (kPathCnt - 1); | 375 int idx = i & (kPathCnt - 1); |
376 fCopies[idx] = fPaths[idx]; | 376 fCopies[idx] = fPaths[idx]; |
377 } | 377 } |
378 } | 378 } |
379 virtual void onPostDraw() SK_OVERRIDE { | 379 virtual void onPostDraw() SK_OVERRIDE { |
380 fPaths.reset(0); | 380 fPaths.reset(0); |
381 fCopies.reset(0); | 381 fCopies.reset(0); |
382 } | 382 } |
383 | 383 |
384 private: | 384 private: |
(...skipping 22 matching lines...) Expand all Loading... |
407 fPaths.reset(kPathCnt); | 407 fPaths.reset(kPathCnt); |
408 for (int i = 0; i < kPathCnt; ++i) { | 408 for (int i = 0; i < kPathCnt; ++i) { |
409 this->makePath(&fPaths[i]); | 409 this->makePath(&fPaths[i]); |
410 } | 410 } |
411 this->finishedMakingPaths(); | 411 this->finishedMakingPaths(); |
412 if (!fInPlace) { | 412 if (!fInPlace) { |
413 fTransformed.reset(kPathCnt); | 413 fTransformed.reset(kPathCnt); |
414 } | 414 } |
415 } | 415 } |
416 | 416 |
417 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 417 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
418 if (fInPlace) { | 418 if (fInPlace) { |
419 for (int i = 0; i < this->getLoops(); ++i) { | 419 for (int i = 0; i < loops; ++i) { |
420 fPaths[i & (kPathCnt - 1)].transform(fMatrix); | 420 fPaths[i & (kPathCnt - 1)].transform(fMatrix); |
421 } | 421 } |
422 } else { | 422 } else { |
423 for (int i = 0; i < this->getLoops(); ++i) { | 423 for (int i = 0; i < loops; ++i) { |
424 int idx = i & (kPathCnt - 1); | 424 int idx = i & (kPathCnt - 1); |
425 fPaths[idx].transform(fMatrix, &fTransformed[idx]); | 425 fPaths[idx].transform(fMatrix, &fTransformed[idx]); |
426 } | 426 } |
427 } | 427 } |
428 } | 428 } |
429 | 429 |
430 virtual void onPostDraw() SK_OVERRIDE { | 430 virtual void onPostDraw() SK_OVERRIDE { |
431 fPaths.reset(0); | 431 fPaths.reset(0); |
432 fTransformed.reset(0); | 432 fTransformed.reset(0); |
433 } | 433 } |
(...skipping 25 matching lines...) Expand all Loading... |
459 this->createData(10, 100); | 459 this->createData(10, 100); |
460 fPaths.reset(kPathCnt); | 460 fPaths.reset(kPathCnt); |
461 fCopies.reset(kPathCnt); | 461 fCopies.reset(kPathCnt); |
462 for (int i = 0; i < kPathCnt; ++i) { | 462 for (int i = 0; i < kPathCnt; ++i) { |
463 this->makePath(&fPaths[i]); | 463 this->makePath(&fPaths[i]); |
464 fCopies[i] = fPaths[i]; | 464 fCopies[i] = fPaths[i]; |
465 } | 465 } |
466 this->finishedMakingPaths(); | 466 this->finishedMakingPaths(); |
467 } | 467 } |
468 | 468 |
469 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 469 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
470 for (int i = 0; i < this->getLoops(); ++i) { | 470 for (int i = 0; i < loops; ++i) { |
471 int idx = i & (kPathCnt - 1); | 471 int idx = i & (kPathCnt - 1); |
472 fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]); | 472 fParity ^= (fPaths[idx] == fCopies[idx & ~0x1]); |
473 } | 473 } |
474 } | 474 } |
475 | 475 |
476 virtual void onPostDraw() SK_OVERRIDE { | 476 virtual void onPostDraw() SK_OVERRIDE { |
477 fPaths.reset(0); | 477 fPaths.reset(0); |
478 fCopies.reset(0); | 478 fCopies.reset(0); |
479 } | 479 } |
480 | 480 |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
528 this->createData(10, 100, allowMoves); | 528 this->createData(10, 100, allowMoves); |
529 fPaths0.reset(kPathCnt); | 529 fPaths0.reset(kPathCnt); |
530 fPaths1.reset(kPathCnt); | 530 fPaths1.reset(kPathCnt); |
531 for (int i = 0; i < kPathCnt; ++i) { | 531 for (int i = 0; i < kPathCnt; ++i) { |
532 this->makePath(&fPaths0[i]); | 532 this->makePath(&fPaths0[i]); |
533 this->makePath(&fPaths1[i]); | 533 this->makePath(&fPaths1[i]); |
534 } | 534 } |
535 this->finishedMakingPaths(); | 535 this->finishedMakingPaths(); |
536 } | 536 } |
537 | 537 |
538 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 538 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
539 switch (fType) { | 539 switch (fType) { |
540 case kAdd_AddType: | 540 case kAdd_AddType: |
541 for (int i = 0; i < this->getLoops(); ++i) { | 541 for (int i = 0; i < loops; ++i) { |
542 int idx = i & (kPathCnt - 1); | 542 int idx = i & (kPathCnt - 1); |
543 SkPath result = fPaths0[idx]; | 543 SkPath result = fPaths0[idx]; |
544 result.addPath(fPaths1[idx]); | 544 result.addPath(fPaths1[idx]); |
545 } | 545 } |
546 break; | 546 break; |
547 case kAddTrans_AddType: | 547 case kAddTrans_AddType: |
548 for (int i = 0; i < this->getLoops(); ++i) { | 548 for (int i = 0; i < loops; ++i) { |
549 int idx = i & (kPathCnt - 1); | 549 int idx = i & (kPathCnt - 1); |
550 SkPath result = fPaths0[idx]; | 550 SkPath result = fPaths0[idx]; |
551 result.addPath(fPaths1[idx], 2 * SK_Scalar1, 5 * SK_Scalar1)
; | 551 result.addPath(fPaths1[idx], 2 * SK_Scalar1, 5 * SK_Scalar1)
; |
552 } | 552 } |
553 break; | 553 break; |
554 case kAddMatrix_AddType: | 554 case kAddMatrix_AddType: |
555 for (int i = 0; i < this->getLoops(); ++i) { | 555 for (int i = 0; i < loops; ++i) { |
556 int idx = i & (kPathCnt - 1); | 556 int idx = i & (kPathCnt - 1); |
557 SkPath result = fPaths0[idx]; | 557 SkPath result = fPaths0[idx]; |
558 result.addPath(fPaths1[idx], fMatrix); | 558 result.addPath(fPaths1[idx], fMatrix); |
559 } | 559 } |
560 break; | 560 break; |
561 case kReverseAdd_AddType: | 561 case kReverseAdd_AddType: |
562 for (int i = 0; i < this->getLoops(); ++i) { | 562 for (int i = 0; i < loops; ++i) { |
563 int idx = i & (kPathCnt - 1); | 563 int idx = i & (kPathCnt - 1); |
564 SkPath result = fPaths0[idx]; | 564 SkPath result = fPaths0[idx]; |
565 result.reverseAddPath(fPaths1[idx]); | 565 result.reverseAddPath(fPaths1[idx]); |
566 } | 566 } |
567 break; | 567 break; |
568 case kReversePathTo_AddType: | 568 case kReversePathTo_AddType: |
569 for (int i = 0; i < this->getLoops(); ++i) { | 569 for (int i = 0; i < loops; ++i) { |
570 int idx = i & (kPathCnt - 1); | 570 int idx = i & (kPathCnt - 1); |
571 SkPath result = fPaths0[idx]; | 571 SkPath result = fPaths0[idx]; |
572 result.reversePathTo(fPaths1[idx]); | 572 result.reversePathTo(fPaths1[idx]); |
573 } | 573 } |
574 break; | 574 break; |
575 } | 575 } |
576 } | 576 } |
577 | 577 |
578 virtual void onPostDraw() SK_OVERRIDE { | 578 virtual void onPostDraw() SK_OVERRIDE { |
579 fPaths0.reset(0); | 579 fPaths0.reset(0); |
(...skipping 21 matching lines...) Expand all Loading... |
601 public: | 601 public: |
602 CirclesBench(Flags flags) : fFlags(flags) { | 602 CirclesBench(Flags flags) : fFlags(flags) { |
603 fName.printf("circles_%s", fFlags & kStroke_Flag ? "stroke" : "fill"); | 603 fName.printf("circles_%s", fFlags & kStroke_Flag ? "stroke" : "fill"); |
604 } | 604 } |
605 | 605 |
606 protected: | 606 protected: |
607 virtual const char* onGetName() SK_OVERRIDE { | 607 virtual const char* onGetName() SK_OVERRIDE { |
608 return fName.c_str(); | 608 return fName.c_str(); |
609 } | 609 } |
610 | 610 |
611 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 611 virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { |
612 SkPaint paint; | 612 SkPaint paint; |
613 | 613 |
614 paint.setColor(SK_ColorBLACK); | 614 paint.setColor(SK_ColorBLACK); |
615 paint.setAntiAlias(true); | 615 paint.setAntiAlias(true); |
616 if (fFlags & kStroke_Flag) { | 616 if (fFlags & kStroke_Flag) { |
617 paint.setStyle(SkPaint::kStroke_Style); | 617 paint.setStyle(SkPaint::kStroke_Style); |
618 } | 618 } |
619 | 619 |
620 SkRandom rand; | 620 SkRandom rand; |
621 | 621 |
622 SkRect r; | 622 SkRect r; |
623 | 623 |
624 for (int i = 0; i < this->getLoops(); ++i) { | 624 for (int i = 0; i < loops; ++i) { |
625 SkScalar radius = rand.nextUScalar1() * 3; | 625 SkScalar radius = rand.nextUScalar1() * 3; |
626 r.fLeft = rand.nextUScalar1() * 300; | 626 r.fLeft = rand.nextUScalar1() * 300; |
627 r.fTop = rand.nextUScalar1() * 300; | 627 r.fTop = rand.nextUScalar1() * 300; |
628 r.fRight = r.fLeft + 2 * radius; | 628 r.fRight = r.fLeft + 2 * radius; |
629 r.fBottom = r.fTop + 2 * radius; | 629 r.fBottom = r.fTop + 2 * radius; |
630 | 630 |
631 if (fFlags & kStroke_Flag) { | 631 if (fFlags & kStroke_Flag) { |
632 paint.setStrokeWidth(rand.nextUScalar1() * 5.0f); | 632 paint.setStrokeWidth(rand.nextUScalar1() * 5.0f); |
633 } | 633 } |
634 | 634 |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
707 // we are lazy here and use the same x & y for each corner | 707 // we are lazy here and use the same x & y for each corner |
708 add_corner_arc(path, r, xCorner, yCorner, 270); | 708 add_corner_arc(path, r, xCorner, yCorner, 270); |
709 add_corner_arc(path, r, xCorner, yCorner, 0); | 709 add_corner_arc(path, r, xCorner, yCorner, 0); |
710 add_corner_arc(path, r, xCorner, yCorner, 90); | 710 add_corner_arc(path, r, xCorner, yCorner, 90); |
711 add_corner_arc(path, r, xCorner, yCorner, 180); | 711 add_corner_arc(path, r, xCorner, yCorner, 180); |
712 path->close(); | 712 path->close(); |
713 | 713 |
714 SkASSERT(path->isConvex()); | 714 SkASSERT(path->isConvex()); |
715 } | 715 } |
716 | 716 |
717 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 717 virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { |
718 SkRandom rand; | 718 SkRandom rand; |
719 SkRect r; | 719 SkRect r; |
720 | 720 |
721 for (int i = 0; i < this->getLoops(); ++i) { | 721 for (int i = 0; i < loops; ++i) { |
722 SkPaint paint; | 722 SkPaint paint; |
723 paint.setColor(0xff000000 | rand.nextU()); | 723 paint.setColor(0xff000000 | rand.nextU()); |
724 paint.setAntiAlias(true); | 724 paint.setAntiAlias(true); |
725 | 725 |
726 SkScalar size = rand.nextUScalar1() * 30; | 726 SkScalar size = rand.nextUScalar1() * 30; |
727 if (size < SK_Scalar1) { | 727 if (size < SK_Scalar1) { |
728 continue; | 728 continue; |
729 } | 729 } |
730 r.fLeft = rand.nextUScalar1() * 300; | 730 r.fLeft = rand.nextUScalar1() * 300; |
731 r.fTop = rand.nextUScalar1() * 300; | 731 r.fTop = rand.nextUScalar1() * 300; |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
781 | 781 |
782 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { | 782 virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { |
783 return backend == kNonRendering_Backend; | 783 return backend == kNonRendering_Backend; |
784 } | 784 } |
785 | 785 |
786 private: | 786 private: |
787 virtual const char* onGetName() SK_OVERRIDE { | 787 virtual const char* onGetName() SK_OVERRIDE { |
788 return fName.c_str(); | 788 return fName.c_str(); |
789 } | 789 } |
790 | 790 |
791 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 791 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
792 for (int i = 0; i < this->getLoops(); ++i) { | 792 for (int i = 0; i < loops; ++i) { |
793 const SkRect& rect = fQueryRects[i % kQueryRectCnt]; | 793 const SkRect& rect = fQueryRects[i % kQueryRectCnt]; |
794 fParity = fParity != fPath.conservativelyContainsRect(rect); | 794 fParity = fParity != fPath.conservativelyContainsRect(rect); |
795 } | 795 } |
796 } | 796 } |
797 | 797 |
798 virtual void onPreDraw() SK_OVERRIDE { | 798 virtual void onPreDraw() SK_OVERRIDE { |
799 fQueryRects.setCount(kQueryRectCnt); | 799 fQueryRects.setCount(kQueryRectCnt); |
800 | 800 |
801 SkRandom rand; | 801 SkRandom rand; |
802 for (int i = 0; i < kQueryRectCnt; ++i) { | 802 for (int i = 0; i < kQueryRectCnt; ++i) { |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
844 fRQ.fPts[1].set(100, 0); | 844 fRQ.fPts[1].set(100, 0); |
845 fRQ.fPts[2].set(100, 100); | 845 fRQ.fPts[2].set(100, 100); |
846 fRQ.fW = SkScalarCos(SK_ScalarPI/4); | 846 fRQ.fW = SkScalarCos(SK_ScalarPI/4); |
847 } | 847 } |
848 | 848 |
849 private: | 849 private: |
850 virtual const char* onGetName() SK_OVERRIDE { | 850 virtual const char* onGetName() SK_OVERRIDE { |
851 return "ratquad-chop-0.5"; | 851 return "ratquad-chop-0.5"; |
852 } | 852 } |
853 | 853 |
854 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 854 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
855 SkConic dst[2]; | 855 SkConic dst[2]; |
856 for (int i = 0; i < this->getLoops(); ++i) { | 856 for (int i = 0; i < loops; ++i) { |
857 fRQ.chopAt(0.5f, dst); | 857 fRQ.chopAt(0.5f, dst); |
858 } | 858 } |
859 } | 859 } |
860 | 860 |
861 typedef SkBenchmark INHERITED; | 861 typedef SkBenchmark INHERITED; |
862 }; | 862 }; |
863 | 863 |
864 class ConicBench_ChopHalf : public SkBenchmark { | 864 class ConicBench_ChopHalf : public SkBenchmark { |
865 SkConic fRQ; | 865 SkConic fRQ; |
866 public: | 866 public: |
867 ConicBench_ChopHalf() { | 867 ConicBench_ChopHalf() { |
868 fRQ.fPts[0].set(0, 0); | 868 fRQ.fPts[0].set(0, 0); |
869 fRQ.fPts[1].set(100, 0); | 869 fRQ.fPts[1].set(100, 0); |
870 fRQ.fPts[2].set(100, 100); | 870 fRQ.fPts[2].set(100, 100); |
871 fRQ.fW = SkScalarCos(SK_ScalarPI/4); | 871 fRQ.fW = SkScalarCos(SK_ScalarPI/4); |
872 } | 872 } |
873 | 873 |
874 private: | 874 private: |
875 virtual const char* onGetName() SK_OVERRIDE { | 875 virtual const char* onGetName() SK_OVERRIDE { |
876 return "ratquad-chop-half"; | 876 return "ratquad-chop-half"; |
877 } | 877 } |
878 | 878 |
879 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 879 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
880 SkConic dst[2]; | 880 SkConic dst[2]; |
881 for (int i = 0; i < this->getLoops(); ++i) { | 881 for (int i = 0; i < loops; ++i) { |
882 fRQ.chop(dst); | 882 fRQ.chop(dst); |
883 } | 883 } |
884 } | 884 } |
885 | 885 |
886 typedef SkBenchmark INHERITED; | 886 typedef SkBenchmark INHERITED; |
887 }; | 887 }; |
888 | 888 |
889 /////////////////////////////////////////////////////////////////////////////// | 889 /////////////////////////////////////////////////////////////////////////////// |
890 | 890 |
891 static void rand_conic(SkConic* conic, SkRandom& rand) { | 891 static void rand_conic(SkConic* conic, SkRandom& rand) { |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
924 | 924 |
925 class ConicBench_ComputeError : public ConicBench { | 925 class ConicBench_ComputeError : public ConicBench { |
926 public: | 926 public: |
927 ConicBench_ComputeError() {} | 927 ConicBench_ComputeError() {} |
928 | 928 |
929 protected: | 929 protected: |
930 virtual const char* onGetName() SK_OVERRIDE { | 930 virtual const char* onGetName() SK_OVERRIDE { |
931 return "conic-compute-error"; | 931 return "conic-compute-error"; |
932 } | 932 } |
933 | 933 |
934 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 934 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
935 SkVector err; | 935 SkVector err; |
936 for (int i = 0; i < this->getLoops(); ++i) { | 936 for (int i = 0; i < loops; ++i) { |
937 for (int j = 0; j < CONICS; ++j) { | 937 for (int j = 0; j < CONICS; ++j) { |
938 fConics[j].computeAsQuadError(&err); | 938 fConics[j].computeAsQuadError(&err); |
939 } | 939 } |
940 } | 940 } |
941 } | 941 } |
942 | 942 |
943 private: | 943 private: |
944 typedef ConicBench INHERITED; | 944 typedef ConicBench INHERITED; |
945 }; | 945 }; |
946 | 946 |
947 class ConicBench_asQuadTol : public ConicBench { | 947 class ConicBench_asQuadTol : public ConicBench { |
948 public: | 948 public: |
949 ConicBench_asQuadTol() {} | 949 ConicBench_asQuadTol() {} |
950 | 950 |
951 protected: | 951 protected: |
952 virtual const char* onGetName() SK_OVERRIDE { | 952 virtual const char* onGetName() SK_OVERRIDE { |
953 return "conic-asQuadTol"; | 953 return "conic-asQuadTol"; |
954 } | 954 } |
955 | 955 |
956 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 956 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
957 for (int i = 0; i < this->getLoops(); ++i) { | 957 for (int i = 0; i < loops; ++i) { |
958 for (int j = 0; j < CONICS; ++j) { | 958 for (int j = 0; j < CONICS; ++j) { |
959 fConics[j].asQuadTol(SK_ScalarHalf); | 959 fConics[j].asQuadTol(SK_ScalarHalf); |
960 } | 960 } |
961 } | 961 } |
962 } | 962 } |
963 | 963 |
964 private: | 964 private: |
965 typedef ConicBench INHERITED; | 965 typedef ConicBench INHERITED; |
966 }; | 966 }; |
967 | 967 |
968 class ConicBench_quadPow2 : public ConicBench { | 968 class ConicBench_quadPow2 : public ConicBench { |
969 public: | 969 public: |
970 ConicBench_quadPow2() {} | 970 ConicBench_quadPow2() {} |
971 | 971 |
972 protected: | 972 protected: |
973 virtual const char* onGetName() SK_OVERRIDE { | 973 virtual const char* onGetName() SK_OVERRIDE { |
974 return "conic-quadPow2"; | 974 return "conic-quadPow2"; |
975 } | 975 } |
976 | 976 |
977 virtual void onDraw(SkCanvas*) SK_OVERRIDE { | 977 virtual void onDraw(const int loops, SkCanvas*) SK_OVERRIDE { |
978 for (int i = 0; i < this->getLoops(); ++i) { | 978 for (int i = 0; i < loops; ++i) { |
979 for (int j = 0; j < CONICS; ++j) { | 979 for (int j = 0; j < CONICS; ++j) { |
980 fConics[j].computeQuadPOW2(SK_ScalarHalf); | 980 fConics[j].computeQuadPOW2(SK_ScalarHalf); |
981 } | 981 } |
982 } | 982 } |
983 } | 983 } |
984 | 984 |
985 private: | 985 private: |
986 typedef ConicBench INHERITED; | 986 typedef ConicBench INHERITED; |
987 }; | 987 }; |
988 | 988 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1040 DEF_BENCH( return new ArbRoundRectBench(true); ) | 1040 DEF_BENCH( return new ArbRoundRectBench(true); ) |
1041 DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::k
Rect_Type); ) | 1041 DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::k
Rect_Type); ) |
1042 DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::k
RoundRect_Type); ) | 1042 DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::k
RoundRect_Type); ) |
1043 DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::k
Oval_Type); ) | 1043 DEF_BENCH( return new ConservativelyContainsBench(ConservativelyContainsBench::k
Oval_Type); ) |
1044 | 1044 |
1045 DEF_BENCH( return new ConicBench_Chop5() ) | 1045 DEF_BENCH( return new ConicBench_Chop5() ) |
1046 DEF_BENCH( return new ConicBench_ChopHalf() ) | 1046 DEF_BENCH( return new ConicBench_ChopHalf() ) |
1047 DEF_BENCH( return new ConicBench_ComputeError() ) | 1047 DEF_BENCH( return new ConicBench_ComputeError() ) |
1048 DEF_BENCH( return new ConicBench_asQuadTol() ) | 1048 DEF_BENCH( return new ConicBench_asQuadTol() ) |
1049 DEF_BENCH( return new ConicBench_quadPow2() ) | 1049 DEF_BENCH( return new ConicBench_quadPow2() ) |
OLD | NEW |