blob: 1294325d23218027e44c085bc56ad6790371764a [file] [log] [blame]
robertphillips72729352015-04-28 07:42:04 -07001/*
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
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "gm/gm.h"
Ben Wagner7fde8e12019-05-01 17:28:53 -04009#include "include/core/SkCanvas.h"
10#include "include/core/SkColor.h"
11#include "include/core/SkMatrix.h"
12#include "include/core/SkPaint.h"
13#include "include/core/SkPath.h"
14#include "include/core/SkPoint.h"
15#include "include/core/SkRect.h"
16#include "include/core/SkScalar.h"
17#include "include/core/SkSize.h"
18#include "include/core/SkString.h"
19#include "include/core/SkTypes.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050020#include "src/core/SkPathPriv.h"
Ben Wagner7fde8e12019-05-01 17:28:53 -040021
22#include <memory>
robertphillips72729352015-04-28 07:42:04 -070023
24static void create_ngon(int n, SkPoint* pts, SkScalar width, SkScalar height) {
Brian Osman4428f2c2019-04-02 10:59:28 -040025 float angleStep = 360.0f / n, angle = 0.0f;
robertphillips72729352015-04-28 07:42:04 -070026 if ((n % 2) == 1) {
27 angle = angleStep/2.0f;
28 }
29
30 for (int i = 0; i < n; ++i) {
Brian Osman4428f2c2019-04-02 10:59:28 -040031 pts[i].fX = -SkScalarSin(SkDegreesToRadians(angle)) * width;
32 pts[i].fY = SkScalarCos(SkDegreesToRadians(angle)) * height;
robertphillips72729352015-04-28 07:42:04 -070033 angle += angleStep;
34 }
35}
36
Brian Salomonab664fa2017-03-24 16:07:20 +000037namespace ConvexLineOnlyData {
38// narrow rect
39const SkPoint gPoints0[] = {
40 { -1.5f, -50.0f },
41 { 1.5f, -50.0f },
42 { 1.5f, 50.0f },
43 { -1.5f, 50.0f }
44};
45// narrow rect on an angle
46const SkPoint gPoints1[] = {
47 { -50.0f, -49.0f },
48 { -49.0f, -50.0f },
49 { 50.0f, 49.0f },
50 { 49.0f, 50.0f }
51};
52// trap - narrow on top - wide on bottom
53const SkPoint gPoints2[] = {
54 { -10.0f, -50.0f },
55 { 10.0f, -50.0f },
56 { 50.0f, 50.0f },
57 { -50.0f, 50.0f }
58};
59// wide skewed rect
60const SkPoint gPoints3[] = {
61 { -50.0f, -50.0f },
62 { 0.0f, -50.0f },
63 { 50.0f, 50.0f },
64 { 0.0f, 50.0f }
65};
66// thin rect with colinear-ish lines
67const SkPoint gPoints4[] = {
68 { -6.0f, -50.0f },
69 { 4.0f, -50.0f },
Cary Clarkc9b7c722018-12-12 14:50:23 -050070 { 5.0f, -25.0f }, // remove if collinear diagonal points are not concave
Brian Salomonab664fa2017-03-24 16:07:20 +000071 { 6.0f, 0.0f },
Cary Clarkc9b7c722018-12-12 14:50:23 -050072 { 5.0f, 25.0f }, // remove if collinear diagonal points are not concave
Brian Salomonab664fa2017-03-24 16:07:20 +000073 { 4.0f, 50.0f },
74 { -4.0f, 50.0f }
75};
76// degenerate
77const SkPoint gPoints5[] = {
78 { -0.025f, -0.025f },
79 { 0.025f, -0.025f },
80 { 0.025f, 0.025f },
81 { -0.025f, 0.025f }
82};
83// Triangle in which the first point should fuse with last
84const SkPoint gPoints6[] = {
85 { -20.0f, -13.0f },
86 { -20.0f, -13.05f },
87 { 20.0f, -13.0f },
88 { 20.0f, 27.0f }
89};
90// thin rect with colinear lines
91const SkPoint gPoints7[] = {
92 { -10.0f, -50.0f },
93 { 10.0f, -50.0f },
94 { 10.0f, -25.0f },
95 { 10.0f, 0.0f },
96 { 10.0f, 25.0f },
97 { 10.0f, 50.0f },
98 { -10.0f, 50.0f }
99};
100// capped teardrop
101const SkPoint gPoints8[] = {
102 { 50.00f, 50.00f },
103 { 0.00f, 50.00f },
104 { -15.45f, 47.55f },
105 { -29.39f, 40.45f },
106 { -40.45f, 29.39f },
107 { -47.55f, 15.45f },
108 { -50.00f, 0.00f },
109 { -47.55f, -15.45f },
110 { -40.45f, -29.39f },
111 { -29.39f, -40.45f },
112 { -15.45f, -47.55f },
113 { 0.00f, -50.00f },
114 { 50.00f, -50.00f }
115};
116// teardrop
117const SkPoint gPoints9[] = {
118 { 4.39f, 40.45f },
119 { -9.55f, 47.55f },
120 { -25.00f, 50.00f },
121 { -40.45f, 47.55f },
122 { -54.39f, 40.45f },
123 { -65.45f, 29.39f },
124 { -72.55f, 15.45f },
125 { -75.00f, 0.00f },
126 { -72.55f, -15.45f },
127 { -65.45f, -29.39f },
128 { -54.39f, -40.45f },
129 { -40.45f, -47.55f },
130 { -25.0f, -50.0f },
131 { -9.55f, -47.55f },
132 { 4.39f, -40.45f },
133 { 75.00f, 0.00f }
134};
135// clipped triangle
136const SkPoint gPoints10[] = {
137 { -10.0f, -50.0f },
138 { 10.0f, -50.0f },
139 { 50.0f, 31.0f },
140 { 40.0f, 50.0f },
141 { -40.0f, 50.0f },
142 { -50.0f, 31.0f },
143};
144
145const SkPoint* gPoints[] = {
146 gPoints0, gPoints1, gPoints2, gPoints3, gPoints4, gPoints5, gPoints6,
147 gPoints7, gPoints8, gPoints9, gPoints10,
148};
149
150const size_t gSizes[] = {
151 SK_ARRAY_COUNT(gPoints0),
152 SK_ARRAY_COUNT(gPoints1),
153 SK_ARRAY_COUNT(gPoints2),
154 SK_ARRAY_COUNT(gPoints3),
155 SK_ARRAY_COUNT(gPoints4),
156 SK_ARRAY_COUNT(gPoints5),
157 SK_ARRAY_COUNT(gPoints6),
158 SK_ARRAY_COUNT(gPoints7),
159 SK_ARRAY_COUNT(gPoints8),
160 SK_ARRAY_COUNT(gPoints9),
161 SK_ARRAY_COUNT(gPoints10),
162};
163static_assert(SK_ARRAY_COUNT(gSizes) == SK_ARRAY_COUNT(gPoints), "array_mismatch");
John Stilesa6841be2020-08-06 14:11:56 -0400164} // namespace ConvexLineOnlyData
Brian Salomonab664fa2017-03-24 16:07:20 +0000165
robertphillips72729352015-04-28 07:42:04 -0700166namespace skiagm {
167
168// This GM is intended to exercise Ganesh's handling of convex line-only
169// paths
170class ConvexLineOnlyPathsGM : public GM {
171public:
robertphillipsad234462016-08-26 05:30:19 -0700172 ConvexLineOnlyPathsGM(bool doStrokeAndFill) : fDoStrokeAndFill(doStrokeAndFill) {
robertphillips72729352015-04-28 07:42:04 -0700173 this->setBGColor(0xFFFFFFFF);
174 }
175
176protected:
robertphillipsad234462016-08-26 05:30:19 -0700177 SkString onShortName() override {
178 if (fDoStrokeAndFill) {
179 return SkString("convex-lineonly-paths-stroke-and-fill");
180 }
181 return SkString("convex-lineonly-paths");
182 }
robertphillips72729352015-04-28 07:42:04 -0700183 SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); }
184 bool runAsBench() const override { return true; }
185
Mike Reed30bc5272019-11-22 18:34:02 +0000186 static SkPath GetPath(int index, SkPathDirection dir) {
Ben Wagner7ecc5962016-11-02 17:07:33 -0400187 std::unique_ptr<SkPoint[]> data(nullptr);
robertphillips72729352015-04-28 07:42:04 -0700188 const SkPoint* points;
189 int numPts;
Brian Salomonab664fa2017-03-24 16:07:20 +0000190 if (index < (int) SK_ARRAY_COUNT(ConvexLineOnlyData::gPoints)) {
robertphillips72729352015-04-28 07:42:04 -0700191 // manually specified
Brian Salomonab664fa2017-03-24 16:07:20 +0000192 points = ConvexLineOnlyData::gPoints[index];
193 numPts = (int)ConvexLineOnlyData::gSizes[index];
robertphillips72729352015-04-28 07:42:04 -0700194 } else {
195 // procedurally generated
196 SkScalar width = kMaxPathHeight/2;
197 SkScalar height = kMaxPathHeight/2;
Brian Salomonab664fa2017-03-24 16:07:20 +0000198 switch (index-SK_ARRAY_COUNT(ConvexLineOnlyData::gPoints)) {
robertphillips72729352015-04-28 07:42:04 -0700199 case 0:
200 numPts = 3;
201 break;
202 case 1:
203 numPts = 4;
204 break;
205 case 2:
206 numPts = 5;
207 break;
208 case 3: // squashed pentagon
209 numPts = 5;
210 width = kMaxPathHeight/5;
211 break;
212 case 4:
213 numPts = 6;
214 break;
215 case 5:
216 numPts = 8;
217 break;
218 case 6: // squashed octogon
219 numPts = 8;
220 width = kMaxPathHeight/5;
221 break;
222 case 7:
223 numPts = 20;
224 break;
225 case 8:
226 numPts = 100;
227 break;
228 default:
229 numPts = 3;
230 break;
231 }
232
John Stilesfbd050b2020-08-03 13:21:46 -0400233 data = std::make_unique<SkPoint[]>(numPts);
robertphillips72729352015-04-28 07:42:04 -0700234
235 create_ngon(numPts, data.get(), width, height);
236 points = data.get();
237 }
238
Mike Reede9d783c2020-08-17 14:14:13 -0400239 SkPathBuilder builder;
robertphillips72729352015-04-28 07:42:04 -0700240
Mike Reed30bc5272019-11-22 18:34:02 +0000241 if (SkPathDirection::kCW == dir) {
Mike Reede9d783c2020-08-17 14:14:13 -0400242 builder.moveTo(points[0]);
robertphillips72729352015-04-28 07:42:04 -0700243 for (int i = 1; i < numPts; ++i) {
Mike Reede9d783c2020-08-17 14:14:13 -0400244 builder.lineTo(points[i]);
robertphillips72729352015-04-28 07:42:04 -0700245 }
246 } else {
Mike Reede9d783c2020-08-17 14:14:13 -0400247 builder.moveTo(points[numPts-1]);
robertphillips72729352015-04-28 07:42:04 -0700248 for (int i = numPts-2; i >= 0; --i) {
Mike Reede9d783c2020-08-17 14:14:13 -0400249 builder.lineTo(points[i]);
robertphillips72729352015-04-28 07:42:04 -0700250 }
251 }
252
Mike Reede9d783c2020-08-17 14:14:13 -0400253 builder.close();
254 SkPath path = builder.detach();
robertphillips72729352015-04-28 07:42:04 -0700255#ifdef SK_DEBUG
256 // Each path this method returns should be convex, only composed of
257 // lines, wound the right direction, and short enough to fit in one
258 // of the GMs rows.
259 SkASSERT(path.isConvex());
260 SkASSERT(SkPath::kLine_SegmentMask == path.getSegmentMasks());
Mike Reed85f51b22020-08-30 10:32:06 -0400261 SkPathFirstDirection actualDir = SkPathPriv::ComputeFirstDirection(path);
reed026beb52015-06-10 14:23:15 -0700262 SkASSERT(SkPathPriv::AsFirstDirection(dir) == actualDir);
robertphillips72729352015-04-28 07:42:04 -0700263 SkRect bounds = path.getBounds();
264 SkASSERT(SkScalarNearlyEqual(bounds.centerX(), 0.0f));
265 SkASSERT(bounds.height() <= kMaxPathHeight);
266#endif
267 return path;
268 }
269
270 // Draw a single path several times, shrinking it, flipping its direction
271 // and changing its start vertex each time.
robertphillips2a974622015-05-08 07:08:13 -0700272 void drawPath(SkCanvas* canvas, int index, SkPoint* offset) {
robertphillips72729352015-04-28 07:42:04 -0700273
274 SkPoint center;
275 {
Mike Reed30bc5272019-11-22 18:34:02 +0000276 SkPath path = GetPath(index, SkPathDirection::kCW);
robertphillips2a974622015-05-08 07:08:13 -0700277 if (offset->fX+path.getBounds().width() > kGMWidth) {
278 offset->fX = 0;
279 offset->fY += kMaxPathHeight;
robertphillipsad234462016-08-26 05:30:19 -0700280 if (fDoStrokeAndFill) {
281 offset->fX += kStrokeWidth / 2.0f;
282 offset->fY += kStrokeWidth / 2.0f;
283 }
robertphillips72729352015-04-28 07:42:04 -0700284 }
robertphillips2a974622015-05-08 07:08:13 -0700285 center = { offset->fX + SkScalarHalf(path.getBounds().width()), offset->fY};
286 offset->fX += path.getBounds().width();
robertphillipsad234462016-08-26 05:30:19 -0700287 if (fDoStrokeAndFill) {
288 offset->fX += kStrokeWidth;
289 }
robertphillips72729352015-04-28 07:42:04 -0700290 }
291
292 const SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE };
Mike Reed30bc5272019-11-22 18:34:02 +0000293 const SkPathDirection dirs[2] = { SkPathDirection::kCW, SkPathDirection::kCCW };
robertphillips72729352015-04-28 07:42:04 -0700294 const float scales[] = { 1.0f, 0.75f, 0.5f, 0.25f, 0.1f, 0.01f, 0.001f };
mtkleindbfd7ab2016-09-01 11:24:54 -0700295 const SkPaint::Join joins[3] = { SkPaint::kRound_Join,
robertphillipsad234462016-08-26 05:30:19 -0700296 SkPaint::kBevel_Join,
297 SkPaint::kMiter_Join };
robertphillips72729352015-04-28 07:42:04 -0700298
299 SkPaint paint;
300 paint.setAntiAlias(true);
301
302 for (size_t i = 0; i < SK_ARRAY_COUNT(scales); ++i) {
Brian Salomonab664fa2017-03-24 16:07:20 +0000303 SkPath path = GetPath(index, dirs[i%2]);
robertphillipsad234462016-08-26 05:30:19 -0700304 if (fDoStrokeAndFill) {
305 paint.setStyle(SkPaint::kStrokeAndFill_Style);
306 paint.setStrokeJoin(joins[i%3]);
307 paint.setStrokeWidth(SkIntToScalar(kStrokeWidth));
308 }
robertphillips72729352015-04-28 07:42:04 -0700309
310 canvas->save();
311 canvas->translate(center.fX, center.fY);
312 canvas->scale(scales[i], scales[i]);
313 paint.setColor(colors[i%2]);
314 canvas->drawPath(path, paint);
315 canvas->restore();
316 }
317 }
318
319 void onDraw(SkCanvas* canvas) override {
robertphillips2a974622015-05-08 07:08:13 -0700320 // the right edge of the last drawn path
halcanary9d524f22016-03-29 09:03:52 -0700321 SkPoint offset = { 0, SkScalarHalf(kMaxPathHeight) };
robertphillipsad234462016-08-26 05:30:19 -0700322 if (fDoStrokeAndFill) {
323 offset.fX += kStrokeWidth / 2.0f;
324 offset.fY += kStrokeWidth / 2.0f;
325 }
robertphillips2a974622015-05-08 07:08:13 -0700326
robertphillips72729352015-04-28 07:42:04 -0700327 for (int i = 0; i < kNumPaths; ++i) {
robertphillips2a974622015-05-08 07:08:13 -0700328 this->drawPath(canvas, i, &offset);
robertphillips72729352015-04-28 07:42:04 -0700329 }
330
robertphillips72729352015-04-28 07:42:04 -0700331 {
Brian Salomon0235c642018-08-31 12:04:18 -0400332 // Repro for crbug.com/472723 (Missing AA on portions of graphic with GPU rasterization)
robertphillips72729352015-04-28 07:42:04 -0700333
334 SkPaint p;
335 p.setAntiAlias(true);
robertphillipsad234462016-08-26 05:30:19 -0700336 if (fDoStrokeAndFill) {
337 p.setStyle(SkPaint::kStrokeAndFill_Style);
338 p.setStrokeJoin(SkPaint::kMiter_Join);
339 p.setStrokeWidth(SkIntToScalar(kStrokeWidth));
340 }
robertphillips72729352015-04-28 07:42:04 -0700341
Mike Reede9d783c2020-08-17 14:14:13 -0400342 SkPath p1 = SkPath::Polygon({
343 {60.8522949f, 364.671021f},
344 {59.4380493f, 364.671021f},
345 {385.414276f, 690.647217f},
346 {386.121399f, 689.940125f},
347 }, false);
Brian Salomon0235c642018-08-31 12:04:18 -0400348 canvas->save();
349 canvas->translate(356.0f, 50.0f);
robertphillips72729352015-04-28 07:42:04 -0700350 canvas->drawPath(p1, p);
Brian Salomon0235c642018-08-31 12:04:18 -0400351 canvas->restore();
352
353 // Repro for crbug.com/869172 (SVG path incorrectly simplified when using GPU
354 // Rasterization). This will only draw anything in the stroke-and-fill version.
Mike Reede9d783c2020-08-17 14:14:13 -0400355 SkPath p2 = SkPath::Polygon({
356 {10.f, 0.f},
357 {38.f, 0.f},
358 {66.f, 0.f},
359 {94.f, 0.f},
360 {122.f, 0.f},
361 {150.f, 0.f},
362 {150.f, 0.f},
363 {122.f, 0.f},
364 {94.f, 0.f},
365 {66.f, 0.f},
366 {38.f, 0.f},
367 {10.f, 0.f},
368 }, true);
Brian Salomon0235c642018-08-31 12:04:18 -0400369 canvas->save();
370 canvas->translate(0.0f, 500.0f);
371 canvas->drawPath(p2, p);
372 canvas->restore();
Brian Salomon8e449eb2018-09-05 15:08:49 -0400373
374 // Repro for crbug.com/856137. This path previously caused GrAAConvexTessellator to turn
375 // inset rings into outsets when adjacent bisector angles converged outside the previous
376 // ring due to accumulated error.
Mike Reede9d783c2020-08-17 14:14:13 -0400377 SkPath p3 = SkPath::Polygon({
378 {1184.96f, 982.557f},
379 {1183.71f, 982.865f},
380 {1180.99f, 982.734f},
381 {1178.5f, 981.541f},
382 {1176.35f, 979.367f},
383 {1178.94f, 938.854f},
384 {1181.35f, 936.038f},
385 {1183.96f, 934.117f},
386 {1186.67f, 933.195f},
387 {1189.36f, 933.342f},
388 {1191.58f, 934.38f},
389 }, true, SkPathFillType::kEvenOdd);
Brian Salomon8e449eb2018-09-05 15:08:49 -0400390 canvas->save();
391 SkMatrix m;
392 m.setAll(0.0893210843f, 0, 79.1197586f, 0, 0.0893210843f, 300, 0, 0, 1);
393 canvas->concat(m);
394 canvas->drawPath(p3, p);
395 canvas->restore();
robertphillips72729352015-04-28 07:42:04 -0700396 }
397 }
398
399private:
mtkleindbfd7ab2016-09-01 11:24:54 -0700400 static constexpr int kStrokeWidth = 10;
401 static constexpr int kNumPaths = 20;
402 static constexpr int kMaxPathHeight = 100;
403 static constexpr int kGMWidth = 512;
404 static constexpr int kGMHeight = 512;
robertphillips72729352015-04-28 07:42:04 -0700405
robertphillipsad234462016-08-26 05:30:19 -0700406 bool fDoStrokeAndFill;
407
John Stiles7571f9e2020-09-02 22:42:33 -0400408 using INHERITED = GM;
robertphillips72729352015-04-28 07:42:04 -0700409};
410
411//////////////////////////////////////////////////////////////////////////////
412
robertphillipsad234462016-08-26 05:30:19 -0700413DEF_GM(return new ConvexLineOnlyPathsGM(false);)
414DEF_GM(return new ConvexLineOnlyPathsGM(true);)
John Stilesa6841be2020-08-06 14:11:56 -0400415} // namespace skiagm