• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
11 typedef SkScalar (*MakePathProc)(SkPath*);
12 
make_triangle(SkPath * path)13 static SkScalar make_triangle(SkPath* path) {
14     constexpr 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 
make_rect(SkPath * path)25 static 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 
make_oval(SkPath * path)33 static 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 
make_star(SkPath * path,int n)41 static 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 + cosV * r, c + sinV * r);
53     }
54     path->close();
55     return r * 2 * 6 / 5;
56 }
57 
make_star_5(SkPath * path)58 static SkScalar make_star_5(SkPath* path) { return make_star(path, 5); }
make_star_13(SkPath * path)59 static SkScalar make_star_13(SkPath* path) { return make_star(path, 13); }
60 
make_three_line(SkPath * path)61 static 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 
make_arrow(SkPath * path)79 static 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 
make_curve(SkPath * path)97 static 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 
make_battery(SkPath * path)108 static SkScalar make_battery(SkPath* path) {
109     static SkScalar xOffset = 5.0f;
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(50);
132 }
133 
make_battery2(SkPath * path)134 static SkScalar make_battery2(SkPath* path) {
135     static SkScalar xOffset = 225.625f;
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 
157 constexpr 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 
170 constexpr 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 
183 constexpr 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 constexpr SkScalar gXTranslate[] = {
197     0.0f,
198     0.0f,
199     0.0f,
200     0.0f,
201     0.0f,
202     0.0f,
203     0.0f,
204     0.0f,
205     -220.625f,
206     0.0f,
207 };
208 
209 #define N   SK_ARRAY_COUNT(gProcs)
210 
211 // This GM tests out drawing small paths (i.e., for Ganesh, using the Distance
212 // Field path renderer) which are filled, stroked and filledAndStroked. In
213 // particular this ensures that any cache keys in use include the stroking
214 // parameters.
215 class SmallPathsGM : public skiagm::GM {
216     SkPath  fPath[N];
217     SkScalar fDY[N];
218 protected:
onOnceBeforeDraw()219     void onOnceBeforeDraw() override {
220         for (size_t i = 0; i < N; i++) {
221             fDY[i] = gProcs[i](&fPath[i]);
222         }
223     }
224 
onShortName()225     SkString onShortName() override {
226         return SkString("smallpaths");
227     }
228 
onISize()229     SkISize onISize() override {
230         return SkISize::Make(640, 480);
231     }
232 
onDraw(SkCanvas * canvas)233     void onDraw(SkCanvas* canvas) override {
234         SkPaint paint;
235         paint.setAntiAlias(true);
236 
237         // first column: filled paths
238         canvas->save();
239         for (size_t i = 0; i < N; i++) {
240             canvas->drawPath(fPath[i], paint);
241             canvas->translate(gXTranslate[i], fDY[i]);
242         }
243         canvas->restore();
244         canvas->translate(SkIntToScalar(120), SkIntToScalar(0));
245 
246         // second column: stroked paths
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]);
252             paint.setStrokeMiter(gMiters[i]);
253             canvas->drawPath(fPath[i], paint);
254             canvas->translate(gXTranslate[i], fDY[i]);
255         }
256         canvas->restore();
257         canvas->translate(SkIntToScalar(120), SkIntToScalar(0));
258 
259         // third column: stroked paths with different widths
260         canvas->save();
261         paint.setStyle(SkPaint::kStroke_Style);
262         paint.setStrokeCap(SkPaint::kButt_Cap);
263         for (size_t i = 0; i < N; i++) {
264             paint.setStrokeWidth(gWidths[i] + 2.0f);
265             paint.setStrokeMiter(gMiters[i]);
266             canvas->drawPath(fPath[i], paint);
267             canvas->translate(gXTranslate[i], fDY[i]);
268         }
269         canvas->restore();
270         canvas->translate(SkIntToScalar(120), SkIntToScalar(0));
271 
272         // fourth column: stroked and filled paths
273         paint.setStyle(SkPaint::kStrokeAndFill_Style);
274         paint.setStrokeCap(SkPaint::kButt_Cap);
275         for (size_t i = 0; i < N; i++) {
276             paint.setStrokeWidth(gWidths[i]);
277             paint.setStrokeMiter(gMiters[i]);
278             canvas->drawPath(fPath[i], paint);
279             canvas->translate(gXTranslate[i], fDY[i]);
280         }
281 
282     }
283 
284 private:
285     typedef skiagm::GM INHERITED;
286 };
287 
288 DEF_GM(return new SmallPathsGM;)
289