case Type::kEmpty:
break;
case Type::kRRect:
- fRRectData.fRRect = that.fRRectData.fRRect;
- fRRectData.fDir = that.fRRectData.fDir;
- fRRectData.fStart = that.fRRectData.fStart;
- fRRectData.fInverted = that.fRRectData.fInverted;
+ fRRectData = that.fRRectData;
+ break;
+ case Type::kLine:
+ fLineData = that.fLineData;
break;
case Type::kPath:
fPathData.fGenID = that.fPathData.fGenID;
return *this;
}
-const SkRect& GrShape::bounds() const {
+SkRect GrShape::bounds() const {
static constexpr SkRect kEmpty = SkRect::MakeEmpty();
switch (fType) {
case Type::kEmpty:
return kEmpty;
+ case Type::kLine: {
+ SkRect bounds;
+ if (fLineData.fPts[0].fX < fLineData.fPts[1].fX) {
+ bounds.fLeft = fLineData.fPts[0].fX;
+ bounds.fRight = fLineData.fPts[1].fX;
+ } else {
+ bounds.fLeft = fLineData.fPts[1].fX;
+ bounds.fRight = fLineData.fPts[0].fX;
+ }
+ if (fLineData.fPts[0].fY < fLineData.fPts[1].fY) {
+ bounds.fTop = fLineData.fPts[0].fY;
+ bounds.fBottom = fLineData.fPts[1].fY;
+ } else {
+ bounds.fTop = fLineData.fPts[1].fY;
+ bounds.fBottom = fLineData.fPts[0].fY;
+ }
+ return bounds;
+ }
case Type::kRRect:
return fRRectData.fRRect.getBounds();
case Type::kPath:
return kEmpty;
}
-void GrShape::styledBounds(SkRect* bounds) const {
+SkRect GrShape::styledBounds() const {
if (Type::kEmpty == fType && !fStyle.hasNonDashPathEffect()) {
- *bounds = SkRect::MakeEmpty();
- } else {
- fStyle.adjustBounds(bounds, this->bounds());
+ return SkRect::MakeEmpty();
}
+ SkRect bounds;
+ fStyle.adjustBounds(&bounds, this->bounds());
+ return bounds;
}
int GrShape::unstyledKeySize() const {
SkASSERT(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
// + 1 for the direction, start index, and inverseness.
return SkRRect::kSizeInMemory / sizeof(uint32_t) + 1;
+ case Type::kLine:
+ GR_STATIC_ASSERT(2 * sizeof(uint32_t) == sizeof(SkPoint));
+ // 4 for the end points and 1 for the inverseness
+ return 5;
case Type::kPath:
if (0 == fPathData.fGenID) {
return -1;
*key++ |= fRRectData.fStart;
SkASSERT(fRRectData.fStart < 8);
break;
+ case Type::kLine:
+ memcpy(key, fLineData.fPts, 2 * sizeof(SkPoint));
+ key += 4;
+ *key++ = fLineData.fInverted ? 1 : 0;
+ break;
case Type::kPath:
SkASSERT(fPathData.fGenID);
*key++ = fPathData.fGenID;
case Type::kEmpty:
break;
case Type::kRRect:
- fRRectData.fRRect = that.fRRectData.fRRect;
- fRRectData.fDir = that.fRRectData.fDir;
- fRRectData.fStart = that.fRRectData.fStart;
- fRRectData.fInverted = that.fRRectData.fInverted;
+ fRRectData = that.fRRectData;
+ break;
+ case Type::kLine:
+ fLineData = that.fLineData;
break;
case Type::kPath:
fPathData.fGenID = that.fPathData.fGenID;
SkPath::Direction rrectDir;
unsigned rrectStart;
bool inverted = this->path().isInverseFillType();
+ SkPoint pts[2];
if (this->path().isEmpty()) {
this->changeType(Type::kEmpty);
+ } else if (this->path().isLine(pts)) {
+ this->changeType(Type::kLine);
+ fLineData.fPts[0] = pts[0];
+ fLineData.fPts[1] = pts[1];
+ fLineData.fInverted = inverted;
} else if (this->path().isRRect(&rrect, &rrectDir, &rrectStart)) {
this->changeType(Type::kRRect);
fRRectData.fRRect = rrect;
fInheritedKey.reset(0);
if (Type::kRRect == fType) {
this->attemptToSimplifyRRect();
+ } else if (Type::kLine == fType) {
+ this->attemptToSimplifyLine();
}
} else {
if (fInheritedKey.count() || this->path().isVolatile()) {
fPathData.fGenID = this->path().getGenerationID();
}
if (this->style().isSimpleFill()) {
- // Filled paths are treated as though all their contours were closed.
- // Since SkPath doesn't track individual contours, this will only close the last. :(
- // There is no point in closing lines, though, since they loose their line-ness.
- if (!this->path().isLine(nullptr)) {
- this->path().close();
- this->path().setIsVolatile(true);
- }
+ this->path().close();
+ this->path().setIsVolatile(true);
}
if (!this->style().hasNonDashPathEffect()) {
if (this->style().strokeRec().getStyle() == SkStrokeRec::kStroke_Style ||
fRRectData.fInverted = false;
}
}
+
+void GrShape::attemptToSimplifyLine() {
+ if (fStyle.isSimpleFill() && !fLineData.fInverted) {
+ this->changeType(Type::kEmpty);
+ } else {
+ // Only path effects could care about the order of the points. Otherwise canonicalize
+ // the point order
+ if (!fStyle.hasPathEffect()) {
+ SkPoint* pts = fLineData.fPts;
+ if (pts[1].fY < pts[0].fY || (pts[1].fY == pts[0].fY && pts[1].fX < pts[0].fX)) {
+ SkTSwap(pts[0], pts[1]);
+ }
+ } else if (fStyle.isDashed()) {
+ // Dashing ignores inverseness.
+ fLineData.fInverted = false;
+ }
+ }
+}
* If the unstyled shape is a straight line segment, returns true and sets pts to the endpoints.
* An inverse filled line path is still considered a line.
*/
- bool asLine(SkPoint pts[2]) const {
- if (fType != Type::kPath) {
- return false;
- }
- return this->path().isLine(pts);
- }
+ bool asLine(SkPoint pts[2], bool* inverted) const {
+ if (fType != Type::kLine) {
+ return false;
+ }
+ if (pts) {
+ pts[0] = fLineData.fPts[0];
+ pts[1] = fLineData.fPts[1];
+ }
+ if (inverted) {
+ *inverted = fLineData.fInverted;
+ }
+ return true;
+ }
/** Returns the unstyled geometry as a path. */
void asPath(SkPath* out) const {
out->setFillType(kDefaultPathFillType);
}
break;
+ case Type::kLine:
+ out->reset();
+ out->moveTo(fLineData.fPts[0]);
+ out->lineTo(fLineData.fPts[1]);
+ if (fLineData.fInverted) {
+ out->setFillType(kDefaultPathInverseFillType);
+ } else {
+ out->setFillType(kDefaultPathFillType);
+ }
+ break;
case Type::kPath:
*out = this->path();
break;
* Gets the bounds of the geometry without reflecting the shape's styling. This ignores
* the inverse fill nature of the geometry.
*/
- const SkRect& bounds() const;
+ SkRect bounds() const;
/**
* Gets the bounds of the geometry reflecting the shape's styling (ignoring inverse fill
* status).
*/
- void styledBounds(SkRect* bounds) const;
+ SkRect styledBounds() const;
/**
* Is this shape known to be convex, before styling is applied. An unclosed but otherwise
return true;
case Type::kRRect:
return true;
+ case Type::kLine:
+ return true;
case Type::kPath:
// SkPath.isConvex() really means "is this path convex were it to be closed" and
// thus doesn't give the correct answer for stroked paths, hence we also check
case Type::kRRect:
ret = fRRectData.fInverted;
break;
+ case Type::kLine:
+ ret = fLineData.fInverted;
+ break;
case Type::kPath:
ret = this->path().isInverseFillType();
break;
return true;
case Type::kRRect:
return true;
+ case Type::kLine:
+ return false;
case Type::kPath:
// SkPath doesn't keep track of the closed status of each contour.
return SkPathPriv::IsClosedSingleContour(this->path());
return SkPath::kLine_SegmentMask;
}
return SkPath::kLine_SegmentMask | SkPath::kConic_SegmentMask;
+ case Type::kLine:
+ return SkPath::kLine_SegmentMask;
case Type::kPath:
return this->path().getSegmentMasks();
}
enum class Type {
kEmpty,
kRRect,
+ kLine,
kPath,
};
void attemptToSimplifyPath();
void attemptToSimplifyRRect();
+ void attemptToSimplifyLine();
// Defaults to use when there is no distinction between even/odd and winding fills.
static constexpr SkPath::FillType kDefaultPathFillType = SkPath::kEvenOdd_FillType;
// Gen ID of the original path (fPath may be modified)
int32_t fGenID;
} fPathData;
+ struct {
+ SkPoint fPts[2];
+ bool fInverted;
+ } fLineData;
};
GrStyle fStyle;
SkAutoSTArray<8, uint32_t> fInheritedKey;
CheckBounds(r, fAppliedPE, fAppliedPE.bounds());
CheckBounds(r, fAppliedPEThenStroke, fAppliedPEThenStroke.bounds());
CheckBounds(r, fAppliedFull, fAppliedFull.bounds());
- SkRect styledBounds;
- fBase.styledBounds(&styledBounds);
+ SkRect styledBounds = fBase.styledBounds();
CheckBounds(r, fAppliedFull, styledBounds);
- fAppliedPE.styledBounds(&styledBounds);
+ styledBounds = fAppliedPE.styledBounds();
CheckBounds(r, fAppliedFull, styledBounds);
// Check that the same path is produced when style is applied by GrShape and GrStyle.
}
REPORTER_ASSERT(r, a.bounds() == b.bounds());
REPORTER_ASSERT(r, a.segmentMask() == b.segmentMask());
- SkPoint pts[4];
- REPORTER_ASSERT(r, a.asLine(pts) == b.asLine(pts + 2));
+ // 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
REPORTER_ASSERT(r, a.mayBeInverseFilledAfterStyling() ==
b.mayBeInverseFilledAfterStyling());
}
- if (a.asLine(pts)) {
+ 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());
}
}
}
+void test_lines(skiatest::Reporter* r) {
+ static constexpr SkPoint kA { 1, 1};
+ static constexpr SkPoint kB { 5, -9};
+ static constexpr SkPoint kC {-3, 17};
+
+ SkPath lineAB;
+ lineAB.moveTo(kA);
+ lineAB.lineTo(kB);
+
+ SkPath lineBA;
+ lineBA.moveTo(kB);
+ lineBA.lineTo(kA);
+
+ SkPath lineAC;
+ lineAC.moveTo(kB);
+ lineAC.lineTo(kC);
+
+ SkPath invLineAB = lineAB;
+ invLineAB.setFillType(SkPath::kInverseEvenOdd_FillType);
+
+ 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(lineAB, fill, r);
+ TestCase fillEmpty(SkPath(), fill, r);
+ fillAB.compare(r, fillEmpty, TestCase::kAllSame_ComparisonExpecation);
+ REPORTER_ASSERT(r, !fillAB.baseShape().asLine(nullptr, nullptr));
+
+ TestCase strokeAB(lineAB, stroke, r);
+ TestCase strokeBA(lineBA, stroke, r);
+ TestCase strokeAC(lineAC, stroke, r);
+
+ TestCase hairlineAB(lineAB, hairline, r);
+ TestCase hairlineBA(lineBA, hairline, r);
+ TestCase hairlineAC(lineAC, hairline, r);
+
+ TestCase dashAB(lineAB, dash, r);
+ TestCase dashBA(lineBA, dash, r);
+ TestCase dashAC(lineAC, dash, r);
+
+ 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
+ // GrShape 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;
+ SkTSwap(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(invLineAB, stroke, r);
+ TestCase hairlineInvAB(invLineAB, hairline, r);
+ TestCase dashInvAB(invLineAB, dash, r);
+ 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(GrShape, reporter) {
for (auto r : { SkRect::MakeWH(10, 20),
SkRect::MakeWH(-10, -20),
test_path_effect_fails(reporter, r);
test_make_hairline_path_effect(reporter, r, true);
GrShape shape(r);
- REPORTER_ASSERT(reporter, !shape.asLine(nullptr));
+ REPORTER_ASSERT(reporter, !shape.asLine(nullptr, nullptr));
}
for (auto rr : { SkRRect::MakeRect(SkRect::MakeWH(10, 10)),
test_path_effect_fails(reporter, rr);
test_make_hairline_path_effect(reporter, rr, true);
GrShape shape(rr);
- REPORTER_ASSERT(reporter, !shape.asLine(nullptr));
+ REPORTER_ASSERT(reporter, !shape.asLine(nullptr, nullptr));
}
struct TestPath {
// These tests all assume that the original GrShape for fill and stroke will be the
// same.
// However, that is not the case in special cases (e.g. an unclosed rect becomes a RRect
- // GrShape with a fill style but becomes a Path GrShape when stroked).
- if (testPath.fIsRRectForFill == testPath.fIsRRectForStroke) {
+ // GrShape with a fill style but becomes a Path GrShape when stroked). Similarly, a path
+ // that is a line becomes empty when filled but is special-cased as a line when stroked.
+ if (testPath.fIsRRectForFill == testPath.fIsRRectForStroke && !testPath.fIsLine) {
test_basic(reporter, path);
test_null_dash(reporter, path);
test_path_effect_makes_rrect(reporter, path);
}
test_scale(reporter, path);
// This test uses a stroking paint, hence use of fIsRRectForStroke
- test_volatile_path(reporter, path, testPath.fIsRRectForStroke);
+ test_volatile_path(reporter, path, testPath.fIsRRectForStroke || testPath.fIsLine);
test_dash_fill(reporter, path);
// Test modifying various stroke params.
test_stroke_param<SkPath, SkScalar>(
test_unknown_path_effect(reporter, path);
test_path_effect_makes_empty_shape(reporter, path);
test_path_effect_fails(reporter, path);
- test_make_hairline_path_effect(reporter, path, testPath.fIsRRectForStroke);
+ test_make_hairline_path_effect(reporter, path, testPath.fIsRRectForStroke ||
+ testPath.fIsLine);
}
}
strokePathCase.compare(reporter, strokeRRectCase,
TestCase::kAllSame_ComparisonExpecation);
}
- REPORTER_ASSERT(reporter, testPath.fIsLine == fillPathCase.baseShape().asLine(nullptr));
- REPORTER_ASSERT(reporter, testPath.fIsLine == strokePathCase.baseShape().asLine(nullptr));
}
// Test a volatile empty path.
test_volatile_path(reporter, SkPath(), true);
test_empty_shape(reporter);
+
+ test_lines(reporter);
}
#endif
projects / platform / upstream / libSkiaSharp.git / commitdiff