/* * Copyright 2016 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include #include #include "Test.h" #if SK_SUPPORT_GPU #include "GrShape.h" #include "SkCanvas.h" #include "SkDashPathEffect.h" #include "SkPath.h" #include "SkSurface.h" using Key = SkTArray; static bool make_key(Key* key, const GrShape& shape) { int size = shape.unstyledKeySize(); if (size <= 0) { key->reset(0); return false; } SkASSERT(size); key->reset(size); shape.writeUnstyledKey(key->begin()); return true; } static bool test_bounds_by_rasterizing(const SkPath& path, const SkRect& bounds) { static constexpr int kRes = 2000; // This tolerance is in units of 1/kRes fractions of the bounds width/height. static constexpr int kTol = 0; GR_STATIC_ASSERT(kRes % 4 == 0); SkImageInfo info = SkImageInfo::MakeA8(kRes, kRes); sk_sp surface = SkSurface::MakeRaster(info); surface->getCanvas()->clear(0x0); SkRect clip = SkRect::MakeXYWH(kRes/4, kRes/4, kRes/2, kRes/2); SkMatrix matrix; matrix.setRectToRect(bounds, clip, SkMatrix::kFill_ScaleToFit); clip.outset(SkIntToScalar(kTol), SkIntToScalar(kTol)); surface->getCanvas()->clipRect(clip, SkRegion::kDifference_Op); surface->getCanvas()->concat(matrix); SkPaint whitePaint; whitePaint.setColor(SK_ColorWHITE); surface->getCanvas()->drawPath(path, whitePaint); SkPixmap pixmap; surface->getCanvas()->peekPixels(&pixmap); #if defined(SK_BUILD_FOR_WIN) // The static constexpr version in #else causes cl.exe to crash. const uint8_t* kZeros = reinterpret_cast(calloc(kRes, 1)); #else static constexpr uint8_t kZeros[kRes] = {0}; #endif for (int y = 0; y < kRes/4; ++y) { const uint8_t* row = pixmap.addr8(0, y); if (0 != memcmp(kZeros, row, kRes)) { return false; } } #ifdef SK_BUILD_FOR_WIN free(const_cast(kZeros)); #endif return true; } namespace { class TestCase { public: template TestCase(const GEO& geo, const SkPaint& paint, skiatest::Reporter* r, SkScalar scale = SK_Scalar1) : fBase(geo, paint) { this->init(r, scale); } struct SelfExpectations { bool fPEHasEffect; bool fPEHasValidKey; bool fStrokeApplies; }; void testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const; enum ComparisonExpecation { kAllDifferent_ComparisonExpecation, kSameUpToPE_ComparisonExpecation, kSameUpToStroke_ComparisonExpecation, kAllSame_ComparisonExpecation, }; void compare(skiatest::Reporter*, const TestCase& that, ComparisonExpecation) const; const GrShape& baseShape() const { return fBase; } const GrShape& appliedPathEffectShape() const { return fAppliedPE; } const GrShape& appliedFullStyleShape() const { return fAppliedFull; } // The returned array's count will be 0 if the key shape has no key. const Key& baseKey() const { return fBaseKey; } const Key& appliedPathEffectKey() const { return fAppliedPEKey; } const Key& appliedFullStyleKey() const { return fAppliedFullKey; } const Key& appliedPathEffectThenStrokeKey() const { return fAppliedPEThenStrokeKey; } private: static void CheckBounds(skiatest::Reporter* r, const GrShape& shape, const SkRect& bounds) { SkPath path; shape.asPath(&path); // If the bounds are empty, the path ought to be as well. if (bounds.isEmpty()) { REPORTER_ASSERT(r, path.isEmpty()); return; } if (path.isEmpty()) { return; } REPORTER_ASSERT(r, test_bounds_by_rasterizing(path, bounds)); } void init(skiatest::Reporter* r, SkScalar scale) { fAppliedPE = fBase.applyStyle(GrStyle::Apply::kPathEffectOnly, scale); fAppliedPEThenStroke = fAppliedPE.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, scale); fAppliedFull = fBase.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, scale); make_key(&fBaseKey, fBase); make_key(&fAppliedPEKey, fAppliedPE); make_key(&fAppliedPEThenStrokeKey, fAppliedPEThenStroke); make_key(&fAppliedFullKey, fAppliedFull); // Applying the path effect and then the stroke should always be the same as applying // both in one go. REPORTER_ASSERT(r, fAppliedPEThenStrokeKey == fAppliedFullKey); SkPath a, b; fAppliedPEThenStroke.asPath(&a); fAppliedFull.asPath(&b); REPORTER_ASSERT(r, a == b); REPORTER_ASSERT(r, fAppliedFull.isEmpty() == fAppliedPEThenStroke.isEmpty()); SkPath path; fBase.asPath(&path); REPORTER_ASSERT(r, path.isEmpty() == fBase.isEmpty()); fAppliedPE.asPath(&path); REPORTER_ASSERT(r, path.isEmpty() == fAppliedPE.isEmpty()); fAppliedFull.asPath(&path); REPORTER_ASSERT(r, path.isEmpty() == fAppliedFull.isEmpty()); CheckBounds(r, fBase, fBase.bounds()); CheckBounds(r, fAppliedPE, fAppliedPE.bounds()); CheckBounds(r, fAppliedPEThenStroke, fAppliedPEThenStroke.bounds()); CheckBounds(r, fAppliedFull, fAppliedFull.bounds()); SkRect styledBounds; fBase.styledBounds(&styledBounds); CheckBounds(r, fAppliedFull, styledBounds); fAppliedPE.styledBounds(&styledBounds); CheckBounds(r, fAppliedFull, styledBounds); // Check that the same path is produced when style is applied by GrShape and GrStyle. SkPath preStyle; SkPath postPathEffect; SkPath postAllStyle; fBase.asPath(&preStyle); SkStrokeRec postPEStrokeRec(SkStrokeRec::kFill_InitStyle); if (fBase.style().applyPathEffectToPath(&postPathEffect, &postPEStrokeRec, preStyle, scale)) { // run postPathEffect through GrShape to get any geometry reductions that would have // occurred to fAppliedPE. GrShape(postPathEffect, GrStyle(postPEStrokeRec, nullptr)).asPath(&postPathEffect); SkPath testPath; fAppliedPE.asPath(&testPath); REPORTER_ASSERT(r, testPath == postPathEffect); REPORTER_ASSERT(r, postPEStrokeRec.hasEqualEffect(fAppliedPE.style().strokeRec())); } SkStrokeRec::InitStyle fillOrHairline; if (fBase.style().applyToPath(&postAllStyle, &fillOrHairline, preStyle, scale)) { // run postPathEffect through GrShape to get any reductions that would have occurred // to fAppliedFull. GrShape(postAllStyle, GrStyle(fillOrHairline)).asPath(&postAllStyle); SkPath testPath; fAppliedFull.asPath(&testPath); REPORTER_ASSERT(r, testPath == postAllStyle); if (fillOrHairline == SkStrokeRec::kFill_InitStyle) { REPORTER_ASSERT(r, fAppliedFull.style().isSimpleFill()); } else { REPORTER_ASSERT(r, fAppliedFull.style().isSimpleHairline()); } } } GrShape fBase; GrShape fAppliedPE; GrShape fAppliedPEThenStroke; GrShape fAppliedFull; Key fBaseKey; Key fAppliedPEKey; Key fAppliedPEThenStrokeKey; Key fAppliedFullKey; }; void TestCase::testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const { // The base's key should always be valid (unless the path is volatile) REPORTER_ASSERT(reporter, fBaseKey.count()); if (expectations.fPEHasEffect) { REPORTER_ASSERT(reporter, fBaseKey != fAppliedPEKey); REPORTER_ASSERT(reporter, expectations.fPEHasValidKey == SkToBool(fAppliedPEKey.count())); REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey); REPORTER_ASSERT(reporter, expectations.fPEHasValidKey == SkToBool(fAppliedFullKey.count())); if (expectations.fStrokeApplies && expectations.fPEHasValidKey) { REPORTER_ASSERT(reporter, fAppliedPEKey != fAppliedFullKey); REPORTER_ASSERT(reporter, SkToBool(fAppliedFullKey.count())); } } else { REPORTER_ASSERT(reporter, fBaseKey == fAppliedPEKey); SkPath a, b; fBase.asPath(&a); fAppliedPE.asPath(&b); REPORTER_ASSERT(reporter, a == b); if (expectations.fStrokeApplies) { REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey); } else { REPORTER_ASSERT(reporter, fBaseKey == fAppliedFullKey); } } } void TestCase::compare(skiatest::Reporter* reporter, const TestCase& that, ComparisonExpecation expectation) const { SkPath a, b; switch (expectation) { case kAllDifferent_ComparisonExpecation: REPORTER_ASSERT(reporter, fBaseKey != that.fBaseKey); REPORTER_ASSERT(reporter, fAppliedPEKey != that.fAppliedPEKey); REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey); break; case kSameUpToPE_ComparisonExpecation: REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey); fBase.asPath(&a); that.fBase.asPath(&b); REPORTER_ASSERT(reporter, a == b); REPORTER_ASSERT(reporter, fBase.isEmpty() == that.fBase.isEmpty()); REPORTER_ASSERT(reporter, fAppliedPEKey != that.fAppliedPEKey); REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey); break; case kSameUpToStroke_ComparisonExpecation: REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey); fBase.asPath(&a); that.fBase.asPath(&b); REPORTER_ASSERT(reporter, a == b); REPORTER_ASSERT(reporter, fBase.isEmpty() == that.fBase.isEmpty()); REPORTER_ASSERT(reporter, fAppliedPEKey == that.fAppliedPEKey); fAppliedPE.asPath(&a); that.fAppliedPE.asPath(&b); REPORTER_ASSERT(reporter, a == b); REPORTER_ASSERT(reporter, fAppliedPE.isEmpty() == that.fAppliedPE.isEmpty()); REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey); break; case kAllSame_ComparisonExpecation: REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey); fBase.asPath(&a); that.fBase.asPath(&b); REPORTER_ASSERT(reporter, a == b); REPORTER_ASSERT(reporter, fBase.isEmpty() == that.fBase.isEmpty()); REPORTER_ASSERT(reporter, fAppliedPEKey == that.fAppliedPEKey); fAppliedPE.asPath(&a); that.fAppliedPE.asPath(&b); REPORTER_ASSERT(reporter, a == b); REPORTER_ASSERT(reporter, fAppliedPE.isEmpty() == that.fAppliedPE.isEmpty()); REPORTER_ASSERT(reporter, fAppliedFullKey == that.fAppliedFullKey); fAppliedFull.asPath(&a); that.fAppliedFull.asPath(&b); REPORTER_ASSERT(reporter, a == b); REPORTER_ASSERT(reporter, fAppliedFull.isEmpty() == that.fAppliedFull.isEmpty()); break; } } } // namespace static sk_sp make_dash() { static const SkScalar kIntervals[] = { 0.25, 3.f, 0.5, 2.f }; static const SkScalar kPhase = 0.75; return SkDashPathEffect::Make(kIntervals, SK_ARRAY_COUNT(kIntervals), kPhase); } static sk_sp make_null_dash() { static const SkScalar kNullIntervals[] = {0, 0, 0, 0, 0, 0}; return SkDashPathEffect::Make(kNullIntervals, SK_ARRAY_COUNT(kNullIntervals), 0.f); } template static void test_basic(skiatest::Reporter* reporter, const GEO& geo) { sk_sp dashPE = make_dash(); TestCase::SelfExpectations expectations; SkPaint fill; TestCase fillCase(geo, fill, reporter); expectations.fPEHasEffect = false; expectations.fPEHasValidKey = false; expectations.fStrokeApplies = false; fillCase.testExpectations(reporter, expectations); // Test that another GrShape instance built from the same primitive is the same. TestCase(geo, fill, reporter).compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation); SkPaint stroke2RoundBevel; stroke2RoundBevel.setStyle(SkPaint::kStroke_Style); stroke2RoundBevel.setStrokeCap(SkPaint::kRound_Cap); stroke2RoundBevel.setStrokeJoin(SkPaint::kBevel_Join); stroke2RoundBevel.setStrokeWidth(2.f); TestCase stroke2RoundBevelCase(geo, stroke2RoundBevel, reporter); expectations.fPEHasValidKey = true; expectations.fPEHasEffect = false; expectations.fStrokeApplies = true; stroke2RoundBevelCase.testExpectations(reporter, expectations); TestCase(geo, stroke2RoundBevel, reporter).compare(reporter, stroke2RoundBevelCase, TestCase::kAllSame_ComparisonExpecation); SkPaint stroke2RoundBevelDash = stroke2RoundBevel; stroke2RoundBevelDash.setPathEffect(make_dash()); TestCase stroke2RoundBevelDashCase(geo, stroke2RoundBevelDash, reporter); expectations.fPEHasValidKey = true; expectations.fPEHasEffect = true; expectations.fStrokeApplies = true; stroke2RoundBevelDashCase.testExpectations(reporter, expectations); TestCase(geo, stroke2RoundBevelDash, reporter).compare(reporter, stroke2RoundBevelDashCase, TestCase::kAllSame_ComparisonExpecation); fillCase.compare(reporter, stroke2RoundBevelCase, TestCase::kSameUpToStroke_ComparisonExpecation); fillCase.compare(reporter, stroke2RoundBevelDashCase, TestCase::kSameUpToPE_ComparisonExpecation); stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase, TestCase::kSameUpToPE_ComparisonExpecation); // Stroke and fill cases SkPaint stroke2RoundBevelAndFill = stroke2RoundBevel; stroke2RoundBevelAndFill.setStyle(SkPaint::kStrokeAndFill_Style); TestCase stroke2RoundBevelAndFillCase(geo, stroke2RoundBevelAndFill, reporter); expectations.fPEHasValidKey = true; expectations.fPEHasEffect = false; expectations.fStrokeApplies = true; stroke2RoundBevelAndFillCase.testExpectations(reporter, expectations); TestCase(geo, stroke2RoundBevelAndFill, reporter).compare(reporter, stroke2RoundBevelAndFillCase, TestCase::kAllSame_ComparisonExpecation); SkPaint stroke2RoundBevelAndFillDash = stroke2RoundBevelDash; stroke2RoundBevelAndFillDash.setStyle(SkPaint::kStrokeAndFill_Style); TestCase stroke2RoundBevelAndFillDashCase(geo, stroke2RoundBevelAndFillDash, reporter); expectations.fPEHasValidKey = true; expectations.fPEHasEffect = true; expectations.fStrokeApplies = true; stroke2RoundBevelAndFillDashCase.testExpectations(reporter, expectations); TestCase(geo, stroke2RoundBevelAndFillDash, reporter).compare( reporter, stroke2RoundBevelAndFillDashCase, TestCase::kAllSame_ComparisonExpecation); stroke2RoundBevelAndFillCase.compare(reporter, stroke2RoundBevelCase, TestCase::kSameUpToStroke_ComparisonExpecation); stroke2RoundBevelAndFillDashCase.compare(reporter, stroke2RoundBevelDashCase, TestCase::kSameUpToStroke_ComparisonExpecation); stroke2RoundBevelAndFillCase.compare(reporter, stroke2RoundBevelAndFillDashCase, TestCase::kSameUpToPE_ComparisonExpecation); SkPaint hairline; hairline.setStyle(SkPaint::kStroke_Style); hairline.setStrokeWidth(0.f); TestCase hairlineCase(geo, hairline, reporter); // Since hairline style doesn't change the SkPath data, it is keyed identically to fill. hairlineCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation); REPORTER_ASSERT(reporter, hairlineCase.baseShape().style().isSimpleHairline()); REPORTER_ASSERT(reporter, hairlineCase.appliedFullStyleShape().style().isSimpleHairline()); REPORTER_ASSERT(reporter, hairlineCase.appliedPathEffectShape().style().isSimpleHairline()); } template static void test_scale(skiatest::Reporter* reporter, const GEO& geo) { sk_sp dashPE = make_dash(); static const SkScalar kS1 = 1.f; static const SkScalar kS2 = 2.f; SkPaint fill; TestCase fillCase1(geo, fill, reporter, kS1); TestCase fillCase2(geo, fill, reporter, kS2); // Scale doesn't affect fills. fillCase1.compare(reporter, fillCase2, TestCase::kAllSame_ComparisonExpecation); SkPaint hairline; hairline.setStyle(SkPaint::kStroke_Style); hairline.setStrokeWidth(0.f); TestCase hairlineCase1(geo, hairline, reporter, kS1); TestCase hairlineCase2(geo, hairline, reporter, kS2); // Scale doesn't affect hairlines. hairlineCase1.compare(reporter, hairlineCase2, TestCase::kAllSame_ComparisonExpecation); SkPaint stroke; stroke.setStyle(SkPaint::kStroke_Style); stroke.setStrokeWidth(2.f); TestCase strokeCase1(geo, stroke, reporter, kS1); TestCase strokeCase2(geo, stroke, reporter, kS2); // Scale affects the stroke. strokeCase1.compare(reporter, strokeCase2, TestCase::kSameUpToStroke_ComparisonExpecation); SkPaint strokeDash = stroke; strokeDash.setPathEffect(make_dash()); TestCase strokeDashCase1(geo, strokeDash, reporter, kS1); TestCase strokeDashCase2(geo, strokeDash, reporter, kS2); // Scale affects the dash and the stroke. strokeDashCase1.compare(reporter, strokeDashCase2, TestCase::kSameUpToPE_ComparisonExpecation); // Stroke and fill cases SkPaint strokeAndFill = stroke; strokeAndFill.setStyle(SkPaint::kStrokeAndFill_Style); TestCase strokeAndFillCase1(geo, strokeAndFill, reporter, kS1); TestCase strokeAndFillCase2(geo, strokeAndFill, reporter, kS2); // Scale affects the stroke. Though, this can wind up creating a rect when the input is a rect. // In that case we wind up with a pure geometry key and the geometries are the same. SkRRect rrect; if (strokeAndFillCase1.appliedFullStyleShape().asRRect(&rrect)) { // We currently only expect to get here in the rect->rect case. REPORTER_ASSERT(reporter, rrect.isRect()); REPORTER_ASSERT(reporter, strokeAndFillCase1.baseShape().asRRect(&rrect) && rrect.isRect()); strokeAndFillCase1.compare(reporter, strokeAndFillCase2, TestCase::kAllSame_ComparisonExpecation); } else { strokeAndFillCase1.compare(reporter, strokeAndFillCase2, TestCase::kSameUpToStroke_ComparisonExpecation); } SkPaint strokeAndFillDash = strokeDash; strokeAndFillDash.setStyle(SkPaint::kStrokeAndFill_Style); TestCase strokeAndFillDashCase1(geo, strokeAndFillDash, reporter, kS1); TestCase strokeAndFillDashCase2(geo, strokeAndFillDash, reporter, kS2); // Scale affects the path effect and stroke. strokeAndFillDashCase1.compare(reporter, strokeAndFillDashCase2, TestCase::kSameUpToPE_ComparisonExpecation); } template static void test_stroke_param_impl(skiatest::Reporter* reporter, const GEO& geo, std::function setter, T a, T b, bool paramAffectsStroke, bool paramAffectsDashAndStroke) { // Set the stroke width so that we don't get hairline. However, call the setter afterward so // that it can override the stroke width. SkPaint strokeA; strokeA.setStyle(SkPaint::kStroke_Style); strokeA.setStrokeWidth(2.f); setter(&strokeA, a); SkPaint strokeB; strokeB.setStyle(SkPaint::kStroke_Style); strokeB.setStrokeWidth(2.f); setter(&strokeB, b); TestCase strokeACase(geo, strokeA, reporter); TestCase strokeBCase(geo, strokeB, reporter); if (paramAffectsStroke) { strokeACase.compare(reporter, strokeBCase, TestCase::kSameUpToStroke_ComparisonExpecation); } else { strokeACase.compare(reporter, strokeBCase, TestCase::kAllSame_ComparisonExpecation); } SkPaint strokeAndFillA = strokeA; SkPaint strokeAndFillB = strokeB; strokeAndFillA.setStyle(SkPaint::kStrokeAndFill_Style); strokeAndFillB.setStyle(SkPaint::kStrokeAndFill_Style); TestCase strokeAndFillACase(geo, strokeAndFillA, reporter); TestCase strokeAndFillBCase(geo, strokeAndFillB, reporter); if (paramAffectsStroke) { strokeAndFillACase.compare(reporter, strokeAndFillBCase, TestCase::kSameUpToStroke_ComparisonExpecation); } else { strokeAndFillACase.compare(reporter, strokeAndFillBCase, TestCase::kAllSame_ComparisonExpecation); } // Make sure stroking params don't affect fill style. SkPaint fillA = strokeA, fillB = strokeB; fillA.setStyle(SkPaint::kFill_Style); fillB.setStyle(SkPaint::kFill_Style); TestCase fillACase(geo, fillA, reporter); TestCase fillBCase(geo, fillB, reporter); fillACase.compare(reporter, fillBCase, TestCase::kAllSame_ComparisonExpecation); // Make sure just applying the dash but not stroke gives the same key for both stroking // variations. SkPaint dashA = strokeA, dashB = strokeB; dashA.setPathEffect(make_dash()); dashB.setPathEffect(make_dash()); TestCase dashACase(geo, dashA, reporter); TestCase dashBCase(geo, dashB, reporter); if (paramAffectsDashAndStroke) { dashACase.compare(reporter, dashBCase, TestCase::kSameUpToStroke_ComparisonExpecation); } else { dashACase.compare(reporter, dashBCase, TestCase::kAllSame_ComparisonExpecation); } SkPaint dashStrokeAndFillA = dashA, dashStrokeAndFillB = dashB; dashStrokeAndFillA.setStyle(SkPaint::kStrokeAndFill_Style); dashStrokeAndFillB.setStyle(SkPaint::kStrokeAndFill_Style); TestCase dashStrokeAndFillACase(geo, dashStrokeAndFillA, reporter); TestCase dashStrokeAndFillBCase(geo, dashStrokeAndFillB, reporter); if (paramAffectsDashAndStroke) { dashStrokeAndFillACase.compare(reporter, dashStrokeAndFillBCase, TestCase::kSameUpToStroke_ComparisonExpecation); } else { dashStrokeAndFillACase.compare(reporter, dashStrokeAndFillBCase, TestCase::kAllSame_ComparisonExpecation); } } template static void test_stroke_param(skiatest::Reporter* reporter, const GEO& geo, std::function setter, T a, T b) { test_stroke_param_impl(reporter, geo, setter, a, b, true, true); }; template static void test_stroke_cap(skiatest::Reporter* reporter, const GEO& geo) { GrShape shape(geo, GrStyle(SkStrokeRec::kHairline_InitStyle)); // The cap should only affect shapes that may be open. bool affectsStroke = !shape.knownToBeClosed(); // Dashing adds ends that need caps. bool affectsDashAndStroke = true; test_stroke_param_impl( reporter, geo, [](SkPaint* p, SkPaint::Cap c) { p->setStrokeCap(c);}, SkPaint::kButt_Cap, SkPaint::kRound_Cap, affectsStroke, affectsDashAndStroke); }; template static void test_miter_limit(skiatest::Reporter* reporter, const GEO& geo) { auto setMiterJoinAndLimit = [](SkPaint* p, SkScalar miter) { p->setStrokeJoin(SkPaint::kMiter_Join); p->setStrokeMiter(miter); }; auto setOtherJoinAndLimit = [](SkPaint* p, SkScalar miter) { p->setStrokeJoin(SkPaint::kRound_Join); p->setStrokeMiter(miter); }; // The miter limit should affect stroked and dashed-stroked cases when the join type is // miter. test_stroke_param_impl( reporter, geo, setMiterJoinAndLimit, 0.5f, 0.75f, true, true); // The miter limit should not affect stroked and dashed-stroked cases when the join type is // not miter. test_stroke_param_impl( reporter, geo, setOtherJoinAndLimit, 0.5f, 0.75f, false, false); } template static void test_dash_fill(skiatest::Reporter* reporter, const GEO& geo) { // A dash with no stroke should have no effect using DashFactoryFn = sk_sp(*)(); for (DashFactoryFn md : {&make_dash, &make_null_dash}) { SkPaint dashFill; dashFill.setPathEffect((*md)()); TestCase dashFillCase(geo, dashFill, reporter); TestCase fillCase(geo, SkPaint(), reporter); dashFillCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation); } } template void test_null_dash(skiatest::Reporter* reporter, const GEO& geo) { SkPaint fill; SkPaint stroke; stroke.setStyle(SkPaint::kStroke_Style); stroke.setStrokeWidth(1.f); SkPaint dash; dash.setStyle(SkPaint::kStroke_Style); dash.setStrokeWidth(1.f); dash.setPathEffect(make_dash()); SkPaint nullDash; nullDash.setStyle(SkPaint::kStroke_Style); nullDash.setStrokeWidth(1.f); nullDash.setPathEffect(make_null_dash()); TestCase fillCase(geo, fill, reporter); TestCase strokeCase(geo, stroke, reporter); TestCase dashCase(geo, dash, reporter); TestCase nullDashCase(geo, nullDash, reporter); nullDashCase.compare(reporter, fillCase, TestCase::kSameUpToStroke_ComparisonExpecation); nullDashCase.compare(reporter, strokeCase, TestCase::kAllSame_ComparisonExpecation); nullDashCase.compare(reporter, dashCase, TestCase::kSameUpToPE_ComparisonExpecation); } template void test_path_effect_makes_rrect(skiatest::Reporter* reporter, const GEO& geo) { /** * This path effect takes any input path and turns it into a rrect. It passes through stroke * info. */ class RRectPathEffect : SkPathEffect { public: static const SkRRect& RRect() { static const SkRRect kRRect = SkRRect::MakeRectXY(SkRect::MakeWH(12, 12), 3, 5); return kRRect; } bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR) const override { dst->reset(); dst->addRRect(RRect()); return true; } void computeFastBounds(SkRect* dst, const SkRect& src) const override { *dst = RRect().getBounds(); } static sk_sp Make() { return sk_sp(new RRectPathEffect); } Factory getFactory() const override { return nullptr; } void toString(SkString*) const override {} private: RRectPathEffect() {} }; SkPaint fill; TestCase fillGeoCase(geo, fill, reporter); SkPaint pe; pe.setPathEffect(RRectPathEffect::Make()); TestCase geoPECase(geo, pe, reporter); SkPaint peStroke; peStroke.setPathEffect(RRectPathEffect::Make()); peStroke.setStrokeWidth(2.f); peStroke.setStyle(SkPaint::kStroke_Style); TestCase geoPEStrokeCase(geo, peStroke, reporter); fillGeoCase.compare(reporter, geoPECase, TestCase::kSameUpToPE_ComparisonExpecation); fillGeoCase.compare(reporter, geoPEStrokeCase, TestCase::kSameUpToPE_ComparisonExpecation); geoPECase.compare(reporter, geoPEStrokeCase, TestCase::kSameUpToStroke_ComparisonExpecation); TestCase rrectFillCase(RRectPathEffect::RRect(), fill, reporter); SkPaint stroke = peStroke; stroke.setPathEffect(nullptr); TestCase rrectStrokeCase(RRectPathEffect::RRect(), stroke, reporter); SkRRect rrect; // Applying the path effect should make a SkRRect shape. There is no further stroking in the // geoPECase, so the full style should be the same as just the PE. REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectShape().asRRect(&rrect)); REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect()); REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectKey() == rrectFillCase.baseKey()); REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleShape().asRRect(&rrect)); REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect()); REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleKey() == rrectFillCase.baseKey()); // In the PE+stroke case applying the full style should be the same as just stroking the rrect. REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectShape().asRRect(&rrect)); REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect()); REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == rrectFillCase.baseKey()); REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedFullStyleShape().asRRect(&rrect)); REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() == rrectStrokeCase.appliedFullStyleKey()); } template void test_unknown_path_effect(skiatest::Reporter* reporter, const GEO& geo) { /** * This path effect just adds two lineTos to the input path. */ class AddLineTosPathEffect : SkPathEffect { public: bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR) const override { *dst = src; dst->lineTo(0, 0); dst->lineTo(10, 10); return true; } void computeFastBounds(SkRect* dst, const SkRect& src) const override { *dst = src; dst->growToInclude(0, 0); dst->growToInclude(10, 10); } static sk_sp Make() { return sk_sp(new AddLineTosPathEffect); } Factory getFactory() const override { return nullptr; } void toString(SkString*) const override {} private: AddLineTosPathEffect() {} }; // This path effect should make the keys invalid when it is applied. We only produce a path // effect key for dash path effects. So the only way another arbitrary path effect can produce // a styled result with a key is to produce a non-path shape that has a purely geometric key. SkPaint peStroke; peStroke.setPathEffect(AddLineTosPathEffect::Make()); peStroke.setStrokeWidth(2.f); peStroke.setStyle(SkPaint::kStroke_Style); TestCase geoPEStrokeCase(geo, peStroke, reporter); TestCase::SelfExpectations expectations; expectations.fPEHasEffect = true; expectations.fPEHasValidKey = false; expectations.fStrokeApplies = true; geoPEStrokeCase.testExpectations(reporter, expectations); } template void test_make_hairline_path_effect(skiatest::Reporter* reporter, const GEO& geo, bool isNonPath) { /** * This path effect just changes the stroke rec to hairline. */ class MakeHairlinePathEffect : SkPathEffect { public: bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec* strokeRec, const SkRect* cullR) const override { *dst = src; strokeRec->setHairlineStyle(); return true; } void computeFastBounds(SkRect* dst, const SkRect& src) const override { *dst = src; } static sk_sp Make() { return sk_sp(new MakeHairlinePathEffect); } Factory getFactory() const override { return nullptr; } void toString(SkString*) const override {} private: MakeHairlinePathEffect() {} }; SkPaint fill; SkPaint pe; pe.setPathEffect(MakeHairlinePathEffect::Make()); TestCase peCase(geo, pe, reporter); SkPath a, b; peCase.baseShape().asPath(&a); peCase.appliedPathEffectShape().asPath(&b); REPORTER_ASSERT(reporter, a == b); peCase.appliedFullStyleShape().asPath(&b); REPORTER_ASSERT(reporter, a == b); REPORTER_ASSERT(reporter, peCase.appliedPathEffectShape().style().isSimpleHairline()); REPORTER_ASSERT(reporter, peCase.appliedFullStyleShape().style().isSimpleHairline()); if (isNonPath) { REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey() == peCase.baseKey()); REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey() == peCase.baseKey()); } else { REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey().empty()); REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey().empty()); } } /** * isNonPath indicates whether the initial shape made from the path is expected to be recognized * as a simpler shape type (e.g. rrect) */ void test_volatile_path(skiatest::Reporter* reporter, const SkPath& path, bool isNonPath) { SkPath vPath(path); vPath.setIsVolatile(true); SkPaint dashAndStroke; dashAndStroke.setPathEffect(make_dash()); dashAndStroke.setStrokeWidth(2.f); dashAndStroke.setStyle(SkPaint::kStroke_Style); TestCase volatileCase(vPath, dashAndStroke, reporter); // We expect a shape made from a volatile path to have a key iff the shape is recognized // as a specialized geometry. if (isNonPath) { REPORTER_ASSERT(reporter, SkToBool(volatileCase.baseKey().count())); // In this case all the keys should be identical to the non-volatile case. TestCase nonVolatileCase(path, dashAndStroke, reporter); volatileCase.compare(reporter, nonVolatileCase, TestCase::kAllSame_ComparisonExpecation); } else { // None of the keys should be valid. REPORTER_ASSERT(reporter, !SkToBool(volatileCase.baseKey().count())); REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedPathEffectKey().count())); REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedFullStyleKey().count())); REPORTER_ASSERT(reporter, !SkToBool(volatileCase.appliedPathEffectThenStrokeKey().count())); } } template void test_path_effect_makes_empty_shape(skiatest::Reporter* reporter, const GEO& geo) { /** * This path effect returns an empty path. */ class EmptyPathEffect : SkPathEffect { public: bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR) const override { dst->reset(); return true; } void computeFastBounds(SkRect* dst, const SkRect& src) const override { dst->setEmpty(); } static sk_sp Make() { return sk_sp(new EmptyPathEffect); } Factory getFactory() const override { return nullptr; } void toString(SkString*) const override {} private: EmptyPathEffect() {} }; SkPath emptyPath; GrShape emptyShape(emptyPath); Key emptyKey; make_key(&emptyKey, emptyShape); REPORTER_ASSERT(reporter, emptyShape.isEmpty()); SkPaint pe; pe.setPathEffect(EmptyPathEffect::Make()); TestCase geoCase(geo, pe, reporter); REPORTER_ASSERT(reporter, geoCase.appliedFullStyleKey() == emptyKey); REPORTER_ASSERT(reporter, geoCase.appliedPathEffectKey() == emptyKey); REPORTER_ASSERT(reporter, geoCase.appliedPathEffectThenStrokeKey() == emptyKey); REPORTER_ASSERT(reporter, geoCase.appliedPathEffectShape().isEmpty()); REPORTER_ASSERT(reporter, geoCase.appliedFullStyleShape().isEmpty()); SkPaint peStroke; peStroke.setPathEffect(EmptyPathEffect::Make()); peStroke.setStrokeWidth(2.f); peStroke.setStyle(SkPaint::kStroke_Style); TestCase geoPEStrokeCase(geo, peStroke, reporter); REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() == emptyKey); REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == emptyKey); REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectThenStrokeKey() == emptyKey); REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectShape().isEmpty()); REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleShape().isEmpty()); } void test_empty_shape(skiatest::Reporter* reporter) { SkPath emptyPath; SkPaint fill; TestCase fillEmptyCase(emptyPath, fill, reporter); REPORTER_ASSERT(reporter, fillEmptyCase.baseShape().isEmpty()); REPORTER_ASSERT(reporter, fillEmptyCase.appliedPathEffectShape().isEmpty()); REPORTER_ASSERT(reporter, fillEmptyCase.appliedFullStyleShape().isEmpty()); Key emptyKey(fillEmptyCase.baseKey()); REPORTER_ASSERT(reporter, emptyKey.count()); TestCase::SelfExpectations expectations; expectations.fStrokeApplies = false; expectations.fPEHasEffect = false; // This will test whether applying style preserves emptiness fillEmptyCase.testExpectations(reporter, expectations); // Stroking an empty path should have no effect SkPath emptyPath2; SkPaint stroke; stroke.setStrokeWidth(2.f); stroke.setStyle(SkPaint::kStroke_Style); TestCase strokeEmptyCase(emptyPath2, stroke, reporter); strokeEmptyCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation); // Dashing and stroking an empty path should have no effect SkPath emptyPath3; SkPaint dashAndStroke; dashAndStroke.setPathEffect(make_dash()); dashAndStroke.setStrokeWidth(2.f); dashAndStroke.setStyle(SkPaint::kStroke_Style); TestCase dashAndStrokeEmptyCase(emptyPath3, dashAndStroke, reporter); dashAndStrokeEmptyCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation); // A shape made from an empty rrect should behave the same as an empty path. SkRRect emptyRRect = SkRRect::MakeRect(SkRect::MakeEmpty()); REPORTER_ASSERT(reporter, emptyRRect.getType() == SkRRect::kEmpty_Type); TestCase dashAndStrokeEmptyRRectCase(emptyRRect, dashAndStroke, reporter); dashAndStrokeEmptyRRectCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation); // Same for a rect. SkRect emptyRect = SkRect::MakeEmpty(); TestCase dashAndStrokeEmptyRectCase(emptyRect, dashAndStroke, reporter); dashAndStrokeEmptyRectCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation); } DEF_TEST(GrShape, reporter) { sk_sp dashPE = make_dash(); for (auto rr : { SkRRect::MakeRect(SkRect::MakeWH(10, 10)), SkRRect::MakeRectXY(SkRect::MakeWH(10, 10), 3, 4)}) { test_basic(reporter, rr); test_scale(reporter, rr); test_dash_fill(reporter, rr); test_null_dash(reporter, rr); // Test modifying various stroke params. test_stroke_param( reporter, rr, [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);}, SkIntToScalar(2), SkIntToScalar(4)); test_stroke_param( reporter, rr, [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);}, SkPaint::kMiter_Join, SkPaint::kRound_Join); test_stroke_cap(reporter, rr); test_miter_limit(reporter, rr); test_path_effect_makes_rrect(reporter, rr); test_unknown_path_effect(reporter, rr); test_path_effect_makes_empty_shape(reporter, rr); test_make_hairline_path_effect(reporter, rr, true); } struct TestPath { TestPath(const SkPath& path, bool isRRectFill, bool isRRectStroke ,const SkRRect& rrect) : fPath(path) , fIsRRectForFill(isRRectFill) , fIsRRectForStroke(isRRectStroke) , fRRect(rrect) {} SkPath fPath; bool fIsRRectForFill; bool fIsRRectForStroke; SkRRect fRRect; }; SkTArray paths; SkPath circlePath; circlePath.addCircle(10, 10, 10); paths.emplace_back(circlePath, true, true, SkRRect::MakeOval(SkRect::MakeWH(20,20))); SkPath rectPath; rectPath.addRect(SkRect::MakeWH(10, 10)); paths.emplace_back(rectPath, true, true, SkRRect::MakeRect(SkRect::MakeWH(10, 10))); SkPath openRectPath; openRectPath.moveTo(0, 0); openRectPath.lineTo(10, 0); openRectPath.lineTo(10, 10); openRectPath.lineTo(0, 10); paths.emplace_back(openRectPath, true, false, SkRRect::MakeRect(SkRect::MakeWH(10, 10))); SkPath quadPath; quadPath.quadTo(10, 10, 5, 8); paths.emplace_back(quadPath, false, false, SkRRect()); for (auto testPath : paths) { const SkPath& path = testPath.fPath; // These tests all assume that the original GrShape for fill and stroke will be the same. // However, that is not the case in special cases (e.g. a unclosed rect becomes a RRect // GrShape with a fill style but becomes a Path GrShape when stroked). if (testPath.fIsRRectForFill == testPath.fIsRRectForStroke) { test_basic(reporter, path); test_null_dash(reporter, path); test_path_effect_makes_rrect(reporter, path); } test_scale(reporter, path); // This test uses a stroking paint, hence use of fIsRRectForStroke test_volatile_path(reporter, path, testPath.fIsRRectForStroke); test_dash_fill(reporter, path); // Test modifying various stroke params. test_stroke_param( reporter, path, [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);}, SkIntToScalar(2), SkIntToScalar(4)); test_stroke_param( reporter, path, [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);}, SkPaint::kMiter_Join, SkPaint::kRound_Join); test_stroke_cap(reporter, path); test_miter_limit(reporter, path); test_unknown_path_effect(reporter, path); test_path_effect_makes_empty_shape(reporter, path); test_make_hairline_path_effect(reporter, path, testPath.fIsRRectForStroke); SkPaint fillPaint; TestCase fillPathCase(path, fillPaint, reporter); SkRRect rrect; REPORTER_ASSERT(reporter, testPath.fIsRRectForFill == fillPathCase.baseShape().asRRect(&rrect)); if (testPath.fIsRRectForFill) { REPORTER_ASSERT(reporter, rrect == testPath.fRRect); TestCase fillRRectCase(rrect, fillPaint, reporter); fillPathCase.compare(reporter, fillRRectCase, TestCase::kAllSame_ComparisonExpecation); } SkPaint strokePaint; strokePaint.setStrokeWidth(3.f); strokePaint.setStyle(SkPaint::kStroke_Style); TestCase strokePathCase(path, strokePaint, reporter); REPORTER_ASSERT(reporter, testPath.fIsRRectForStroke == strokePathCase.baseShape().asRRect(&rrect)); if (testPath.fIsRRectForStroke) { REPORTER_ASSERT(reporter, rrect == testPath.fRRect); TestCase strokeRRectCase(rrect, strokePaint, reporter); strokePathCase.compare(reporter, strokeRRectCase, TestCase::kAllSame_ComparisonExpecation); } } // Test a volatile empty path. test_volatile_path(reporter, SkPath(), true); test_empty_shape(reporter); } #endif