smallpaths.cpp revision 8450cc3d3d5c6df6caad0445557871f48108d041 
1/*
2 * Copyright 2015 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
11typedef SkScalar (*MakePathProc)(SkPath*);
12
13static SkScalar make_triangle(SkPath* path) {
14    static const int gCoord[] = {
15        10, 20, 15, 5, 30, 30
16    };
17    path->moveTo(SkIntToScalar(gCoord[0]), SkIntToScalar(gCoord[1]));
18    path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3]));
19    path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5]));
20    path->close();
21    path->offset(SkIntToScalar(10), SkIntToScalar(0));
22    return SkIntToScalar(30);
23}
24
25static SkScalar make_rect(SkPath* path) {
26    SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
27                 SkIntToScalar(30), SkIntToScalar(30) };
28    path->addRect(r);
29    path->offset(SkIntToScalar(10), SkIntToScalar(0));
30    return SkIntToScalar(30);
31}
32
33static SkScalar make_oval(SkPath* path) {
34    SkRect r = { SkIntToScalar(10), SkIntToScalar(10),
35                 SkIntToScalar(30), SkIntToScalar(30) };
36    path->addOval(r);
37    path->offset(SkIntToScalar(10), SkIntToScalar(0));
38    return SkIntToScalar(30);
39}
40
41static SkScalar make_star(SkPath* path, int n) {
42    const SkScalar c = SkIntToScalar(45);
43    const SkScalar r = SkIntToScalar(20);
44
45    SkScalar rad = -SK_ScalarPI / 2;
46    const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
47
48    path->moveTo(c, c - r);
49    for (int i = 1; i < n; i++) {
50        rad += drad;
51        SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
52        path->lineTo(c + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r));
53    }
54    path->close();
55    return r * 2 * 6 / 5;
56}
57
58static SkScalar make_star_5(SkPath* path) { return make_star(path, 5); }
59static SkScalar make_star_13(SkPath* path) { return make_star(path, 13); }
60
61static SkScalar make_three_line(SkPath* path) {
62    static SkScalar xOffset = 34.f;
63    static SkScalar yOffset = 50.f;
64    path->moveTo(-32.5f + xOffset, 0.0f + yOffset);
65    path->lineTo(32.5f + xOffset, 0.0f + yOffset);
66
67    path->moveTo(-32.5f + xOffset, 19 + yOffset);
68    path->lineTo(32.5f + xOffset, 19 + yOffset);
69
70    path->moveTo(-32.5f + xOffset, -19 + yOffset);
71    path->lineTo(32.5f + xOffset, -19 + yOffset);
72    path->lineTo(-32.5f + xOffset, -19 + yOffset);
73
74    path->close();
75
76    return SkIntToScalar(70);
77}
78
79static SkScalar make_arrow(SkPath* path) {
80    static SkScalar xOffset = 34.f;
81    static SkScalar yOffset = 40.f;
82    path->moveTo(-26.f + xOffset, 0.0f + yOffset);
83    path->lineTo(26.f + xOffset, 0.0f + yOffset);
84
85    path->moveTo(-28.f + xOffset, -2.4748745f + yOffset);
86    path->lineTo(0 + xOffset, 25.525126f + yOffset);
87
88    path->moveTo(-28.f + xOffset, 2.4748745f + yOffset);
89    path->lineTo(0 + xOffset, -25.525126f + yOffset);
90    path->lineTo(-28.f + xOffset, 2.4748745f + yOffset);
91
92    path->close();
93
94    return SkIntToScalar(70);
95}
96
97static SkScalar make_curve(SkPath* path) {
98    static SkScalar xOffset = -382.f;
99    static SkScalar yOffset = -50.f;
100    path->moveTo(491 + xOffset, 56 + yOffset);
101    path->conicTo(435.93292f + xOffset, 56.000031f + yOffset,
102                  382.61078f + xOffset, 69.752716f + yOffset,
103                  0.9920463f);
104
105    return SkIntToScalar(40);
106}
107
108static SkScalar make_battery(SkPath* path) {
109    static SkScalar xOffset = 5.f;
110
111    path->moveTo(24.67f + xOffset, 0.33000004f);
112    path->lineTo(8.3299999f + xOffset, 0.33000004f);
113    path->lineTo(8.3299999f + xOffset, 5.3299999f);
114    path->lineTo(0.33000004f + xOffset, 5.3299999f);
115    path->lineTo(0.33000004f + xOffset, 50.669998f);
116    path->lineTo(32.669998f + xOffset, 50.669998f);
117    path->lineTo(32.669998f + xOffset, 5.3299999f);
118    path->lineTo(24.67f + xOffset, 5.3299999f);
119    path->lineTo(24.67f + xOffset, 0.33000004f);
120    path->close();
121
122    path->moveTo(25.727224f + xOffset, 12.886665f);
123    path->lineTo(10.907918f + xOffset, 12.886665f);
124    path->lineTo(7.5166659f + xOffset, 28.683645f);
125    path->lineTo(14.810181f + xOffset, 28.683645f);
126    path->lineTo(7.7024879f + xOffset, 46.135998f);
127    path->lineTo(28.049999f + xOffset, 25.136419f);
128    path->lineTo(16.854223f + xOffset, 25.136419f);
129    path->lineTo(25.727224f + xOffset, 12.886665f);
130    path->close();
131    return SkIntToScalar(70);
132}
133
134static SkScalar make_battery2(SkPath* path) {
135    static SkScalar xOffset = 5.f;
136
137    path->moveTo(32.669998f + xOffset, 9.8640003f);
138    path->lineTo(0.33000004f + xOffset, 9.8640003f);
139    path->lineTo(0.33000004f + xOffset, 50.669998f);
140    path->lineTo(32.669998f + xOffset, 50.669998f);
141    path->lineTo(32.669998f + xOffset, 9.8640003f);
142    path->close();
143
144    path->moveTo(10.907918f + xOffset, 12.886665f);
145    path->lineTo(25.727224f + xOffset, 12.886665f);
146    path->lineTo(16.854223f + xOffset, 25.136419f);
147    path->lineTo(28.049999f + xOffset, 25.136419f);
148    path->lineTo(7.7024879f + xOffset, 46.135998f);
149    path->lineTo(14.810181f + xOffset, 28.683645f);
150    path->lineTo(7.5166659f + xOffset, 28.683645f);
151    path->lineTo(10.907918f + xOffset, 12.886665f);
152    path->close();
153
154    return SkIntToScalar(70);
155}
156
157static const MakePathProc gProcs[] = {
158    make_triangle,
159    make_rect,
160    make_oval,
161    make_star_5,
162    make_star_13,
163    make_three_line,
164    make_arrow,
165    make_curve,
166    make_battery,
167    make_battery2
168};
169
170static const SkScalar gWidths[] = {
171    2.0f,
172    3.0f,
173    4.0f,
174    5.0f,
175    6.0f,
176    7.0f,
177    7.0f,
178    14.0f,
179    0.0f,
180    0.0f,
181};
182
183static const SkScalar gMiters[] = {
184    2.0f,
185    3.0f,
186    3.0f,
187    3.0f,
188    4.0f,
189    4.0f,
190    4.0f,
191    4.0f,
192    4.0f,
193    4.0f,
194};
195
196#define N   SK_ARRAY_COUNT(gProcs)
197
198// This GM tests out drawing small paths (i.e., for Ganesh, using the Distance
199// Field path renderer) which are filled, stroked and filledAndStroked. In
200// particular this ensures that any cache keys in use include the stroking
201// parameters.
202class SmallPathsGM : public skiagm::GM {
203    SkPath  fPath[N];
204    SkScalar fDY[N];
205protected:
206    void onOnceBeforeDraw() override {
207        for (size_t i = 0; i < N; i++) {
208            fDY[i] = gProcs[i](&fPath[i]);
209        }
210    }
211
212    SkString onShortName() override {
213        return SkString("smallpaths");
214    }
215
216    SkISize onISize() override {
217        return SkISize::Make(640, 480);
218    }
219
220    void onDraw(SkCanvas* canvas) override {
221        SkPaint paint;
222        paint.setAntiAlias(true);
223
224        // first column: filled paths
225        canvas->save();
226        for (size_t i = 0; i < N; i++) {
227            canvas->drawPath(fPath[i], paint);
228            canvas->translate(SkIntToScalar(0), fDY[i]);
229        }
230        canvas->restore();
231        canvas->translate(SkIntToScalar(120), SkIntToScalar(0));
232
233        // second column: stroked paths
234        canvas->save();
235        paint.setStyle(SkPaint::kStroke_Style);
236        paint.setStrokeCap(SkPaint::kButt_Cap);
237        for (size_t i = 0; i < N; i++) {
238            paint.setStrokeWidth(gWidths[i]);
239            paint.setStrokeMiter(gMiters[i]);
240            canvas->drawPath(fPath[i], paint);
241            canvas->translate(SkIntToScalar(0), fDY[i]);
242        }
243        canvas->restore();
244        canvas->translate(SkIntToScalar(120), SkIntToScalar(0));
245
246        // third column: stroked paths with different widths
247        canvas->save();
248        paint.setStyle(SkPaint::kStroke_Style);
249        paint.setStrokeCap(SkPaint::kButt_Cap);
250        for (size_t i = 0; i < N; i++) {
251            paint.setStrokeWidth(gWidths[i] + 2.0f);
252            paint.setStrokeMiter(gMiters[i]);
253            canvas->drawPath(fPath[i], paint);
254            canvas->translate(SkIntToScalar(0), fDY[i]);
255        }
256        canvas->restore();
257        canvas->translate(SkIntToScalar(120), SkIntToScalar(0));
258
259        // fourth column: stroked and filled paths
260        paint.setStyle(SkPaint::kStrokeAndFill_Style);
261        paint.setStrokeCap(SkPaint::kButt_Cap);
262        for (size_t i = 0; i < N; i++) {
263            paint.setStrokeWidth(gWidths[i]);
264            paint.setStrokeMiter(gMiters[i]);
265            canvas->drawPath(fPath[i], paint);
266            canvas->translate(SkIntToScalar(0), fDY[i]);
267        }
268
269    }
270
271private:
272    typedef skiagm::GM INHERITED;
273};
274
275DEF_GM(return new SmallPathsGM;)
276
277