Home | History | Annotate | Download | only in gm 
      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 "SkPath.h"
     10 
     11 typedef SkScalar (*MakePathProc)(SkPath*);
     12 
     13 static SkScalar make_frame(SkPath* path) {
     14     SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
     15                  SkIntToScalar(630), SkIntToScalar(470) };
     16     path->addRoundRect(r, SkIntToScalar(15), SkIntToScalar(15));
     17 
     18     SkPaint paint;
     19     paint.setStyle(SkPaint::kStroke_Style);
     20     paint.setStrokeWidth(SkIntToScalar(5));
     21     paint.getFillPath(*path, path);
     22     return SkIntToScalar(15);
     23 }
     24 
     25 static SkScalar make_triangle(SkPath* path) {
     26     constexpr int gCoord[] = {
     27         10, 20, 15, 5, 30, 30
     28     };
     29     path->moveTo(SkIntToScalar(gCoord[0]), SkIntToScalar(gCoord[1]));
     30     path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3]));
     31     path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5]));
     32     path->close();
     33     path->offset(SkIntToScalar(10), SkIntToScalar(0));
     34     return SkIntToScalar(30);
     35 }
     36 
     37 static SkScalar make_rect(SkPath* path) {
     38     SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
     39                  SkIntToScalar(30), SkIntToScalar(30) };
     40     path->addRect(r);
     41     path->offset(SkIntToScalar(10), SkIntToScalar(0));
     42     return SkIntToScalar(30);
     43 }
     44 
     45 static SkScalar make_oval(SkPath* path) {
     46     SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
     47                  SkIntToScalar(30), SkIntToScalar(30) };
     48     path->addOval(r);
     49     path->offset(SkIntToScalar(10), SkIntToScalar(0));
     50     return SkIntToScalar(30);
     51 }
     52 
     53 static SkScalar make_sawtooth(SkPath* path, int teeth) {
     54     SkScalar x = SkIntToScalar(20);
     55     SkScalar y = SkIntToScalar(20);
     56     const SkScalar x0 = x;
     57     const SkScalar dx = SkIntToScalar(5);
     58     const SkScalar dy = SkIntToScalar(10);
     59 
     60     path->moveTo(x, y);
     61     for (int i = 0; i < teeth; i++) {
     62         x += dx;
     63         path->lineTo(x, y - dy);
     64         x += dx;
     65         path->lineTo(x, y + dy);
     66     }
     67     path->lineTo(x, y + (2 * dy));
     68     path->lineTo(x0, y + (2 * dy));
     69     path->close();
     70     return SkIntToScalar(30);
     71 }
     72 
     73 static SkScalar make_sawtooth_3(SkPath* path) { return make_sawtooth(path, 3); }
     74 static SkScalar make_sawtooth_32(SkPath* path) { return make_sawtooth(path, 32); }
     75 
     76 static SkScalar make_house(SkPath* path) {
     77     path->moveTo(21, 23);
     78     path->lineTo(21, 11.534f);
     79     path->lineTo(22.327f, 12.741f);
     80     path->lineTo(23.673f, 11.261f);
     81     path->lineTo(12, 0.648f);
     82     path->lineTo(8, 4.285f);
     83     path->lineTo(8, 2);
     84     path->lineTo(4, 2);
     85     path->lineTo(4, 7.921f);
     86     path->lineTo(0.327f, 11.26f);
     87     path->lineTo(1.673f, 12.74f);
     88     path->lineTo(3, 11.534f);
     89     path->lineTo(3, 23);
     90     path->lineTo(11, 23);
     91     path->lineTo(11, 18);
     92     path->lineTo(13, 18);
     93     path->lineTo(13, 23);
     94     path->lineTo(21, 23);
     95     path->close();
     96     path->lineTo(9, 16);
     97     path->lineTo(9, 21);
     98     path->lineTo(5, 21);
     99     path->lineTo(5, 9.715f);
    100     path->lineTo(12, 3.351f);
    101     path->lineTo(19, 9.715f);
    102     path->lineTo(19, 21);
    103     path->lineTo(15, 21);
    104     path->lineTo(15, 16);
    105     path->lineTo(9, 16);
    106     path->close();
    107     path->offset(20, 0);
    108     return SkIntToScalar(30);
    109 }
    110 
    111 static SkScalar make_star(SkPath* path, int n) {
    112     const SkScalar c = SkIntToScalar(45);
    113     const SkScalar r = SkIntToScalar(20);
    114 
    115     SkScalar rad = -SK_ScalarPI / 2;
    116     const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
    117 
    118     path->moveTo(c, c - r);
    119     for (int i = 1; i < n; i++) {
    120         rad += drad;
    121         SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
    122         path->lineTo(c + cosV * r, c + sinV * r);
    123     }
    124     path->close();
    125     return r * 2 * 6 / 5;
    126 }
    127 
    128 static SkScalar make_star_5(SkPath* path) { return make_star(path, 5); }
    129 static SkScalar make_star_13(SkPath* path) { return make_star(path, 13); }
    130 
    131 // We don't expect any output from this path.
    132 static SkScalar make_line(SkPath* path) {
    133     path->moveTo(SkIntToScalar(30), SkIntToScalar(30));
    134     path->lineTo(SkIntToScalar(120), SkIntToScalar(40));
    135     path->close();
    136     path->moveTo(SkIntToScalar(150), SkIntToScalar(30));
    137     path->lineTo(SkIntToScalar(150), SkIntToScalar(30));
    138     path->lineTo(SkIntToScalar(300), SkIntToScalar(40));
    139     path->close();
    140     return SkIntToScalar(40);
    141 }
    142 
    143 static void make_info(SkPath* path) {
    144     path->moveTo(24, 4);
    145     path->cubicTo(12.94999980926514f,
    146                   4,
    147                   4,
    148                   12.94999980926514f,
    149                   4,
    150                   24);
    151     path->cubicTo(4,
    152                   35.04999923706055f,
    153                   12.94999980926514f,
    154                   44,
    155                   24,
    156                   44);
    157     path->cubicTo(35.04999923706055f,
    158                   44,
    159                   44,
    160                   35.04999923706055f,
    161                   44,
    162                   24);
    163     path->cubicTo(44,
    164                   12.95000076293945f,
    165                   35.04999923706055f,
    166                   4,
    167                   24,
    168                   4);
    169     path->close();
    170     path->moveTo(26, 34);
    171     path->lineTo(22, 34);
    172     path->lineTo(22, 22);
    173     path->lineTo(26, 22);
    174     path->lineTo(26, 34);
    175     path->close();
    176     path->moveTo(26, 18);
    177     path->lineTo(22, 18);
    178     path->lineTo(22, 14);
    179     path->lineTo(26, 14);
    180     path->lineTo(26, 18);
    181     path->close();
    182 }
    183 
    184 static void make_accessibility(SkPath* path) {
    185     path->moveTo(12, 2);
    186     path->cubicTo(13.10000038146973f,
    187                   2,
    188                   14,
    189                   2.900000095367432f,
    190                   14,
    191                   4);
    192     path->cubicTo(14,
    193                   5.099999904632568f,
    194                   13.10000038146973f,
    195                   6,
    196                   12,
    197                   6);
    198     path->cubicTo(10.89999961853027f,
    199                   6,
    200                   10,
    201                   5.099999904632568f,
    202                   10,
    203                   4);
    204     path->cubicTo(10,
    205                   2.900000095367432f,
    206                   10.89999961853027f,
    207                   2,
    208                   12,
    209                   2);
    210     path->close();
    211     path->moveTo(21, 9);
    212     path->lineTo(15, 9);
    213     path->lineTo(15, 22);
    214     path->lineTo(13, 22);
    215     path->lineTo(13, 16);
    216     path->lineTo(11, 16);
    217     path->lineTo(11, 22);
    218     path->lineTo(9, 22);
    219     path->lineTo(9, 9);
    220     path->lineTo(3, 9);
    221     path->lineTo(3, 7);
    222     path->lineTo(21, 7);
    223     path->lineTo(21, 9);
    224     path->close();
    225 }
    226 
    227 // test case for http://crbug.com/695196
    228 static void make_visualizer(SkPath* path) {
    229     path->moveTo(1.9520f, 2.0000f);
    230     path->conicTo(1.5573f, 1.9992f, 1.2782f, 2.2782f, 0.9235f);
    231     path->conicTo(0.9992f, 2.5573f, 1.0000f, 2.9520f, 0.9235f);
    232     path->lineTo(1.0000f, 5.4300f);
    233     path->lineTo(17.0000f, 5.4300f);
    234     path->lineTo(17.0000f, 2.9520f);
    235     path->conicTo(17.0008f, 2.5573f, 16.7218f, 2.2782f, 0.9235f);
    236     path->conicTo(16.4427f, 1.9992f, 16.0480f, 2.0000f, 0.9235f);
    237     path->lineTo(1.9520f, 2.0000f);
    238     path->close();
    239     path->moveTo(2.7140f, 3.1430f);
    240     path->conicTo(3.0547f, 3.1287f, 3.2292f, 3.4216f, 0.8590f);
    241     path->conicTo(3.4038f, 3.7145f, 3.2292f, 4.0074f, 0.8590f);
    242     path->conicTo(3.0547f, 4.3003f, 2.7140f, 4.2860f, 0.8590f);
    243     path->conicTo(2.1659f, 4.2631f, 2.1659f, 3.7145f, 0.7217f);
    244     path->conicTo(2.1659f, 3.1659f, 2.7140f, 3.1430f, 0.7217f);
    245     path->lineTo(2.7140f, 3.1430f);
    246     path->close();
    247     path->moveTo(5.0000f, 3.1430f);
    248     path->conicTo(5.3407f, 3.1287f, 5.5152f, 3.4216f, 0.8590f);
    249     path->conicTo(5.6898f, 3.7145f, 5.5152f, 4.0074f, 0.8590f);
    250     path->conicTo(5.3407f, 4.3003f, 5.0000f, 4.2860f, 0.8590f);
    251     path->conicTo(4.4519f, 4.2631f, 4.4519f, 3.7145f, 0.7217f);
    252     path->conicTo(4.4519f, 3.1659f, 5.0000f, 3.1430f, 0.7217f);
    253     path->lineTo(5.0000f, 3.1430f);
    254     path->close();
    255     path->moveTo(7.2860f, 3.1430f);
    256     path->conicTo(7.6267f, 3.1287f, 7.8012f, 3.4216f, 0.8590f);
    257     path->conicTo(7.9758f, 3.7145f, 7.8012f, 4.0074f, 0.8590f);
    258     path->conicTo(7.6267f, 4.3003f, 7.2860f, 4.2860f, 0.8590f);
    259     path->conicTo(6.7379f, 4.2631f, 6.7379f, 3.7145f, 0.7217f);
    260     path->conicTo(6.7379f, 3.1659f, 7.2860f, 3.1430f, 0.7217f);
    261     path->close();
    262     path->moveTo(1.0000f, 6.1900f);
    263     path->lineTo(1.0000f, 14.3810f);
    264     path->conicTo(0.9992f, 14.7757f, 1.2782f, 15.0548f, 0.9235f);
    265     path->conicTo(1.5573f, 15.3338f, 1.9520f, 15.3330f, 0.9235f);
    266     path->lineTo(16.0480f, 15.3330f);
    267     path->conicTo(16.4427f, 15.3338f, 16.7218f, 15.0548f, 0.9235f);
    268     path->conicTo(17.0008f, 14.7757f, 17.0000f, 14.3810f, 0.9235f);
    269     path->lineTo(17.0000f, 6.1910f);
    270     path->lineTo(1.0000f, 6.1910f);
    271     path->lineTo(1.0000f, 6.1900f);
    272     path->close();
    273 }
    274 
    275 constexpr MakePathProc gProcs[] = {
    276     make_frame,
    277     make_triangle,
    278     make_rect,
    279     make_oval,
    280     make_sawtooth_32,
    281     make_star_5,
    282     make_star_13,
    283     make_line,
    284     make_house,
    285     make_sawtooth_3,
    286 };
    287 
    288 #define N   SK_ARRAY_COUNT(gProcs)
    289 
    290 class PathFillGM : public skiagm::GM {
    291     SkPath  fPath[N];
    292     SkScalar fDY[N];
    293     SkPath  fInfoPath;
    294     SkPath  fAccessibilityPath;
    295     SkPath  fVisualizerPath;
    296 protected:
    297     void onOnceBeforeDraw() override {
    298         for (size_t i = 0; i < N; i++) {
    299             fDY[i] = gProcs[i](&fPath[i]);
    300         }
    301 
    302         make_info(&fInfoPath);
    303         make_accessibility(&fAccessibilityPath);
    304         make_visualizer(&fVisualizerPath);
    305     }
    306 
    307 
    308     SkString onShortName() override {
    309         return SkString("pathfill");
    310     }
    311 
    312     SkISize onISize() override {
    313         return SkISize::Make(640, 480);
    314     }
    315 
    316     void onDraw(SkCanvas* canvas) override {
    317         SkPaint paint;
    318         paint.setAntiAlias(true);
    319 
    320         for (size_t i = 0; i < N; i++) {
    321             canvas->drawPath(fPath[i], paint);
    322             canvas->translate(SkIntToScalar(0), fDY[i]);
    323         }
    324 
    325         canvas->save();
    326         canvas->scale(0.300000011920929f, 0.300000011920929f);
    327         canvas->translate(50, 50);
    328         canvas->drawPath(fInfoPath, paint);
    329         canvas->restore();
    330 
    331         canvas->scale(2, 2);
    332         canvas->translate(5, 15);
    333         canvas->drawPath(fAccessibilityPath, paint);
    334 
    335         canvas->scale(0.5f, 0.5f);
    336         canvas->translate(5, 50);
    337         canvas->drawPath(fVisualizerPath, paint);
    338     }
    339 
    340 private:
    341     typedef skiagm::GM INHERITED;
    342 };
    343 
    344 // test inverse-fill w/ a clip that completely excludes the geometry
    345 class PathInverseFillGM : public skiagm::GM {
    346     SkPath  fPath[N];
    347     SkScalar fDY[N];
    348 protected:
    349     void onOnceBeforeDraw() override {
    350         for (size_t i = 0; i < N; i++) {
    351             fDY[i] = gProcs[i](&fPath[i]);
    352         }
    353     }
    354 
    355     SkString onShortName() override {
    356         return SkString("pathinvfill");
    357     }
    358 
    359     SkISize onISize() override {
    360         return SkISize::Make(450, 220);
    361     }
    362 
    363     static void show(SkCanvas* canvas, const SkPath& path, const SkPaint& paint,
    364                      const SkRect* clip, SkScalar top, const SkScalar bottom) {
    365         canvas->save();
    366         if (clip) {
    367             SkRect r = *clip;
    368             r.fTop = top;
    369             r.fBottom = bottom;
    370             canvas->clipRect(r);
    371         }
    372         canvas->drawPath(path, paint);
    373         canvas->restore();
    374     }
    375 
    376     void onDraw(SkCanvas* canvas) override {
    377         SkPath path;
    378 
    379         path.addCircle(SkIntToScalar(50), SkIntToScalar(50), SkIntToScalar(40));
    380         path.toggleInverseFillType();
    381 
    382         SkRect clipR = { 0, 0, SkIntToScalar(100), SkIntToScalar(200) };
    383 
    384         canvas->translate(SkIntToScalar(10), SkIntToScalar(10));
    385 
    386         for (int doclip = 0; doclip <= 1; ++doclip) {
    387             for (int aa = 0; aa <= 1; ++aa) {
    388                 SkPaint paint;
    389                 paint.setAntiAlias(SkToBool(aa));
    390 
    391                 canvas->save();
    392                 canvas->clipRect(clipR);
    393 
    394                 const SkRect* clipPtr = doclip ? &clipR : nullptr;
    395 
    396                 show(canvas, path, paint, clipPtr, clipR.fTop, clipR.centerY());
    397                 show(canvas, path, paint, clipPtr, clipR.centerY(), clipR.fBottom);
    398 
    399                 canvas->restore();
    400                 canvas->translate(SkIntToScalar(110), 0);
    401             }
    402         }
    403     }
    404 
    405 private:
    406     typedef skiagm::GM INHERITED;
    407 };
    408 
    409 DEF_SIMPLE_GM(rotatedcubicpath, canvas, 200, 200) {
    410     SkPaint p;
    411     p.setAntiAlias(true);
    412     p.setStyle(SkPaint::kFill_Style);
    413 
    414     canvas->translate(50, 50);
    415     SkPath path;
    416     path.moveTo(48,-23);
    417     path.cubicTo(48,-29.5, 6,-30, 6,-30);
    418     path.cubicTo(6,-30, 2,0, 2,0);
    419     path.cubicTo(2,0, 44,-21.5, 48,-23);
    420     path.close();
    421 
    422     p.setColor(SK_ColorBLUE);
    423     canvas->drawPath(path, p);
    424 
    425     // Rotated path, which is not antialiased on GPU
    426     p.setColor(SK_ColorRED);
    427     canvas->rotate(90);
    428     canvas->drawPath(path, p);
    429 }
    430 
    431 ///////////////////////////////////////////////////////////////////////////////
    432 
    433 DEF_GM( return new PathFillGM; )
    434 DEF_GM( return new PathInverseFillGM; )
    435