aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/core/SkClipStack.h12
-rw-r--r--src/core/SkClipStack.cpp51
-rw-r--r--src/gpu/GrClipMaskManager.cpp18
-rw-r--r--tests/ClipStackTest.cpp168
4 files changed, 235 insertions, 14 deletions
diff --git a/include/core/SkClipStack.h b/include/core/SkClipStack.h
index 79fd2c9dd4..443e6ad7d9 100644
--- a/include/core/SkClipStack.h
+++ b/include/core/SkClipStack.h
@@ -103,7 +103,7 @@ public:
/**
* The generation ID has three reserved values to indicate special
- * (potentially ignoreable) cases
+ * (potentially ignorable) cases
*/
static const int32_t kInvalidGenID = 0;
static const int32_t kEmptyGenID = 1; // no pixels writeable
@@ -159,6 +159,14 @@ public:
const Clip* prev();
/**
+ * This is a variant of next() that greedily attempts to combine elements when possible.
+ * Currently it attempts to combine intersecting rectangles, though it may do more in the
+ * future. The returned Clip may not refer to a single element in the stack, so its
+ * generation ID may be invalid.
+ */
+ const Clip* nextCombined();
+
+ /**
* Moves the iterator to the topmost clip with the specified RegionOp
* and returns that clip. If no clip with that op is found,
* returns NULL.
@@ -174,7 +182,7 @@ public:
const SkClipStack* fStack;
Clip fClip;
SkDeque::Iter fIter;
-
+ SkRect fCombinedRect; // used for nextCombined()
/**
* updateClip updates fClip to the current state of fIter. It unifies
* functionality needed by both next() and prev().
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index a5b591e72a..38f258039f 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -819,6 +819,57 @@ const SkClipStack::Iter::Clip* SkClipStack::Iter::skipToTopmost(SkRegion::Op op)
return this->next();
}
+const SkClipStack::Iter::Clip* SkClipStack::Iter::nextCombined() {
+ const Clip* clip;
+
+ if (NULL != (clip = this->next()) &&
+ SkRegion::kIntersect_Op == clip->fOp &&
+ NULL != clip->fRect) {
+ fCombinedRect = *clip->fRect;
+ bool doAA = clip->fDoAA;
+
+ while(NULL != (clip = this->next()) &&
+ SkRegion::kIntersect_Op == clip->fOp &&
+ NULL != clip->fRect) { // backup if non-null
+ /**
+ * If the AA settings don't match on consecutive rects we can still continue if
+ * either contains the other. Otherwise, we must stop.
+ */
+ if (doAA != clip->fDoAA) {
+ if (fCombinedRect.contains(*clip->fRect)) {
+ fCombinedRect = *clip->fRect;
+ doAA = clip->fDoAA;
+ } else if (!clip->fRect->contains(fCombinedRect)) {
+ break;
+ }
+ } else if (!fCombinedRect.intersect(*fClip.fRect)) {
+ fCombinedRect.setEmpty();
+ clip = NULL; // prevents unnecessary rewind below.
+ break;
+ }
+ }
+ // If we got here and clip is non-NULL then we got an element that we weren't able to
+ // combine. We need to backup one to ensure that the callers next next() call returns it.
+ if (NULL != clip) {
+ // If next() above returned the last element then due to Iter's internal workings prev()
+ // will return NULL. In that case we reset to the last element.
+ if (NULL == this->prev()) {
+ this->reset(*fStack, SkClipStack::Iter::kTop_IterStart);
+ }
+ }
+
+ // Must do this last because it is overwritten in the above backup.
+ fClip.fRect = &fCombinedRect;
+ fClip.fPath = NULL;
+ fClip.fOp = SkRegion::kIntersect_Op;
+ fClip.fDoAA = doAA;
+ fClip.fGenID = kInvalidGenID;
+ return &fClip;
+ } else {
+ return clip;
+ }
+}
+
void SkClipStack::Iter::reset(const SkClipStack& stack, IterStart startLoc) {
fStack = &stack;
fIter.reset(stack.fDeque, static_cast<SkDeque::Iter::IterStart>(startLoc));
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index 606b90eeeb..2db006a532 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -88,7 +88,7 @@ bool requires_AA(const SkClipStack& clipIn) {
const SkClipStack::Iter::Clip* clip = NULL;
for (clip = iter.skipToTopmost(SkRegion::kReplace_Op);
NULL != clip;
- clip = iter.next()) {
+ clip = iter.nextCombined()) {
if (clip->fDoAA) {
return true;
@@ -117,13 +117,7 @@ bool GrClipMaskManager::useSWOnlyPath(const SkClipStack& clipIn) {
for (clip = iter.skipToTopmost(SkRegion::kReplace_Op);
NULL != clip;
- clip = iter.next()) {
-
- if (SkRegion::kReplace_Op == clip->fOp) {
- // Everything before a replace op can be ignored so start
- // afresh w.r.t. determining if any element uses the SW path
- useSW = false;
- }
+ clip = iter.nextCombined()) {
// rects can always be drawn directly w/o using the software path
// so only paths need to be checked
@@ -297,7 +291,7 @@ const SkClipStack::Iter::Clip* process_initial_clip_elements(
for (clip = iter->skipToTopmost(SkRegion::kReplace_Op);
NULL != clip && !done;
- clip = iter->next()) {
+ clip = iter->nextCombined()) {
switch (clip->fOp) {
case SkRegion::kReplace_Op:
// replace ignores everything previous
@@ -644,7 +638,7 @@ bool GrClipMaskManager::createAlphaClipMask(const GrClipData& clipDataIn,
GrAutoScratchTexture temp;
bool first = true;
// walk through each clip element and perform its set op
- for ( ; NULL != clip; clip = iter.next()) {
+ for ( ; NULL != clip; clip = iter.nextCombined()) {
SkRegion::Op op = clip->fOp;
if (first) {
@@ -785,7 +779,7 @@ bool GrClipMaskManager::createStencilClipMask(const GrClipData& clipDataIn,
// walk through each clip element and perform its set op
// with the existing clip.
- for ( ; NULL != clip; clip = iter.next()) {
+ for ( ; NULL != clip; clip = iter.nextCombined()) {
GrPathFill fill;
bool fillInverted = false;
// enabled at bottom of loop
@@ -1151,7 +1145,7 @@ bool GrClipMaskManager::createSoftwareClipMask(const GrClipData& clipDataIn,
helper.clear(clearToInside ? 0xFF : 0x00);
bool first = true;
- for ( ; NULL != clip; clip = iter.next()) {
+ for ( ; NULL != clip; clip = iter.nextCombined()) {
SkRegion::Op op = clip->fOp;
if (first) {
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
index 8a74dc8712..0516d9eba7 100644
--- a/tests/ClipStackTest.cpp
+++ b/tests/ClipStackTest.cpp
@@ -473,6 +473,173 @@ static void test_rect_merging(skiatest::Reporter* reporter) {
}
}
+
+// This is similar to the above test but tests the iterator's ability to merge rects in the
+// middle of a clip stack's sequence using nextCombined(). There is a save after every clip
+// element to prevent the clip stack from merging the rectangles as they are added.
+static void test_iter_rect_merging(skiatest::Reporter* reporter) {
+
+ SkRect overlapLeft = SkRect::MakeLTRB(10, 10, 50, 50);
+ SkRect overlapRight = SkRect::MakeLTRB(40, 40, 80, 80);
+
+ SkRect nestedParent = SkRect::MakeLTRB(10, 10, 90, 90);
+ SkRect nestedChild = SkRect::MakeLTRB(40, 40, 60, 60);
+
+ SkRect farAway = SkRect::MakeLTRB(1000, 1000, 1010, 1010);
+
+ SkRect overlapIntersect;
+ overlapIntersect.intersect(overlapLeft, overlapRight);
+
+ SkPath path1, path2;
+ path1.addCircle(SkIntToScalar(30), SkIntToScalar(30), SkIntToScalar(1000));
+ path2.addOval(SkRect::MakeWH(500, 600));
+
+ const SkClipStack::Iter::Clip* clip;
+
+ // call nextCombined with an empty clip stack
+ {
+ SkClipStack stack;
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+ REPORTER_ASSERT(reporter, NULL == iter.nextCombined());
+ }
+
+ // two bw overlapping - should merge, bracketed by paths
+ {
+ SkClipStack stack;
+ stack.clipDevPath(path1, SkRegion::kIntersect_Op, false); stack.save();
+
+ stack.clipDevRect(overlapLeft, SkRegion::kIntersect_Op, false); stack.save();
+
+ stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false); stack.save();
+
+ stack.clipDevPath(path2, SkRegion::kIntersect_Op, false); stack.save();
+
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, *clip->fPath == path1 && !clip->fDoAA);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, !clip->fDoAA && *clip->fRect == overlapIntersect);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, *clip->fPath == path2 && !clip->fDoAA);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, NULL == clip);
+ }
+
+ // same as above but rects are aa and no final path.
+ {
+ SkClipStack stack;
+ stack.clipDevPath(path1, SkRegion::kIntersect_Op, false); stack.save();
+
+ stack.clipDevRect(overlapLeft, SkRegion::kIntersect_Op, true); stack.save();
+
+ stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, true); stack.save();
+
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, *clip->fPath == path1 && !clip->fDoAA);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, clip->fDoAA && *clip->fRect == overlapIntersect);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, NULL == clip);
+ }
+
+ // mixed overlapping - no paths - should _not_ merge
+ {
+ SkClipStack stack;
+
+ stack.clipDevRect(overlapLeft, SkRegion::kIntersect_Op, true); stack.save();
+ stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false); stack.save();
+
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, clip->fDoAA && *clip->fRect == overlapLeft);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, !clip->fDoAA && *clip->fRect == overlapRight);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, NULL == clip);
+ }
+
+ // three rects in a row where the third rect uses a non-intersect op.
+ {
+ SkClipStack stack;
+
+ stack.clipDevRect(overlapLeft, SkRegion::kIntersect_Op, true); stack.save();
+ stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, true); stack.save();
+ stack.clipDevRect(nestedParent, SkRegion::kXOR_Op, true); stack.save();
+
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, clip->fDoAA && *clip->fRect == overlapIntersect);
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, clip->fDoAA && *clip->fRect == nestedParent);
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, NULL == clip);
+ }
+
+ // mixed nested (bw inside aa) - should merge
+ {
+ SkClipStack stack;
+ stack.clipDevRect(nestedParent, SkRegion::kIntersect_Op, false); stack.save();
+
+ stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, true); stack.save();
+
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, clip->fDoAA && *clip->fRect == nestedChild);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, NULL == clip);
+ }
+
+ // mixed nested (aa inside bw) - should merge
+ {
+ SkClipStack stack;
+ stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, false); stack.save();
+
+ stack.clipDevRect(nestedParent, SkRegion::kIntersect_Op, true); stack.save();
+
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, !clip->fDoAA && *clip->fRect == nestedChild);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, NULL == clip);
+ }
+
+ // three rect intersects in a row where result is empty after the second.
+ {
+ SkClipStack stack;
+
+ stack.clipDevRect(overlapLeft, SkRegion::kIntersect_Op, false); stack.save();
+ stack.clipDevRect(farAway, SkRegion::kIntersect_Op, false); stack.save();
+ stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false); stack.save();
+
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, clip->fRect->isEmpty());
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, *clip->fRect == overlapRight);
+
+ clip = iter.nextCombined();
+ REPORTER_ASSERT(reporter, NULL == clip);
+ }
+}
+
static void TestClipStack(skiatest::Reporter* reporter) {
SkClipStack stack;
@@ -513,6 +680,7 @@ static void TestClipStack(skiatest::Reporter* reporter) {
test_bounds(reporter, false); // once with paths
test_isWideOpen(reporter);
test_rect_merging(reporter);
+ test_iter_rect_merging(reporter);
}
#include "TestClassDef.h"
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-02 22:52:04 +0000