gm/convex_all_line_paths.cpp - skia - Git at Google

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "gm/gm.h"
 #include "include/core/SkCanvas.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkMatrix.h"
 #include "include/core/SkPaint.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
 #include "src/core/SkPathPriv.h"

 #include <memory>

 static void create_ngon(int n, SkPoint* pts, SkScalar width, SkScalar height) {
     float angleStep = 360.0f / n, angle = 0.0f;
     if ((n % 2) == 1) {
         angle = angleStep/2.0f;
     }

     for (int i = 0; i < n; ++i) {
         pts[i].fX = -SkScalarSin(SkDegreesToRadians(angle)) * width;
         pts[i].fY =  SkScalarCos(SkDegreesToRadians(angle)) * height;
         angle += angleStep;
     }
 }

 namespace ConvexLineOnlyData {
 // narrow rect
 const SkPoint gPoints0[] = {
     { -1.5f, -50.0f },
     { 1.5f, -50.0f },
     { 1.5f,  50.0f },
     { -1.5f,  50.0f }
 };
 // narrow rect on an angle
 const SkPoint gPoints1[] = {
     { -50.0f, -49.0f },
     { -49.0f, -50.0f },
     { 50.0f,  49.0f },
     { 49.0f,  50.0f }
 };
 // trap - narrow on top - wide on bottom
 const SkPoint gPoints2[] = {
     { -10.0f, -50.0f },
     { 10.0f, -50.0f },
     { 50.0f,  50.0f },
     { -50.0f,  50.0f }
 };
 // wide skewed rect
 const SkPoint gPoints3[] = {
     { -50.0f, -50.0f },
     { 0.0f, -50.0f },
     { 50.0f,  50.0f },
     { 0.0f,  50.0f }
 };
 // thin rect with colinear-ish lines
 const SkPoint gPoints4[] = {
     { -6.0f, -50.0f },
     { 4.0f, -50.0f },
     { 5.0f, -25.0f },  // remove if collinear diagonal points are not concave
     { 6.0f,   0.0f },
     { 5.0f,  25.0f },  // remove if collinear diagonal points are not concave
     { 4.0f,  50.0f },
     { -4.0f,  50.0f }
 };
 // degenerate
 const SkPoint gPoints5[] = {
     { -0.025f, -0.025f },
     { 0.025f, -0.025f },
     { 0.025f,  0.025f },
     { -0.025f,  0.025f }
 };
 // Triangle in which the first point should fuse with last
 const SkPoint gPoints6[] = {
     { -20.0f, -13.0f },
     { -20.0f, -13.05f },
     { 20.0f, -13.0f },
     { 20.0f,  27.0f }
 };
 // thin rect with colinear lines
 const SkPoint gPoints7[] = {
     { -10.0f, -50.0f },
     { 10.0f, -50.0f },
     { 10.0f, -25.0f },
     { 10.0f,   0.0f },
     { 10.0f,  25.0f },
     { 10.0f,  50.0f },
     { -10.0f,  50.0f }
 };
 // capped teardrop
 const SkPoint gPoints8[] = {
     { 50.00f,  50.00f },
     { 0.00f,  50.00f },
     { -15.45f,  47.55f },
     { -29.39f,  40.45f },
     { -40.45f,  29.39f },
     { -47.55f,  15.45f },
     { -50.00f,   0.00f },
     { -47.55f, -15.45f },
     { -40.45f, -29.39f },
     { -29.39f, -40.45f },
     { -15.45f, -47.55f },
     { 0.00f, -50.00f },
     { 50.00f, -50.00f }
 };
 // teardrop
 const SkPoint gPoints9[] = {
     { 4.39f,  40.45f },
     { -9.55f,  47.55f },
     { -25.00f,  50.00f },
     { -40.45f,  47.55f },
     { -54.39f,  40.45f },
     { -65.45f,  29.39f },
     { -72.55f,  15.45f },
     { -75.00f,   0.00f },
     { -72.55f, -15.45f },
     { -65.45f, -29.39f },
     { -54.39f, -40.45f },
     { -40.45f, -47.55f },
     { -25.0f,  -50.0f },
     { -9.55f, -47.55f },
     { 4.39f, -40.45f },
     { 75.00f,   0.00f }
 };
 // clipped triangle
 const SkPoint gPoints10[] = {
     { -10.0f, -50.0f },
     { 10.0f, -50.0f },
     { 50.0f,  31.0f },
     { 40.0f,  50.0f },
     { -40.0f,  50.0f },
     { -50.0f,  31.0f },
 };

 const SkPoint* gPoints[] = {
     gPoints0, gPoints1, gPoints2, gPoints3, gPoints4, gPoints5, gPoints6,
     gPoints7, gPoints8, gPoints9, gPoints10,
 };

 const size_t gSizes[] = {
     std::size(gPoints0),
     std::size(gPoints1),
     std::size(gPoints2),
     std::size(gPoints3),
     std::size(gPoints4),
     std::size(gPoints5),
     std::size(gPoints6),
     std::size(gPoints7),
     std::size(gPoints8),
     std::size(gPoints9),
     std::size(gPoints10),
 };
 static_assert(std::size(gSizes) == std::size(gPoints), "array_mismatch");
 }  // namespace ConvexLineOnlyData

 namespace skiagm {

 // This GM is intended to exercise Ganesh's handling of convex line-only
 // paths
 class ConvexLineOnlyPathsGM : public GM {
 public:
     ConvexLineOnlyPathsGM(bool doStrokeAndFill) : fDoStrokeAndFill(doStrokeAndFill) {
         this->setBGColor(0xFFFFFFFF);
     }

 protected:
     SkString onShortName() override {
         if (fDoStrokeAndFill) {
             return SkString("convex-lineonly-paths-stroke-and-fill");
         }
         return SkString("convex-lineonly-paths");
     }
     SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); }
     bool runAsBench() const override { return true; }

     static SkPath GetPath(int index, SkPathDirection dir) {
         std::unique_ptr<SkPoint[]> data(nullptr);
         const SkPoint* points;
         int numPts;
         if (index < (int) std::size(ConvexLineOnlyData::gPoints)) {
             // manually specified
             points = ConvexLineOnlyData::gPoints[index];
             numPts = (int)ConvexLineOnlyData::gSizes[index];
         } else {
             // procedurally generated
             SkScalar width = kMaxPathHeight/2;
             SkScalar height = kMaxPathHeight/2;
             switch (index-std::size(ConvexLineOnlyData::gPoints)) {
             case 0:
                 numPts = 3;
                 break;
             case 1:
                 numPts = 4;
                 break;
             case 2:
                 numPts = 5;
                 break;
             case 3:             // squashed pentagon
                 numPts = 5;
                 width = kMaxPathHeight/5;
                 break;
             case 4:
                 numPts = 6;
                 break;
             case 5:
                 numPts = 8;
                 break;
             case 6:              // squashed octogon
                 numPts = 8;
                 width = kMaxPathHeight/5;
                 break;
             case 7:
                 numPts = 20;
                 break;
             case 8:
                 numPts = 100;
                 break;
             default:
                 numPts = 3;
                 break;
             }

             data = std::make_unique<SkPoint[]>(numPts);

             create_ngon(numPts, data.get(), width, height);
             points = data.get();
         }

         SkPathBuilder builder;

         if (SkPathDirection::kCW == dir) {
             builder.moveTo(points[0]);
             for (int i = 1; i < numPts; ++i) {
                 builder.lineTo(points[i]);
             }
         } else {
             builder.moveTo(points[numPts-1]);
             for (int i = numPts-2; i >= 0; --i) {
                 builder.lineTo(points[i]);
             }
         }

         builder.close();
         SkPath path = builder.detach();
 #ifdef SK_DEBUG
         // Each path this method returns should be convex, only composed of
         // lines, wound the right direction, and short enough to fit in one
         // of the GMs rows.
         SkASSERT(path.isConvex());
         SkASSERT(SkPath::kLine_SegmentMask == path.getSegmentMasks());
         SkPathFirstDirection actualDir = SkPathPriv::ComputeFirstDirection(path);
         SkASSERT(SkPathPriv::AsFirstDirection(dir) == actualDir);
         SkRect bounds = path.getBounds();
         SkASSERT(SkScalarNearlyEqual(bounds.centerX(), 0.0f));
         SkASSERT(bounds.height() <= kMaxPathHeight);
 #endif
         return path;
     }

     // Draw a single path several times, shrinking it, flipping its direction
     // and changing its start vertex each time.
     void drawPath(SkCanvas* canvas, int index, SkPoint* offset) {

         SkPoint center;
         {
             SkPath path = GetPath(index, SkPathDirection::kCW);
             if (offset->fX+path.getBounds().width() > kGMWidth) {
                 offset->fX = 0;
                 offset->fY += kMaxPathHeight;
                 if (fDoStrokeAndFill) {
                     offset->fX += kStrokeWidth / 2.0f;
                     offset->fY += kStrokeWidth / 2.0f;
                 }
             }
             center = { offset->fX + SkScalarHalf(path.getBounds().width()), offset->fY};
             offset->fX += path.getBounds().width();
             if (fDoStrokeAndFill) {
                 offset->fX += kStrokeWidth;
             }
         }

         const SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE };
         const SkPathDirection dirs[2] = { SkPathDirection::kCW, SkPathDirection::kCCW };
         const float scales[] = { 1.0f, 0.75f, 0.5f, 0.25f, 0.1f, 0.01f, 0.001f };
         const SkPaint::Join joins[3] = { SkPaint::kRound_Join,
                                          SkPaint::kBevel_Join,
                                          SkPaint::kMiter_Join };

         SkPaint paint;
         paint.setAntiAlias(true);

         for (size_t i = 0; i < std::size(scales); ++i) {
             SkPath path = GetPath(index, dirs[i%2]);
             if (fDoStrokeAndFill) {
                 paint.setStyle(SkPaint::kStrokeAndFill_Style);
                 paint.setStrokeJoin(joins[i%3]);
                 paint.setStrokeWidth(SkIntToScalar(kStrokeWidth));
             }

             canvas->save();
                 canvas->translate(center.fX, center.fY);
                 canvas->scale(scales[i], scales[i]);
                 paint.setColor(colors[i%2]);
                 canvas->drawPath(path, paint);
             canvas->restore();
         }
     }

     void onDraw(SkCanvas* canvas) override {
         // the right edge of the last drawn path
         SkPoint offset = { 0, SkScalarHalf(kMaxPathHeight) };
         if (fDoStrokeAndFill) {
             offset.fX += kStrokeWidth / 2.0f;
             offset.fY += kStrokeWidth / 2.0f;
         }

         for (int i = 0; i < kNumPaths; ++i) {
             this->drawPath(canvas, i, &offset);
         }

         {
             // Repro for crbug.com/472723 (Missing AA on portions of graphic with GPU rasterization)

             SkPaint p;
             p.setAntiAlias(true);
             if (fDoStrokeAndFill) {
                 p.setStyle(SkPaint::kStrokeAndFill_Style);
                 p.setStrokeJoin(SkPaint::kMiter_Join);
                 p.setStrokeWidth(SkIntToScalar(kStrokeWidth));
             }

             SkPath p1 = SkPath::Polygon({
                 {60.8522949f, 364.671021f},
                 {59.4380493f, 364.671021f},
                 {385.414276f, 690.647217f},
                 {386.121399f, 689.940125f},
             }, false);
             canvas->save();
             canvas->translate(356.0f, 50.0f);
             canvas->drawPath(p1, p);
             canvas->restore();

             // Repro for crbug.com/869172 (SVG path incorrectly simplified when using GPU
             // Rasterization). This will only draw anything in the stroke-and-fill version.
             SkPath p2 = SkPath::Polygon({
                 {10.f, 0.f},
                 {38.f, 0.f},
                 {66.f, 0.f},
                 {94.f, 0.f},
                 {122.f, 0.f},
                 {150.f, 0.f},
                 {150.f, 0.f},
                 {122.f, 0.f},
                 {94.f, 0.f},
                 {66.f, 0.f},
                 {38.f, 0.f},
                 {10.f, 0.f},
             }, true);
             canvas->save();
             canvas->translate(0.0f, 500.0f);
             canvas->drawPath(p2, p);
             canvas->restore();

             // Repro for crbug.com/856137. This path previously caused GrAAConvexTessellator to turn
             // inset rings into outsets when adjacent bisector angles converged outside the previous
             // ring due to accumulated error.
             SkPath p3 = SkPath::Polygon({
                 {1184.96f, 982.557f},
                 {1183.71f, 982.865f},
                 {1180.99f, 982.734f},
                 {1178.5f,  981.541f},
                 {1176.35f, 979.367f},
                 {1178.94f, 938.854f},
                 {1181.35f, 936.038f},
                 {1183.96f, 934.117f},
                 {1186.67f, 933.195f},
                 {1189.36f, 933.342f},
                 {1191.58f, 934.38f},
             }, true, SkPathFillType::kEvenOdd);
             canvas->save();
             SkMatrix m;
             m.setAll(0.0893210843f, 0, 79.1197586f, 0, 0.0893210843f, 300, 0, 0, 1);
             canvas->concat(m);
             canvas->drawPath(p3, p);
             canvas->restore();
         }
     }

 private:
     inline static constexpr int kStrokeWidth   = 10;
     inline static constexpr int kNumPaths      = 20;
     inline static constexpr int kMaxPathHeight = 100;
     inline static constexpr int kGMWidth       = 512;
     inline static constexpr int kGMHeight      = 512;

     bool fDoStrokeAndFill;

     using INHERITED = GM;
 };

 //////////////////////////////////////////////////////////////////////////////

 DEF_GM(return new ConvexLineOnlyPathsGM(false);)
 DEF_GM(return new ConvexLineOnlyPathsGM(true);)
 }  // namespace skiagm
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "gm/gm.h"
	#include "include/core/SkCanvas.h"
	#include "include/core/SkColor.h"
	#include "include/core/SkMatrix.h"
	#include "include/core/SkPaint.h"
	#include "include/core/SkPath.h"
	#include "include/core/SkPoint.h"
	#include "include/core/SkRect.h"
	#include "include/core/SkScalar.h"
	#include "include/core/SkSize.h"
	#include "include/core/SkString.h"
	#include "include/core/SkTypes.h"
	#include "src/core/SkPathPriv.h"

	#include <memory>

	static void create_ngon(int n, SkPoint* pts, SkScalar width, SkScalar height) {
	float angleStep = 360.0f / n, angle = 0.0f;
	if ((n % 2) == 1) {
	angle = angleStep/2.0f;
	}

	for (int i = 0; i < n; ++i) {
	pts[i].fX = -SkScalarSin(SkDegreesToRadians(angle)) * width;
	pts[i].fY = SkScalarCos(SkDegreesToRadians(angle)) * height;
	angle += angleStep;
	}
	}

	namespace ConvexLineOnlyData {
	// narrow rect
	const SkPoint gPoints0[] = {
	{ -1.5f, -50.0f },
	{ 1.5f, -50.0f },
	{ 1.5f, 50.0f },
	{ -1.5f, 50.0f }
	};
	// narrow rect on an angle
	const SkPoint gPoints1[] = {
	{ -50.0f, -49.0f },
	{ -49.0f, -50.0f },
	{ 50.0f, 49.0f },
	{ 49.0f, 50.0f }
	};
	// trap - narrow on top - wide on bottom
	const SkPoint gPoints2[] = {
	{ -10.0f, -50.0f },
	{ 10.0f, -50.0f },
	{ 50.0f, 50.0f },
	{ -50.0f, 50.0f }
	};
	// wide skewed rect
	const SkPoint gPoints3[] = {
	{ -50.0f, -50.0f },
	{ 0.0f, -50.0f },
	{ 50.0f, 50.0f },
	{ 0.0f, 50.0f }
	};
	// thin rect with colinear-ish lines
	const SkPoint gPoints4[] = {
	{ -6.0f, -50.0f },
	{ 4.0f, -50.0f },
	{ 5.0f, -25.0f }, // remove if collinear diagonal points are not concave
	{ 6.0f, 0.0f },
	{ 5.0f, 25.0f }, // remove if collinear diagonal points are not concave
	{ 4.0f, 50.0f },
	{ -4.0f, 50.0f }
	};
	// degenerate
	const SkPoint gPoints5[] = {
	{ -0.025f, -0.025f },
	{ 0.025f, -0.025f },
	{ 0.025f, 0.025f },
	{ -0.025f, 0.025f }
	};
	// Triangle in which the first point should fuse with last
	const SkPoint gPoints6[] = {
	{ -20.0f, -13.0f },
	{ -20.0f, -13.05f },
	{ 20.0f, -13.0f },
	{ 20.0f, 27.0f }
	};
	// thin rect with colinear lines
	const SkPoint gPoints7[] = {
	{ -10.0f, -50.0f },
	{ 10.0f, -50.0f },
	{ 10.0f, -25.0f },
	{ 10.0f, 0.0f },
	{ 10.0f, 25.0f },
	{ 10.0f, 50.0f },
	{ -10.0f, 50.0f }
	};
	// capped teardrop
	const SkPoint gPoints8[] = {
	{ 50.00f, 50.00f },
	{ 0.00f, 50.00f },
	{ -15.45f, 47.55f },
	{ -29.39f, 40.45f },
	{ -40.45f, 29.39f },
	{ -47.55f, 15.45f },
	{ -50.00f, 0.00f },
	{ -47.55f, -15.45f },
	{ -40.45f, -29.39f },
	{ -29.39f, -40.45f },
	{ -15.45f, -47.55f },
	{ 0.00f, -50.00f },
	{ 50.00f, -50.00f }
	};
	// teardrop
	const SkPoint gPoints9[] = {
	{ 4.39f, 40.45f },
	{ -9.55f, 47.55f },
	{ -25.00f, 50.00f },
	{ -40.45f, 47.55f },
	{ -54.39f, 40.45f },
	{ -65.45f, 29.39f },
	{ -72.55f, 15.45f },
	{ -75.00f, 0.00f },
	{ -72.55f, -15.45f },
	{ -65.45f, -29.39f },
	{ -54.39f, -40.45f },
	{ -40.45f, -47.55f },
	{ -25.0f, -50.0f },
	{ -9.55f, -47.55f },
	{ 4.39f, -40.45f },
	{ 75.00f, 0.00f }
	};
	// clipped triangle
	const SkPoint gPoints10[] = {
	{ -10.0f, -50.0f },
	{ 10.0f, -50.0f },
	{ 50.0f, 31.0f },
	{ 40.0f, 50.0f },
	{ -40.0f, 50.0f },
	{ -50.0f, 31.0f },
	};

	const SkPoint* gPoints[] = {
	gPoints0, gPoints1, gPoints2, gPoints3, gPoints4, gPoints5, gPoints6,
	gPoints7, gPoints8, gPoints9, gPoints10,
	};

	const size_t gSizes[] = {
	std::size(gPoints0),
	std::size(gPoints1),
	std::size(gPoints2),
	std::size(gPoints3),
	std::size(gPoints4),
	std::size(gPoints5),
	std::size(gPoints6),
	std::size(gPoints7),
	std::size(gPoints8),
	std::size(gPoints9),
	std::size(gPoints10),
	};
	static_assert(std::size(gSizes) == std::size(gPoints), "array_mismatch");
	} // namespace ConvexLineOnlyData

	namespace skiagm {

	// This GM is intended to exercise Ganesh's handling of convex line-only
	// paths
	class ConvexLineOnlyPathsGM : public GM {
	public:
	ConvexLineOnlyPathsGM(bool doStrokeAndFill) : fDoStrokeAndFill(doStrokeAndFill) {
	this->setBGColor(0xFFFFFFFF);
	}

	protected:
	SkString onShortName() override {
	if (fDoStrokeAndFill) {
	return SkString("convex-lineonly-paths-stroke-and-fill");
	}
	return SkString("convex-lineonly-paths");
	}
	SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); }
	bool runAsBench() const override { return true; }

	static SkPath GetPath(int index, SkPathDirection dir) {
	std::unique_ptr<SkPoint[]> data(nullptr);
	const SkPoint* points;
	int numPts;
	if (index < (int) std::size(ConvexLineOnlyData::gPoints)) {
	// manually specified
	points = ConvexLineOnlyData::gPoints[index];
	numPts = (int)ConvexLineOnlyData::gSizes[index];
	} else {
	// procedurally generated
	SkScalar width = kMaxPathHeight/2;
	SkScalar height = kMaxPathHeight/2;
	switch (index-std::size(ConvexLineOnlyData::gPoints)) {
	case 0:
	numPts = 3;
	break;
	case 1:
	numPts = 4;
	break;
	case 2:
	numPts = 5;
	break;
	case 3: // squashed pentagon
	numPts = 5;
	width = kMaxPathHeight/5;
	break;
	case 4:
	numPts = 6;
	break;
	case 5:
	numPts = 8;
	break;
	case 6: // squashed octogon
	numPts = 8;
	width = kMaxPathHeight/5;
	break;
	case 7:
	numPts = 20;
	break;
	case 8:
	numPts = 100;
	break;
	default:
	numPts = 3;
	break;
	}

	data = std::make_unique<SkPoint[]>(numPts);

	create_ngon(numPts, data.get(), width, height);
	points = data.get();
	}

	SkPathBuilder builder;

	if (SkPathDirection::kCW == dir) {
	builder.moveTo(points[0]);
	for (int i = 1; i < numPts; ++i) {
	builder.lineTo(points[i]);
	}
	} else {
	builder.moveTo(points[numPts-1]);
	for (int i = numPts-2; i >= 0; --i) {
	builder.lineTo(points[i]);
	}
	}

	builder.close();
	SkPath path = builder.detach();
	#ifdef SK_DEBUG
	// Each path this method returns should be convex, only composed of
	// lines, wound the right direction, and short enough to fit in one
	// of the GMs rows.
	SkASSERT(path.isConvex());
	SkASSERT(SkPath::kLine_SegmentMask == path.getSegmentMasks());
	SkPathFirstDirection actualDir = SkPathPriv::ComputeFirstDirection(path);
	SkASSERT(SkPathPriv::AsFirstDirection(dir) == actualDir);
	SkRect bounds = path.getBounds();
	SkASSERT(SkScalarNearlyEqual(bounds.centerX(), 0.0f));
	SkASSERT(bounds.height() <= kMaxPathHeight);
	#endif
	return path;
	}

	// Draw a single path several times, shrinking it, flipping its direction
	// and changing its start vertex each time.
	void drawPath(SkCanvas* canvas, int index, SkPoint* offset) {

	SkPoint center;
	{
	SkPath path = GetPath(index, SkPathDirection::kCW);
	if (offset->fX+path.getBounds().width() > kGMWidth) {
	offset->fX = 0;
	offset->fY += kMaxPathHeight;
	if (fDoStrokeAndFill) {
	offset->fX += kStrokeWidth / 2.0f;
	offset->fY += kStrokeWidth / 2.0f;
	}
	}
	center = { offset->fX + SkScalarHalf(path.getBounds().width()), offset->fY};
	offset->fX += path.getBounds().width();
	if (fDoStrokeAndFill) {
	offset->fX += kStrokeWidth;
	}
	}

	const SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE };
	const SkPathDirection dirs[2] = { SkPathDirection::kCW, SkPathDirection::kCCW };
	const float scales[] = { 1.0f, 0.75f, 0.5f, 0.25f, 0.1f, 0.01f, 0.001f };
	const SkPaint::Join joins[3] = { SkPaint::kRound_Join,
	SkPaint::kBevel_Join,
	SkPaint::kMiter_Join };

	SkPaint paint;
	paint.setAntiAlias(true);

	for (size_t i = 0; i < std::size(scales); ++i) {
	SkPath path = GetPath(index, dirs[i%2]);
	if (fDoStrokeAndFill) {
	paint.setStyle(SkPaint::kStrokeAndFill_Style);
	paint.setStrokeJoin(joins[i%3]);
	paint.setStrokeWidth(SkIntToScalar(kStrokeWidth));
	}

	canvas->save();
	canvas->translate(center.fX, center.fY);
	canvas->scale(scales[i], scales[i]);
	paint.setColor(colors[i%2]);
	canvas->drawPath(path, paint);
	canvas->restore();
	}
	}

	void onDraw(SkCanvas* canvas) override {
	// the right edge of the last drawn path
	SkPoint offset = { 0, SkScalarHalf(kMaxPathHeight) };
	if (fDoStrokeAndFill) {
	offset.fX += kStrokeWidth / 2.0f;
	offset.fY += kStrokeWidth / 2.0f;
	}

	for (int i = 0; i < kNumPaths; ++i) {
	this->drawPath(canvas, i, &offset);
	}

	{
	// Repro for crbug.com/472723 (Missing AA on portions of graphic with GPU rasterization)

	SkPaint p;
	p.setAntiAlias(true);
	if (fDoStrokeAndFill) {
	p.setStyle(SkPaint::kStrokeAndFill_Style);
	p.setStrokeJoin(SkPaint::kMiter_Join);
	p.setStrokeWidth(SkIntToScalar(kStrokeWidth));
	}

	SkPath p1 = SkPath::Polygon({
	{60.8522949f, 364.671021f},
	{59.4380493f, 364.671021f},
	{385.414276f, 690.647217f},
	{386.121399f, 689.940125f},
	}, false);
	canvas->save();
	canvas->translate(356.0f, 50.0f);
	canvas->drawPath(p1, p);
	canvas->restore();

	// Repro for crbug.com/869172 (SVG path incorrectly simplified when using GPU
	// Rasterization). This will only draw anything in the stroke-and-fill version.
	SkPath p2 = SkPath::Polygon({
	{10.f, 0.f},
	{38.f, 0.f},
	{66.f, 0.f},
	{94.f, 0.f},
	{122.f, 0.f},
	{150.f, 0.f},
	{150.f, 0.f},
	{122.f, 0.f},
	{94.f, 0.f},
	{66.f, 0.f},
	{38.f, 0.f},
	{10.f, 0.f},
	}, true);
	canvas->save();
	canvas->translate(0.0f, 500.0f);
	canvas->drawPath(p2, p);
	canvas->restore();

	// Repro for crbug.com/856137. This path previously caused GrAAConvexTessellator to turn
	// inset rings into outsets when adjacent bisector angles converged outside the previous
	// ring due to accumulated error.
	SkPath p3 = SkPath::Polygon({
	{1184.96f, 982.557f},
	{1183.71f, 982.865f},
	{1180.99f, 982.734f},
	{1178.5f, 981.541f},
	{1176.35f, 979.367f},
	{1178.94f, 938.854f},
	{1181.35f, 936.038f},
	{1183.96f, 934.117f},
	{1186.67f, 933.195f},
	{1189.36f, 933.342f},
	{1191.58f, 934.38f},
	}, true, SkPathFillType::kEvenOdd);
	canvas->save();
	SkMatrix m;
	m.setAll(0.0893210843f, 0, 79.1197586f, 0, 0.0893210843f, 300, 0, 0, 1);
	canvas->concat(m);
	canvas->drawPath(p3, p);
	canvas->restore();
	}
	}

	private:
	inline static constexpr int kStrokeWidth = 10;
	inline static constexpr int kNumPaths = 20;
	inline static constexpr int kMaxPathHeight = 100;
	inline static constexpr int kGMWidth = 512;
	inline static constexpr int kGMHeight = 512;

	bool fDoStrokeAndFill;

	using INHERITED = GM;
	};

	//////////////////////////////////////////////////////////////////////////////

	DEF_GM(return new ConvexLineOnlyPathsGM(false);)
	DEF_GM(return new ConvexLineOnlyPathsGM(true);)
	} // namespace skiagm