epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2011 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 | */ |
bungeman | d3ebb48 | 2015-08-05 13:57:49 -0700 | [diff] [blame] | 7 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 8 | #include "gm.h" |
bungeman | d3ebb48 | 2015-08-05 13:57:49 -0700 | [diff] [blame] | 9 | #include "SkPath.h" |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 10 | |
| 11 | typedef SkScalar (*MakePathProc)(SkPath*); |
| 12 | |
| 13 | static SkScalar make_frame(SkPath* path) { |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 14 | SkRect r = { SkIntToScalar(10), SkIntToScalar(10), |
| 15 | SkIntToScalar(630), SkIntToScalar(470) }; |
| 16 | path->addRoundRect(r, SkIntToScalar(15), SkIntToScalar(15)); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 17 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 18 | SkPaint paint; |
| 19 | paint.setStyle(SkPaint::kStroke_Style); |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 20 | paint.setStrokeWidth(SkIntToScalar(5)); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 21 | paint.getFillPath(*path, path); |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 22 | return SkIntToScalar(15); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 23 | } |
| 24 | |
| 25 | static SkScalar make_triangle(SkPath* path) { |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 26 | constexpr int gCoord[] = { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 27 | 10, 20, 15, 5, 30, 30 |
| 28 | }; |
| 29 | path->moveTo(SkIntToScalar(gCoord[0]), SkIntToScalar(gCoord[1])); |
| 30 | path->lineTo(SkIntToScalar(gCoord[2]), SkIntToScalar(gCoord[3])); |
| 31 | path->lineTo(SkIntToScalar(gCoord[4]), SkIntToScalar(gCoord[5])); |
| 32 | path->close(); |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 33 | path->offset(SkIntToScalar(10), SkIntToScalar(0)); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 34 | return SkIntToScalar(30); |
| 35 | } |
| 36 | |
| 37 | static SkScalar make_rect(SkPath* path) { |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 38 | SkRect r = { SkIntToScalar(10), SkIntToScalar(10), |
| 39 | SkIntToScalar(30), SkIntToScalar(30) }; |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 40 | path->addRect(r); |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 41 | path->offset(SkIntToScalar(10), SkIntToScalar(0)); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 42 | return SkIntToScalar(30); |
| 43 | } |
| 44 | |
| 45 | static SkScalar make_oval(SkPath* path) { |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 46 | SkRect r = { SkIntToScalar(10), SkIntToScalar(10), |
| 47 | SkIntToScalar(30), SkIntToScalar(30) }; |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 48 | path->addOval(r); |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 49 | path->offset(SkIntToScalar(10), SkIntToScalar(0)); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 50 | return SkIntToScalar(30); |
| 51 | } |
| 52 | |
Jim Van Verth | ecdb686 | 2016-12-13 18:17:47 -0500 | [diff] [blame] | 53 | static SkScalar make_sawtooth(SkPath* path, int teeth) { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 54 | SkScalar x = SkIntToScalar(20); |
| 55 | SkScalar y = SkIntToScalar(20); |
| 56 | const SkScalar x0 = x; |
Jim Van Verth | ecdb686 | 2016-12-13 18:17:47 -0500 | [diff] [blame] | 57 | const SkScalar dx = SkIntToScalar(5); |
| 58 | const SkScalar dy = SkIntToScalar(10); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 59 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 60 | path->moveTo(x, y); |
Jim Van Verth | ecdb686 | 2016-12-13 18:17:47 -0500 | [diff] [blame] | 61 | for (int i = 0; i < teeth; i++) { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 62 | x += dx; |
| 63 | path->lineTo(x, y - dy); |
| 64 | x += dx; |
| 65 | path->lineTo(x, y + dy); |
| 66 | } |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 67 | path->lineTo(x, y + (2 * dy)); |
| 68 | path->lineTo(x0, y + (2 * dy)); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 69 | path->close(); |
| 70 | return SkIntToScalar(30); |
| 71 | } |
| 72 | |
Jim Van Verth | ecdb686 | 2016-12-13 18:17:47 -0500 | [diff] [blame] | 73 | static SkScalar make_sawtooth_3(SkPath* path) { return make_sawtooth(path, 3); } |
| 74 | static SkScalar make_sawtooth_32(SkPath* path) { return make_sawtooth(path, 32); } |
| 75 | |
| 76 | static SkScalar make_house(SkPath* path) { |
| 77 | path->moveTo(21, 23); |
| 78 | path->lineTo(21, 11.534f); |
| 79 | path->lineTo(22.327f, 12.741f); |
| 80 | path->lineTo(23.673f, 11.261f); |
| 81 | path->lineTo(12, 0.648f); |
| 82 | path->lineTo(8, 4.285f); |
| 83 | path->lineTo(8, 2); |
| 84 | path->lineTo(4, 2); |
| 85 | path->lineTo(4, 7.921f); |
| 86 | path->lineTo(0.327f, 11.26f); |
| 87 | path->lineTo(1.673f, 12.74f); |
| 88 | path->lineTo(3, 11.534f); |
| 89 | path->lineTo(3, 23); |
| 90 | path->lineTo(11, 23); |
| 91 | path->lineTo(11, 18); |
| 92 | path->lineTo(13, 18); |
| 93 | path->lineTo(13, 23); |
| 94 | path->lineTo(21, 23); |
| 95 | path->close(); |
| 96 | path->lineTo(9, 16); |
| 97 | path->lineTo(9, 21); |
| 98 | path->lineTo(5, 21); |
| 99 | path->lineTo(5, 9.715f); |
| 100 | path->lineTo(12, 3.351f); |
| 101 | path->lineTo(19, 9.715f); |
| 102 | path->lineTo(19, 21); |
| 103 | path->lineTo(15, 21); |
| 104 | path->lineTo(15, 16); |
| 105 | path->lineTo(9, 16); |
| 106 | path->close(); |
| 107 | path->offset(20, 0); |
| 108 | return SkIntToScalar(30); |
| 109 | } |
| 110 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 111 | static SkScalar make_star(SkPath* path, int n) { |
| 112 | const SkScalar c = SkIntToScalar(45); |
| 113 | const SkScalar r = SkIntToScalar(20); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 114 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 115 | SkScalar rad = -SK_ScalarPI / 2; |
| 116 | const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 117 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 118 | path->moveTo(c, c - r); |
| 119 | for (int i = 1; i < n; i++) { |
| 120 | rad += drad; |
| 121 | SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV); |
Mike Reed | df85c38 | 2017-02-14 10:59:19 -0500 | [diff] [blame] | 122 | path->lineTo(c + cosV * r, c + sinV * r); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 123 | } |
| 124 | path->close(); |
| 125 | return r * 2 * 6 / 5; |
| 126 | } |
| 127 | |
| 128 | static SkScalar make_star_5(SkPath* path) { return make_star(path, 5); } |
| 129 | static SkScalar make_star_13(SkPath* path) { return make_star(path, 13); } |
| 130 | |
vandebo@chromium.org | 683001c | 2012-05-09 17:17:51 +0000 | [diff] [blame] | 131 | // We don't expect any output from this path. |
| 132 | static SkScalar make_line(SkPath* path) { |
| 133 | path->moveTo(SkIntToScalar(30), SkIntToScalar(30)); |
| 134 | path->lineTo(SkIntToScalar(120), SkIntToScalar(40)); |
| 135 | path->close(); |
| 136 | path->moveTo(SkIntToScalar(150), SkIntToScalar(30)); |
| 137 | path->lineTo(SkIntToScalar(150), SkIntToScalar(30)); |
| 138 | path->lineTo(SkIntToScalar(300), SkIntToScalar(40)); |
| 139 | path->close(); |
| 140 | return SkIntToScalar(40); |
| 141 | } |
| 142 | |
Jim Van Verth | f9e678d | 2017-02-15 15:46:52 -0500 | [diff] [blame] | 143 | static void make_info(SkPath* path) { |
Jim Van Verth | 7704754 | 2017-01-11 14:17:00 -0500 | [diff] [blame] | 144 | path->moveTo(24, 4); |
| 145 | path->cubicTo(12.94999980926514f, |
| 146 | 4, |
| 147 | 4, |
| 148 | 12.94999980926514f, |
| 149 | 4, |
| 150 | 24); |
| 151 | path->cubicTo(4, |
| 152 | 35.04999923706055f, |
| 153 | 12.94999980926514f, |
| 154 | 44, |
| 155 | 24, |
| 156 | 44); |
| 157 | path->cubicTo(35.04999923706055f, |
| 158 | 44, |
| 159 | 44, |
| 160 | 35.04999923706055f, |
| 161 | 44, |
| 162 | 24); |
| 163 | path->cubicTo(44, |
| 164 | 12.95000076293945f, |
| 165 | 35.04999923706055f, |
| 166 | 4, |
| 167 | 24, |
| 168 | 4); |
| 169 | path->close(); |
| 170 | path->moveTo(26, 34); |
| 171 | path->lineTo(22, 34); |
| 172 | path->lineTo(22, 22); |
| 173 | path->lineTo(26, 22); |
| 174 | path->lineTo(26, 34); |
| 175 | path->close(); |
| 176 | path->moveTo(26, 18); |
| 177 | path->lineTo(22, 18); |
| 178 | path->lineTo(22, 14); |
| 179 | path->lineTo(26, 14); |
| 180 | path->lineTo(26, 18); |
| 181 | path->close(); |
Jim Van Verth | f9e678d | 2017-02-15 15:46:52 -0500 | [diff] [blame] | 182 | } |
Jim Van Verth | 7704754 | 2017-01-11 14:17:00 -0500 | [diff] [blame] | 183 | |
Jim Van Verth | f9e678d | 2017-02-15 15:46:52 -0500 | [diff] [blame] | 184 | static void make_accessibility(SkPath* path) { |
| 185 | path->moveTo(12, 2); |
| 186 | path->cubicTo(13.10000038146973f, |
| 187 | 2, |
| 188 | 14, |
| 189 | 2.900000095367432f, |
| 190 | 14, |
| 191 | 4); |
| 192 | path->cubicTo(14, |
| 193 | 5.099999904632568f, |
| 194 | 13.10000038146973f, |
| 195 | 6, |
| 196 | 12, |
| 197 | 6); |
| 198 | path->cubicTo(10.89999961853027f, |
| 199 | 6, |
| 200 | 10, |
| 201 | 5.099999904632568f, |
| 202 | 10, |
| 203 | 4); |
| 204 | path->cubicTo(10, |
| 205 | 2.900000095367432f, |
| 206 | 10.89999961853027f, |
| 207 | 2, |
| 208 | 12, |
| 209 | 2); |
| 210 | path->close(); |
| 211 | path->moveTo(21, 9); |
| 212 | path->lineTo(15, 9); |
| 213 | path->lineTo(15, 22); |
| 214 | path->lineTo(13, 22); |
| 215 | path->lineTo(13, 16); |
| 216 | path->lineTo(11, 16); |
| 217 | path->lineTo(11, 22); |
| 218 | path->lineTo(9, 22); |
| 219 | path->lineTo(9, 9); |
| 220 | path->lineTo(3, 9); |
| 221 | path->lineTo(3, 7); |
| 222 | path->lineTo(21, 7); |
| 223 | path->lineTo(21, 9); |
| 224 | path->close(); |
Jim Van Verth | 7704754 | 2017-01-11 14:17:00 -0500 | [diff] [blame] | 225 | } |
| 226 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 227 | constexpr MakePathProc gProcs[] = { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 228 | make_frame, |
| 229 | make_triangle, |
| 230 | make_rect, |
| 231 | make_oval, |
Jim Van Verth | ecdb686 | 2016-12-13 18:17:47 -0500 | [diff] [blame] | 232 | make_sawtooth_32, |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 233 | make_star_5, |
vandebo@chromium.org | 683001c | 2012-05-09 17:17:51 +0000 | [diff] [blame] | 234 | make_star_13, |
| 235 | make_line, |
Jim Van Verth | ecdb686 | 2016-12-13 18:17:47 -0500 | [diff] [blame] | 236 | make_house, |
| 237 | make_sawtooth_3, |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 238 | }; |
| 239 | |
| 240 | #define N SK_ARRAY_COUNT(gProcs) |
| 241 | |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 242 | class PathFillGM : public skiagm::GM { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 243 | SkPath fPath[N]; |
| 244 | SkScalar fDY[N]; |
Jim Van Verth | 7704754 | 2017-01-11 14:17:00 -0500 | [diff] [blame] | 245 | SkPath fInfoPath; |
Jim Van Verth | f9e678d | 2017-02-15 15:46:52 -0500 | [diff] [blame] | 246 | SkPath fAccessibilityPath; |
caryclark | 88c748a | 2015-02-18 10:56:00 -0800 | [diff] [blame] | 247 | protected: |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 248 | void onOnceBeforeDraw() override { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 249 | for (size_t i = 0; i < N; i++) { |
| 250 | fDY[i] = gProcs[i](&fPath[i]); |
| 251 | } |
Jim Van Verth | 7704754 | 2017-01-11 14:17:00 -0500 | [diff] [blame] | 252 | |
Jim Van Verth | f9e678d | 2017-02-15 15:46:52 -0500 | [diff] [blame] | 253 | make_info(&fInfoPath); |
| 254 | make_accessibility(&fAccessibilityPath); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 255 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 256 | |
commit-bot@chromium.org | a90c680 | 2014-04-30 13:20:45 +0000 | [diff] [blame] | 257 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 258 | SkString onShortName() override { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 259 | return SkString("pathfill"); |
| 260 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 261 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 262 | SkISize onISize() override { |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 263 | return SkISize::Make(640, 480); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 264 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 265 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 266 | void onDraw(SkCanvas* canvas) override { |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 267 | SkPaint paint; |
| 268 | paint.setAntiAlias(true); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 269 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 270 | for (size_t i = 0; i < N; i++) { |
| 271 | canvas->drawPath(fPath[i], paint); |
bungeman@google.com | 3c14d0f | 2011-05-20 14:05:03 +0000 | [diff] [blame] | 272 | canvas->translate(SkIntToScalar(0), fDY[i]); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 273 | } |
Jim Van Verth | 7704754 | 2017-01-11 14:17:00 -0500 | [diff] [blame] | 274 | |
Jim Van Verth | f9e678d | 2017-02-15 15:46:52 -0500 | [diff] [blame] | 275 | canvas->save(); |
Jim Van Verth | 7704754 | 2017-01-11 14:17:00 -0500 | [diff] [blame] | 276 | canvas->scale(0.300000011920929f, 0.300000011920929f); |
| 277 | canvas->translate(50, 50); |
| 278 | canvas->drawPath(fInfoPath, paint); |
Jim Van Verth | f9e678d | 2017-02-15 15:46:52 -0500 | [diff] [blame] | 279 | canvas->restore(); |
| 280 | |
| 281 | canvas->scale(2, 2); |
| 282 | canvas->translate(5, 15); |
| 283 | canvas->drawPath(fAccessibilityPath, paint); |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 284 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 285 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 286 | private: |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 287 | typedef skiagm::GM INHERITED; |
| 288 | }; |
| 289 | |
| 290 | // test inverse-fill w/ a clip that completely excludes the geometry |
| 291 | class PathInverseFillGM : public skiagm::GM { |
| 292 | SkPath fPath[N]; |
| 293 | SkScalar fDY[N]; |
caryclark | 88c748a | 2015-02-18 10:56:00 -0800 | [diff] [blame] | 294 | protected: |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 295 | void onOnceBeforeDraw() override { |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 296 | for (size_t i = 0; i < N; i++) { |
| 297 | fDY[i] = gProcs[i](&fPath[i]); |
| 298 | } |
| 299 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 300 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 301 | SkString onShortName() override { |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 302 | return SkString("pathinvfill"); |
| 303 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 304 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 305 | SkISize onISize() override { |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 306 | return SkISize::Make(450, 220); |
| 307 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 308 | |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 309 | static void show(SkCanvas* canvas, const SkPath& path, const SkPaint& paint, |
| 310 | const SkRect* clip, SkScalar top, const SkScalar bottom) { |
| 311 | canvas->save(); |
| 312 | if (clip) { |
| 313 | SkRect r = *clip; |
| 314 | r.fTop = top; |
| 315 | r.fBottom = bottom; |
| 316 | canvas->clipRect(r); |
| 317 | } |
| 318 | canvas->drawPath(path, paint); |
| 319 | canvas->restore(); |
| 320 | } |
| 321 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 322 | void onDraw(SkCanvas* canvas) override { |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 323 | SkPath path; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 324 | |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 325 | path.addCircle(SkIntToScalar(50), SkIntToScalar(50), SkIntToScalar(40)); |
| 326 | path.toggleInverseFillType(); |
| 327 | |
| 328 | SkRect clipR = { 0, 0, SkIntToScalar(100), SkIntToScalar(200) }; |
| 329 | |
| 330 | canvas->translate(SkIntToScalar(10), SkIntToScalar(10)); |
| 331 | |
| 332 | for (int doclip = 0; doclip <= 1; ++doclip) { |
| 333 | for (int aa = 0; aa <= 1; ++aa) { |
| 334 | SkPaint paint; |
| 335 | paint.setAntiAlias(SkToBool(aa)); |
| 336 | |
| 337 | canvas->save(); |
| 338 | canvas->clipRect(clipR); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 339 | |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 340 | const SkRect* clipPtr = doclip ? &clipR : nullptr; |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 341 | |
| 342 | show(canvas, path, paint, clipPtr, clipR.fTop, clipR.centerY()); |
| 343 | show(canvas, path, paint, clipPtr, clipR.centerY(), clipR.fBottom); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 344 | |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 345 | canvas->restore(); |
| 346 | canvas->translate(SkIntToScalar(110), 0); |
| 347 | } |
| 348 | } |
| 349 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 350 | |
reed@google.com | 5ee6491 | 2012-06-11 17:30:33 +0000 | [diff] [blame] | 351 | private: |
| 352 | typedef skiagm::GM INHERITED; |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 353 | }; |
| 354 | |
caryclark | e3e8c72 | 2016-03-01 09:42:03 -0800 | [diff] [blame] | 355 | DEF_SIMPLE_GM(rotatedcubicpath, canvas, 200, 200) { |
| 356 | SkPaint p; |
| 357 | p.setAntiAlias(true); |
| 358 | p.setStyle(SkPaint::kFill_Style); |
| 359 | |
| 360 | canvas->translate(50, 50); |
| 361 | SkPath path; |
| 362 | path.moveTo(48,-23); |
| 363 | path.cubicTo(48,-29.5, 6,-30, 6,-30); |
| 364 | path.cubicTo(6,-30, 2,0, 2,0); |
| 365 | path.cubicTo(2,0, 44,-21.5, 48,-23); |
| 366 | path.close(); |
| 367 | |
| 368 | p.setColor(SK_ColorBLUE); |
| 369 | canvas->drawPath(path, p); |
| 370 | |
| 371 | // Rotated path, which is not antialiased on GPU |
| 372 | p.setColor(SK_ColorRED); |
| 373 | canvas->rotate(90); |
| 374 | canvas->drawPath(path, p); |
| 375 | } |
| 376 | |
reed@google.com | c280700 | 2011-04-11 13:57:04 +0000 | [diff] [blame] | 377 | /////////////////////////////////////////////////////////////////////////////// |
| 378 | |
scroggo | 96f16e8 | 2015-12-10 13:31:59 -0800 | [diff] [blame] | 379 | DEF_GM( return new PathFillGM; ) |
| 380 | DEF_GM( return new PathInverseFillGM; ) |