| /* |
| * 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/core/SkCanvas.h" |
| #include "include/core/SkPath.h" |
| #include "include/core/SkSurface.h" |
| #include "include/effects/SkDashPathEffect.h" |
| #include "include/pathops/SkPathOps.h" |
| #include "src/core/SkClipOpPriv.h" |
| #include "src/core/SkRectPriv.h" |
| #include "src/gpu/geometry/GrStyledShape.h" |
| #include "tests/Test.h" |
| |
| #include <initializer_list> |
| #include <functional> |
| #include <memory> |
| #include <utility> |
| |
| uint32_t GrStyledShape::testingOnly_getOriginalGenerationID() const { |
| if (const auto* lp = this->originalPathForListeners()) { |
| return lp->getGenerationID(); |
| } |
| return SkPath().getGenerationID(); |
| } |
| |
| bool GrStyledShape::testingOnly_isPath() const { |
| return fShape.isPath(); |
| } |
| |
| bool GrStyledShape::testingOnly_isNonVolatilePath() const { |
| return fShape.isPath() && !fShape.path().isVolatile(); |
| } |
| |
| using Key = SkTArray<uint32_t>; |
| |
| static bool make_key(Key* key, const GrStyledShape& 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 paths_fill_same(const SkPath& a, const SkPath& b) { |
| SkPath pathXor; |
| Op(a, b, SkPathOp::kXOR_SkPathOp, &pathXor); |
| return pathXor.isEmpty(); |
| } |
| |
| static bool test_bounds_by_rasterizing(const SkPath& path, const SkRect& bounds) { |
| // We test the bounds by rasterizing the path into a kRes by kRes grid. The bounds is |
| // mapped to the range kRes/4 to 3*kRes/4 in x and y. A difference clip is used to avoid |
| // rendering within the bounds (with a tolerance). Then we render the path and check that |
| // everything got clipped out. |
| static constexpr int kRes = 2000; |
| // This tolerance is in units of 1/kRes fractions of the bounds width/height. |
| static constexpr int kTol = 2; |
| static_assert(kRes % 4 == 0); |
| SkImageInfo info = SkImageInfo::MakeA8(kRes, kRes); |
| sk_sp<SkSurface> surface = SkSurface::MakeRaster(info); |
| surface->getCanvas()->clear(0x0); |
| SkRect clip = SkRect::MakeXYWH(kRes/4, kRes/4, kRes/2, kRes/2); |
| SkMatrix matrix = SkMatrix::RectToRect(bounds, clip); |
| clip.outset(SkIntToScalar(kTol), SkIntToScalar(kTol)); |
| surface->getCanvas()->clipRect(clip, kDifference_SkClipOp); |
| 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<uint8_t*>(calloc(kRes, 1)); |
| #else |
| static constexpr uint8_t kZeros[kRes] = {0}; |
| #endif |
| for (int y = 0; y < kRes; ++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<uint8_t*>(kZeros)); |
| #endif |
| return true; |
| } |
| |
| static bool can_interchange_winding_and_even_odd_fill(const GrStyledShape& shape) { |
| SkPath path; |
| shape.asPath(&path); |
| if (shape.style().hasNonDashPathEffect()) { |
| return false; |
| } |
| const SkStrokeRec::Style strokeRecStyle = shape.style().strokeRec().getStyle(); |
| return strokeRecStyle == SkStrokeRec::kStroke_Style || |
| strokeRecStyle == SkStrokeRec::kHairline_Style || |
| (shape.style().isSimpleFill() && path.isConvex()); |
| } |
| |
| static void check_equivalence(skiatest::Reporter* r, const GrStyledShape& a, const GrStyledShape& b, |
| const Key& keyA, const Key& keyB) { |
| // GrStyledShape only respects the input winding direction and start point for rrect shapes |
| // when there is a path effect. Thus, if there are two GrStyledShapes representing the same |
| // rrect but one has a path effect in its style and the other doesn't then asPath() and the |
| // unstyled key will differ. GrStyledShape will have canonicalized the direction and start point |
| // for the shape without the path effect. If *both* have path effects then they should have both |
| // preserved the direction and starting point. |
| |
| // The asRRect() output params are all initialized just to silence compiler warnings about |
| // uninitialized variables. |
| SkRRect rrectA = SkRRect::MakeEmpty(), rrectB = SkRRect::MakeEmpty(); |
| SkPathDirection dirA = SkPathDirection::kCW, dirB = SkPathDirection::kCW; |
| unsigned startA = ~0U, startB = ~0U; |
| bool invertedA = true, invertedB = true; |
| |
| bool aIsRRect = a.asRRect(&rrectA, &dirA, &startA, &invertedA); |
| bool bIsRRect = b.asRRect(&rrectB, &dirB, &startB, &invertedB); |
| bool aHasPE = a.style().hasPathEffect(); |
| bool bHasPE = b.style().hasPathEffect(); |
| bool allowSameRRectButDiffStartAndDir = (aIsRRect && bIsRRect) && (aHasPE != bHasPE); |
| // GrStyledShape will close paths with simple fill style. |
| bool allowedClosednessDiff = (a.style().isSimpleFill() != b.style().isSimpleFill()); |
| SkPath pathA, pathB; |
| a.asPath(&pathA); |
| b.asPath(&pathB); |
| |
| // Having a dash path effect can allow 'a' but not 'b' to turn a inverse fill type into a |
| // non-inverse fill type (or vice versa). |
| bool ignoreInversenessDifference = false; |
| if (pathA.isInverseFillType() != pathB.isInverseFillType()) { |
| const GrStyledShape* s1 = pathA.isInverseFillType() ? &a : &b; |
| const GrStyledShape* s2 = pathA.isInverseFillType() ? &b : &a; |
| bool canDropInverse1 = s1->style().isDashed(); |
| bool canDropInverse2 = s2->style().isDashed(); |
| ignoreInversenessDifference = (canDropInverse1 != canDropInverse2); |
| } |
| bool ignoreWindingVsEvenOdd = false; |
| if (SkPathFillType_ConvertToNonInverse(pathA.getFillType()) != |
| SkPathFillType_ConvertToNonInverse(pathB.getFillType())) { |
| bool aCanChange = can_interchange_winding_and_even_odd_fill(a); |
| bool bCanChange = can_interchange_winding_and_even_odd_fill(b); |
| if (aCanChange != bCanChange) { |
| ignoreWindingVsEvenOdd = true; |
| } |
| } |
| if (allowSameRRectButDiffStartAndDir) { |
| REPORTER_ASSERT(r, rrectA == rrectB); |
| REPORTER_ASSERT(r, paths_fill_same(pathA, pathB)); |
| REPORTER_ASSERT(r, ignoreInversenessDifference || invertedA == invertedB); |
| } else { |
| SkPath pA = pathA; |
| SkPath pB = pathB; |
| REPORTER_ASSERT(r, a.inverseFilled() == pA.isInverseFillType()); |
| REPORTER_ASSERT(r, b.inverseFilled() == pB.isInverseFillType()); |
| if (ignoreInversenessDifference) { |
| pA.setFillType(SkPathFillType_ConvertToNonInverse(pathA.getFillType())); |
| pB.setFillType(SkPathFillType_ConvertToNonInverse(pathB.getFillType())); |
| } |
| if (ignoreWindingVsEvenOdd) { |
| pA.setFillType(pA.isInverseFillType() ? SkPathFillType::kInverseEvenOdd |
| : SkPathFillType::kEvenOdd); |
| pB.setFillType(pB.isInverseFillType() ? SkPathFillType::kInverseEvenOdd |
| : SkPathFillType::kEvenOdd); |
| } |
| if (!ignoreInversenessDifference && !ignoreWindingVsEvenOdd) { |
| REPORTER_ASSERT(r, keyA == keyB); |
| } else { |
| REPORTER_ASSERT(r, keyA != keyB); |
| } |
| if (allowedClosednessDiff) { |
| // GrStyledShape will close paths with simple fill style. Make the non-filled path |
| // closed so that the comparision will succeed. Make sure both are closed before |
| // comparing. |
| pA.close(); |
| pB.close(); |
| } |
| REPORTER_ASSERT(r, pA == pB); |
| REPORTER_ASSERT(r, aIsRRect == bIsRRect); |
| if (aIsRRect) { |
| REPORTER_ASSERT(r, rrectA == rrectB); |
| REPORTER_ASSERT(r, dirA == dirB); |
| REPORTER_ASSERT(r, startA == startB); |
| REPORTER_ASSERT(r, ignoreInversenessDifference || invertedA == invertedB); |
| } |
| } |
| REPORTER_ASSERT(r, a.isEmpty() == b.isEmpty()); |
| REPORTER_ASSERT(r, allowedClosednessDiff || a.knownToBeClosed() == b.knownToBeClosed()); |
| // closedness can affect convexity. |
| REPORTER_ASSERT(r, allowedClosednessDiff || a.knownToBeConvex() == b.knownToBeConvex()); |
| if (a.knownToBeConvex()) { |
| REPORTER_ASSERT(r, pathA.isConvex()); |
| } |
| if (b.knownToBeConvex()) { |
| REPORTER_ASSERT(r, pathB.isConvex()); |
| } |
| REPORTER_ASSERT(r, a.bounds() == b.bounds()); |
| REPORTER_ASSERT(r, a.segmentMask() == b.segmentMask()); |
| // Init these to suppress warnings. |
| SkPoint pts[4] {{0, 0,}, {0, 0}, {0, 0}, {0, 0}} ; |
| bool invertedLine[2] {true, true}; |
| REPORTER_ASSERT(r, a.asLine(pts, &invertedLine[0]) == b.asLine(pts + 2, &invertedLine[1])); |
| // mayBeInverseFilledAfterStyling() is allowed to differ if one has a arbitrary PE and the other |
| // doesn't (since the PE can set any fill type on its output path). |
| // Moreover, dash style explicitly ignores inverseness. So if one is dashed but not the other |
| // then they may disagree about inverseness. |
| if (a.style().hasNonDashPathEffect() == b.style().hasNonDashPathEffect() && |
| a.style().isDashed() == b.style().isDashed()) { |
| REPORTER_ASSERT(r, a.mayBeInverseFilledAfterStyling() == |
| b.mayBeInverseFilledAfterStyling()); |
| } |
| if (a.asLine(nullptr, nullptr)) { |
| REPORTER_ASSERT(r, pts[2] == pts[0] && pts[3] == pts[1]); |
| REPORTER_ASSERT(r, ignoreInversenessDifference || invertedLine[0] == invertedLine[1]); |
| REPORTER_ASSERT(r, invertedLine[0] == a.inverseFilled()); |
| REPORTER_ASSERT(r, invertedLine[1] == b.inverseFilled()); |
| } |
| REPORTER_ASSERT(r, ignoreInversenessDifference || a.inverseFilled() == b.inverseFilled()); |
| } |
| |
| static void check_original_path_ids(skiatest::Reporter* r, const GrStyledShape& base, |
| const GrStyledShape& pe, const GrStyledShape& peStroke, |
| const GrStyledShape& full) { |
| bool baseIsNonVolatilePath = base.testingOnly_isNonVolatilePath(); |
| bool peIsPath = pe.testingOnly_isPath(); |
| bool peStrokeIsPath = peStroke.testingOnly_isPath(); |
| bool fullIsPath = full.testingOnly_isPath(); |
| |
| REPORTER_ASSERT(r, peStrokeIsPath == fullIsPath); |
| |
| uint32_t baseID = base.testingOnly_getOriginalGenerationID(); |
| uint32_t peID = pe.testingOnly_getOriginalGenerationID(); |
| uint32_t peStrokeID = peStroke.testingOnly_getOriginalGenerationID(); |
| uint32_t fullID = full.testingOnly_getOriginalGenerationID(); |
| |
| // All empty paths have the same gen ID |
| uint32_t emptyID = SkPath().getGenerationID(); |
| |
| // If we started with a real path, then our genID should match that path's gen ID (and not be |
| // empty). If we started with a simple shape or a volatile path, our original path should have |
| // been reset. |
| REPORTER_ASSERT(r, baseIsNonVolatilePath == (baseID != emptyID)); |
| |
| // For the derived shapes, if they're simple types, their original paths should have been reset |
| REPORTER_ASSERT(r, peIsPath || (peID == emptyID)); |
| REPORTER_ASSERT(r, peStrokeIsPath || (peStrokeID == emptyID)); |
| REPORTER_ASSERT(r, fullIsPath || (fullID == emptyID)); |
| |
| if (!peIsPath) { |
| // If the path effect produces a simple shape, then there are no unbroken chains to test |
| return; |
| } |
| |
| // From here on, we know that the path effect produced a shape that was a "real" path |
| |
| if (baseIsNonVolatilePath) { |
| REPORTER_ASSERT(r, baseID == peID); |
| } |
| |
| if (peStrokeIsPath) { |
| REPORTER_ASSERT(r, peID == peStrokeID); |
| REPORTER_ASSERT(r, peStrokeID == fullID); |
| } |
| |
| if (baseIsNonVolatilePath && peStrokeIsPath) { |
| REPORTER_ASSERT(r, baseID == peStrokeID); |
| REPORTER_ASSERT(r, baseID == fullID); |
| } |
| } |
| |
| void test_inversions(skiatest::Reporter* r, const GrStyledShape& shape, const Key& shapeKey) { |
| GrStyledShape preserve = GrStyledShape::MakeFilled( |
| shape, GrStyledShape::FillInversion::kPreserve); |
| Key preserveKey; |
| make_key(&preserveKey, preserve); |
| |
| GrStyledShape flip = GrStyledShape::MakeFilled(shape, GrStyledShape::FillInversion::kFlip); |
| Key flipKey; |
| make_key(&flipKey, flip); |
| |
| GrStyledShape inverted = GrStyledShape::MakeFilled( |
| shape, GrStyledShape::FillInversion::kForceInverted); |
| Key invertedKey; |
| make_key(&invertedKey, inverted); |
| |
| GrStyledShape noninverted = GrStyledShape::MakeFilled( |
| shape, GrStyledShape::FillInversion::kForceNoninverted); |
| Key noninvertedKey; |
| make_key(&noninvertedKey, noninverted); |
| |
| if (invertedKey.count() || noninvertedKey.count()) { |
| REPORTER_ASSERT(r, invertedKey != noninvertedKey); |
| } |
| if (shape.style().isSimpleFill()) { |
| check_equivalence(r, shape, preserve, shapeKey, preserveKey); |
| } |
| if (shape.inverseFilled()) { |
| check_equivalence(r, preserve, inverted, preserveKey, invertedKey); |
| check_equivalence(r, flip, noninverted, flipKey, noninvertedKey); |
| } else { |
| check_equivalence(r, preserve, noninverted, preserveKey, noninvertedKey); |
| check_equivalence(r, flip, inverted, flipKey, invertedKey); |
| } |
| |
| GrStyledShape doubleFlip = GrStyledShape::MakeFilled(flip, GrStyledShape::FillInversion::kFlip); |
| Key doubleFlipKey; |
| make_key(&doubleFlipKey, doubleFlip); |
| // It can be the case that the double flip has no key but preserve does. This happens when the |
| // original shape has an inherited style key. That gets dropped on the first inversion flip. |
| if (preserveKey.count() && !doubleFlipKey.count()) { |
| preserveKey.reset(); |
| } |
| check_equivalence(r, preserve, doubleFlip, preserveKey, doubleFlipKey); |
| } |
| |
| namespace { |
| /** |
| * Geo is a factory for creating a GrStyledShape from another representation. It also answers some |
| * questions about expected behavior for GrStyledShape given the inputs. |
| */ |
| class Geo { |
| public: |
| virtual ~Geo() {} |
| virtual GrStyledShape makeShape(const SkPaint&) const = 0; |
| virtual SkPath path() const = 0; |
| // These functions allow tests to check for special cases where style gets |
| // applied by GrStyledShape in its constructor (without calling GrStyledShape::applyStyle). |
| // These unfortunately rely on knowing details of GrStyledShape's implementation. |
| // These predicates are factored out here to avoid littering the rest of the |
| // test code with GrStyledShape implementation details. |
| virtual bool fillChangesGeom() const { return false; } |
| virtual bool strokeIsConvertedToFill() const { return false; } |
| virtual bool strokeAndFillIsConvertedToFill(const SkPaint&) const { return false; } |
| // Is this something we expect GrStyledShape to recognize as something simpler than a path. |
| virtual bool isNonPath(const SkPaint& paint) const { return true; } |
| }; |
| |
| class RectGeo : public Geo { |
| public: |
| RectGeo(const SkRect& rect) : fRect(rect) {} |
| |
| SkPath path() const override { |
| SkPath path; |
| path.addRect(fRect); |
| return path; |
| } |
| |
| GrStyledShape makeShape(const SkPaint& paint) const override { |
| return GrStyledShape(fRect, paint); |
| } |
| |
| bool strokeAndFillIsConvertedToFill(const SkPaint& paint) const override { |
| SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style); |
| // Converted to an outset rectangle or round rect |
| return (paint.getStrokeJoin() == SkPaint::kMiter_Join && |
| paint.getStrokeMiter() >= SK_ScalarSqrt2) || |
| paint.getStrokeJoin() == SkPaint::kRound_Join; |
| } |
| |
| private: |
| SkRect fRect; |
| }; |
| |
| class RRectGeo : public Geo { |
| public: |
| RRectGeo(const SkRRect& rrect) : fRRect(rrect) {} |
| |
| GrStyledShape makeShape(const SkPaint& paint) const override { |
| return GrStyledShape(fRRect, paint); |
| } |
| |
| SkPath path() const override { |
| SkPath path; |
| path.addRRect(fRRect); |
| return path; |
| } |
| |
| bool strokeAndFillIsConvertedToFill(const SkPaint& paint) const override { |
| SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style); |
| if (fRRect.isRect()) { |
| return RectGeo(fRRect.rect()).strokeAndFillIsConvertedToFill(paint); |
| } |
| return false; |
| } |
| |
| private: |
| SkRRect fRRect; |
| }; |
| |
| class ArcGeo : public Geo { |
| public: |
| ArcGeo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter) |
| : fOval(oval) |
| , fStartAngle(startAngle) |
| , fSweepAngle(sweepAngle) |
| , fUseCenter(useCenter) {} |
| |
| SkPath path() const override { |
| SkPath path; |
| SkPathPriv::CreateDrawArcPath(&path, fOval, fStartAngle, fSweepAngle, fUseCenter, false); |
| return path; |
| } |
| |
| GrStyledShape makeShape(const SkPaint& paint) const override { |
| return GrStyledShape::MakeArc(fOval, fStartAngle, fSweepAngle, fUseCenter, GrStyle(paint)); |
| } |
| |
| // GrStyledShape specializes when created from arc params but it doesn't recognize arcs from |
| // SkPath. |
| bool isNonPath(const SkPaint& paint) const override { return false; } |
| |
| private: |
| SkRect fOval; |
| SkScalar fStartAngle; |
| SkScalar fSweepAngle; |
| bool fUseCenter; |
| }; |
| |
| class PathGeo : public Geo { |
| public: |
| enum class Invert { kNo, kYes }; |
| |
| PathGeo(const SkPath& path, Invert invert) : fPath(path) { |
| SkASSERT(!path.isInverseFillType()); |
| if (Invert::kYes == invert) { |
| if (fPath.getFillType() == SkPathFillType::kEvenOdd) { |
| fPath.setFillType(SkPathFillType::kInverseEvenOdd); |
| } else { |
| SkASSERT(fPath.getFillType() == SkPathFillType::kWinding); |
| fPath.setFillType(SkPathFillType::kInverseWinding); |
| } |
| } |
| } |
| |
| GrStyledShape makeShape(const SkPaint& paint) const override { |
| return GrStyledShape(fPath, paint); |
| } |
| |
| SkPath path() const override { return fPath; } |
| |
| bool fillChangesGeom() const override { |
| // unclosed rects get closed. Lines get turned into empty geometry |
| return this->isUnclosedRect() || fPath.isLine(nullptr); |
| } |
| |
| bool strokeIsConvertedToFill() const override { |
| return this->isAxisAlignedLine(); |
| } |
| |
| bool strokeAndFillIsConvertedToFill(const SkPaint& paint) const override { |
| SkASSERT(paint.getStyle() == SkPaint::kStrokeAndFill_Style); |
| if (this->isAxisAlignedLine()) { |
| // The fill is ignored (zero area) and the stroke is converted to a rrect. |
| return true; |
| } |
| SkRect rect; |
| unsigned start; |
| SkPathDirection dir; |
| if (SkPathPriv::IsSimpleRect(fPath, false, &rect, &dir, &start)) { |
| return RectGeo(rect).strokeAndFillIsConvertedToFill(paint); |
| } |
| return false; |
| } |
| |
| bool isNonPath(const SkPaint& paint) const override { |
| return fPath.isLine(nullptr) || fPath.isEmpty(); |
| } |
| |
| private: |
| bool isAxisAlignedLine() const { |
| SkPoint pts[2]; |
| if (!fPath.isLine(pts)) { |
| return false; |
| } |
| return pts[0].fX == pts[1].fX || pts[0].fY == pts[1].fY; |
| } |
| |
| bool isUnclosedRect() const { |
| bool closed; |
| return fPath.isRect(nullptr, &closed, nullptr) && !closed; |
| } |
| |
| SkPath fPath; |
| }; |
| |
| class RRectPathGeo : public PathGeo { |
| public: |
| enum class RRectForStroke { kNo, kYes }; |
| |
| RRectPathGeo(const SkPath& path, const SkRRect& equivalentRRect, RRectForStroke rrectForStroke, |
| Invert invert) |
| : PathGeo(path, invert) |
| , fRRect(equivalentRRect) |
| , fRRectForStroke(rrectForStroke) {} |
| |
| RRectPathGeo(const SkPath& path, const SkRect& equivalentRect, RRectForStroke rrectForStroke, |
| Invert invert) |
| : RRectPathGeo(path, SkRRect::MakeRect(equivalentRect), rrectForStroke, invert) {} |
| |
| bool isNonPath(const SkPaint& paint) const override { |
| if (SkPaint::kFill_Style == paint.getStyle() || RRectForStroke::kYes == fRRectForStroke) { |
| return true; |
| } |
| return false; |
| } |
| |
| const SkRRect& rrect() const { return fRRect; } |
| |
| private: |
| SkRRect fRRect; |
| RRectForStroke fRRectForStroke; |
| }; |
| |
| class TestCase { |
| public: |
| TestCase(const Geo& geo, const SkPaint& paint, skiatest::Reporter* r, |
| SkScalar scale = SK_Scalar1) |
| : fBase(new GrStyledShape(geo.makeShape(paint))) { |
| this->init(r, scale); |
| } |
| |
| template <typename... ShapeArgs> |
| TestCase(skiatest::Reporter* r, ShapeArgs... shapeArgs) |
| : fBase(new GrStyledShape(shapeArgs...)) { |
| this->init(r, SK_Scalar1); |
| } |
| |
| TestCase(const GrStyledShape& shape, skiatest::Reporter* r, SkScalar scale = SK_Scalar1) |
| : fBase(new GrStyledShape(shape)) { |
| 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 GrStyledShape& baseShape() const { return *fBase; } |
| const GrStyledShape& appliedPathEffectShape() const { return *fAppliedPE; } |
| const GrStyledShape& 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 GrStyledShape& shape, |
| const SkRect& bounds) { |
| SkPath path; |
| shape.asPath(&path); |
| // If the bounds are empty, the path ought to be as well. |
| if (bounds.fLeft > bounds.fRight || bounds.fTop > bounds.fBottom) { |
| REPORTER_ASSERT(r, path.isEmpty()); |
| return; |
| } |
| if (path.isEmpty()) { |
| return; |
| } |
| // The bounds API explicitly calls out that it does not consider inverseness. |
| SkPath p = path; |
| p.setFillType(SkPathFillType_ConvertToNonInverse(path.getFillType())); |
| REPORTER_ASSERT(r, test_bounds_by_rasterizing(p, bounds)); |
| } |
| |
| void init(skiatest::Reporter* r, SkScalar scale) { |
| fAppliedPE = std::make_unique<GrStyledShape>(); |
| fAppliedPEThenStroke = std::make_unique<GrStyledShape>(); |
| fAppliedFull = std::make_unique<GrStyledShape>(); |
| |
| *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); |
| |
| // All shapes should report the same "original" path, so that path renderers can get to it |
| // if necessary. |
| check_original_path_ids(r, *fBase, *fAppliedPE, *fAppliedPEThenStroke, *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); |
| // If the output of the path effect is a rrect then it is possible for a and b to be |
| // different paths that fill identically. The reason is that fAppliedFull will do this: |
| // base -> apply path effect -> rrect_as_path -> stroke -> stroked_rrect_as_path |
| // fAppliedPEThenStroke will have converted the rrect_as_path back to a rrect. However, |
| // now that there is no longer a path effect, the direction and starting index get |
| // canonicalized before the stroke. |
| if (fAppliedPE->asRRect(nullptr, nullptr, nullptr, nullptr)) { |
| REPORTER_ASSERT(r, paths_fill_same(a, b)); |
| } else { |
| REPORTER_ASSERT(r, a == b); |
| } |
| REPORTER_ASSERT(r, fAppliedFull->isEmpty() == fAppliedPEThenStroke->isEmpty()); |
| |
| SkPath path; |
| fBase->asPath(&path); |
| REPORTER_ASSERT(r, path.isEmpty() == fBase->isEmpty()); |
| REPORTER_ASSERT(r, path.getSegmentMasks() == fBase->segmentMask()); |
| fAppliedPE->asPath(&path); |
| REPORTER_ASSERT(r, path.isEmpty() == fAppliedPE->isEmpty()); |
| REPORTER_ASSERT(r, path.getSegmentMasks() == fAppliedPE->segmentMask()); |
| fAppliedFull->asPath(&path); |
| REPORTER_ASSERT(r, path.isEmpty() == fAppliedFull->isEmpty()); |
| REPORTER_ASSERT(r, path.getSegmentMasks() == fAppliedFull->segmentMask()); |
| |
| CheckBounds(r, *fBase, fBase->bounds()); |
| CheckBounds(r, *fAppliedPE, fAppliedPE->bounds()); |
| CheckBounds(r, *fAppliedPEThenStroke, fAppliedPEThenStroke->bounds()); |
| CheckBounds(r, *fAppliedFull, fAppliedFull->bounds()); |
| SkRect styledBounds = fBase->styledBounds(); |
| CheckBounds(r, *fAppliedFull, styledBounds); |
| styledBounds = fAppliedPE->styledBounds(); |
| CheckBounds(r, *fAppliedFull, styledBounds); |
| |
| // Check that the same path is produced when style is applied by GrStyledShape 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 GrStyledShape to get any geometry reductions that would |
| // have occurred to fAppliedPE. |
| GrStyledShape(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)) { |
| SkPath testPath; |
| fAppliedFull->asPath(&testPath); |
| if (fBase->style().hasPathEffect()) { |
| // Because GrStyledShape always does two-stage application when there is a path |
| // effect there may be a reduction/canonicalization step between the path effect and |
| // strokerec not reflected in postAllStyle since it applied both the path effect |
| // and strokerec without analyzing the intermediate path. |
| REPORTER_ASSERT(r, paths_fill_same(postAllStyle, testPath)); |
| } else { |
| // Make sure that postAllStyle sees any reductions/canonicalizations that |
| // GrStyledShape would apply. |
| GrStyledShape(postAllStyle, GrStyle(fillOrHairline)).asPath(&postAllStyle); |
| REPORTER_ASSERT(r, testPath == postAllStyle); |
| } |
| |
| if (fillOrHairline == SkStrokeRec::kFill_InitStyle) { |
| REPORTER_ASSERT(r, fAppliedFull->style().isSimpleFill()); |
| } else { |
| REPORTER_ASSERT(r, fAppliedFull->style().isSimpleHairline()); |
| } |
| } |
| test_inversions(r, *fBase, fBaseKey); |
| test_inversions(r, *fAppliedPE, fAppliedPEKey); |
| test_inversions(r, *fAppliedFull, fAppliedFullKey); |
| } |
| |
| std::unique_ptr<GrStyledShape> fBase; |
| std::unique_ptr<GrStyledShape> fAppliedPE; |
| std::unique_ptr<GrStyledShape> fAppliedPEThenStroke; |
| std::unique_ptr<GrStyledShape> 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* r, const TestCase& that, |
| ComparisonExpecation expectation) const { |
| SkPath a, b; |
| switch (expectation) { |
| case kAllDifferent_ComparisonExpecation: |
| REPORTER_ASSERT(r, fBaseKey != that.fBaseKey); |
| REPORTER_ASSERT(r, fAppliedPEKey != that.fAppliedPEKey); |
| REPORTER_ASSERT(r, fAppliedFullKey != that.fAppliedFullKey); |
| break; |
| case kSameUpToPE_ComparisonExpecation: |
| check_equivalence(r, *fBase, *that.fBase, fBaseKey, that.fBaseKey); |
| REPORTER_ASSERT(r, fAppliedPEKey != that.fAppliedPEKey); |
| REPORTER_ASSERT(r, fAppliedFullKey != that.fAppliedFullKey); |
| break; |
| case kSameUpToStroke_ComparisonExpecation: |
| check_equivalence(r, *fBase, *that.fBase, fBaseKey, that.fBaseKey); |
| check_equivalence(r, *fAppliedPE, *that.fAppliedPE, fAppliedPEKey, that.fAppliedPEKey); |
| REPORTER_ASSERT(r, fAppliedFullKey != that.fAppliedFullKey); |
| break; |
| case kAllSame_ComparisonExpecation: |
| check_equivalence(r, *fBase, *that.fBase, fBaseKey, that.fBaseKey); |
| check_equivalence(r, *fAppliedPE, *that.fAppliedPE, fAppliedPEKey, that.fAppliedPEKey); |
| check_equivalence(r, *fAppliedFull, *that.fAppliedFull, fAppliedFullKey, |
| that.fAppliedFullKey); |
| break; |
| } |
| } |
| } // namespace |
| |
| static sk_sp<SkPathEffect> 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<SkPathEffect> make_null_dash() { |
| static const SkScalar kNullIntervals[] = {0, 0, 0, 0, 0, 0}; |
| return SkDashPathEffect::Make(kNullIntervals, SK_ARRAY_COUNT(kNullIntervals), 0.f); |
| } |
| |
| // We make enough TestCases, and they're large enough, that on Google3 builds we exceed |
| // the maximum stack frame limit. make_TestCase() moves those temporaries over to the heap. |
| template <typename... Args> |
| static std::unique_ptr<TestCase> make_TestCase(Args&&... args) { |
| return std::make_unique<TestCase>( std::forward<Args>(args)... ); |
| } |
| |
| static void test_basic(skiatest::Reporter* reporter, const Geo& geo) { |
| sk_sp<SkPathEffect> 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 GrStyledShape instance built from the same primitive is the same. |
| make_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 = !geo.strokeIsConvertedToFill(); |
| stroke2RoundBevelCase.testExpectations(reporter, expectations); |
| make_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); |
| make_TestCase(geo, stroke2RoundBevelDash, reporter) |
| ->compare(reporter, stroke2RoundBevelDashCase, TestCase::kAllSame_ComparisonExpecation); |
| |
| if (geo.fillChangesGeom() || geo.strokeIsConvertedToFill()) { |
| fillCase.compare(reporter, stroke2RoundBevelCase, |
| TestCase::kAllDifferent_ComparisonExpecation); |
| fillCase.compare(reporter, stroke2RoundBevelDashCase, |
| TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| fillCase.compare(reporter, stroke2RoundBevelCase, |
| TestCase::kSameUpToStroke_ComparisonExpecation); |
| fillCase.compare(reporter, stroke2RoundBevelDashCase, |
| TestCase::kSameUpToPE_ComparisonExpecation); |
| } |
| if (geo.strokeIsConvertedToFill()) { |
| stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase, |
| TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| 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 = !geo.strokeIsConvertedToFill(); |
| stroke2RoundBevelAndFillCase.testExpectations(reporter, expectations); |
| make_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 = false; |
| expectations.fStrokeApplies = !geo.strokeIsConvertedToFill(); |
| stroke2RoundBevelAndFillDashCase.testExpectations(reporter, expectations); |
| make_TestCase(geo, stroke2RoundBevelAndFillDash, reporter)->compare( |
| reporter, stroke2RoundBevelAndFillDashCase, TestCase::kAllSame_ComparisonExpecation); |
| stroke2RoundBevelAndFillDashCase.compare(reporter, stroke2RoundBevelAndFillCase, |
| TestCase::kAllSame_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 (except |
| // in the line and unclosed rect cases). |
| if (geo.fillChangesGeom()) { |
| hairlineCase.compare(reporter, fillCase, TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| 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()); |
| |
| } |
| |
| static void test_scale(skiatest::Reporter* reporter, const Geo& geo) { |
| sk_sp<SkPathEffect> 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 |
| if (geo.strokeIsConvertedToFill()) { |
| REPORTER_ASSERT(reporter, !strokeCase1.baseShape().style().applies()); |
| strokeCase1.compare(reporter, strokeCase2, TestCase::kAllSame_ComparisonExpecation); |
| } else { |
| 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); |
| SkPaint strokeAndFillDash = strokeDash; |
| strokeAndFillDash.setStyle(SkPaint::kStrokeAndFill_Style); |
| // Dash is ignored for stroke and fill |
| TestCase strokeAndFillDashCase1(geo, strokeAndFillDash, reporter, kS1); |
| TestCase strokeAndFillDashCase2(geo, strokeAndFillDash, reporter, kS2); |
| // Scale affects the stroke, but check to make sure this didn't become a simpler shape (e.g. |
| // stroke-and-filled rect can become a rect), in which case the scale shouldn't matter and the |
| // geometries should agree. |
| if (geo.strokeAndFillIsConvertedToFill(strokeAndFillDash)) { |
| REPORTER_ASSERT(reporter, !strokeAndFillCase1.baseShape().style().applies()); |
| strokeAndFillCase1.compare(reporter, strokeAndFillCase2, |
| TestCase::kAllSame_ComparisonExpecation); |
| strokeAndFillDashCase1.compare(reporter, strokeAndFillDashCase2, |
| TestCase::kAllSame_ComparisonExpecation); |
| } else { |
| strokeAndFillCase1.compare(reporter, strokeAndFillCase2, |
| TestCase::kSameUpToStroke_ComparisonExpecation); |
| } |
| strokeAndFillDashCase1.compare(reporter, strokeAndFillCase1, |
| TestCase::kAllSame_ComparisonExpecation); |
| strokeAndFillDashCase2.compare(reporter, strokeAndFillCase2, |
| TestCase::kAllSame_ComparisonExpecation); |
| } |
| |
| template <typename T> |
| static void test_stroke_param_impl(skiatest::Reporter* reporter, const Geo& geo, |
| std::function<void(SkPaint*, T)> 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) { |
| // If stroking is immediately incorporated into a geometric transformation then the base |
| // shapes will differ. |
| if (geo.strokeIsConvertedToFill()) { |
| strokeACase.compare(reporter, strokeBCase, |
| TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| 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) { |
| // If stroking is immediately incorporated into a geometric transformation then the base |
| // shapes will differ. |
| if (geo.strokeAndFillIsConvertedToFill(strokeAndFillA) || |
| geo.strokeAndFillIsConvertedToFill(strokeAndFillB)) { |
| strokeAndFillACase.compare(reporter, strokeAndFillBCase, |
| TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| 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); |
| } |
| } |
| |
| template <typename T> |
| static void test_stroke_param(skiatest::Reporter* reporter, const Geo& geo, |
| std::function<void(SkPaint*, T)> setter, T a, T b) { |
| test_stroke_param_impl(reporter, geo, setter, a, b, true, true); |
| }; |
| |
| static void test_stroke_cap(skiatest::Reporter* reporter, const Geo& geo) { |
| SkPaint hairline; |
| hairline.setStrokeWidth(0); |
| hairline.setStyle(SkPaint::kStroke_Style); |
| GrStyledShape shape = geo.makeShape(hairline); |
| // 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<SkPaint::Cap>( |
| reporter, |
| geo, |
| [](SkPaint* p, SkPaint::Cap c) { p->setStrokeCap(c);}, |
| SkPaint::kButt_Cap, SkPaint::kRound_Cap, |
| affectsStroke, |
| affectsDashAndStroke); |
| }; |
| |
| static bool shape_known_not_to_have_joins(const GrStyledShape& shape) { |
| return shape.asLine(nullptr, nullptr) || shape.isEmpty(); |
| } |
| |
| static void test_stroke_join(skiatest::Reporter* reporter, const Geo& geo) { |
| SkPaint hairline; |
| hairline.setStrokeWidth(0); |
| hairline.setStyle(SkPaint::kStroke_Style); |
| GrStyledShape shape = geo.makeShape(hairline); |
| // GrStyledShape recognizes certain types don't have joins and will prevent the join type from |
| // affecting the style key. |
| // Dashing doesn't add additional joins. However, GrStyledShape currently loses track of this |
| // after applying the dash. |
| bool affectsStroke = !shape_known_not_to_have_joins(shape); |
| test_stroke_param_impl<SkPaint::Join>( |
| reporter, |
| geo, |
| [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);}, |
| SkPaint::kRound_Join, SkPaint::kBevel_Join, |
| affectsStroke, true); |
| }; |
| |
| 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); |
| }; |
| |
| SkPaint hairline; |
| hairline.setStrokeWidth(0); |
| hairline.setStyle(SkPaint::kStroke_Style); |
| GrStyledShape shape = geo.makeShape(hairline); |
| bool mayHaveJoins = !shape_known_not_to_have_joins(shape); |
| |
| // The miter limit should affect stroked and dashed-stroked cases when the join type is |
| // miter. |
| test_stroke_param_impl<SkScalar>( |
| reporter, |
| geo, |
| setMiterJoinAndLimit, |
| 0.5f, 0.75f, |
| mayHaveJoins, |
| true); |
| |
| // The miter limit should not affect stroked and dashed-stroked cases when the join type is |
| // not miter. |
| test_stroke_param_impl<SkScalar>( |
| reporter, |
| geo, |
| setOtherJoinAndLimit, |
| 0.5f, 0.75f, |
| false, |
| false); |
| } |
| |
| static void test_dash_fill(skiatest::Reporter* reporter, const Geo& geo) { |
| // A dash with no stroke should have no effect |
| using DashFactoryFn = sk_sp<SkPathEffect>(*)(); |
| 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); |
| } |
| } |
| |
| 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); |
| |
| // We expect the null dash to be ignored so nullDashCase should match strokeCase, always. |
| nullDashCase.compare(reporter, strokeCase, TestCase::kAllSame_ComparisonExpecation); |
| // Check whether the fillCase or strokeCase/nullDashCase would undergo a geometric tranformation |
| // on construction in order to determine how to compare the fill and stroke. |
| if (geo.fillChangesGeom() || geo.strokeIsConvertedToFill()) { |
| nullDashCase.compare(reporter, fillCase, TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| nullDashCase.compare(reporter, fillCase, TestCase::kSameUpToStroke_ComparisonExpecation); |
| } |
| // In the null dash case we may immediately convert to a fill, but not for the normal dash case. |
| if (geo.strokeIsConvertedToFill()) { |
| nullDashCase.compare(reporter, dashCase, TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| nullDashCase.compare(reporter, dashCase, TestCase::kSameUpToPE_ComparisonExpecation); |
| } |
| } |
| |
| 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; |
| } |
| |
| static sk_sp<SkPathEffect> Make() { return sk_sp<SkPathEffect>(new RRectPathEffect); } |
| Factory getFactory() const override { return nullptr; } |
| const char* getTypeName() const override { return nullptr; } |
| |
| protected: |
| bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, |
| const SkRect* cullR) const override { |
| dst->reset(); |
| dst->addRRect(RRect()); |
| return true; |
| } |
| |
| SkRect onComputeFastBounds(const SkRect& src) const override { |
| return RRect().getBounds(); |
| } |
| |
| 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); |
| |
| // Check whether constructing the filled case would cause the base shape to have a different |
| // geometry (because of a geometric transformation upon initial GrStyledShape construction). |
| if (geo.fillChangesGeom()) { |
| fillGeoCase.compare(reporter, geoPECase, TestCase::kAllDifferent_ComparisonExpecation); |
| fillGeoCase.compare(reporter, geoPEStrokeCase, |
| TestCase::kAllDifferent_ComparisonExpecation); |
| } else { |
| fillGeoCase.compare(reporter, geoPECase, TestCase::kSameUpToPE_ComparisonExpecation); |
| fillGeoCase.compare(reporter, geoPEStrokeCase, TestCase::kSameUpToPE_ComparisonExpecation); |
| } |
| geoPECase.compare(reporter, geoPEStrokeCase, |
| TestCase::kSameUpToStroke_ComparisonExpecation); |
| |
| TestCase rrectFillCase(reporter, RRectPathEffect::RRect(), fill); |
| SkPaint stroke = peStroke; |
| stroke.setPathEffect(nullptr); |
| TestCase rrectStrokeCase(reporter, RRectPathEffect::RRect(), stroke); |
| |
| 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, nullptr, nullptr, |
| nullptr)); |
| REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect()); |
| REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectKey() == rrectFillCase.baseKey()); |
| |
| REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleShape().asRRect(&rrect, nullptr, nullptr, |
| nullptr)); |
| 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, nullptr, |
| nullptr, nullptr)); |
| REPORTER_ASSERT(reporter, rrect == RRectPathEffect::RRect()); |
| REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedPathEffectKey() == rrectFillCase.baseKey()); |
| |
| REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedFullStyleShape().asRRect(&rrect, nullptr, |
| nullptr, nullptr)); |
| REPORTER_ASSERT(reporter, geoPEStrokeCase.appliedFullStyleKey() == |
| rrectStrokeCase.appliedFullStyleKey()); |
| } |
| |
| 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: |
| static sk_sp<SkPathEffect> Make() { return sk_sp<SkPathEffect>(new AddLineTosPathEffect); } |
| Factory getFactory() const override { return nullptr; } |
| const char* getTypeName() const override { return nullptr; } |
| |
| protected: |
| bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, |
| const SkRect* cullR) const override { |
| *dst = src; |
| // To avoid triggering data-based keying of paths with few verbs we add many segments. |
| for (int i = 0; i < 100; ++i) { |
| dst->lineTo(SkIntToScalar(i), SkIntToScalar(i)); |
| } |
| return true; |
| } |
| SkRect onComputeFastBounds(const SkRect& src) const override { |
| SkRect dst = src; |
| SkRectPriv::GrowToInclude(&dst, {0, 0}); |
| SkRectPriv::GrowToInclude(&dst, {100, 100}); |
| return dst; |
| } |
| 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); |
| } |
| |
| void test_make_hairline_path_effect(skiatest::Reporter* reporter, const Geo& geo) { |
| /** |
| * This path effect just changes the stroke rec to hairline. |
| */ |
| class MakeHairlinePathEffect : SkPathEffect { |
| public: |
| static sk_sp<SkPathEffect> Make() { |
| return sk_sp<SkPathEffect>(new MakeHairlinePathEffect); |
| } |
| Factory getFactory() const override { return nullptr; } |
| const char* getTypeName() const override { return nullptr; } |
| |
| protected: |
| bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec* strokeRec, |
| const SkRect* cullR) const override { |
| *dst = src; |
| strokeRec->setHairlineStyle(); |
| return true; |
| } |
| private: |
| MakeHairlinePathEffect() {} |
| }; |
| |
| SkPaint fill; |
| SkPaint pe; |
| pe.setPathEffect(MakeHairlinePathEffect::Make()); |
| |
| TestCase peCase(geo, pe, reporter); |
| |
| SkPath a, b, c; |
| peCase.baseShape().asPath(&a); |
| peCase.appliedPathEffectShape().asPath(&b); |
| peCase.appliedFullStyleShape().asPath(&c); |
| if (geo.isNonPath(pe)) { |
| // RRect types can have a change in start index or direction after the PE is applied. This |
| // is because once the PE is applied, GrStyledShape may canonicalize the dir and index since |
| // it is not germane to the styling any longer. |
| // Instead we just check that the paths would fill the same both before and after styling. |
| REPORTER_ASSERT(reporter, paths_fill_same(a, b)); |
| REPORTER_ASSERT(reporter, paths_fill_same(a, c)); |
| } else { |
| // The base shape cannot perform canonicalization on the path's fill type because of an |
| // unknown path effect. However, after the path effect is applied the resulting hairline |
| // shape will canonicalize the path fill type since hairlines (and stroking in general) |
| // don't distinguish between even/odd and non-zero winding. |
| a.setFillType(b.getFillType()); |
| REPORTER_ASSERT(reporter, a == b); |
| REPORTER_ASSERT(reporter, a == c); |
| // If the resulting path is small enough then it will have a key. |
| REPORTER_ASSERT(reporter, paths_fill_same(a, b)); |
| REPORTER_ASSERT(reporter, paths_fill_same(a, c)); |
| REPORTER_ASSERT(reporter, peCase.appliedPathEffectKey().empty()); |
| REPORTER_ASSERT(reporter, peCase.appliedFullStyleKey().empty()); |
| } |
| REPORTER_ASSERT(reporter, peCase.appliedPathEffectShape().style().isSimpleHairline()); |
| REPORTER_ASSERT(reporter, peCase.appliedFullStyleShape().style().isSimpleHairline()); |
| } |
| |
| void test_volatile_path(skiatest::Reporter* reporter, const Geo& geo) { |
| SkPath vPath = geo.path(); |
| vPath.setIsVolatile(true); |
| |
| SkPaint dashAndStroke; |
| dashAndStroke.setPathEffect(make_dash()); |
| dashAndStroke.setStrokeWidth(2.f); |
| dashAndStroke.setStyle(SkPaint::kStroke_Style); |
| TestCase volatileCase(reporter, vPath, dashAndStroke); |
| // We expect a shape made from a volatile path to have a key iff the shape is recognized |
| // as a specialized geometry. |
| if (geo.isNonPath(dashAndStroke)) { |
| REPORTER_ASSERT(reporter, SkToBool(volatileCase.baseKey().count())); |
| // In this case all the keys should be identical to the non-volatile case. |
| TestCase nonVolatileCase(reporter, geo.path(), dashAndStroke); |
| 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())); |
| } |
| } |
| |
| void test_path_effect_makes_empty_shape(skiatest::Reporter* reporter, const Geo& geo) { |
| /** |
| * This path effect returns an empty path (possibly inverted) |
| */ |
| class EmptyPathEffect : SkPathEffect { |
| public: |
| static sk_sp<SkPathEffect> Make(bool invert) { |
| return sk_sp<SkPathEffect>(new EmptyPathEffect(invert)); |
| } |
| Factory getFactory() const override { return nullptr; } |
| const char* getTypeName() const override { return nullptr; } |
| protected: |
| bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, |
| const SkRect* cullR) const override { |
| dst->reset(); |
| if (fInvert) { |
| dst->toggleInverseFillType(); |
| } |
| return true; |
| } |
| SkRect onComputeFastBounds(const SkRect& src) const override { |
| return { 0, 0, 0, 0 }; |
| } |
| private: |
| bool fInvert; |
| EmptyPathEffect(bool invert) : fInvert(invert) {} |
| }; |
| |
| SkPath emptyPath; |
| GrStyledShape emptyShape(emptyPath); |
| Key emptyKey; |
| make_key(&emptyKey, emptyShape); |
| REPORTER_ASSERT(reporter, emptyShape.isEmpty()); |
| |
| emptyPath.toggleInverseFillType(); |
| GrStyledShape invertedEmptyShape(emptyPath); |
| Key invertedEmptyKey; |
| make_key(&invertedEmptyKey, invertedEmptyShape); |
| REPORTER_ASSERT(reporter, invertedEmptyShape.isEmpty()); |
| |
| REPORTER_ASSERT(reporter, invertedEmptyKey != emptyKey); |
| |
| SkPaint pe; |
| pe.setPathEffect(EmptyPathEffect::Make(false)); |
| TestCase geoPECase(geo, pe, reporter); |
| REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleKey() == emptyKey); |
| REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectKey() == emptyKey); |
| REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectThenStrokeKey() == emptyKey); |
| REPORTER_ASSERT(reporter, geoPECase.appliedPathEffectShape().isEmpty()); |
| REPORTER_ASSERT(reporter, geoPECase.appliedFullStyleShape().isEmpty()); |
| REPORTER_ASSERT(reporter, !geoPECase.appliedPathEffectShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, !geoPECase.appliedFullStyleShape().inverseFilled()); |
| |
| SkPaint peStroke; |
| peStroke.setPathEffect(EmptyPathEffect::Make(false)); |
| 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()); |
| REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedPathEffectShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, !geoPEStrokeCase.appliedFullStyleShape().inverseFilled()); |
| pe.setPathEffect(EmptyPathEffect::Make(true)); |
| |
| TestCase geoPEInvertCase(geo, pe, reporter); |
| REPORTER_ASSERT(reporter, geoPEInvertCase.appliedFullStyleKey() == invertedEmptyKey); |
| REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectKey() == invertedEmptyKey); |
| REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectThenStrokeKey() == invertedEmptyKey); |
| REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectShape().isEmpty()); |
| REPORTER_ASSERT(reporter, geoPEInvertCase.appliedFullStyleShape().isEmpty()); |
| REPORTER_ASSERT(reporter, geoPEInvertCase.appliedPathEffectShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, geoPEInvertCase.appliedFullStyleShape().inverseFilled()); |
| |
| peStroke.setPathEffect(EmptyPathEffect::Make(true)); |
| TestCase geoPEInvertStrokeCase(geo, peStroke, reporter); |
| REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedFullStyleKey() == invertedEmptyKey); |
| REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedPathEffectKey() == invertedEmptyKey); |
| REPORTER_ASSERT(reporter, |
| geoPEInvertStrokeCase.appliedPathEffectThenStrokeKey() == invertedEmptyKey); |
| REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedPathEffectShape().isEmpty()); |
| REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedFullStyleShape().isEmpty()); |
| REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedPathEffectShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, geoPEInvertStrokeCase.appliedFullStyleShape().inverseFilled()); |
| } |
| |
| void test_path_effect_fails(skiatest::Reporter* reporter, const Geo& geo) { |
| /** |
| * This path effect always fails to apply. |
| */ |
| class FailurePathEffect : SkPathEffect { |
| public: |
| static sk_sp<SkPathEffect> Make() { return sk_sp<SkPathEffect>(new FailurePathEffect); } |
| Factory getFactory() const override { return nullptr; } |
| const char* getTypeName() const override { return nullptr; } |
| protected: |
| bool onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, |
| const SkRect* cullR) const override { |
| return false; |
| } |
| private: |
| FailurePathEffect() {} |
| }; |
| |
| SkPaint fill; |
| TestCase fillCase(geo, fill, reporter); |
| |
| SkPaint pe; |
| pe.setPathEffect(FailurePathEffect::Make()); |
| TestCase peCase(geo, pe, reporter); |
| |
| SkPaint stroke; |
| stroke.setStrokeWidth(2.f); |
| stroke.setStyle(SkPaint::kStroke_Style); |
| TestCase strokeCase(geo, stroke, reporter); |
| |
| SkPaint peStroke = stroke; |
| peStroke.setPathEffect(FailurePathEffect::Make()); |
| TestCase peStrokeCase(geo, peStroke, reporter); |
| |
| // In general the path effect failure can cause some of the TestCase::compare() tests to fail |
| // for at least two reasons: 1) We will initially treat the shape as unkeyable because of the |
| // path effect, but then when the path effect fails we can key it. 2) GrStyledShape will change |
| // its mind about whether a unclosed rect is actually rect. The path effect initially bars us |
| // from closing it but after the effect fails we can (for the fill+pe case). This causes |
| // different routes through GrStyledShape to have equivalent but different representations of |
| // the path (closed or not) but that fill the same. |
| SkPath a; |
| SkPath b; |
| fillCase.appliedPathEffectShape().asPath(&a); |
| peCase.appliedPathEffectShape().asPath(&b); |
| REPORTER_ASSERT(reporter, paths_fill_same(a, b)); |
| |
| fillCase.appliedFullStyleShape().asPath(&a); |
| peCase.appliedFullStyleShape().asPath(&b); |
| REPORTER_ASSERT(reporter, paths_fill_same(a, b)); |
| |
| strokeCase.appliedPathEffectShape().asPath(&a); |
| peStrokeCase.appliedPathEffectShape().asPath(&b); |
| REPORTER_ASSERT(reporter, paths_fill_same(a, b)); |
| |
| strokeCase.appliedFullStyleShape().asPath(&a); |
| peStrokeCase.appliedFullStyleShape().asPath(&b); |
| REPORTER_ASSERT(reporter, paths_fill_same(a, b)); |
| } |
| |
| DEF_TEST(GrStyledShape_empty_shape, reporter) { |
| SkPath emptyPath; |
| SkPath invertedEmptyPath; |
| invertedEmptyPath.toggleInverseFillType(); |
| SkPaint fill; |
| TestCase fillEmptyCase(reporter, emptyPath, fill); |
| REPORTER_ASSERT(reporter, fillEmptyCase.baseShape().isEmpty()); |
| REPORTER_ASSERT(reporter, fillEmptyCase.appliedPathEffectShape().isEmpty()); |
| REPORTER_ASSERT(reporter, fillEmptyCase.appliedFullStyleShape().isEmpty()); |
| REPORTER_ASSERT(reporter, !fillEmptyCase.baseShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, !fillEmptyCase.appliedPathEffectShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, !fillEmptyCase.appliedFullStyleShape().inverseFilled()); |
| TestCase fillInvertedEmptyCase(reporter, invertedEmptyPath, fill); |
| REPORTER_ASSERT(reporter, fillInvertedEmptyCase.baseShape().isEmpty()); |
| REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedPathEffectShape().isEmpty()); |
| REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedFullStyleShape().isEmpty()); |
| REPORTER_ASSERT(reporter, fillInvertedEmptyCase.baseShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedPathEffectShape().inverseFilled()); |
| REPORTER_ASSERT(reporter, fillInvertedEmptyCase.appliedFullStyleShape().inverseFilled()); |
| |
| const Key& emptyKey = fillEmptyCase.baseKey(); |
| REPORTER_ASSERT(reporter, emptyKey.count()); |
| const Key& inverseEmptyKey = fillInvertedEmptyCase.baseKey(); |
| REPORTER_ASSERT(reporter, inverseEmptyKey.count()); |
| TestCase::SelfExpectations expectations; |
| expectations.fStrokeApplies = false; |
| expectations.fPEHasEffect = false; |
| // This will test whether applying style preserves emptiness |
| fillEmptyCase.testExpectations(reporter, expectations); |
| fillInvertedEmptyCase.testExpectations(reporter, expectations); |
| |
| // Stroking an empty path should have no effect |
| SkPaint stroke; |
| stroke.setStrokeWidth(2.f); |
| stroke.setStyle(SkPaint::kStroke_Style); |
| stroke.setStrokeJoin(SkPaint::kRound_Join); |
| stroke.setStrokeCap(SkPaint::kRound_Cap); |
| TestCase strokeEmptyCase(reporter, emptyPath, stroke); |
| strokeEmptyCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation); |
| TestCase strokeInvertedEmptyCase(reporter, invertedEmptyPath, stroke); |
| strokeInvertedEmptyCase.compare(reporter, fillInvertedEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| // Dashing and stroking an empty path should have no effect |
| SkPaint dashAndStroke; |
| dashAndStroke.setPathEffect(make_dash()); |
| dashAndStroke.setStrokeWidth(2.f); |
| dashAndStroke.setStyle(SkPaint::kStroke_Style); |
| TestCase dashAndStrokeEmptyCase(reporter, emptyPath, dashAndStroke); |
| dashAndStrokeEmptyCase.compare(reporter, fillEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| TestCase dashAndStrokeInvertexEmptyCase(reporter, invertedEmptyPath, dashAndStroke); |
| // Dashing ignores inverseness so this is equivalent to the non-inverted empty fill. |
| dashAndStrokeInvertexEmptyCase.compare(reporter, fillEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| // A shape made from an empty rrect should behave the same as an empty path when filled and |
| // when stroked. The shape is closed so it does not produce caps when stroked. When dashed there |
| // is no path to dash along, making it equivalent as well. |
| SkRRect emptyRRect = SkRRect::MakeEmpty(); |
| REPORTER_ASSERT(reporter, emptyRRect.getType() == SkRRect::kEmpty_Type); |
| |
| TestCase fillEmptyRRectCase(reporter, emptyRRect, fill); |
| fillEmptyRRectCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation); |
| |
| TestCase strokeEmptyRRectCase(reporter, emptyRRect, stroke); |
| strokeEmptyRRectCase.compare(reporter, strokeEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| TestCase dashAndStrokeEmptyRRectCase(reporter, emptyRRect, dashAndStroke); |
| dashAndStrokeEmptyRRectCase.compare(reporter, fillEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| static constexpr SkPathDirection kDir = SkPathDirection::kCCW; |
| static constexpr int kStart = 0; |
| |
| TestCase fillInvertedEmptyRRectCase(reporter, emptyRRect, kDir, kStart, true, GrStyle(fill)); |
| fillInvertedEmptyRRectCase.compare(reporter, fillInvertedEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| TestCase strokeInvertedEmptyRRectCase(reporter, emptyRRect, kDir, kStart, true, |
| GrStyle(stroke)); |
| strokeInvertedEmptyRRectCase.compare(reporter, strokeInvertedEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| TestCase dashAndStrokeEmptyInvertedRRectCase(reporter, emptyRRect, kDir, kStart, true, |
| GrStyle(dashAndStroke)); |
| dashAndStrokeEmptyInvertedRRectCase.compare(reporter, fillEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| // Same for a rect. |
| SkRect emptyRect = SkRect::MakeEmpty(); |
| TestCase fillEmptyRectCase(reporter, emptyRect, fill); |
| fillEmptyRectCase.compare(reporter, fillEmptyCase, TestCase::kAllSame_ComparisonExpecation); |
| |
| TestCase dashAndStrokeEmptyRectCase(reporter, emptyRect, dashAndStroke); |
| dashAndStrokeEmptyRectCase.compare(reporter, fillEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| TestCase dashAndStrokeEmptyInvertedRectCase(reporter, SkRRect::MakeRect(emptyRect), kDir, |
| kStart, true, GrStyle(dashAndStroke)); |
| // Dashing ignores inverseness so this is equivalent to the non-inverted empty fill. |
| dashAndStrokeEmptyInvertedRectCase.compare(reporter, fillEmptyCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| } |
| |
| // rect and oval types have rrect start indices that collapse to the same point. Here we select the |
| // canonical point in these cases. |
| unsigned canonicalize_rrect_start(int s, const SkRRect& rrect) { |
| switch (rrect.getType()) { |
| case SkRRect::kRect_Type: |
| return (s + 1) & 0b110; |
| case SkRRect::kOval_Type: |
| return s & 0b110; |
| default: |
| return s; |
| } |
| } |
| |
| void test_rrect(skiatest::Reporter* r, const SkRRect& rrect) { |
| enum Style { |
| kFill, |
| kStroke, |
| kHairline, |
| kStrokeAndFill |
| }; |
| |
| // SkStrokeRec has no default cons., so init with kFill before calling the setters below. |
| SkStrokeRec strokeRecs[4] { SkStrokeRec::kFill_InitStyle, SkStrokeRec::kFill_InitStyle, |
| SkStrokeRec::kFill_InitStyle, SkStrokeRec::kFill_InitStyle}; |
| strokeRecs[kFill].setFillStyle(); |
| strokeRecs[kStroke].setStrokeStyle(2.f); |
| strokeRecs[kHairline].setHairlineStyle(); |
| strokeRecs[kStrokeAndFill].setStrokeStyle(3.f, true); |
| // Use a bevel join to avoid complications of stroke+filled rects becoming filled rects before |
| // applyStyle() is called. |
| strokeRecs[kStrokeAndFill].setStrokeParams(SkPaint::kButt_Cap, SkPaint::kBevel_Join, 1.f); |
| sk_sp<SkPathEffect> dashEffect = make_dash(); |
| |
| static constexpr Style kStyleCnt = static_cast<Style>(SK_ARRAY_COUNT(strokeRecs)); |
| |
| auto index = [](bool inverted, |
| SkPathDirection dir, |
| unsigned start, |
| Style style, |
| bool dash) -> int { |
| return inverted * (2 * 8 * kStyleCnt * 2) + |
| (int)dir * ( 8 * kStyleCnt * 2) + |
| start * ( kStyleCnt * 2) + |
| style * ( 2) + |
| dash; |
| }; |
| static const SkPathDirection kSecondDirection = static_cast<SkPathDirection>(1); |
| const int cnt = index(true, kSecondDirection, 7, static_cast<Style>(kStyleCnt - 1), true) + 1; |
| SkAutoTArray<GrStyledShape> shapes(cnt); |
| for (bool inverted : {false, true}) { |
| for (SkPathDirection dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) { |
| for (unsigned start = 0; start < 8; ++start) { |
| for (Style style : {kFill, kStroke, kHairline, kStrokeAndFill}) { |
| for (bool dash : {false, true}) { |
| sk_sp<SkPathEffect> pe = dash ? dashEffect : nullptr; |
| shapes[index(inverted, dir, start, style, dash)] = |
| GrStyledShape(rrect, dir, start, SkToBool(inverted), |
| GrStyle(strokeRecs[style], std::move(pe))); |
| } |
| } |
| } |
| } |
| } |
| |
| // Get the keys for some example shape instances that we'll use for comparision against the |
| // rest. |
| static constexpr SkPathDirection kExamplesDir = SkPathDirection::kCW; |
| static constexpr unsigned kExamplesStart = 0; |
| const GrStyledShape& exampleFillCase = shapes[index(false, kExamplesDir, kExamplesStart, kFill, |
| false)]; |
| Key exampleFillCaseKey; |
| make_key(&exampleFillCaseKey, exampleFillCase); |
| |
| const GrStyledShape& exampleStrokeAndFillCase = shapes[index(false, kExamplesDir, |
| kExamplesStart, kStrokeAndFill, false)]; |
| Key exampleStrokeAndFillCaseKey; |
| make_key(&exampleStrokeAndFillCaseKey, exampleStrokeAndFillCase); |
| |
| const GrStyledShape& exampleInvFillCase = shapes[index(true, kExamplesDir, |
| kExamplesStart, kFill, false)]; |
| Key exampleInvFillCaseKey; |
| make_key(&exampleInvFillCaseKey, exampleInvFillCase); |
| |
| const GrStyledShape& exampleInvStrokeAndFillCase = shapes[index(true, kExamplesDir, |
| kExamplesStart, kStrokeAndFill, |
| false)]; |
| Key exampleInvStrokeAndFillCaseKey; |
| make_key(&exampleInvStrokeAndFillCaseKey, exampleInvStrokeAndFillCase); |
| |
| const GrStyledShape& exampleStrokeCase = shapes[index(false, kExamplesDir, kExamplesStart, |
| kStroke, false)]; |
| Key exampleStrokeCaseKey; |
| make_key(&exampleStrokeCaseKey, exampleStrokeCase); |
| |
| const GrStyledShape& exampleInvStrokeCase = shapes[index(true, kExamplesDir, kExamplesStart, |
| kStroke, false)]; |
| Key exampleInvStrokeCaseKey; |
| make_key(&exampleInvStrokeCaseKey, exampleInvStrokeCase); |
| |
| const GrStyledShape& exampleHairlineCase = shapes[index(false, kExamplesDir, kExamplesStart, |
| kHairline, false)]; |
| Key exampleHairlineCaseKey; |
| make_key(&exampleHairlineCaseKey, exampleHairlineCase); |
| |
| const GrStyledShape& exampleInvHairlineCase = shapes[index(true, kExamplesDir, kExamplesStart, |
| kHairline, false)]; |
| Key exampleInvHairlineCaseKey; |
| make_key(&exampleInvHairlineCaseKey, exampleInvHairlineCase); |
| |
| // These are dummy initializations to suppress warnings. |
| SkRRect queryRR = SkRRect::MakeEmpty(); |
| SkPathDirection queryDir = SkPathDirection::kCW; |
| unsigned queryStart = ~0U; |
| bool queryInverted = true; |
| |
| REPORTER_ASSERT(r, exampleFillCase.asRRect(&queryRR, &queryDir, &queryStart, &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, !queryInverted); |
| |
| REPORTER_ASSERT(r, exampleInvFillCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, queryInverted); |
| |
| REPORTER_ASSERT(r, exampleStrokeAndFillCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, !queryInverted); |
| |
| REPORTER_ASSERT(r, exampleInvStrokeAndFillCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, queryInverted); |
| |
| REPORTER_ASSERT(r, exampleHairlineCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, !queryInverted); |
| |
| REPORTER_ASSERT(r, exampleInvHairlineCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, queryInverted); |
| |
| REPORTER_ASSERT(r, exampleStrokeCase.asRRect(&queryRR, &queryDir, &queryStart, &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, !queryInverted); |
| |
| REPORTER_ASSERT(r, exampleInvStrokeCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, SkPathDirection::kCW == queryDir); |
| REPORTER_ASSERT(r, 0 == queryStart); |
| REPORTER_ASSERT(r, queryInverted); |
| |
| // Remember that the key reflects the geometry before styling is applied. |
| REPORTER_ASSERT(r, exampleFillCaseKey != exampleInvFillCaseKey); |
| REPORTER_ASSERT(r, exampleFillCaseKey == exampleStrokeAndFillCaseKey); |
| REPORTER_ASSERT(r, exampleFillCaseKey != exampleInvStrokeAndFillCaseKey); |
| REPORTER_ASSERT(r, exampleFillCaseKey == exampleStrokeCaseKey); |
| REPORTER_ASSERT(r, exampleFillCaseKey != exampleInvStrokeCaseKey); |
| REPORTER_ASSERT(r, exampleFillCaseKey == exampleHairlineCaseKey); |
| REPORTER_ASSERT(r, exampleFillCaseKey != exampleInvHairlineCaseKey); |
| REPORTER_ASSERT(r, exampleInvStrokeAndFillCaseKey == exampleInvFillCaseKey); |
| REPORTER_ASSERT(r, exampleInvStrokeAndFillCaseKey == exampleInvStrokeCaseKey); |
| REPORTER_ASSERT(r, exampleInvStrokeAndFillCaseKey == exampleInvHairlineCaseKey); |
| |
| for (bool inverted : {false, true}) { |
| for (SkPathDirection dir : {SkPathDirection::kCW, SkPathDirection::kCCW}) { |
| for (unsigned start = 0; start < 8; ++start) { |
| for (bool dash : {false, true}) { |
| const GrStyledShape& fillCase = shapes[index(inverted, dir, start, kFill, |
| dash)]; |
| Key fillCaseKey; |
| make_key(&fillCaseKey, fillCase); |
| |
| const GrStyledShape& strokeAndFillCase = shapes[index(inverted, dir, start, |
| kStrokeAndFill, dash)]; |
| Key strokeAndFillCaseKey; |
| make_key(&strokeAndFillCaseKey, strokeAndFillCase); |
| |
| // Both fill and stroke-and-fill shapes must respect the inverseness and both |
| // ignore dashing. |
| REPORTER_ASSERT(r, !fillCase.style().pathEffect()); |
| REPORTER_ASSERT(r, !strokeAndFillCase.style().pathEffect()); |
| TestCase a(fillCase, r); |
| TestCase b(inverted ? exampleInvFillCase : exampleFillCase, r); |
| TestCase c(strokeAndFillCase, r); |
| TestCase d(inverted ? exampleInvStrokeAndFillCase |
| : exampleStrokeAndFillCase, r); |
| a.compare(r, b, TestCase::kAllSame_ComparisonExpecation); |
| c.compare(r, d, TestCase::kAllSame_ComparisonExpecation); |
| |
| const GrStyledShape& strokeCase = shapes[index(inverted, dir, start, kStroke, |
| dash)]; |
| const GrStyledShape& hairlineCase = shapes[index(inverted, dir, start, |
| kHairline, dash)]; |
| |
| TestCase e(strokeCase, r); |
| TestCase g(hairlineCase, r); |
| |
| // Both hairline and stroke shapes must respect the dashing. |
| if (dash) { |
| // Dashing always ignores the inverseness. skbug.com/5421 |
| TestCase f(exampleStrokeCase, r); |
| TestCase h(exampleHairlineCase, r); |
| unsigned expectedStart = canonicalize_rrect_start(start, rrect); |
| REPORTER_ASSERT(r, strokeCase.style().pathEffect()); |
| REPORTER_ASSERT(r, hairlineCase.style().pathEffect()); |
| |
| REPORTER_ASSERT(r, strokeCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, queryDir == dir); |
| REPORTER_ASSERT(r, queryStart == expectedStart); |
| REPORTER_ASSERT(r, !queryInverted); |
| REPORTER_ASSERT(r, hairlineCase.asRRect(&queryRR, &queryDir, &queryStart, |
| &queryInverted)); |
| REPORTER_ASSERT(r, queryRR == rrect); |
| REPORTER_ASSERT(r, queryDir == dir); |
| REPORTER_ASSERT(r, queryStart == expectedStart); |
| REPORTER_ASSERT(r, !queryInverted); |
| |
| // The pre-style case for the dash will match the non-dash example iff the |
| // dir and start match (dir=cw, start=0). |
| if (0 == expectedStart && SkPathDirection::kCW == dir) { |
| e.compare(r, f, TestCase::kSameUpToPE_ComparisonExpecation); |
| g.compare(r, h, TestCase::kSameUpToPE_ComparisonExpecation); |
| } else { |
| e.compare(r, f, TestCase::kAllDifferent_ComparisonExpecation); |
| g.compare(r, h, TestCase::kAllDifferent_ComparisonExpecation); |
| } |
| } else { |
| TestCase f(inverted ? exampleInvStrokeCase : exampleStrokeCase, r); |
| TestCase h(inverted ? exampleInvHairlineCase : exampleHairlineCase, r); |
| REPORTER_ASSERT(r, !strokeCase.style().pathEffect()); |
| REPORTER_ASSERT(r, !hairlineCase.style().pathEffect()); |
| e.compare(r, f, TestCase::kAllSame_ComparisonExpecation); |
| g.compare(r, h, TestCase::kAllSame_ComparisonExpecation); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| DEF_TEST(GrStyledShape_lines, r) { |
| static constexpr SkPoint kA { 1, 1}; |
| static constexpr SkPoint kB { 5, -9}; |
| static constexpr SkPoint kC {-3, 17}; |
| |
| SkPath lineAB = SkPath::Line(kA, kB); |
| SkPath lineBA = SkPath::Line(kB, kA); |
| SkPath lineAC = SkPath::Line(kB, kC); |
| SkPath invLineAB = lineAB; |
| |
| invLineAB.setFillType(SkPathFillType::kInverseEvenOdd); |
| |
| SkPaint fill; |
| SkPaint stroke; |
| stroke.setStyle(SkPaint::kStroke_Style); |
| stroke.setStrokeWidth(2.f); |
| SkPaint hairline; |
| hairline.setStyle(SkPaint::kStroke_Style); |
| hairline.setStrokeWidth(0.f); |
| SkPaint dash = stroke; |
| dash.setPathEffect(make_dash()); |
| |
| TestCase fillAB(r, lineAB, fill); |
| TestCase fillEmpty(r, SkPath(), fill); |
| fillAB.compare(r, fillEmpty, TestCase::kAllSame_ComparisonExpecation); |
| REPORTER_ASSERT(r, !fillAB.baseShape().asLine(nullptr, nullptr)); |
| |
| SkPath path; |
| path.toggleInverseFillType(); |
| TestCase fillEmptyInverted(r, path, fill); |
| TestCase fillABInverted(r, invLineAB, fill); |
| fillABInverted.compare(r, fillEmptyInverted, TestCase::kAllSame_ComparisonExpecation); |
| REPORTER_ASSERT(r, !fillABInverted.baseShape().asLine(nullptr, nullptr)); |
| |
| TestCase strokeAB(r, lineAB, stroke); |
| TestCase strokeBA(r, lineBA, stroke); |
| TestCase strokeAC(r, lineAC, stroke); |
| |
| TestCase hairlineAB(r, lineAB, hairline); |
| TestCase hairlineBA(r, lineBA, hairline); |
| TestCase hairlineAC(r, lineAC, hairline); |
| |
| TestCase dashAB(r, lineAB, dash); |
| TestCase dashBA(r, lineBA, dash); |
| TestCase dashAC(r, lineAC, dash); |
| |
| strokeAB.compare(r, fillAB, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| strokeAB.compare(r, strokeBA, TestCase::kAllSame_ComparisonExpecation); |
| strokeAB.compare(r, strokeAC, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| hairlineAB.compare(r, hairlineBA, TestCase::kAllSame_ComparisonExpecation); |
| hairlineAB.compare(r, hairlineAC, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| dashAB.compare(r, dashBA, TestCase::kAllDifferent_ComparisonExpecation); |
| dashAB.compare(r, dashAC, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| strokeAB.compare(r, hairlineAB, TestCase::kSameUpToStroke_ComparisonExpecation); |
| |
| // One of dashAB or dashBA should have the same line as strokeAB. It depends upon how |
| // GrStyledShape canonicalizes line endpoints (when it can, i.e. when not dashed). |
| bool canonicalizeAsAB; |
| SkPoint canonicalPts[2] {kA, kB}; |
| // Init these to suppress warnings. |
| bool inverted = true; |
| SkPoint pts[2] {{0, 0}, {0, 0}}; |
| REPORTER_ASSERT(r, strokeAB.baseShape().asLine(pts, &inverted) && !inverted); |
| if (pts[0] == kA && pts[1] == kB) { |
| canonicalizeAsAB = true; |
| } else if (pts[1] == kA && pts[0] == kB) { |
| canonicalizeAsAB = false; |
| using std::swap; |
| swap(canonicalPts[0], canonicalPts[1]); |
| } else { |
| ERRORF(r, "Should return pts (a,b) or (b, a)"); |
| return; |
| } |
| |
| strokeAB.compare(r, canonicalizeAsAB ? dashAB : dashBA, |
| TestCase::kSameUpToPE_ComparisonExpecation); |
| REPORTER_ASSERT(r, strokeAB.baseShape().asLine(pts, &inverted) && !inverted && |
| pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]); |
| REPORTER_ASSERT(r, hairlineAB.baseShape().asLine(pts, &inverted) && !inverted && |
| pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]); |
| REPORTER_ASSERT(r, dashAB.baseShape().asLine(pts, &inverted) && !inverted && |
| pts[0] == kA && pts[1] == kB); |
| REPORTER_ASSERT(r, dashBA.baseShape().asLine(pts, &inverted) && !inverted && |
| pts[0] == kB && pts[1] == kA); |
| |
| |
| TestCase strokeInvAB(r, invLineAB, stroke); |
| TestCase hairlineInvAB(r, invLineAB, hairline); |
| TestCase dashInvAB(r, invLineAB, dash); |
| strokeInvAB.compare(r, strokeAB, TestCase::kAllDifferent_ComparisonExpecation); |
| hairlineInvAB.compare(r, hairlineAB, TestCase::kAllDifferent_ComparisonExpecation); |
| // Dashing ignores inverse. |
| dashInvAB.compare(r, dashAB, TestCase::kAllSame_ComparisonExpecation); |
| |
| REPORTER_ASSERT(r, strokeInvAB.baseShape().asLine(pts, &inverted) && inverted && |
| pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]); |
| REPORTER_ASSERT(r, hairlineInvAB.baseShape().asLine(pts, &inverted) && inverted && |
| pts[0] == canonicalPts[0] && pts[1] == canonicalPts[1]); |
| // Dashing ignores inverse. |
| REPORTER_ASSERT(r, dashInvAB.baseShape().asLine(pts, &inverted) && !inverted && |
| pts[0] == kA && pts[1] == kB); |
| |
| } |
| |
| DEF_TEST(GrStyledShape_stroked_lines, r) { |
| static constexpr SkScalar kIntervals1[] = {1.f, 0.f}; |
| auto dash1 = SkDashPathEffect::Make(kIntervals1, SK_ARRAY_COUNT(kIntervals1), 0.f); |
| REPORTER_ASSERT(r, dash1); |
| static constexpr SkScalar kIntervals2[] = {10.f, 0.f, 5.f, 0.f}; |
| auto dash2 = SkDashPathEffect::Make(kIntervals2, SK_ARRAY_COUNT(kIntervals2), 10.f); |
| REPORTER_ASSERT(r, dash2); |
| |
| sk_sp<SkPathEffect> pathEffects[] = {nullptr, std::move(dash1), std::move(dash2)}; |
| |
| for (const auto& pe : pathEffects) { |
| // Paints to try |
| SkPaint buttCap; |
| buttCap.setStyle(SkPaint::kStroke_Style); |
| buttCap.setStrokeWidth(4); |
| buttCap.setStrokeCap(SkPaint::kButt_Cap); |
| buttCap.setPathEffect(pe); |
| |
| SkPaint squareCap = buttCap; |
| squareCap.setStrokeCap(SkPaint::kSquare_Cap); |
| squareCap.setPathEffect(pe); |
| |
| SkPaint roundCap = buttCap; |
| roundCap.setStrokeCap(SkPaint::kRound_Cap); |
| roundCap.setPathEffect(pe); |
| |
| // vertical |
| SkPath linePath; |
| linePath.moveTo(4, 4); |
| linePath.lineTo(4, 5); |
| |
| SkPaint fill; |
| |
| make_TestCase(r, linePath, buttCap)->compare( |
| r, TestCase(r, SkRect::MakeLTRB(2, 4, 6, 5), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| make_TestCase(r, linePath, squareCap)->compare( |
| r, TestCase(r, SkRect::MakeLTRB(2, 2, 6, 7), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| make_TestCase(r, linePath, roundCap)->compare(r, |
| TestCase(r, SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 6, 7), 2, 2), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| // horizontal |
| linePath.reset(); |
| linePath.moveTo(4, 4); |
| linePath.lineTo(5, 4); |
| |
| make_TestCase(r, linePath, buttCap)->compare( |
| r, TestCase(r, SkRect::MakeLTRB(4, 2, 5, 6), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| make_TestCase(r, linePath, squareCap)->compare( |
| r, TestCase(r, SkRect::MakeLTRB(2, 2, 7, 6), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| make_TestCase(r, linePath, roundCap)->compare( |
| r, TestCase(r, SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 7, 6), 2, 2), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| |
| // point |
| linePath.reset(); |
| linePath.moveTo(4, 4); |
| linePath.lineTo(4, 4); |
| |
| make_TestCase(r, linePath, buttCap)->compare( |
| r, TestCase(r, SkRect::MakeEmpty(), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| make_TestCase(r, linePath, squareCap)->compare( |
| r, TestCase(r, SkRect::MakeLTRB(2, 2, 6, 6), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| make_TestCase(r, linePath, roundCap)->compare( |
| r, TestCase(r, SkRRect::MakeRectXY(SkRect::MakeLTRB(2, 2, 6, 6), 2, 2), fill), |
| TestCase::kAllSame_ComparisonExpecation); |
| } |
| } |
| |
| DEF_TEST(GrStyledShape_short_path_keys, r) { |
| SkPaint paints[4]; |
| paints[1].setStyle(SkPaint::kStroke_Style); |
| paints[1].setStrokeWidth(5.f); |
| paints[2].setStyle(SkPaint::kStroke_Style); |
| paints[2].setStrokeWidth(0.f); |
| paints[3].setStyle(SkPaint::kStrokeAndFill_Style); |
| paints[3].setStrokeWidth(5.f); |
| |
| auto compare = [r, &paints] (const SkPath& pathA, const SkPath& pathB, |
| TestCase::ComparisonExpecation expectation) { |
| SkPath volatileA = pathA; |
| SkPath volatileB = pathB; |
| volatileA.setIsVolatile(true); |
| volatileB.setIsVolatile(true); |
| for (const SkPaint& paint : paints) { |
| REPORTER_ASSERT(r, !GrStyledShape(volatileA, paint).hasUnstyledKey()); |
| REPORTER_ASSERT(r, !GrStyledShape(volatileB, paint).hasUnstyledKey()); |
| for (PathGeo::Invert invert : {PathGeo::Invert::kNo, PathGeo::Invert::kYes}) { |
| TestCase caseA(PathGeo(pathA, invert), paint, r); |
| TestCase caseB(PathGeo(pathB, invert), paint, r); |
| caseA.compare(r, caseB, expectation); |
| } |
| } |
| }; |
| |
| SkPath pathA; |
| SkPath pathB; |
| |
| // Two identical paths |
| pathA.lineTo(10.f, 10.f); |
| pathA.conicTo(20.f, 20.f, 20.f, 30.f, 0.7f); |
| |
| pathB.lineTo(10.f, 10.f); |
| pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.7f); |
| compare(pathA, pathB, TestCase::kAllSame_ComparisonExpecation); |
| |
| // Give path b a different point |
| pathB.reset(); |
| pathB.lineTo(10.f, 10.f); |
| pathB.conicTo(21.f, 20.f, 20.f, 30.f, 0.7f); |
| compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| // Give path b a different conic weight |
| pathB.reset(); |
| pathB.lineTo(10.f, 10.f); |
| pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.6f); |
| compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| // Give path b an extra lineTo verb |
| pathB.reset(); |
| pathB.lineTo(10.f, 10.f); |
| pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.6f); |
| pathB.lineTo(50.f, 50.f); |
| compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| // Give path b a close |
| pathB.reset(); |
| pathB.lineTo(10.f, 10.f); |
| pathB.conicTo(20.f, 20.f, 20.f, 30.f, 0.7f); |
| pathB.close(); |
| compare(pathA, pathB, TestCase::kAllDifferent_ComparisonExpecation); |
| } |
| |
| DEF_TEST(GrStyledShape, reporter) { |
| SkTArray<std::unique_ptr<Geo>> geos; |
| SkTArray<std::unique_ptr<RRectPathGeo>> rrectPathGeos; |
| |
| for (auto r : { SkRect::MakeWH(10, 20), |
| SkRect::MakeWH(-10, -20), |
| SkRect::MakeWH(-10, 20), |
| SkRect::MakeWH(10, -20)}) { |
| geos.emplace_back(new RectGeo(r)); |
| SkPath rectPath; |
| rectPath.addRect(r); |
| geos.emplace_back(new RRectPathGeo(rectPath, r, RRectPathGeo::RRectForStroke::kYes, |
| PathGeo::Invert::kNo)); |
| geos.emplace_back(new RRectPathGeo(rectPath, r, RRectPathGeo::RRectForStroke::kYes, |
| PathGeo::Invert::kYes)); |
| rrectPathGeos.emplace_back(new RRectPathGeo(rectPath, r, RRectPathGeo::RRectForStroke::kYes, |
| PathGeo::Invert::kNo)); |
| } |
| for (auto rr : { SkRRect::MakeRect(SkRect::MakeWH(10, 10)), |
| SkRRect::MakeRectXY(SkRect::MakeWH(10, 10), 3, 4), |
| SkRRect::MakeOval(SkRect::MakeWH(20, 20))}) { |
| geos.emplace_back(new RRectGeo(rr)); |
| test_rrect(reporter, rr); |
| SkPath rectPath; |
| rectPath.addRRect(rr); |
| geos.emplace_back(new RRectPathGeo(rectPath, rr, RRectPathGeo::RRectForStroke::kYes, |
| PathGeo::Invert::kNo)); |
| geos.emplace_back(new RRectPathGeo(rectPath, rr, RRectPathGeo::RRectForStroke::kYes, |
| PathGeo::Invert::kYes)); |
| rrectPathGeos.emplace_back(new RRectPathGeo(rectPath, rr, |
| RRectPathGeo::RRectForStroke::kYes, |
| PathGeo::Invert::kNo)); |
| } |
| |
| // Arcs |
| geos.emplace_back(new ArcGeo(SkRect::MakeWH(200, 100), 12.f, 110.f, false)); |
| geos.emplace_back(new ArcGeo(SkRect::MakeWH(200, 100), 12.f, 110.f, true)); |
| |
| { |
| SkPath openRectPath; |
| openRectPath.moveTo(0, 0); |
| openRectPath.lineTo(10, 0); |
| openRectPath.lineTo(10, 10); |
| openRectPath.lineTo(0, 10); |
| geos.emplace_back(new RRectPathGeo( |
| openRectPath, SkRect::MakeWH(10, 10), |
| RRectPathGeo::RRectForStroke::kNo, PathGeo::Invert::kNo)); |
| geos.emplace_back(new RRectPathGeo( |
| openRectPath, SkRect::MakeWH(10, 10), |
| RRectPathGeo::RRectForStroke::kNo, PathGeo::Invert::kYes)); |
| rrectPathGeos.emplace_back(new RRectPathGeo( |
| openRectPath, SkRect::MakeWH(10, 10), |
| RRectPathGeo::RRectForStroke::kNo, PathGeo::Invert::kNo)); |
| } |
| |
| { |
| SkPath quadPath; |
| quadPath.quadTo(10, 10, 5, 8); |
| geos.emplace_back(new PathGeo(quadPath, PathGeo::Invert::kNo)); |
| geos.emplace_back(new PathGeo(quadPath, PathGeo::Invert::kYes)); |
| } |
| |
| { |
| SkPath linePath; |
| linePath.lineTo(10, 10); |
| geos.emplace_back(new PathGeo(linePath, PathGeo::Invert::kNo)); |
| geos.emplace_back(new PathGeo(linePath, PathGeo::Invert::kYes)); |
| } |
| |
| // Horizontal and vertical paths become rrects when stroked. |
| { |
| SkPath vLinePath; |
| vLinePath.lineTo(0, 10); |
| geos.emplace_back(new PathGeo(vLinePath, PathGeo::Invert::kNo)); |
| geos.emplace_back(new PathGeo(vLinePath, PathGeo::Invert::kYes)); |
| } |
| |
| { |
| SkPath hLinePath; |
| hLinePath.lineTo(10, 0); |
| geos.emplace_back(new PathGeo(hLinePath, PathGeo::Invert::kNo)); |
| geos.emplace_back(new PathGeo(hLinePath, PathGeo::Invert::kYes)); |
| } |
| |
| for (int i = 0; i < geos.count(); ++i) { |
| test_basic(reporter, *geos[i]); |
| test_scale(reporter, *geos[i]); |
| test_dash_fill(reporter, *geos[i]); |
| test_null_dash(reporter, *geos[i]); |
| // Test modifying various stroke params. |
| test_stroke_param<SkScalar>( |
| reporter, *geos[i], |
| [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);}, |
| SkIntToScalar(2), SkIntToScalar(4)); |
| test_stroke_join(reporter, *geos[i]); |
| test_stroke_cap(reporter, *geos[i]); |
| test_miter_limit(reporter, *geos[i]); |
| test_path_effect_makes_rrect(reporter, *geos[i]); |
| test_unknown_path_effect(reporter, *geos[i]); |
| test_path_effect_makes_empty_shape(reporter, *geos[i]); |
| test_path_effect_fails(reporter, *geos[i]); |
| test_make_hairline_path_effect(reporter, *geos[i]); |
| test_volatile_path(reporter, *geos[i]); |
| } |
| |
| for (int i = 0; i < rrectPathGeos.count(); ++i) { |
| const RRectPathGeo& rrgeo = *rrectPathGeos[i]; |
| SkPaint fillPaint; |
| TestCase fillPathCase(reporter, rrgeo.path(), fillPaint); |
| SkRRect rrect; |
| REPORTER_ASSERT(reporter, rrgeo.isNonPath(fillPaint) == |
| fillPathCase.baseShape().asRRect(&rrect, nullptr, nullptr, |
| nullptr)); |
| if (rrgeo.isNonPath(fillPaint)) { |
| TestCase fillPathCase2(reporter, rrgeo.path(), fillPaint); |
| REPORTER_ASSERT(reporter, rrect == rrgeo.rrect()); |
| TestCase fillRRectCase(reporter, rrect, fillPaint); |
| fillPathCase2.compare(reporter, fillRRectCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| } |
| SkPaint strokePaint; |
| strokePaint.setStrokeWidth(3.f); |
| strokePaint.setStyle(SkPaint::kStroke_Style); |
| TestCase strokePathCase(reporter, rrgeo.path(), strokePaint); |
| if (rrgeo.isNonPath(strokePaint)) { |
| REPORTER_ASSERT(reporter, strokePathCase.baseShape().asRRect(&rrect, nullptr, nullptr, |
| nullptr)); |
| REPORTER_ASSERT(reporter, rrect == rrgeo.rrect()); |
| TestCase strokeRRectCase(reporter, rrect, strokePaint); |
| strokePathCase.compare(reporter, strokeRRectCase, |
| TestCase::kAllSame_ComparisonExpecation); |
| } |
| } |
| |
| // Test a volatile empty path. |
| test_volatile_path(reporter, PathGeo(SkPath(), PathGeo::Invert::kNo)); |
| } |
| |
| DEF_TEST(GrStyledShape_arcs, reporter) { |
| SkStrokeRec roundStroke(SkStrokeRec::kFill_InitStyle); |
| roundStroke.setStrokeStyle(2.f); |
| roundStroke.setStrokeParams(SkPaint::kRound_Cap, SkPaint::kRound_Join, 1.f); |
| |
| SkStrokeRec squareStroke(roundStroke); |
| squareStroke.setStrokeParams(SkPaint::kSquare_Cap, SkPaint::kRound_Join, 1.f); |
| |
| SkStrokeRec roundStrokeAndFill(roundStroke); |
| roundStrokeAndFill.setStrokeStyle(2.f, true); |
| |
| static constexpr SkScalar kIntervals[] = {1, 2}; |
| auto dash = SkDashPathEffect::Make(kIntervals, SK_ARRAY_COUNT(kIntervals), 1.5f); |
| |
| SkTArray<GrStyle> styles; |
| styles.push_back(GrStyle::SimpleFill()); |
| styles.push_back(GrStyle::SimpleHairline()); |
| styles.push_back(GrStyle(roundStroke, nullptr)); |
| styles.push_back(GrStyle(squareStroke, nullptr)); |
| styles.push_back(GrStyle(roundStrokeAndFill, nullptr)); |
| styles.push_back(GrStyle(roundStroke, dash)); |
| |
| for (const auto& style : styles) { |
| // An empty rect never draws anything according to SkCanvas::drawArc() docs. |
| TestCase emptyArc(GrStyledShape::MakeArc(SkRect::MakeEmpty(), 0, 90.f, false, style), |
| reporter); |
| TestCase emptyPath(reporter, SkPath(), style); |
| emptyArc.compare(reporter, emptyPath, TestCase::kAllSame_ComparisonExpecation); |
| |
| static constexpr SkRect kOval1{0, 0, 50, 50}; |
| static constexpr SkRect kOval2{50, 0, 100, 50}; |
| // Test that swapping starting and ending angle doesn't change the shape unless the arc |
| // has a path effect. Also test that different ovals produce different shapes. |
| TestCase arc1CW(GrStyledShape::MakeArc(kOval1, 0, 90.f, false, style), reporter); |
| TestCase arc1CCW(GrStyledShape::MakeArc(kOval1, 90.f, -90.f, false, style), reporter); |
| |
| TestCase arc1CWWithCenter(GrStyledShape::MakeArc(kOval1, 0, 90.f, true, style), reporter); |
| TestCase arc1CCWWithCenter(GrStyledShape::MakeArc(kOval1, 90.f, -90.f, true, style), |
| reporter); |
| |
| TestCase arc2CW(GrStyledShape::MakeArc(kOval2, 0, 90.f, false, style), reporter); |
| TestCase arc2CWWithCenter(GrStyledShape::MakeArc(kOval2, 0, 90.f, true, style), reporter); |
| |
| auto reversedExepectations = style.hasPathEffect() |
| ? TestCase::kAllDifferent_ComparisonExpecation |
| : TestCase::kAllSame_ComparisonExpecation; |
| arc1CW.compare(reporter, arc1CCW, reversedExepectations); |
| arc1CWWithCenter.compare(reporter, arc1CCWWithCenter, reversedExepectations); |
| arc1CW.compare(reporter, arc2CW, TestCase::kAllDifferent_ComparisonExpecation); |
| arc1CW.compare(reporter, arc1CWWithCenter, TestCase::kAllDifferent_ComparisonExpecation); |
| arc1CWWithCenter.compare(reporter, arc2CWWithCenter, |
| TestCase::kAllDifferent_ComparisonExpecation); |
| |
| // Test that two arcs that start at the same angle but specified differently are equivalent. |
| TestCase arc3A(GrStyledShape::MakeArc(kOval1, 224.f, 73.f, false, style), reporter); |
| TestCase arc3B(GrStyledShape::MakeArc(kOval1, 224.f - 360.f, 73.f, false, style), reporter); |
| arc3A.compare(reporter, arc3B, TestCase::kAllDifferent_ComparisonExpecation); |
| |
| // Test that an arc that traverses the entire oval (and then some) is equivalent to the |
| // oval itself unless there is a path effect. |
| TestCase ovalArc(GrStyledShape::MakeArc(kOval1, 150.f, -790.f, false, style), reporter); |
| TestCase oval(GrStyledShape(SkRRect::MakeOval(kOval1)), reporter); |
| auto ovalExpectations = style.hasPathEffect() ? TestCase::kAllDifferent_ComparisonExpecation |
| : TestCase::kAllSame_ComparisonExpecation; |
| if (style.strokeRec().getWidth() >= 0 && style.strokeRec().getCap() != SkPaint::kButt_Cap) { |
| ovalExpectations = TestCase::kAllDifferent_ComparisonExpecation; |
| } |
| ovalArc.compare(reporter, oval, ovalExpectations); |
| |
| // If the the arc starts/ends at the center then it is then equivalent to the oval only for |
| // simple fills. |
| TestCase ovalArcWithCenter(GrStyledShape::MakeArc(kOval1, 304.f, 1225.f, true, style), |
| reporter); |
| ovalExpectations = style.isSimpleFill() ? TestCase::kAllSame_ComparisonExpecation |
| : TestCase::kAllDifferent_ComparisonExpecation; |
| ovalArcWithCenter.compare(reporter, oval, ovalExpectations); |
| } |
| } |
| |
| DEF_TEST(GrShapeInversion, r) { |
| SkPath path; |
| SkScalar radii[] = {10.f, 10.f, 10.f, 10.f, |
| 10.f, 10.f, 10.f, 10.f}; |
| path.addRoundRect(SkRect::MakeWH(50, 50), radii); |
| path.toggleInverseFillType(); |
| |
| GrShape inverseRRect(path); |
| GrShape rrect(inverseRRect); |
| rrect.setInverted(false); |
| |
| REPORTER_ASSERT(r, inverseRRect.inverted() && inverseRRect.isPath()); |
| REPORTER_ASSERT(r, !rrect.inverted() && rrect.isPath()); |
| |
| // Invertedness should be preserved after simplification |
| inverseRRect.simplify(); |
| rrect.simplify(); |
| |
| REPORTER_ASSERT(r, inverseRRect.inverted() && inverseRRect.isRRect()); |
| REPORTER_ASSERT(r, !rrect.inverted() && rrect.isRRect()); |
| |
| // Invertedness should be reset when calling reset(). |
| inverseRRect.reset(); |
| REPORTER_ASSERT(r, !inverseRRect.inverted() && inverseRRect.isEmpty()); |
| inverseRRect.setPath(path); |
| inverseRRect.reset(); |
| REPORTER_ASSERT(r, !inverseRRect.inverted() && inverseRRect.isEmpty()); |
| } |