OLD | NEW |
(Empty) | |
| 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 |
| 13 static 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 |
| 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 |
| 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 |
| 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 + SkScalarMul(cosV, r), c + SkScalarMul(sinV, r)); |
| 53 } |
| 54 path->close(); |
| 55 return r * 2 * 6 / 5; |
| 56 } |
| 57 |
| 58 static SkScalar make_star_5(SkPath* path) { return make_star(path, 5); } |
| 59 static SkScalar make_star_13(SkPath* path) { return make_star(path, 13); } |
| 60 |
| 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 |
| 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 |
| 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 |
| 108 static 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 |
| 134 static 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 |
| 157 static 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 |
| 170 static 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 |
| 183 static 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. |
| 202 class SmallPathsGM : public skiagm::GM { |
| 203 SkPath fPath[N]; |
| 204 SkScalar fDY[N]; |
| 205 protected: |
| 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 |
| 271 private: |
| 272 typedef skiagm::GM INHERITED; |
| 273 }; |
| 274 |
| 275 DEF_GM(return new SmallPathsGM;) |
| 276 |
OLD | NEW |