/* * Copyright 2013 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "gm.h" #include "SkCanvas.h" #include "SkPath.h" #include "SkTArray.h" namespace skiagm { class HairlinesGM : public GM { protected: SkString onShortName() override { return SkString("hairlines"); } SkISize onISize() override { return SkISize::Make(1250, 1250); } void onOnceBeforeDraw() override { { SkPath* lineAnglesPath = &fPaths.push_back(); enum { kNumAngles = 15, kRadius = 40, }; for (int i = 0; i < kNumAngles; ++i) { SkScalar angle = SK_ScalarPI * SkIntToScalar(i) / kNumAngles; SkScalar x = kRadius * SkScalarCos(angle); SkScalar y = kRadius * SkScalarSin(angle); lineAnglesPath->moveTo(x, y); lineAnglesPath->lineTo(-x, -y); } } { SkPath* kindaTightQuad = &fPaths.push_back(); kindaTightQuad->moveTo(0, -10 * SK_Scalar1); kindaTightQuad->quadTo(SkIntToScalar(100), SkIntToScalar(100), -10 * SK_Scalar1, 0); } { SkPath* tightQuad = &fPaths.push_back(); tightQuad->moveTo(0, -5 * SK_Scalar1); tightQuad->quadTo(SkIntToScalar(100), SkIntToScalar(100), -5 * SK_Scalar1, 0); } { SkPath* tighterQuad = &fPaths.push_back(); tighterQuad->moveTo(0, -2 * SK_Scalar1); tighterQuad->quadTo(SkIntToScalar(100), SkIntToScalar(100), -2 * SK_Scalar1, 0); } { SkPath* unevenTighterQuad = &fPaths.push_back(); unevenTighterQuad->moveTo(0, -1 * SK_Scalar1); SkPoint p; p.set(-2 * SK_Scalar1 + 3 * SkIntToScalar(102) / 4, SkIntToScalar(75)); unevenTighterQuad->quadTo(SkIntToScalar(100), SkIntToScalar(100), p.fX, p.fY); } { SkPath* reallyTightQuad = &fPaths.push_back(); reallyTightQuad->moveTo(0, -1 * SK_Scalar1); reallyTightQuad->quadTo(SkIntToScalar(100), SkIntToScalar(100), -1 * SK_Scalar1, 0); } { SkPath* closedQuad = &fPaths.push_back(); closedQuad->moveTo(0, -0); closedQuad->quadTo(SkIntToScalar(100), SkIntToScalar(100), 0, 0); } { SkPath* unevenClosedQuad = &fPaths.push_back(); unevenClosedQuad->moveTo(0, -0); unevenClosedQuad->quadTo(SkIntToScalar(100), SkIntToScalar(100), SkIntToScalar(75), SkIntToScalar(75)); } // Two problem cases for gpu hairline renderer found by shapeops testing. These used // to assert that the computed bounding box didn't contain all the vertices. { SkPath* problem1 = &fPaths.push_back(); problem1->moveTo(SkIntToScalar(4), SkIntToScalar(6)); problem1->cubicTo(SkIntToScalar(5), SkIntToScalar(6), SkIntToScalar(5), SkIntToScalar(4), SkIntToScalar(4), SkIntToScalar(0)); problem1->close(); } { SkPath* problem2 = &fPaths.push_back(); problem2->moveTo(SkIntToScalar(5), SkIntToScalar(1)); problem2->lineTo(4.32787323f, 1.67212653f); problem2->cubicTo(2.75223875f, 3.24776125f, 3.00581908f, 4.51236057f, 3.7580452f, 4.37367964f); problem2->cubicTo(4.66472578f, 3.888381f, 5.f, 2.875f, 5.f, 1.f); problem2->close(); } // Three paths that show the same bug (missing end caps) { // A caret (crbug.com/131770) SkPath* bug0 = &fPaths.push_back(); bug0->moveTo(6.5f,5.5f); bug0->lineTo(3.5f,0.5f); bug0->moveTo(0.5f,5.5f); bug0->lineTo(3.5f,0.5f); } { // An X (crbug.com/137317) SkPath* bug1 = &fPaths.push_back(); bug1->moveTo(1, 1); bug1->lineTo(6, 6); bug1->moveTo(1, 6); bug1->lineTo(6, 1); } { // A right angle (crbug.com/137465 and crbug.com/256776) SkPath* bug2 = &fPaths.push_back(); bug2->moveTo(5.5f, 5.5f); bug2->lineTo(5.5f, 0.5f); bug2->lineTo(0.5f, 0.5f); } { // Arc example to test imperfect truncation bug (crbug.com/295626) constexpr SkScalar kRad = SkIntToScalar(2000); constexpr SkScalar kStartAngle = 262.59717f; constexpr SkScalar kSweepAngle = SkScalarHalf(17.188717f); SkPath* bug = &fPaths.push_back(); // Add a circular arc SkRect circle = SkRect::MakeLTRB(-kRad, -kRad, kRad, kRad); bug->addArc(circle, kStartAngle, kSweepAngle); // Now add the chord that should cap the circular arc SkScalar cosV, sinV = SkScalarSinCos(SkDegreesToRadians(kStartAngle), &cosV); SkPoint p0 = SkPoint::Make(kRad * cosV, kRad * sinV); sinV = SkScalarSinCos(SkDegreesToRadians(kStartAngle + kSweepAngle), &cosV); SkPoint p1 = SkPoint::Make(kRad * cosV, kRad * sinV); bug->moveTo(p0); bug->lineTo(p1); } } void onDraw(SkCanvas* canvas) override { constexpr SkAlpha kAlphaValue[] = { 0xFF, 0x40 }; constexpr SkScalar kWidths[] = { 0, 0.5f, 1.5f }; enum { kMargin = 5, }; int wrapX = 1250 - kMargin; SkScalar maxH = 0; canvas->translate(SkIntToScalar(kMargin), SkIntToScalar(kMargin)); canvas->save(); SkScalar x = SkIntToScalar(kMargin); for (int p = 0; p < fPaths.count(); ++p) { for (size_t a = 0; a < SK_ARRAY_COUNT(kAlphaValue); ++a) { for (int aa = 0; aa < 2; ++aa) { for (size_t w = 0; w < SK_ARRAY_COUNT(kWidths); w++) { const SkRect& bounds = fPaths[p].getBounds(); if (x + bounds.width() > wrapX) { canvas->restore(); canvas->translate(0, maxH + SkIntToScalar(kMargin)); canvas->save(); maxH = 0; x = SkIntToScalar(kMargin); } SkPaint paint; paint.setARGB(kAlphaValue[a], 0, 0, 0); paint.setAntiAlias(SkToBool(aa)); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(kWidths[w]); canvas->save(); canvas->translate(-bounds.fLeft, -bounds.fTop); canvas->drawPath(fPaths[p], paint); canvas->restore(); maxH = SkMaxScalar(maxH, bounds.height()); SkScalar dx = bounds.width() + SkIntToScalar(kMargin); x += dx; canvas->translate(dx, 0); } } } } canvas->restore(); } private: SkTArray fPaths; typedef GM INHERITED; }; static void draw_squarehair_tests(SkCanvas* canvas, SkScalar width, SkPaint::Cap cap, bool aa) { SkPaint paint; paint.setStrokeCap(cap); paint.setStrokeWidth(width); paint.setAntiAlias(aa); paint.setStyle(SkPaint::kStroke_Style); canvas->drawLine(10, 10, 20, 10, paint); canvas->drawLine(30, 10, 30, 20, paint); canvas->drawLine(40, 10, 50, 20, paint); SkPath path; path.moveTo(60, 10); path.quadTo(60, 20, 70, 20); path.conicTo(70, 10, 80, 10, 0.707f); canvas->drawPath(path, paint); path.reset(); path.moveTo(90, 10); path.cubicTo(90, 20, 100, 20, 100, 10); path.lineTo(110, 10); canvas->drawPath(path, paint); canvas->translate(0, 30); } DEF_SIMPLE_GM(squarehair, canvas, 240, 360) { const bool aliases[] = { false, true }; const SkScalar widths[] = { 0, 0.999f, 1, 1.001f }; const SkPaint::Cap caps[] = { SkPaint::kButt_Cap, SkPaint::kSquare_Cap, SkPaint::kRound_Cap }; for (auto alias : aliases) { canvas->save(); for (auto width : widths) { for (auto cap : caps) { draw_squarehair_tests(canvas, width, cap, alias); } } canvas->restore(); canvas->translate(120, 0); } } ////////////////////////////////////////////////////////////////////////////// static GM* MyFactory(void*) { return new HairlinesGM; } static GMRegistry reg(MyFactory); }