gm/dashing.cpp

   1 /*
   2  * Copyright 2012 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 "SkCanvas.h"
  10 #include "SkPaint.h"
  11 #include "SkDashPathEffect.h"
  12
  13 static void drawline(SkCanvas* canvas, int on, int off, const SkPaint& paint,
  14                      SkScalar finalX = SkIntToScalar(600), SkScalar finalY = SkIntToScalar(0),
  15                      SkScalar phase = SkIntToScalar(0),
  16                      SkScalar startX = SkIntToScalar(0), SkScalar startY = SkIntToScalar(0)) {
  17     SkPaint p(paint);
  18
  19     const SkScalar intervals[] = {
  20         SkIntToScalar(on),
  21         SkIntToScalar(off),
  22     };
  23
  24     p.setPathEffect(SkDashPathEffect::Create(intervals, 2, phase))->unref();
  25     canvas->drawLine(startX, startY, finalX, finalY, p);
  26 }
  27
  28 // earlier bug stopped us from drawing very long single-segment dashes, because
  29 // SkPathMeasure was skipping very small delta-T values (nearlyzero). This is
  30 // now fixes, so this giant dash should appear.
  31 static void show_giant_dash(SkCanvas* canvas) {
  32     SkPaint paint;
  33
  34     drawline(canvas, 1, 1, paint, SkIntToScalar(20 * 1000));
  35 }
  36
  37 static void show_zero_len_dash(SkCanvas* canvas) {
  38     SkPaint paint;
  39
  40     drawline(canvas, 2, 2, paint, SkIntToScalar(0));
  41     paint.setStyle(SkPaint::kStroke_Style);
  42     paint.setStrokeWidth(SkIntToScalar(2));
  43     canvas->translate(0, SkIntToScalar(20));
  44     drawline(canvas, 4, 4, paint, SkIntToScalar(0));
  45 }
  46
  47 class DashingGM : public skiagm::GM {
  48 public:
  49     DashingGM() {}
  50
  51 protected:
  52
  53     SkString onShortName() {
  54         return SkString("dashing");
  55     }
  56
  57     SkISize onISize() { return SkISize::Make(640, 300); }
  58
  59     virtual void onDraw(SkCanvas* canvas) {
  60         static const struct {
  61             int fOnInterval;
  62             int fOffInterval;
  63         } gData[] = {
  64             { 1, 1 },
  65             { 4, 1 },
  66         };
  67
  68         SkPaint paint;
  69         paint.setStyle(SkPaint::kStroke_Style);
  70
  71         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
  72         canvas->translate(0, SK_ScalarHalf);
  73         for (int width = 0; width <= 2; ++width) {
  74             for (size_t data = 0; data < SK_ARRAY_COUNT(gData); ++data) {
  75                 for (int aa = 0; aa <= 1; ++aa) {
  76                     int w = width * width * width;
  77                     paint.setAntiAlias(SkToBool(aa));
  78                     paint.setStrokeWidth(SkIntToScalar(w));
  79
  80                     int scale = w ? w : 1;
  81
  82                     drawline(canvas, gData[data].fOnInterval * scale,
  83                              gData[data].fOffInterval * scale,
  84                              paint);
  85                     canvas->translate(0, SkIntToScalar(20));
  86                 }
  87             }
  88         }
  89
  90         show_giant_dash(canvas);
  91         canvas->translate(0, SkIntToScalar(20));
  92         show_zero_len_dash(canvas);
  93     }
  94 };
  95
  96 ///////////////////////////////////////////////////////////////////////////////
  97
  98 static void make_unit_star(SkPath* path, int n) {
  99     SkScalar rad = -SK_ScalarPI / 2;
 100     const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
 101
 102     path->moveTo(0, -SK_Scalar1);
 103     for (int i = 1; i < n; i++) {
 104         rad += drad;
 105         SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
 106         path->lineTo(cosV, sinV);
 107     }
 108     path->close();
 109 }
 110
 111 static void make_path_line(SkPath* path, const SkRect& bounds) {
 112     path->moveTo(bounds.left(), bounds.top());
 113     path->lineTo(bounds.right(), bounds.bottom());
 114 }
 115
 116 static void make_path_rect(SkPath* path, const SkRect& bounds) {
 117     path->addRect(bounds);
 118 }
 119
 120 static void make_path_oval(SkPath* path, const SkRect& bounds) {
 121     path->addOval(bounds);
 122 }
 123
 124 static void make_path_star(SkPath* path, const SkRect& bounds) {
 125     make_unit_star(path, 5);
 126     SkMatrix matrix;
 127     matrix.setRectToRect(path->getBounds(), bounds, SkMatrix::kCenter_ScaleToFit);
 128     path->transform(matrix);
 129 }
 130
 131 class Dashing2GM : public skiagm::GM {
 132 public:
 133     Dashing2GM() {}
 134
 135 protected:
 136
 137     SkString onShortName() {
 138         return SkString("dashing2");
 139     }
 140
 141     SkISize onISize() { return SkISize::Make(640, 480); }
 142
 143     virtual void onDraw(SkCanvas* canvas) {
 144         static const int gIntervals[] = {
 145             3,  // 3 dashes: each count [0] followed by intervals [1..count]
 146             2,  10, 10,
 147             4,  20, 5, 5, 5,
 148             2,  2, 2
 149         };
 150
 151         void (*gProc[])(SkPath*, const SkRect&) = {
 152             make_path_line, make_path_rect, make_path_oval, make_path_star,
 153         };
 154
 155         SkPaint paint;
 156         paint.setAntiAlias(true);
 157         paint.setStyle(SkPaint::kStroke_Style);
 158         paint.setStrokeWidth(SkIntToScalar(6));
 159
 160         SkRect bounds = SkRect::MakeWH(SkIntToScalar(120), SkIntToScalar(120));
 161         bounds.offset(SkIntToScalar(20), SkIntToScalar(20));
 162         SkScalar dx = bounds.width() * 4 / 3;
 163         SkScalar dy = bounds.height() * 4 / 3;
 164
 165         const int* intervals = &gIntervals[1];
 166         for (int y = 0; y < gIntervals[0]; ++y) {
 167             SkScalar vals[SK_ARRAY_COUNT(gIntervals)];  // more than enough
 168             int count = *intervals++;
 169             for (int i = 0; i < count; ++i) {
 170                 vals[i] = SkIntToScalar(*intervals++);
 171             }
 172             SkScalar phase = vals[0] / 2;
 173             paint.setPathEffect(SkDashPathEffect::Create(vals, count, phase))->unref();
 174
 175             for (size_t x = 0; x < SK_ARRAY_COUNT(gProc); ++x) {
 176                 SkPath path;
 177                 SkRect r = bounds;
 178                 r.offset(x * dx, y * dy);
 179                 gProc[x](&path, r);
 180
 181                 canvas->drawPath(path, paint);
 182             }
 183         }
 184     }
 185 };
 186
 187 //////////////////////////////////////////////////////////////////////////////
 188
 189 // Test out the on/off line dashing Chrome if fond of
 190 class Dashing3GM : public skiagm::GM {
 191 public:
 192     Dashing3GM() {}
 193
 194 protected:
 195
 196     SkString onShortName() {
 197         return SkString("dashing3");
 198     }
 199
 200     SkISize onISize() { return SkISize::Make(640, 480); }
 201
 202     // Draw a 100x100 block of dashed lines. The horizontal ones are BW
 203     // while the vertical ones are AA.
 204     void drawDashedLines(SkCanvas* canvas,
 205                          SkScalar lineLength,
 206                          SkScalar phase,
 207                          SkScalar dashLength,
 208                          int strokeWidth,
 209                          bool circles) {
 210         SkPaint p;
 211         p.setColor(SK_ColorBLACK);
 212         p.setStyle(SkPaint::kStroke_Style);
 213         p.setStrokeWidth(SkIntToScalar(strokeWidth));
 214
 215         if (circles) {
 216             p.setStrokeCap(SkPaint::kRound_Cap);
 217         }
 218
 219         SkScalar intervals[2] = { dashLength, dashLength };
 220
 221         p.setPathEffect(SkDashPathEffect::Create(intervals, 2, phase))->unref();
 222
 223         SkPoint pts[2];
 224
 225         for (int y = 0; y < 100; y += 10*strokeWidth) {
 226             pts[0].set(0, SkIntToScalar(y));
 227             pts[1].set(lineLength, SkIntToScalar(y));
 228
 229             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p);
 230         }
 231
 232         p.setAntiAlias(true);
 233
 234         for (int x = 0; x < 100; x += 14*strokeWidth) {
 235             pts[0].set(SkIntToScalar(x), 0);
 236             pts[1].set(SkIntToScalar(x), lineLength);
 237
 238             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p);
 239         }
 240     }
 241
 242     virtual void onDraw(SkCanvas* canvas) {
 243         // 1on/1off 1x1 squares with phase of 0 - points fastpath
 244         canvas->save();
 245             canvas->translate(2, 0);
 246             this->drawDashedLines(canvas, 100, 0, SK_Scalar1, 1, false);
 247         canvas->restore();
 248
 249         // 1on/1off 1x1 squares with phase of .5 - rects fastpath (due to partial squares)
 250         canvas->save();
 251             canvas->translate(112, 0);
 252             this->drawDashedLines(canvas, 100, SK_ScalarHalf, SK_Scalar1, 1, false);
 253         canvas->restore();
 254
 255         // 1on/1off 1x1 squares with phase of 1 - points fastpath
 256         canvas->save();
 257             canvas->translate(222, 0);
 258             this->drawDashedLines(canvas, 100, SK_Scalar1, SK_Scalar1, 1, false);
 259         canvas->restore();
 260
 261         // 1on/1off 1x1 squares with phase of 1 and non-integer length - rects fastpath
 262         canvas->save();
 263             canvas->translate(332, 0);
 264             this->drawDashedLines(canvas, 99.5f, SK_ScalarHalf, SK_Scalar1, 1, false);
 265         canvas->restore();
 266
 267         // 255on/255off 1x1 squares with phase of 0 - rects fast path
 268         canvas->save();
 269             canvas->translate(446, 0);
 270             this->drawDashedLines(canvas, 100, 0, SkIntToScalar(255), 1, false);
 271         canvas->restore();
 272
 273         // 1on/1off 3x3 squares with phase of 0 - points fast path
 274         canvas->save();
 275             canvas->translate(2, 110);
 276             this->drawDashedLines(canvas, 100, 0, SkIntToScalar(3), 3, false);
 277         canvas->restore();
 278
 279         // 1on/1off 3x3 squares with phase of 1.5 - rects fast path
 280         canvas->save();
 281             canvas->translate(112, 110);
 282             this->drawDashedLines(canvas, 100, 1.5f, SkIntToScalar(3), 3, false);
 283         canvas->restore();
 284
 285         // 1on/1off 1x1 circles with phase of 1 - no fast path yet
 286         canvas->save();
 287             canvas->translate(2, 220);
 288             this->drawDashedLines(canvas, 100, SK_Scalar1, SK_Scalar1, 1, true);
 289         canvas->restore();
 290
 291         // 1on/1off 3x3 circles with phase of 1 - no fast path yet
 292         canvas->save();
 293             canvas->translate(112, 220);
 294             this->drawDashedLines(canvas, 100, 0, SkIntToScalar(3), 3, true);
 295         canvas->restore();
 296
 297         // 1on/1off 1x1 squares with rotation - should break fast path
 298         canvas->save();
 299             canvas->translate(332+SK_ScalarRoot2Over2*100, 110+SK_ScalarRoot2Over2*100);
 300             canvas->rotate(45);
 301             canvas->translate(-50, -50);
 302
 303             this->drawDashedLines(canvas, 100, SK_Scalar1, SK_Scalar1, 1, false);
 304         canvas->restore();
 305
 306         // 3on/3off 3x1 rects - should use rect fast path regardless of phase
 307         for (int phase = 0; phase <= 3; ++phase) {
 308             canvas->save();
 309                 canvas->translate(SkIntToScalar(phase*110+2),
 310                                   SkIntToScalar(330));
 311                 this->drawDashedLines(canvas, 100, SkIntToScalar(phase), SkIntToScalar(3), 1, false);
 312             canvas->restore();
 313         }
 314     }
 315
 316 };
 317
 318 //////////////////////////////////////////////////////////////////////////////
 319
 320 class Dashing4GM : public skiagm::GM {
 321 public:
 322     Dashing4GM() {}
 323
 324 protected:
 325
 326     SkString onShortName() {
 327         return SkString("dashing4");
 328     }
 329
 330     SkISize onISize() { return SkISize::Make(640, 950); }
 331
 332     virtual void onDraw(SkCanvas* canvas) {
 333         static const struct {
 334             int fOnInterval;
 335             int fOffInterval;
 336         } gData[] = {
 337             { 1, 1 },
 338             { 4, 2 },
 339             { 0, 4 }, // test for zero length on interval
 340         };
 341
 342         SkPaint paint;
 343         paint.setStyle(SkPaint::kStroke_Style);
 344
 345         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
 346         canvas->translate(0, SK_ScalarHalf);
 347
 348         for (int width = 0; width <= 2; ++width) {
 349             for (size_t data = 0; data < SK_ARRAY_COUNT(gData); ++data) {
 350                 for (int aa = 0; aa <= 1; ++aa) {
 351                     for (int cap = 0; cap <= 1; ++cap) {
 352                         int w = width * width * width;
 353                         paint.setAntiAlias(SkToBool(aa));
 354                         paint.setStrokeWidth(SkIntToScalar(w));
 355
 356                         SkToBool(cap) ? paint.setStrokeCap(SkPaint::kSquare_Cap)
 357                             : paint.setStrokeCap(SkPaint::kRound_Cap);
 358
 359                         int scale = w ? w : 1;
 360
 361                         drawline(canvas, gData[data].fOnInterval * scale,
 362                                  gData[data].fOffInterval * scale,
 363                                  paint);
 364                         canvas->translate(0, SkIntToScalar(20));
 365                     }
 366                 }
 367             }
 368         }
 369
 370         for (int aa = 0; aa <= 1; ++aa) {
 371             paint.setAntiAlias(SkToBool(aa));
 372             paint.setStrokeWidth(8.f);
 373             paint.setStrokeCap(SkPaint::kSquare_Cap);
 374             // Single dash element that is cut off at start and end
 375             drawline(canvas, 32, 16, paint, 20.f, 0, 5.f);
 376             canvas->translate(0, SkIntToScalar(20));
 377
 378             // Two dash elements where each one is cut off at beginning and end respectively
 379             drawline(canvas, 32, 16, paint, 56.f, 0, 5.f);
 380             canvas->translate(0, SkIntToScalar(20));
 381
 382             // Many dash elements where first and last are cut off at beginning and end respectively
 383             drawline(canvas, 32, 16, paint, 584.f, 0, 5.f);
 384             canvas->translate(0, SkIntToScalar(20));
 385
 386             // Diagonal dash line where src pnts are not axis aligned (as apposed to being diagonal from
 387             // a canvas rotation)
 388             drawline(canvas, 32, 16, paint, 600.f, 30.f);
 389             canvas->translate(0, SkIntToScalar(20));
 390
 391             // Case where only the off interval exists on the line. Thus nothing should be drawn
 392             drawline(canvas, 32, 16, paint, 8.f, 0.f, 40.f);
 393             canvas->translate(0, SkIntToScalar(20));
 394         }
 395     }
 396 };
 397
 398 //////////////////////////////////////////////////////////////////////////////
 399
 400 class Dashing5GM : public skiagm::GM {
 401 public:
 402     Dashing5GM(bool doAA) : fDoAA(doAA) {}
 403
 404 protected:
 405
 406     bool runAsBench() const SK_OVERRIDE { return true; }
 407
 408     SkString onShortName() SK_OVERRIDE {
 409         if (fDoAA) {
 410             return SkString("dashing5_aa");
 411         } else {
 412             return SkString("dashing5_bw");
 413         }
 414     }
 415
 416     SkISize onISize() SK_OVERRIDE { return SkISize::Make(400, 200); }
 417
 418     void onDraw(SkCanvas* canvas) SK_OVERRIDE {
 419         static const int kOn = 4;
 420         static const int kOff = 4;
 421         static const int kIntervalLength = kOn + kOff;
 422
 423         static const SkColor gColors[kIntervalLength] = {
 424             SK_ColorRED,
 425             SK_ColorGREEN,
 426             SK_ColorBLUE,
 427             SK_ColorCYAN,
 428             SK_ColorMAGENTA,
 429             SK_ColorYELLOW,
 430             SK_ColorGRAY,
 431             SK_ColorDKGRAY
 432         };
 433
 434         SkPaint paint;
 435         paint.setStyle(SkPaint::kStroke_Style);
 436
 437         paint.setAntiAlias(fDoAA);
 438
 439         SkMatrix rot;
 440         rot.setRotate(90);
 441         SkASSERT(rot.rectStaysRect());
 442
 443         canvas->concat(rot);
 444
 445         int sign;       // used to toggle the direction of the lines
 446         int phase = 0;
 447
 448         for (int x = 0; x < 200; x += 10) {
 449             paint.setStrokeWidth(SkIntToScalar(phase+1));
 450             paint.setColor(gColors[phase]);
 451             sign = (x % 20) ? 1 : -1;
 452             drawline(canvas, kOn, kOff, paint,
 453                      SkIntToScalar(x), -sign * SkIntToScalar(10003),
 454                      SkIntToScalar(phase),
 455                      SkIntToScalar(x),  sign * SkIntToScalar(10003));
 456             phase = (phase + 1) % kIntervalLength;
 457         }
 458
 459         for (int y = -400; y < 0; y += 10) {
 460             paint.setStrokeWidth(SkIntToScalar(phase+1));
 461             paint.setColor(gColors[phase]);
 462             sign = (y % 20) ? 1 : -1;
 463             drawline(canvas, kOn, kOff, paint,
 464                      -sign * SkIntToScalar(10003), SkIntToScalar(y),
 465                      SkIntToScalar(phase),
 466                       sign * SkIntToScalar(10003), SkIntToScalar(y));
 467             phase = (phase + 1) % kIntervalLength;
 468         }
 469     }
 470
 471 private:
 472     bool fDoAA;
 473 };
 474
 475 //////////////////////////////////////////////////////////////////////////////
 476
 477 DEF_GM(return SkNEW(DashingGM);)
 478 DEF_GM(return SkNEW(Dashing2GM);)
 479 DEF_GM(return SkNEW(Dashing3GM);)
 480 DEF_GM(return SkNEW(Dashing4GM);)
 481 DEF_GM(return SkNEW_ARGS(Dashing5GM, (true));)
 482 DEF_GM(return SkNEW_ARGS(Dashing5GM, (false));)
 483