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