AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Avoid re-rendering stencil clip for every draw with reducable clip stack"

Browse Source 
This reverts commit 92a7d4bf6a371f1f864154be902e8d86938e560b.

Revert "fix mac 10.6 build"

This reverts commit 114cd1a9f2734aaed6914718814364811b78bd7f.

BUG=

Review URL: https://codereview.chromium.org/54543008

git-svn-id: http://skia.googlecode.com/svn/trunk@12087 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
reed@google.com 2013-11-01 16:25:59 +00:00
parent eea3ab78e9
commit f0784bde75
11 changed files with 147 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
include/core/SkClipStack.h
View File

@ -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
@ -315,13 +315,26 @@ 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,11 +440,28 @@ 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.
*/

64
src/core/SkClipStack.cpp
View File

@ -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;
return kInvalidGenID;
}
const Element* back = static_cast<const Element*>(fDeque.back());
if (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty()) {
return kWideOpenGenID;
}
return back->getGenID();
Element* element = (Element*)fDeque.back();
return element->fGenID;
}

4
src/gpu/GrClipMaskCache.h
View File

@ -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

28
src/gpu/GrClipMaskManager.cpp
View File

@ -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;
}

9
src/gpu/GrClipMaskManager.h
View File

@ -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);

31
src/gpu/GrReducedClip.cpp
View File

@ -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

4
src/gpu/GrReducedClip.h
View File

@ -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);

3
src/gpu/GrStencilBuffer.h
View File

@ -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);
}

19
src/gpu/SkGpuDevice.cpp
View File

@ -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;
}

28
tests/ClipCacheTest.cpp
View File

@ -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
}

169
tests/ClipStackTest.cpp
View File

@ -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
}