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 "SkPolyUtils.h" 10 #include "SkPathPriv.h" 11 12 static void create_ngon(int n, SkPoint* pts, SkScalar width, SkScalar height) { 13 float angleStep = 360.0f / n, angle = 0.0f, sin, cos; 14 if ((n % 2) == 1) { 15 angle = angleStep/2.0f; 16 } 17 18 for (int i = 0; i < n; ++i) { 19 sin = SkScalarSinCos(SkDegreesToRadians(angle), &cos); 20 pts[i].fX = -sin * width; 21 pts[i].fY = cos * height; 22 angle += angleStep; 23 } 24 } 25 26 namespace ConvexLineOnlyData { 27 // narrow rect 28 const SkPoint gPoints0[] = { 29 { -1.5f, -50.0f }, 30 { 1.5f, -50.0f }, 31 { 1.5f, 50.0f }, 32 { -1.5f, 50.0f } 33 }; 34 // narrow rect on an angle 35 const SkPoint gPoints1[] = { 36 { -50.0f, -49.0f }, 37 { -49.0f, -50.0f }, 38 { 50.0f, 49.0f }, 39 { 49.0f, 50.0f } 40 }; 41 // trap - narrow on top - wide on bottom 42 const SkPoint gPoints2[] = { 43 { -10.0f, -50.0f }, 44 { 10.0f, -50.0f }, 45 { 50.0f, 50.0f }, 46 { -50.0f, 50.0f } 47 }; 48 // wide skewed rect 49 const SkPoint gPoints3[] = { 50 { -50.0f, -50.0f }, 51 { 0.0f, -50.0f }, 52 { 50.0f, 50.0f }, 53 { 0.0f, 50.0f } 54 }; 55 // thin rect with colinear-ish lines 56 const SkPoint gPoints4[] = { 57 { -6.0f, -50.0f }, 58 { 4.0f, -50.0f }, 59 #if SK_TREAT_COLINEAR_DIAGONAL_POINTS_AS_CONCAVE == 0 60 { 5.0f, -25.0f }, // remove if collinear diagonal points are not concave 61 #endif 62 { 6.0f, 0.0f }, 63 #if SK_TREAT_COLINEAR_DIAGONAL_POINTS_AS_CONCAVE == 0 64 { 5.0f, 25.0f }, // remove if collinear diagonal points are not concave 65 #endif 66 { 4.0f, 50.0f }, 67 { -4.0f, 50.0f } 68 }; 69 // degenerate 70 const SkPoint gPoints5[] = { 71 { -0.025f, -0.025f }, 72 { 0.025f, -0.025f }, 73 { 0.025f, 0.025f }, 74 { -0.025f, 0.025f } 75 }; 76 // Triangle in which the first point should fuse with last 77 const SkPoint gPoints6[] = { 78 { -20.0f, -13.0f }, 79 { -20.0f, -13.05f }, 80 { 20.0f, -13.0f }, 81 { 20.0f, 27.0f } 82 }; 83 // thin rect with colinear lines 84 const SkPoint gPoints7[] = { 85 { -10.0f, -50.0f }, 86 { 10.0f, -50.0f }, 87 { 10.0f, -25.0f }, 88 { 10.0f, 0.0f }, 89 { 10.0f, 25.0f }, 90 { 10.0f, 50.0f }, 91 { -10.0f, 50.0f } 92 }; 93 // capped teardrop 94 const SkPoint gPoints8[] = { 95 { 50.00f, 50.00f }, 96 { 0.00f, 50.00f }, 97 { -15.45f, 47.55f }, 98 { -29.39f, 40.45f }, 99 { -40.45f, 29.39f }, 100 { -47.55f, 15.45f }, 101 { -50.00f, 0.00f }, 102 { -47.55f, -15.45f }, 103 { -40.45f, -29.39f }, 104 { -29.39f, -40.45f }, 105 { -15.45f, -47.55f }, 106 { 0.00f, -50.00f }, 107 { 50.00f, -50.00f } 108 }; 109 // teardrop 110 const SkPoint gPoints9[] = { 111 { 4.39f, 40.45f }, 112 { -9.55f, 47.55f }, 113 { -25.00f, 50.00f }, 114 { -40.45f, 47.55f }, 115 { -54.39f, 40.45f }, 116 { -65.45f, 29.39f }, 117 { -72.55f, 15.45f }, 118 { -75.00f, 0.00f }, 119 { -72.55f, -15.45f }, 120 { -65.45f, -29.39f }, 121 { -54.39f, -40.45f }, 122 { -40.45f, -47.55f }, 123 { -25.0f, -50.0f }, 124 { -9.55f, -47.55f }, 125 { 4.39f, -40.45f }, 126 { 75.00f, 0.00f } 127 }; 128 // clipped triangle 129 const SkPoint gPoints10[] = { 130 { -10.0f, -50.0f }, 131 { 10.0f, -50.0f }, 132 { 50.0f, 31.0f }, 133 { 40.0f, 50.0f }, 134 { -40.0f, 50.0f }, 135 { -50.0f, 31.0f }, 136 }; 137 138 const SkPoint* gPoints[] = { 139 gPoints0, gPoints1, gPoints2, gPoints3, gPoints4, gPoints5, gPoints6, 140 gPoints7, gPoints8, gPoints9, gPoints10, 141 }; 142 143 const size_t gSizes[] = { 144 SK_ARRAY_COUNT(gPoints0), 145 SK_ARRAY_COUNT(gPoints1), 146 SK_ARRAY_COUNT(gPoints2), 147 SK_ARRAY_COUNT(gPoints3), 148 SK_ARRAY_COUNT(gPoints4), 149 SK_ARRAY_COUNT(gPoints5), 150 SK_ARRAY_COUNT(gPoints6), 151 SK_ARRAY_COUNT(gPoints7), 152 SK_ARRAY_COUNT(gPoints8), 153 SK_ARRAY_COUNT(gPoints9), 154 SK_ARRAY_COUNT(gPoints10), 155 }; 156 static_assert(SK_ARRAY_COUNT(gSizes) == SK_ARRAY_COUNT(gPoints), "array_mismatch"); 157 } 158 159 namespace skiagm { 160 161 // This GM is intended to exercise Ganesh's handling of convex line-only 162 // paths 163 class ConvexLineOnlyPathsGM : public GM { 164 public: 165 ConvexLineOnlyPathsGM(bool doStrokeAndFill) : fDoStrokeAndFill(doStrokeAndFill) { 166 this->setBGColor(0xFFFFFFFF); 167 } 168 169 protected: 170 SkString onShortName() override { 171 if (fDoStrokeAndFill) { 172 return SkString("convex-lineonly-paths-stroke-and-fill"); 173 } 174 return SkString("convex-lineonly-paths"); 175 } 176 SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); } 177 bool runAsBench() const override { return true; } 178 179 static SkPath GetPath(int index, SkPath::Direction dir) { 180 std::unique_ptr<SkPoint[]> data(nullptr); 181 const SkPoint* points; 182 int numPts; 183 if (index < (int) SK_ARRAY_COUNT(ConvexLineOnlyData::gPoints)) { 184 // manually specified 185 points = ConvexLineOnlyData::gPoints[index]; 186 numPts = (int)ConvexLineOnlyData::gSizes[index]; 187 } else { 188 // procedurally generated 189 SkScalar width = kMaxPathHeight/2; 190 SkScalar height = kMaxPathHeight/2; 191 switch (index-SK_ARRAY_COUNT(ConvexLineOnlyData::gPoints)) { 192 case 0: 193 numPts = 3; 194 break; 195 case 1: 196 numPts = 4; 197 break; 198 case 2: 199 numPts = 5; 200 break; 201 case 3: // squashed pentagon 202 numPts = 5; 203 width = kMaxPathHeight/5; 204 break; 205 case 4: 206 numPts = 6; 207 break; 208 case 5: 209 numPts = 8; 210 break; 211 case 6: // squashed octogon 212 numPts = 8; 213 width = kMaxPathHeight/5; 214 break; 215 case 7: 216 numPts = 20; 217 break; 218 case 8: 219 numPts = 100; 220 break; 221 default: 222 numPts = 3; 223 break; 224 } 225 226 data.reset(new SkPoint[numPts]); 227 228 create_ngon(numPts, data.get(), width, height); 229 points = data.get(); 230 } 231 232 SkPath path; 233 234 if (SkPath::kCW_Direction == dir) { 235 path.moveTo(points[0]); 236 for (int i = 1; i < numPts; ++i) { 237 path.lineTo(points[i]); 238 } 239 } else { 240 path.moveTo(points[numPts-1]); 241 for (int i = numPts-2; i >= 0; --i) { 242 path.lineTo(points[i]); 243 } 244 } 245 246 path.close(); 247 #ifdef SK_DEBUG 248 // Each path this method returns should be convex, only composed of 249 // lines, wound the right direction, and short enough to fit in one 250 // of the GMs rows. 251 SkASSERT(path.isConvex()); 252 SkASSERT(SkPath::kLine_SegmentMask == path.getSegmentMasks()); 253 SkPathPriv::FirstDirection actualDir; 254 SkASSERT(SkPathPriv::CheapComputeFirstDirection(path, &actualDir)); 255 SkASSERT(SkPathPriv::AsFirstDirection(dir) == actualDir); 256 SkRect bounds = path.getBounds(); 257 SkASSERT(SkScalarNearlyEqual(bounds.centerX(), 0.0f)); 258 SkASSERT(bounds.height() <= kMaxPathHeight); 259 #endif 260 return path; 261 } 262 263 // Draw a single path several times, shrinking it, flipping its direction 264 // and changing its start vertex each time. 265 void drawPath(SkCanvas* canvas, int index, SkPoint* offset) { 266 267 SkPoint center; 268 { 269 SkPath path = GetPath(index, SkPath::kCW_Direction); 270 if (offset->fX+path.getBounds().width() > kGMWidth) { 271 offset->fX = 0; 272 offset->fY += kMaxPathHeight; 273 if (fDoStrokeAndFill) { 274 offset->fX += kStrokeWidth / 2.0f; 275 offset->fY += kStrokeWidth / 2.0f; 276 } 277 } 278 center = { offset->fX + SkScalarHalf(path.getBounds().width()), offset->fY}; 279 offset->fX += path.getBounds().width(); 280 if (fDoStrokeAndFill) { 281 offset->fX += kStrokeWidth; 282 } 283 } 284 285 const SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE }; 286 const SkPath::Direction dirs[2] = { SkPath::kCW_Direction, SkPath::kCCW_Direction }; 287 const float scales[] = { 1.0f, 0.75f, 0.5f, 0.25f, 0.1f, 0.01f, 0.001f }; 288 const SkPaint::Join joins[3] = { SkPaint::kRound_Join, 289 SkPaint::kBevel_Join, 290 SkPaint::kMiter_Join }; 291 292 SkPaint paint; 293 paint.setAntiAlias(true); 294 295 for (size_t i = 0; i < SK_ARRAY_COUNT(scales); ++i) { 296 SkPath path = GetPath(index, dirs[i%2]); 297 if (fDoStrokeAndFill) { 298 paint.setStyle(SkPaint::kStrokeAndFill_Style); 299 paint.setStrokeJoin(joins[i%3]); 300 paint.setStrokeWidth(SkIntToScalar(kStrokeWidth)); 301 } 302 303 canvas->save(); 304 canvas->translate(center.fX, center.fY); 305 canvas->scale(scales[i], scales[i]); 306 paint.setColor(colors[i%2]); 307 canvas->drawPath(path, paint); 308 canvas->restore(); 309 } 310 } 311 312 void onDraw(SkCanvas* canvas) override { 313 // the right edge of the last drawn path 314 SkPoint offset = { 0, SkScalarHalf(kMaxPathHeight) }; 315 if (fDoStrokeAndFill) { 316 offset.fX += kStrokeWidth / 2.0f; 317 offset.fY += kStrokeWidth / 2.0f; 318 } 319 320 for (int i = 0; i < kNumPaths; ++i) { 321 this->drawPath(canvas, i, &offset); 322 } 323 324 { 325 // Repro for crbug.com/472723 (Missing AA on portions of graphic with GPU rasterization) 326 327 SkPaint p; 328 p.setAntiAlias(true); 329 if (fDoStrokeAndFill) { 330 p.setStyle(SkPaint::kStrokeAndFill_Style); 331 p.setStrokeJoin(SkPaint::kMiter_Join); 332 p.setStrokeWidth(SkIntToScalar(kStrokeWidth)); 333 } 334 335 SkPath p1; 336 p1.moveTo(60.8522949f, 364.671021f); 337 p1.lineTo(59.4380493f, 364.671021f); 338 p1.lineTo(385.414276f, 690.647217f); 339 p1.lineTo(386.121399f, 689.940125f); 340 canvas->save(); 341 canvas->translate(356.0f, 50.0f); 342 canvas->drawPath(p1, p); 343 canvas->restore(); 344 345 // Repro for crbug.com/869172 (SVG path incorrectly simplified when using GPU 346 // Rasterization). This will only draw anything in the stroke-and-fill version. 347 SkPath p2; 348 p2.moveTo(10.f, 0.f); 349 p2.lineTo(38.f, 0.f); 350 p2.lineTo(66.f, 0.f); 351 p2.lineTo(94.f, 0.f); 352 p2.lineTo(122.f, 0.f); 353 p2.lineTo(150.f, 0.f); 354 p2.lineTo(150.f, 0.f); 355 p2.lineTo(122.f, 0.f); 356 p2.lineTo(94.f, 0.f); 357 p2.lineTo(66.f, 0.f); 358 p2.lineTo(38.f, 0.f); 359 p2.lineTo(10.f, 0.f); 360 p2.close(); 361 canvas->save(); 362 canvas->translate(0.0f, 500.0f); 363 canvas->drawPath(p2, p); 364 canvas->restore(); 365 366 // Repro for crbug.com/856137. This path previously caused GrAAConvexTessellator to turn 367 // inset rings into outsets when adjacent bisector angles converged outside the previous 368 // ring due to accumulated error. 369 SkPath p3; 370 p3.setFillType(SkPath::kEvenOdd_FillType); 371 p3.moveTo(1184.96f, 982.557f); 372 p3.lineTo(1183.71f, 982.865f); 373 p3.lineTo(1180.99f, 982.734f); 374 p3.lineTo(1178.5f, 981.541f); 375 p3.lineTo(1176.35f, 979.367f); 376 p3.lineTo(1178.94f, 938.854f); 377 p3.lineTo(1181.35f, 936.038f); 378 p3.lineTo(1183.96f, 934.117f); 379 p3.lineTo(1186.67f, 933.195f); 380 p3.lineTo(1189.36f, 933.342f); 381 p3.lineTo(1191.58f, 934.38f); 382 p3.close(); 383 canvas->save(); 384 SkMatrix m; 385 m.setAll(0.0893210843f, 0, 79.1197586f, 0, 0.0893210843f, 300, 0, 0, 1); 386 canvas->concat(m); 387 canvas->drawPath(p3, p); 388 canvas->restore(); 389 } 390 } 391 392 private: 393 static constexpr int kStrokeWidth = 10; 394 static constexpr int kNumPaths = 20; 395 static constexpr int kMaxPathHeight = 100; 396 static constexpr int kGMWidth = 512; 397 static constexpr int kGMHeight = 512; 398 399 bool fDoStrokeAndFill; 400 401 typedef GM INHERITED; 402 }; 403 404 ////////////////////////////////////////////////////////////////////////////// 405 406 DEF_GM(return new ConvexLineOnlyPathsGM(false);) 407 DEF_GM(return new ConvexLineOnlyPathsGM(true);) 408 } 409
