aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/core/SkClipStack.h38
-rw-r--r--src/core/SkClipStack.cpp64
-rw-r--r--src/gpu/GrClipMaskCache.h4
-rw-r--r--src/gpu/GrClipMaskManager.cpp28
-rw-r--r--src/gpu/GrClipMaskManager.h9
-rw-r--r--src/gpu/GrReducedClip.cpp31
-rw-r--r--src/gpu/GrReducedClip.h4
-rw-r--r--src/gpu/GrStencilBuffer.h3
-rw-r--r--src/gpu/SkGpuDevice.cpp19
-rw-r--r--tests/ClipCacheTest.cpp28
-rw-r--r--tests/ClipStackTest.cpp169
11 files changed, 147 insertions, 250 deletions
diff --git a/include/core/SkClipStack.h b/include/core/SkClipStack.h
index 0d6cfb296f..145552dc13 100644
--- a/include/core/SkClipStack.h
+++ b/include/core/SkClipStack.h
@@ -109,7 +109,7 @@ public:
stack not to the element itself. That is the same clip path in different stacks will
have a different ID since the elements produce different clip result in the context of
their stacks. */
- int32_t getGenID() const { SkASSERT(kInvalidGenID != fGenID); return fGenID; }
+ int32_t getGenID() const { return fGenID; }
/**
* Gets the bounds of the clip element, either the rect or path bounds. (Whether the shape
@@ -316,12 +316,25 @@ public:
bool isWideOpen() const;
/**
+ * Add a callback function that will be called whenever a clip state
+ * is no longer viable. This will occur whenever restore
+ * is called or when a clipDevRect or clipDevPath call updates the
+ * clip within an existing save/restore state. Each clip state is
+ * represented by a unique generation ID.
+ */
+ typedef void (*PFPurgeClipCB)(int genID, void* data);
+ void addPurgeClipCallback(PFPurgeClipCB callback, void* data) const;
+
+ /**
+ * Remove a callback added earlier via addPurgeClipCallback
+ */
+ void removePurgeClipCallback(PFPurgeClipCB callback, void* data) const;
+
+ /**
* The generation ID has three reserved values to indicate special
* (potentially ignorable) cases
*/
- static const int32_t kInvalidGenID = 0; //!< Invalid id that is never returned by
- //!< SkClipStack. Useful when caching clips
- //!< based on GenID.
+ static const int32_t kInvalidGenID = 0;
static const int32_t kEmptyGenID = 1; // no pixels writeable
static const int32_t kWideOpenGenID = 2; // all pixels writeable
@@ -427,12 +440,29 @@ private:
// invalid ID.
static int32_t gGenID;
+ struct ClipCallbackData {
+ PFPurgeClipCB fCallback;
+ void* fData;
+
+ friend bool operator==(const ClipCallbackData& a,
+ const ClipCallbackData& b) {
+ return a.fCallback == b.fCallback && a.fData == b.fData;
+ }
+ };
+
+ mutable SkTDArray<ClipCallbackData> fCallbackData;
+
/**
* Restore the stack back to the specified save count.
*/
void restoreTo(int saveCount);
/**
+ * Invoke all the purge callbacks passing in element's generation ID.
+ */
+ void purgeClip(Element* element);
+
+ /**
* Return the next unique generation ID.
*/
static int32_t GetNextGenID();
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index 9e3f7c6b30..2c0961ab83 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -452,6 +452,7 @@ void SkClipStack::restoreTo(int saveCount) {
if (element->fSaveCount <= saveCount) {
break;
}
+ this->purgeClip(element);
element->~Element();
fDeque.pop_back();
}
@@ -539,6 +540,7 @@ void SkClipStack::clipDevRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
return;
case Element::kRect_Type:
if (element->rectRectIntersectAllowed(rect, doAA)) {
+ this->purgeClip(element);
if (!element->fRect.intersect(rect)) {
element->setEmpty();
return;
@@ -552,6 +554,7 @@ void SkClipStack::clipDevRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
break;
case Element::kPath_Type:
if (!SkRect::Intersects(element->fPath.getBounds(), rect)) {
+ this->purgeClip(element);
element->setEmpty();
return;
}
@@ -564,6 +567,10 @@ void SkClipStack::clipDevRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
}
new (fDeque.push_back()) Element(fSaveCount, rect, op, doAA);
((Element*) fDeque.back())->updateBoundAndGenID(element);
+
+ if (element && element->fSaveCount == fSaveCount) {
+ this->purgeClip(element);
+ }
}
void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op, bool doAA) {
@@ -582,12 +589,14 @@ void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op, bool doAA) {
return;
case Element::kRect_Type:
if (!SkRect::Intersects(element->fRect, pathBounds)) {
+ this->purgeClip(element);
element->setEmpty();
return;
}
break;
case Element::kPath_Type:
if (!SkRect::Intersects(element->fPath.getBounds(), pathBounds)) {
+ this->purgeClip(element);
element->setEmpty();
return;
}
@@ -600,6 +609,10 @@ void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op, bool doAA) {
}
new (fDeque.push_back()) Element(fSaveCount, path, op, doAA);
((Element*) fDeque.back())->updateBoundAndGenID(element);
+
+ if (element && element->fSaveCount == fSaveCount) {
+ this->purgeClip(element);
+ }
}
void SkClipStack::clipEmpty() {
@@ -613,17 +626,27 @@ void SkClipStack::clipEmpty() {
return;
case Element::kRect_Type:
case Element::kPath_Type:
+ this->purgeClip(element);
element->setEmpty();
return;
}
}
new (fDeque.push_back()) Element(fSaveCount);
+ if (element && element->fSaveCount == fSaveCount) {
+ this->purgeClip(element);
+ }
((Element*)fDeque.back())->fGenID = kEmptyGenID;
}
bool SkClipStack::isWideOpen() const {
- return this->getTopmostGenID() == kWideOpenGenID;
+ if (0 == fDeque.count()) {
+ return true;
+ }
+
+ const Element* back = (const Element*) fDeque.back();
+ return kWideOpenGenID == back->fGenID ||
+ (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty());
}
///////////////////////////////////////////////////////////////////////////////
@@ -717,20 +740,45 @@ void SkClipStack::getConservativeBounds(int offsetX,
}
}
+void SkClipStack::addPurgeClipCallback(PFPurgeClipCB callback, void* data) const {
+ ClipCallbackData temp = { callback, data };
+ fCallbackData.append(1, &temp);
+}
+
+void SkClipStack::removePurgeClipCallback(PFPurgeClipCB callback, void* data) const {
+ ClipCallbackData temp = { callback, data };
+ int index = fCallbackData.find(temp);
+ if (index >= 0) {
+ fCallbackData.removeShuffle(index);
+ }
+}
+
+// The clip state represented by 'element' will never be used again. Purge it.
+void SkClipStack::purgeClip(Element* element) {
+ SkASSERT(NULL != element);
+ if (element->fGenID >= 0 && element->fGenID < kFirstUnreservedGenID) {
+ return;
+ }
+
+ for (int i = 0; i < fCallbackData.count(); ++i) {
+ (*fCallbackData[i].fCallback)(element->fGenID, fCallbackData[i].fData);
+ }
+
+ // Invalidate element's gen ID so handlers can detect already handled records
+ element->fGenID = kInvalidGenID;
+}
+
int32_t SkClipStack::GetNextGenID() {
// TODO: handle overflow.
return sk_atomic_inc(&gGenID);
}
int32_t SkClipStack::getTopmostGenID() const {
- if (fDeque.empty()) {
- return kWideOpenGenID;
- }
- const Element* back = static_cast<const Element*>(fDeque.back());
- if (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty()) {
- return kWideOpenGenID;
+ if (fDeque.empty()) {
+ return kInvalidGenID;
}
- return back->getGenID();
+ Element* element = (Element*)fDeque.back();
+ return element->fGenID;
}
diff --git a/src/gpu/GrClipMaskCache.h b/src/gpu/GrClipMaskCache.h
index 213e2823e3..97b4b515cc 100644
--- a/src/gpu/GrClipMaskCache.h
+++ b/src/gpu/GrClipMaskCache.h
@@ -36,6 +36,10 @@ public:
SkASSERT(clipGenID != SkClipStack::kWideOpenGenID);
SkASSERT(clipGenID != SkClipStack::kEmptyGenID);
+ if (SkClipStack::kInvalidGenID == clipGenID) {
+ return false;
+ }
+
GrClipStackFrame* back = (GrClipStackFrame*) fStack.back();
// We could reuse the mask if bounds is a subset of last bounds. We'd have to communicate
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index 3aef3dee67..0f915666fb 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -113,7 +113,6 @@ bool GrClipMaskManager::setupClipping(const GrClipData* clipDataIn,
fCurrClipMaskType = kNone_ClipMaskType;
ElementList elements(16);
- int32_t genID;
InitialState initialState;
SkIRect clipSpaceIBounds;
bool requiresAA;
@@ -133,7 +132,6 @@ bool GrClipMaskManager::setupClipping(const GrClipData* clipDataIn,
ReduceClipStack(*clipDataIn->fClipStack,
clipSpaceRTIBounds,
&elements,
- &genID,
&initialState,
&clipSpaceIBounds,
&requiresAA);
@@ -158,6 +156,7 @@ bool GrClipMaskManager::setupClipping(const GrClipData* clipDataIn,
// If MSAA is enabled we can do everything in the stencil buffer.
if (0 == rt->numSamples() && requiresAA) {
+ int32_t genID = clipDataIn->fClipStack->getTopmostGenID();
GrTexture* result = NULL;
if (this->useSWOnlyPath(elements)) {
@@ -208,8 +207,7 @@ bool GrClipMaskManager::setupClipping(const GrClipData* clipDataIn,
// use the stencil clip if we can't represent the clip as a rectangle.
SkIPoint clipSpaceToStencilSpaceOffset = -clipDataIn->fOrigin;
- this->createStencilClipMask(genID,
- initialState,
+ this->createStencilClipMask(initialState,
elements,
clipSpaceIBounds,
clipSpaceToStencilSpaceOffset);
@@ -392,11 +390,11 @@ void GrClipMaskManager::getTemp(int width, int height, GrAutoScratchTexture* tem
// Handles caching & allocation (if needed) of a clip alpha-mask texture for both the sw-upload
// or gpu-rendered cases. Returns true if there is no more work to be done (i.e., we got a cache
// hit)
-bool GrClipMaskManager::getMaskTexture(int32_t elementsGenID,
+bool GrClipMaskManager::getMaskTexture(int32_t clipStackGenID,
const SkIRect& clipSpaceIBounds,
GrTexture** result,
bool willUpload) {
- bool cached = fAACache.canReuse(elementsGenID, clipSpaceIBounds);
+ bool cached = fAACache.canReuse(clipStackGenID, clipSpaceIBounds);
if (!cached) {
// There isn't a suitable entry in the cache so we create a new texture to store the mask.
@@ -414,7 +412,7 @@ bool GrClipMaskManager::getMaskTexture(int32_t elementsGenID,
desc.fConfig = kAlpha_8_GrPixelConfig;
}
- fAACache.acquireMask(elementsGenID, desc, clipSpaceIBounds);
+ fAACache.acquireMask(clipStackGenID, desc, clipSpaceIBounds);
}
*result = fAACache.getLastMask();
@@ -423,14 +421,14 @@ bool GrClipMaskManager::getMaskTexture(int32_t elementsGenID,
////////////////////////////////////////////////////////////////////////////////
// Create a 8-bit clip mask in alpha
-GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID,
+GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t clipStackGenID,
InitialState initialState,
const ElementList& elements,
const SkIRect& clipSpaceIBounds) {
SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
GrTexture* result;
- if (this->getMaskTexture(elementsGenID, clipSpaceIBounds, &result, false)) {
+ if (this->getMaskTexture(clipStackGenID, clipSpaceIBounds, &result, false)) {
fCurrClipMaskType = kAlpha_ClipMaskType;
return result;
}
@@ -571,8 +569,7 @@ GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID,
////////////////////////////////////////////////////////////////////////////////
// Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
// (as opposed to canvas) coordinates
-bool GrClipMaskManager::createStencilClipMask(int32_t elementsGenID,
- InitialState initialState,
+bool GrClipMaskManager::createStencilClipMask(InitialState initialState,
const ElementList& elements,
const SkIRect& clipSpaceIBounds,
const SkIPoint& clipSpaceToStencilOffset) {
@@ -590,10 +587,11 @@ bool GrClipMaskManager::createStencilClipMask(int32_t elementsGenID,
if (NULL == stencilBuffer) {
return false;
}
+ int32_t genID = elements.tail()->getGenID();
- if (stencilBuffer->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
+ if (stencilBuffer->mustRenderClip(genID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
- stencilBuffer->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset);
+ stencilBuffer->setLastClip(genID, clipSpaceIBounds, clipSpaceToStencilOffset);
// Set the matrix so that rendered clip elements are transformed from clip to stencil space.
SkVector translate = {
@@ -923,14 +921,14 @@ void GrClipMaskManager::adjustStencilParams(GrStencilSettings* settings,
}
////////////////////////////////////////////////////////////////////////////////
-GrTexture* GrClipMaskManager::createSoftwareClipMask(int32_t elementsGenID,
+GrTexture* GrClipMaskManager::createSoftwareClipMask(int32_t clipStackGenID,
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkIRect& clipSpaceIBounds) {
SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
GrTexture* result;
- if (this->getMaskTexture(elementsGenID, clipSpaceIBounds, &result, true)) {
+ if (this->getMaskTexture(clipStackGenID, clipSpaceIBounds, &result, true)) {
return result;
}
diff --git a/src/gpu/GrClipMaskManager.h b/src/gpu/GrClipMaskManager.h
index f44a8e7b22..015c801d54 100644
--- a/src/gpu/GrClipMaskManager.h
+++ b/src/gpu/GrClipMaskManager.h
@@ -103,19 +103,18 @@ private:
GrClipMaskCache fAACache; // cache for the AA path
// Draws the clip into the stencil buffer
- bool createStencilClipMask(int32_t elementsGenID,
- GrReducedClip::InitialState initialState,
+ bool createStencilClipMask(GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkIRect& clipSpaceIBounds,
const SkIPoint& clipSpaceToStencilOffset);
// Creates an alpha mask of the clip. The mask is a rasterization of elements through the
// rect specified by clipSpaceIBounds.
- GrTexture* createAlphaClipMask(int32_t elementsGenID,
+ GrTexture* createAlphaClipMask(int32_t clipStackGenID,
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkIRect& clipSpaceIBounds);
// Similar to createAlphaClipMask but it rasterizes in SW and uploads to the result texture.
- GrTexture* createSoftwareClipMask(int32_t elementsGenID,
+ GrTexture* createSoftwareClipMask(int32_t clipStackGenID,
GrReducedClip::InitialState initialState,
const GrReducedClip::ElementList& elements,
const SkIRect& clipSpaceIBounds);
@@ -123,7 +122,7 @@ private:
// Gets a texture to use for the clip mask. If true is returned then a cached mask was found
// that already contains the rasterization of the clip stack, otherwise an uninitialized texture
// is returned. 'willUpload' is set when the alpha mask needs to be uploaded from the CPU.
- bool getMaskTexture(int32_t elementsGenID,
+ bool getMaskTexture(int32_t clipStackGenID,
const SkIRect& clipSpaceIBounds,
GrTexture** result,
bool willUpload);
diff --git a/src/gpu/GrReducedClip.cpp b/src/gpu/GrReducedClip.cpp
index 8480e041b8..a5f4519ea7 100644
--- a/src/gpu/GrReducedClip.cpp
+++ b/src/gpu/GrReducedClip.cpp
@@ -17,7 +17,6 @@ namespace GrReducedClip {
void reduced_stack_walker(const SkClipStack& stack,
const SkRect& queryBounds,
ElementList* result,
- int32_t* resultGenID,
InitialState* initialState,
bool* requiresAA);
@@ -31,17 +30,11 @@ take a rect in case the caller knows a bound on what is to be drawn through this
void ReduceClipStack(const SkClipStack& stack,
const SkIRect& queryBounds,
ElementList* result,
- int32_t* resultGenID,
InitialState* initialState,
SkIRect* tighterBounds,
bool* requiresAA) {
result->reset();
- // The clip established by the element list might be cached based on the last
- // generation id. When we make early returns, we do not know what was the generation
- // id that lead to the state. Make a conservative guess.
- *resultGenID = stack.getTopmostGenID();
-
if (stack.isWideOpen()) {
*initialState = kAllIn_InitialState;
return;
@@ -77,9 +70,7 @@ void ReduceClipStack(const SkClipStack& stack,
SkRect scalarTighterBounds = SkRect::Make(*tighterBounds);
if (scalarTighterBounds == isectRect) {
// the round-out didn't add any area outside the clip rect.
- if (NULL != requiresAA) {
- *requiresAA = false;
- }
+ *requiresAA = false;
*initialState = kAllIn_InitialState;
return;
}
@@ -132,17 +123,12 @@ void ReduceClipStack(const SkClipStack& stack,
// Now that we have determined the bounds to use and filtered out the trivial cases, call the
// helper that actually walks the stack.
- reduced_stack_walker(stack, scalarBounds, result, resultGenID, initialState, requiresAA);
-
- // The list that was computed in this function may be cached based on the gen id of the last
- // element.
- SkASSERT(SkClipStack::kInvalidGenID != *resultGenID);
+ reduced_stack_walker(stack, scalarBounds, result, initialState, requiresAA);
}
void reduced_stack_walker(const SkClipStack& stack,
const SkRect& queryBounds,
ElementList* result,
- int32_t* resultGenID,
InitialState* initialState,
bool* requiresAA) {
@@ -326,11 +312,6 @@ void reduced_stack_walker(const SkClipStack& stack,
break;
}
if (!skippable) {
- if (0 == result->count()) {
- // This will be the last element. Record the stricter genID.
- *resultGenID = element->getGenID();
- }
-
// if it is a flip, change it to a bounds-filling rect
if (isFlip) {
SkASSERT(SkRegion::kXOR_Op == element->getOp() ||
@@ -436,13 +417,5 @@ void reduced_stack_walker(const SkClipStack& stack,
if (NULL != requiresAA) {
*requiresAA = numAAElements > 0;
}
-
- if (0 == result->count()) {
- if (*initialState == kAllIn_InitialState) {
- *resultGenID = SkClipStack::kWideOpenGenID;
- } else {
- *resultGenID = SkClipStack::kEmptyGenID;
- }
- }
}
} // namespace GrReducedClip
diff --git a/src/gpu/GrReducedClip.h b/src/gpu/GrReducedClip.h
index 0b79f2c7f5..abfc244f20 100644
--- a/src/gpu/GrReducedClip.h
+++ b/src/gpu/GrReducedClip.h
@@ -20,8 +20,7 @@ enum InitialState {
/**
* This function takes a clip stack and a query rectangle and it produces a reduced set of
- * SkClipStack::Elements that are equivalent to applying the full stack to the rectangle. The clip
- * stack generation id that represents the list of elements is returned in resultGenID. The
+ * SkClipStack::Elements that are equivalent to applying the full stack to the rectangle. The
* initial state of the query rectangle before the first clip element is applied is returned via
* initialState. Optionally, the caller can request a tighter bounds on the clip be returned via
* tighterBounds. If not NULL, tighterBounds will always be contained by queryBounds after return.
@@ -34,7 +33,6 @@ enum InitialState {
void ReduceClipStack(const SkClipStack& stack,
const SkIRect& queryBounds,
ElementList* result,
- int32_t* resultGenID,
InitialState* initialState,
SkIRect* tighterBounds = NULL,
bool* requiresAA = NULL);
diff --git a/src/gpu/GrStencilBuffer.h b/src/gpu/GrStencilBuffer.h
index 37d40f16ba..3765a4c657 100644
--- a/src/gpu/GrStencilBuffer.h
+++ b/src/gpu/GrStencilBuffer.h
@@ -43,7 +43,8 @@ public:
bool mustRenderClip(int32_t clipStackGenID,
const SkIRect& clipSpaceRect,
const SkIPoint clipSpaceToStencilOffset) const {
- return fLastClipStackGenID != clipStackGenID ||
+ return SkClipStack::kInvalidGenID == clipStackGenID ||
+ fLastClipStackGenID != clipStackGenID ||
fLastClipSpaceOffset != clipSpaceToStencilOffset ||
!fLastClipStackRect.contains(clipSpaceRect);
}
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index d98b005b19..0f4b93140e 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -344,15 +344,34 @@ void SkGpuDevice::writePixels(const SkBitmap& bitmap, int x, int y,
config, bitmap.getPixels(), bitmap.rowBytes(), flags);
}
+namespace {
+void purgeClipCB(int genID, void* ) {
+
+ if (SkClipStack::kInvalidGenID == genID ||
+ SkClipStack::kEmptyGenID == genID ||
+ SkClipStack::kWideOpenGenID == genID) {
+ // none of these cases will have a cached clip mask
+ return;
+ }
+
+}
+};
+
void SkGpuDevice::onAttachToCanvas(SkCanvas* canvas) {
INHERITED::onAttachToCanvas(canvas);
// Canvas promises that this ptr is valid until onDetachFromCanvas is called
fClipData.fClipStack = canvas->getClipStack();
+
+ fClipData.fClipStack->addPurgeClipCallback(purgeClipCB, fContext);
}
void SkGpuDevice::onDetachFromCanvas() {
INHERITED::onDetachFromCanvas();
+
+ // TODO: iterate through the clip stack and clean up any cached clip masks
+ fClipData.fClipStack->removePurgeClipCallback(purgeClipCB, fContext);
+
fClipData.fClipStack = NULL;
}
diff --git a/tests/ClipCacheTest.cpp b/tests/ClipCacheTest.cpp
index 070f8eb469..fab1f58dd7 100644
--- a/tests/ClipCacheTest.cpp
+++ b/tests/ClipCacheTest.cpp
@@ -106,6 +106,7 @@ static void check_state(skiatest::Reporter* reporter,
const SkClipStack& clip,
GrTexture* mask,
const SkIRect& bound) {
+ SkClipStack cacheClip;
REPORTER_ASSERT(reporter, clip.getTopmostGenID() == cache.getLastClipGenID());
REPORTER_ASSERT(reporter, mask == cache.getLastMask());
@@ -115,19 +116,6 @@ static void check_state(skiatest::Reporter* reporter,
REPORTER_ASSERT(reporter, bound == cacheBound);
}
-static void check_empty_state(skiatest::Reporter* reporter,
- const GrClipMaskCache& cache) {
- REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID == cache.getLastClipGenID());
- REPORTER_ASSERT(reporter, NULL == cache.getLastMask());
-
- SkIRect emptyBound;
- emptyBound.setEmpty();
-
- SkIRect cacheBound;
- cache.getLastBound(&cacheBound);
- REPORTER_ASSERT(reporter, emptyBound == cacheBound);
-}
-
////////////////////////////////////////////////////////////////////////////////
// basic test of the cache's base functionality:
// push, pop, set, canReuse & getters
@@ -140,8 +128,14 @@ static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
cache.setContext(context);
+ SkClipStack emptyClip;
+ emptyClip.reset();
+
+ SkIRect emptyBound;
+ emptyBound.setEmpty();
+
// check initial state
- check_empty_state(reporter, cache);
+ check_state(reporter, cache, emptyClip, NULL, emptyBound);
// set the current state
SkIRect bound1;
@@ -171,7 +165,7 @@ static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
cache.push();
// verify that the pushed state is initially empty
- check_empty_state(reporter, cache);
+ check_state(reporter, cache, emptyClip, NULL, emptyBound);
REPORTER_ASSERT(reporter, texture1->getRefCnt());
// modify the new state
@@ -208,7 +202,7 @@ static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
cache.reset();
// verify it is now empty
- check_empty_state(reporter, cache);
+ check_state(reporter, cache, emptyClip, NULL, emptyBound);
// pop again - so there is no state
cache.pop();
@@ -216,7 +210,7 @@ static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
#if !defined(SK_DEBUG)
// verify that the getters don't crash
// only do in release since it generates asserts in debug
- check_empty_state(reporter, cache);
+ check_state(reporter, cache, emptyClip, NULL, emptyBound);
#endif
}
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
index 3161674a77..04b48b6783 100644
--- a/tests/ClipStackTest.cpp
+++ b/tests/ClipStackTest.cpp
@@ -271,7 +271,6 @@ static void test_bounds(skiatest::Reporter* reporter, bool useRects) {
}
REPORTER_ASSERT(reporter, !stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
stack.getConservativeBounds(0, 0, 100, 100, &devClipBound,
&isIntersectionOfRects);
@@ -294,12 +293,6 @@ static void test_bounds(skiatest::Reporter* reporter, bool useRects) {
// Test out 'isWideOpen' entry point
static void test_isWideOpen(skiatest::Reporter* reporter) {
- {
- // Empty stack is wide open. Wide open stack means that gen id is wide open.
- SkClipStack stack;
- REPORTER_ASSERT(reporter, stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
- }
SkRect rectA, rectB;
@@ -311,7 +304,6 @@ static void test_isWideOpen(skiatest::Reporter* reporter) {
SkClipStack stack;
REPORTER_ASSERT(reporter, stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
}
// Test out case where the user specifies a union that includes everything
@@ -330,7 +322,6 @@ static void test_isWideOpen(skiatest::Reporter* reporter) {
stack.clipDevPath(clipB, SkRegion::kUnion_Op, false);
REPORTER_ASSERT(reporter, stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
}
// Test out union w/ a wide open clip
@@ -340,7 +331,6 @@ static void test_isWideOpen(skiatest::Reporter* reporter) {
stack.clipDevRect(rectA, SkRegion::kUnion_Op, false);
REPORTER_ASSERT(reporter, stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
}
// Test out empty difference from a wide open clip
@@ -353,7 +343,6 @@ static void test_isWideOpen(skiatest::Reporter* reporter) {
stack.clipDevRect(emptyRect, SkRegion::kDifference_Op, false);
REPORTER_ASSERT(reporter, stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
}
// Test out return to wide open
@@ -365,12 +354,10 @@ static void test_isWideOpen(skiatest::Reporter* reporter) {
stack.clipDevRect(rectA, SkRegion::kReplace_Op, false);
REPORTER_ASSERT(reporter, !stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
stack.restore();
REPORTER_ASSERT(reporter, stack.isWideOpen());
- REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
}
}
@@ -953,19 +940,16 @@ static void test_reduced_clip_stack(skiatest::Reporter* reporter) {
typedef GrReducedClip::ElementList ElementList;
// Get the reduced version of the stack.
ElementList reducedClips;
- int32_t reducedGenID;
+
GrReducedClip::InitialState initial;
SkIRect tBounds(inflatedIBounds);
SkIRect* tightBounds = r.nextBool() ? &tBounds : NULL;
GrReducedClip::ReduceClipStack(stack,
inflatedIBounds,
&reducedClips,
- &reducedGenID,
&initial,
tightBounds);
- REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID != reducedGenID);
-
// Build a new clip stack based on the reduced clip elements
SkClipStack reducedStack;
if (GrReducedClip::kAllOut_InitialState == initial) {
@@ -1002,155 +986,6 @@ static void test_reduced_clip_stack(skiatest::Reporter* reporter) {
}
}
-static void test_reduced_clip_stack_genid(skiatest::Reporter* reporter) {
- {
- SkClipStack stack;
- stack.clipDevRect(SkRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op, true);
- stack.clipDevRect(SkRect::MakeXYWH(0, 0, 50.3f, 50.3f), SkRegion::kReplace_Op, true);
- SkIRect inflatedIBounds = SkIRect::MakeXYWH(0, 0, 100, 100);
-
- GrReducedClip::ElementList reducedClips;
- int32_t reducedGenID;
- GrReducedClip::InitialState initial;
- SkIRect tightBounds;
-
- GrReducedClip::ReduceClipStack(stack,
- inflatedIBounds,
- &reducedClips,
- &reducedGenID,
- &initial,
- &tightBounds);
-
- REPORTER_ASSERT(reporter, reducedClips.count() == 1);
- // Clips will be cached based on the generation id. Make sure the gen id is valid.
- REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID != reducedGenID);
- }
- {
- SkClipStack stack;
-
- // Create a clip with following 25.3, 25.3 boxes which are 25 apart:
- // A B
- // C D
-
- stack.clipDevRect(SkRect::MakeXYWH(0, 0, 25.3f, 25.3f), SkRegion::kReplace_Op, true);
- int32_t genIDA = stack.getTopmostGenID();
- stack.clipDevRect(SkRect::MakeXYWH(50, 0, 25.3f, 25.3f), SkRegion::kUnion_Op, true);
- int32_t genIDB = stack.getTopmostGenID();
- stack.clipDevRect(SkRect::MakeXYWH(0, 50, 25.3f, 25.3f), SkRegion::kUnion_Op, true);
- int32_t genIDC = stack.getTopmostGenID();
- stack.clipDevRect(SkRect::MakeXYWH(50, 50, 25.3f, 25.3f), SkRegion::kUnion_Op, true);
- int32_t genIDD = stack.getTopmostGenID();
-
-#define XYWH SkIRect::MakeXYWH
-
- SkIRect unused;
- unused.setEmpty();
- SkIRect stackBounds = XYWH(0, 0, 76, 76);
-
- // The base test is to test each rect in two ways:
- // 1) The box dimensions. (Should reduce to "all in", no elements).
- // 2) A bit over the box dimensions.
- // In the case 2, test that the generation id is what is expected.
- // The rects are of fractional size so that case 2 never gets optimized to an empty element
- // list.
-
- // Not passing in tighter bounds is tested for consistency.
- struct {
- SkIRect testBounds;
- int reducedClipCount;
- int32_t reducedGenID;
- GrReducedClip::InitialState initialState;
- SkIRect tighterBounds; // If this is empty, the query will not pass tighter bounds
- // parameter.
- } testCases[] = {
- // Rect A.
- { XYWH(0, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(0, 0, 25, 25) },
- { XYWH(0, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
- { XYWH(0, 0, 27, 27), 1, genIDA, GrReducedClip::kAllOut_InitialState, XYWH(0, 0, 27, 27)},
- { XYWH(0, 0, 27, 27), 1, genIDA, GrReducedClip::kAllOut_InitialState, unused },
-
- // Rect B.
- { XYWH(50, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(50, 0, 25, 25) },
- { XYWH(50, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
- { XYWH(50, 0, 27, 27), 1, genIDB, GrReducedClip::kAllOut_InitialState, XYWH(50, 0, 26, 27) },
- { XYWH(50, 0, 27, 27), 1, genIDB, GrReducedClip::kAllOut_InitialState, unused },
-
- // Rect C.
- { XYWH(0, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(0, 50, 25, 25) },
- { XYWH(0, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
- { XYWH(0, 50, 27, 27), 1, genIDC, GrReducedClip::kAllOut_InitialState, XYWH(0, 50, 27, 26) },
- { XYWH(0, 50, 27, 27), 1, genIDC, GrReducedClip::kAllOut_InitialState, unused },
-
- // Rect D.
- { XYWH(50, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
- { XYWH(50, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(50, 50, 25, 25)},
- { XYWH(50, 50, 27, 27), 1, genIDD, GrReducedClip::kAllOut_InitialState, unused },
- { XYWH(50, 50, 27, 27), 1, genIDD, GrReducedClip::kAllOut_InitialState, XYWH(50, 50, 26, 26)},
-
- // Other tests:
- { XYWH(0, 0, 100, 100), 4, genIDD, GrReducedClip::kAllOut_InitialState, unused },
- { XYWH(0, 0, 100, 100), 4, genIDD, GrReducedClip::kAllOut_InitialState, stackBounds },
-
- // Rect in the middle, touches none.
- { XYWH(26, 26, 24, 24), 0, SkClipStack::kEmptyGenID, GrReducedClip::kAllOut_InitialState, unused },
- { XYWH(26, 26, 24, 24), 0, SkClipStack::kEmptyGenID, GrReducedClip::kAllOut_InitialState, XYWH(26, 26, 24, 24) },
-
- // Rect in the middle, touches all the rects. GenID is the last rect.
- { XYWH(24, 24, 27, 27), 4, genIDD, GrReducedClip::kAllOut_InitialState, unused },
- { XYWH(24, 24, 27, 27), 4, genIDD, GrReducedClip::kAllOut_InitialState, XYWH(24, 24, 27, 27) },
- };
-
-#undef XYWH
-
- for (size_t i = 0; i < SK_ARRAY_COUNT(testCases); ++i) {
- GrReducedClip::ElementList reducedClips;
- int32_t reducedGenID;
- GrReducedClip::InitialState initial;
- SkIRect tightBounds;
-
- GrReducedClip::ReduceClipStack(stack,
- testCases[i].testBounds,
- &reducedClips,
- &reducedGenID,
- &initial,
- testCases[i].tighterBounds.isEmpty() ? NULL : &tightBounds);
-
- REPORTER_ASSERT(reporter, reducedClips.count() == testCases[i].reducedClipCount);
- SkASSERT(reducedClips.count() == testCases[i].reducedClipCount);
- REPORTER_ASSERT(reporter, reducedGenID == testCases[i].reducedGenID);
- SkASSERT(reducedGenID == testCases[i].reducedGenID);
- REPORTER_ASSERT(reporter, initial == testCases[i].initialState);
- SkASSERT(initial == testCases[i].initialState);
- if (!testCases[i].tighterBounds.isEmpty()) {
- REPORTER_ASSERT(reporter, tightBounds == testCases[i].tighterBounds);
- SkASSERT(tightBounds == testCases[i].tighterBounds);
- }
- }
- }
-}
-
-static void test_reduced_clip_stack_no_aa_crash(skiatest::Reporter* reporter) {
- SkClipStack stack;
- stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op);
- stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 50, 50), SkRegion::kReplace_Op);
- SkIRect inflatedIBounds = SkIRect::MakeXYWH(0, 0, 100, 100);
-
- GrReducedClip::ElementList reducedClips;
- int32_t reducedGenID;
- GrReducedClip::InitialState initial;
- SkIRect tightBounds;
-
- // At the time, this would crash.
- GrReducedClip::ReduceClipStack(stack,
- inflatedIBounds,
- &reducedClips,
- &reducedGenID,
- &initial,
- &tightBounds);
-
- REPORTER_ASSERT(reporter, 0 == reducedClips.count());
-}
-
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1199,8 +1034,6 @@ static void TestClipStack(skiatest::Reporter* reporter) {
test_quickContains(reporter);
#if SK_SUPPORT_GPU
test_reduced_clip_stack(reporter);
- test_reduced_clip_stack_genid(reporter);
- test_reduced_clip_stack_no_aa_crash(reporter);
#endif
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-01 16:07:38 +0000