Home | History | Annotate | Download | only in gm 
      1 /*
      2  * Copyright 2013 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 "SkPath.h"
     11 
     12 namespace skiagm {
     13 
     14 // This GM tests a grab-bag of non-closed paths. All these paths look like
     15 // closed rects, but they don't call path.close(). Depending on the stroke
     16 // settings these slightly different paths give widely different results.
     17 class NonClosedPathsGM: public GM {
     18 public:
     19     NonClosedPathsGM() {}
     20 
     21     enum ClosureType {
     22         TotallyNonClosed,  // The last point doesn't coincide with the first one in the contour.
     23                            // The path looks not closed at all.
     24 
     25         FakeCloseCorner,   // The last point coincides with the first one at a corner.
     26                            // The path looks closed, but final rendering has 2 ends with cap.
     27 
     28         FakeCloseMiddle,   // The last point coincides with the first one in the middle of a line.
     29                            // The path looks closed, and the final rendering looks closed too.
     30 
     31         kClosureTypeCount
     32     };
     33 
     34 protected:
     35     virtual uint32_t onGetFlags() const SK_OVERRIDE {
     36         return kSkipTiled_Flag;
     37     }
     38 
     39     virtual SkString onShortName() SK_OVERRIDE {
     40         return SkString("nonclosedpaths");
     41     }
     42 
     43     // 12 * 18 + 3 cases, every case is 100 * 100 pixels.
     44     virtual SkISize onISize() SK_OVERRIDE {
     45         return SkISize::Make(1220, 1920);
     46     }
     47 
     48     // Use rect-like geometry for non-closed path, for right angles make it
     49     // easier to show the visual difference of lineCap and lineJoin.
     50     static void MakePath(SkPath* path, ClosureType type) {
     51         if (FakeCloseMiddle == type) {
     52             path->moveTo(30, 50);
     53             path->lineTo(30, 30);
     54         } else {
     55             path->moveTo(30, 30);
     56         }
     57         path->lineTo(70, 30);
     58         path->lineTo(70, 70);
     59         path->lineTo(30, 70);
     60         path->lineTo(30, 50);
     61         if (FakeCloseCorner == type) {
     62             path->lineTo(30, 30);
     63         }
     64     }
     65 
     66     // Set the location for the current test on the canvas
     67     static void SetLocation(SkCanvas* canvas, int counter, int lineNum) {
     68         SkScalar x = SK_Scalar1 * 100 * (counter % lineNum) + 10 + SK_Scalar1 / 4;
     69         SkScalar y = SK_Scalar1 * 100 * (counter / lineNum) + 10 + 3 * SK_Scalar1 / 4;
     70         canvas->translate(x, y);
     71     }
     72 
     73     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
     74         // Stroke widths are:
     75         // 0(may use hairline rendering), 10(common case for stroke-style)
     76         // 40 and 50(>= geometry width/height, make the contour filled in fact)
     77         static const int kStrokeWidth[] = {0, 10, 40, 50};
     78         int numWidths = SK_ARRAY_COUNT(kStrokeWidth);
     79 
     80         static const SkPaint::Style kStyle[] = {
     81             SkPaint::kStroke_Style, SkPaint::kStrokeAndFill_Style
     82         };
     83 
     84         static const SkPaint::Cap kCap[] = {
     85             SkPaint::kButt_Cap, SkPaint::kRound_Cap, SkPaint::kSquare_Cap
     86         };
     87 
     88         static const SkPaint::Join kJoin[] = {
     89             SkPaint::kMiter_Join, SkPaint::kRound_Join, SkPaint::kBevel_Join
     90         };
     91 
     92         static const ClosureType kType[] = {
     93             TotallyNonClosed, FakeCloseCorner, FakeCloseMiddle
     94         };
     95 
     96         int counter = 0;
     97         SkPaint paint;
     98         paint.setAntiAlias(true);
     99 
    100         // For stroke style painter and fill-and-stroke style painter
    101         for (size_t type = 0; type < kClosureTypeCount; ++type) {
    102             for (size_t style = 0; style < SK_ARRAY_COUNT(kStyle); ++style) {
    103                 for (size_t cap = 0; cap < SK_ARRAY_COUNT(kCap); ++cap) {
    104                     for (size_t join = 0; join < SK_ARRAY_COUNT(kJoin); ++join) {
    105                         for (int width = 0; width < numWidths; ++width) {
    106                             canvas->save();
    107                             SetLocation(canvas, counter, SkPaint::kJoinCount * numWidths);
    108 
    109                             SkPath path;
    110                             MakePath(&path, kType[type]);
    111 
    112                             paint.setStyle(kStyle[style]);
    113                             paint.setStrokeCap(kCap[cap]);
    114                             paint.setStrokeJoin(kJoin[join]);
    115                             paint.setStrokeWidth(SkIntToScalar(kStrokeWidth[width]));
    116 
    117                             canvas->drawPath(path, paint);
    118                             canvas->restore();
    119                             ++counter;
    120                         }
    121                     }
    122                 }
    123             }
    124         }
    125 
    126         // For fill style painter
    127         paint.setStyle(SkPaint::kFill_Style);
    128         for (size_t type = 0; type < kClosureTypeCount; ++type) {
    129             canvas->save();
    130             SetLocation(canvas, counter, SkPaint::kJoinCount * numWidths);
    131 
    132             SkPath path;
    133             MakePath(&path, kType[type]);
    134 
    135             canvas->drawPath(path, paint);
    136             canvas->restore();
    137             ++counter;
    138         }
    139     }
    140 
    141 private:
    142     typedef GM INHERITED;
    143 };
    144 
    145 //////////////////////////////////////////////////////////////////////////////
    146 
    147 DEF_GM(return new NonClosedPathsGM;)
    148 
    149 }
    150