Store SkRRects in SkClipStack
BUG=skia:2181
R=robertphillips@google.com
Author: bsalomon@google.com
Review URL: https://codereview.chromium.org/163683002
git-svn-id: http://skia.googlecode.com/svn/trunk@13465 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 61acf26..2cc504f 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -1295,13 +1295,7 @@
continue;
}
SkPath operand;
- if (type == SkClipStack::Element::kRect_Type) {
- operand.addRect(element->getRect());
- } else if (type == SkClipStack::Element::kPath_Type) {
- operand = element->getPath();
- } else {
- SkDEBUGFAIL("Unexpected type.");
- }
+ element->asPath(&operand);
SkRegion::Op elementOp = element->getOp();
if (elementOp == SkRegion::kReplace_Op) {
devPath = operand;
@@ -1458,6 +1452,9 @@
case SkClipStack::Element::kPath_Type:
visitor->clipPath(element->getPath(), element->getOp(), element->isAA());
break;
+ case SkClipStack::Element::kRRect_Type:
+ visitor->clipRRect(element->getRRect(), element->getOp(), element->isAA());
+ break;
case SkClipStack::Element::kRect_Type:
visitor->clipRect(element->getRect(), element->getOp(), element->isAA());
break;
diff --git a/src/core/SkClipStack.cpp b/src/core/SkClipStack.cpp
index c66a219..17eb6f9 100644
--- a/src/core/SkClipStack.cpp
+++ b/src/core/SkClipStack.cpp
@@ -16,17 +16,89 @@
static const int32_t kFirstUnreservedGenID = 3;
int32_t SkClipStack::gGenID = kFirstUnreservedGenID;
+bool SkClipStack::Element::operator== (const Element& element) const {
+ if (this == &element) {
+ return true;
+ }
+ if (fOp != element.fOp ||
+ fType != element.fType ||
+ fDoAA != element.fDoAA ||
+ fSaveCount != element.fSaveCount) {
+ return false;
+ }
+ switch (fType) {
+ case kPath_Type:
+ return fPath == element.fPath;
+ case kRRect_Type:
+ return fRRect == element.fRRect;
+ case kRect_Type:
+ return fRect == element.fRect;
+ case kEmpty_Type:
+ return true;
+ default:
+ SkDEBUGFAIL("Unexpected type.");
+ return false;
+ }
+}
+
void SkClipStack::Element::invertShapeFillType() {
switch (fType) {
case kRect_Type:
fPath.reset();
fPath.addRect(fRect);
- fPath.setFillType(SkPath::kInverseWinding_FillType);
+ fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
+ fType = kPath_Type;
+ break;
+ case kRRect_Type:
+ fPath.reset();
+ fPath.addRRect(fRRect);
+ fPath.setFillType(SkPath::kInverseEvenOdd_FillType);
fType = kPath_Type;
break;
case kPath_Type:
fPath.toggleInverseFillType();
+ break;
case kEmpty_Type:
+ // Should this set to an empty, inverse filled path?
+ break;
+ }
+}
+
+void SkClipStack::Element::initPath(int saveCount, const SkPath& path, SkRegion::Op op,
+ bool doAA) {
+ if (!path.isInverseFillType()) {
+ if (SkPath::kNone_PathAsRect != path.asRect()) {
+ this->initRect(saveCount, path.getBounds(), op, doAA);
+ return;
+ }
+ SkRect ovalRect;
+ if (path.isOval(&ovalRect)) {
+ SkRRect rrect;
+ rrect.setOval(ovalRect);
+ this->initRRect(saveCount, rrect, op, doAA);
+ return;
+ }
+ }
+ fPath = path;
+ fType = kPath_Type;
+ this->initCommon(saveCount, op, doAA);
+}
+
+void SkClipStack::Element::asPath(SkPath* path) const {
+ switch (fType) {
+ case kEmpty_Type:
+ path->reset();
+ break;
+ case kRect_Type:
+ path->reset();
+ path->addRect(fRect);
+ break;
+ case kRRect_Type:
+ path->reset();
+ path->addRRect(fRRect);
+ break;
+ case kPath_Type:
+ *path = fPath;
break;
}
}
@@ -100,10 +172,10 @@
// is erased, so the only pixels that can remain set
// occur w/in the intersection of the two finite bounds
if (!fFiniteBound.intersect(prevFinite)) {
- fFiniteBound.setEmpty();
- fGenID = kEmptyGenID;
+ this->setEmpty();
+ } else {
+ fFiniteBoundType = kNormal_BoundsType;
}
- fFiniteBoundType = kNormal_BoundsType;
break;
case kPrev_Cur_FillCombo:
// The most conservative result bound is that of the
@@ -205,8 +277,7 @@
break;
case kPrev_Cur_FillCombo:
if (!fFiniteBound.intersect(prevFinite)) {
- fFiniteBound.setEmpty();
- fGenID = kEmptyGenID;
+ this->setEmpty();
}
break;
default:
@@ -228,10 +299,10 @@
break;
case kInvPrev_Cur_FillCombo:
if (!fFiniteBound.intersect(prevFinite)) {
- fFiniteBound.setEmpty();
- fGenID = kEmptyGenID;
+ this->setEmpty();
+ } else {
+ fFiniteBoundType = kNormal_BoundsType;
}
- fFiniteBoundType = kNormal_BoundsType;
break;
case kPrev_InvCur_FillCombo:
fFiniteBound.join(prevFinite);
@@ -258,27 +329,34 @@
// First, optimistically update the current Element's bound information
// with the current clip's bound
fIsIntersectionOfRects = false;
- if (kRect_Type == fType) {
- fFiniteBound = fRect;
- fFiniteBoundType = kNormal_BoundsType;
-
- if (SkRegion::kReplace_Op == fOp ||
- (SkRegion::kIntersect_Op == fOp && NULL == prior) ||
- (SkRegion::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
- prior->rectRectIntersectAllowed(fRect, fDoAA))) {
- fIsIntersectionOfRects = true;
- }
-
- } else {
- SkASSERT(kPath_Type == fType);
-
- fFiniteBound = fPath.getBounds();
-
- if (fPath.isInverseFillType()) {
- fFiniteBoundType = kInsideOut_BoundsType;
- } else {
+ switch (fType) {
+ case kRect_Type:
+ fFiniteBound = fRect;
fFiniteBoundType = kNormal_BoundsType;
- }
+
+ if (SkRegion::kReplace_Op == fOp ||
+ (SkRegion::kIntersect_Op == fOp && NULL == prior) ||
+ (SkRegion::kIntersect_Op == fOp && prior->fIsIntersectionOfRects &&
+ prior->rectRectIntersectAllowed(fRect, fDoAA))) {
+ fIsIntersectionOfRects = true;
+ }
+ break;
+ case kRRect_Type:
+ fFiniteBound = fRRect.getBounds();
+ fFiniteBoundType = kNormal_BoundsType;
+ break;
+ case kPath_Type:
+ fFiniteBound = fPath.getBounds();
+
+ if (fPath.isInverseFillType()) {
+ fFiniteBoundType = kInsideOut_BoundsType;
+ } else {
+ fFiniteBoundType = kNormal_BoundsType;
+ }
+ break;
+ case kEmpty_Type:
+ SkDEBUGFAIL("We shouldn't get here with an empty element.");
+ break;
}
if (!fDoAA) {
@@ -344,7 +422,7 @@
// so nothing to do
break;
default:
- SkDebugf("SkRegion::Op error/n");
+ SkDebugf("SkRegion::Op error\n");
SkASSERT(0);
break;
}
@@ -528,97 +606,69 @@
return true;
}
-void SkClipStack::clipDevRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
-
+void SkClipStack::pushElement(const Element& element) {
// Use reverse iterator instead of back because Rect path may need previous
SkDeque::Iter iter(fDeque, SkDeque::Iter::kBack_IterStart);
- Element* element = (Element*) iter.prev();
+ Element* prior = (Element*) iter.prev();
- if (NULL != element) {
- if (element->canBeIntersectedInPlace(fSaveCount, op)) {
- switch (element->fType) {
+ if (NULL != prior) {
+ if (prior->canBeIntersectedInPlace(fSaveCount, element.getOp())) {
+ switch (prior->fType) {
case Element::kEmpty_Type:
- element->checkEmpty();
+ SkDEBUGCODE(prior->checkEmpty();)
return;
case Element::kRect_Type:
- if (element->rectRectIntersectAllowed(rect, doAA)) {
- if (!element->fRect.intersect(rect)) {
- element->setEmpty();
+ if (Element::kRect_Type == element.getType()) {
+ if (prior->rectRectIntersectAllowed(element.getRect(), element.isAA())) {
+ if (!prior->fRect.intersect(element.getRect())) {
+ prior->setEmpty();
+ return;
+ }
+
+ prior->fDoAA = element.isAA();
+ Element* priorPrior = (Element*) iter.prev();
+ prior->updateBoundAndGenID(priorPrior);
return;
}
-
- element->fDoAA = doAA;
- Element* prev = (Element*) iter.prev();
- element->updateBoundAndGenID(prev);
- return;
+ break;
}
- break;
- case Element::kPath_Type:
- if (!SkRect::Intersects(element->fPath.getBounds(), rect)) {
- element->setEmpty();
+ // fallthrough
+ default:
+ if (!SkRect::Intersects(prior->getBounds(), element.getBounds())) {
+ prior->setEmpty();
return;
}
break;
}
- } else if (SkRegion::kReplace_Op == op) {
+ } else if (SkRegion::kReplace_Op == element.getOp()) {
this->restoreTo(fSaveCount - 1);
- element = (Element*) fDeque.back();
+ prior = (Element*) fDeque.back();
}
}
- new (fDeque.push_back()) Element(fSaveCount, rect, op, doAA);
- ((Element*) fDeque.back())->updateBoundAndGenID(element);
+ Element* newElement = SkNEW_PLACEMENT_ARGS(fDeque.push_back(), Element, (element));
+ newElement->updateBoundAndGenID(prior);
+}
+
+void SkClipStack::clipDevRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) {
+ Element element(fSaveCount, rrect, op, doAA);
+ this->pushElement(element);
+}
+
+void SkClipStack::clipDevRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
+ Element element(fSaveCount, rect, op, doAA);
+ this->pushElement(element);
}
void SkClipStack::clipDevPath(const SkPath& path, SkRegion::Op op, bool doAA) {
- SkRect alt;
- if (path.isRect(&alt) && !path.isInverseFillType()) {
- return this->clipDevRect(alt, op, doAA);
- }
-
- Element* element = (Element*)fDeque.back();
- if (NULL != element) {
- if (element->canBeIntersectedInPlace(fSaveCount, op)) {
- const SkRect& pathBounds = path.getBounds();
- switch (element->fType) {
- case Element::kEmpty_Type:
- element->checkEmpty();
- return;
- case Element::kRect_Type:
- if (!SkRect::Intersects(element->fRect, pathBounds)) {
- element->setEmpty();
- return;
- }
- break;
- case Element::kPath_Type:
- if (!SkRect::Intersects(element->fPath.getBounds(), pathBounds)) {
- element->setEmpty();
- return;
- }
- break;
- }
- } else if (SkRegion::kReplace_Op == op) {
- this->restoreTo(fSaveCount - 1);
- element = (Element*) fDeque.back();
- }
- }
- new (fDeque.push_back()) Element(fSaveCount, path, op, doAA);
- ((Element*) fDeque.back())->updateBoundAndGenID(element);
+ Element element(fSaveCount, path, op, doAA);
+ this->pushElement(element);
}
void SkClipStack::clipEmpty() {
-
Element* element = (Element*) fDeque.back();
if (element && element->canBeIntersectedInPlace(fSaveCount, SkRegion::kIntersect_Op)) {
- switch (element->fType) {
- case Element::kEmpty_Type:
- element->checkEmpty();
- return;
- case Element::kRect_Type:
- case Element::kPath_Type:
- element->setEmpty();
- return;
- }
+ element->setEmpty();
}
new (fDeque.push_back()) Element(fSaveCount);
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index 83b3b01..8a7aac2 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -94,13 +94,13 @@
for (ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
const Element* element = iter.get();
// rects can always be drawn directly w/o using the software path
- // so only paths need to be checked
- if (Element::kPath_Type == element->getType() &&
- path_needs_SW_renderer(this->getContext(), fGpu,
- element->getPath(),
- stroke,
- element->isAA())) {
- return true;
+ // Skip rrects once we're drawing them directly.
+ if (Element::kRect_Type != element->getType()) {
+ SkPath path;
+ element->asPath(&path);
+ if (path_needs_SW_renderer(this->getContext(), fGpu, path, stroke, element->isAA())) {
+ return true;
+ }
}
}
return false;
@@ -169,10 +169,11 @@
return true;
}
}
+ Element::Type type = elements.tail()->getType();
+ bool isAA = GR_AA_CLIP && elements.tail()->isAA();
SkAutoTUnref<GrEffectRef> effect;
- if (SkClipStack::Element::kPath_Type == elements.tail()->getType()) {
+ if (SkClipStack::Element::kPath_Type == type) {
const SkPath& path = elements.tail()->getPath();
- bool isAA = GR_AA_CLIP && elements.tail()->isAA();
if (rt->isMultisampled()) {
// A coverage effect for AA clipping won't play nicely with MSAA.
if (!isAA) {
@@ -188,13 +189,12 @@
GrConvexPolyEffect::kFillNoAA_EdgeType;
effect.reset(GrConvexPolyEffect::Create(type, path, &offset));
}
- } else if (GR_AA_CLIP && elements.tail()->isAA() && !rt->isMultisampled()) {
+ } else if (isAA && SkClipStack::Element::kRect_Type == type && !rt->isMultisampled()) {
// We only handle AA/non-MSAA rects here. Coverage effect AA isn't MSAA friendly and
// non-AA rect clips are handled by the scissor.
- SkASSERT(SkClipStack::Element::kRect_Type == elements.tail()->getType());
SkRect rect = elements.tail()->getRect();
SkVector offset = { SkIntToScalar(-clipDataIn->fOrigin.fX),
- SkIntToScalar(-clipDataIn->fOrigin.fY) };
+ SkIntToScalar(-clipDataIn->fOrigin.fY) };
rect.offset(offset);
effect.reset(GrConvexPolyEffect::CreateForAAFillRect(rect));
// This should never fail.
@@ -332,7 +332,11 @@
drawState->setRenderTarget(target->asRenderTarget());
+ // TODO: Draw rrects directly here.
switch (element->getType()) {
+ case Element::kEmpty_Type:
+ SkDEBUGFAIL("Should never get here with an empty element.");
+ break;
case Element::kRect_Type:
// TODO: Do rects directly to the accumulator using a aa-rect GrEffect that covers the
// entire mask bounds and writes 0 outside the rect.
@@ -347,28 +351,25 @@
fGpu->drawSimpleRect(element->getRect(), NULL);
}
return true;
- case Element::kPath_Type: {
- SkTCopyOnFirstWrite<SkPath> path(element->getPath());
- if (path->isInverseFillType()) {
- path.writable()->toggleInverseFillType();
+ default: {
+ SkPath path;
+ element->asPath(&path);
+ if (path.isInverseFillType()) {
+ path.toggleInverseFillType();
}
SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
if (NULL == pr) {
GrPathRendererChain::DrawType type;
type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
GrPathRendererChain::kColor_DrawType;
- pr = this->getContext()->getPathRenderer(*path, stroke, fGpu, false, type);
+ pr = this->getContext()->getPathRenderer(path, stroke, fGpu, false, type);
}
if (NULL == pr) {
return false;
}
- pr->drawPath(element->getPath(), stroke, fGpu, element->isAA());
+ pr->drawPath(path, stroke, fGpu, element->isAA());
break;
}
- default:
- // something is wrong if we're trying to draw an empty element.
- GrCrash("Unexpected element type");
- return false;
}
return true;
}
@@ -379,25 +380,22 @@
GrDrawState* drawState = fGpu->drawState();
drawState->setRenderTarget(target->asRenderTarget());
- switch (element->getType()) {
- case Element::kRect_Type:
- return true;
- case Element::kPath_Type: {
- SkTCopyOnFirstWrite<SkPath> path(element->getPath());
- if (path->isInverseFillType()) {
- path.writable()->toggleInverseFillType();
- }
- SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
- GrPathRendererChain::DrawType type = element->isAA() ?
- GrPathRendererChain::kStencilAndColorAntiAlias_DrawType :
- GrPathRendererChain::kStencilAndColor_DrawType;
- *pr = this->getContext()->getPathRenderer(*path, stroke, fGpu, false, type);
- return NULL != *pr;
+ if (Element::kRect_Type == element->getType()) {
+ return true;
+ } else {
+ // We shouldn't get here with an empty clip element.
+ SkASSERT(Element::kEmpty_Type != element->getType());
+ SkPath path;
+ element->asPath(&path);
+ if (path.isInverseFillType()) {
+ path.toggleInverseFillType();
}
- default:
- // something is wrong if we're trying to draw an empty element.
- GrCrash("Unexpected element type");
- return false;
+ SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
+ GrPathRendererChain::DrawType type = element->isAA() ?
+ GrPathRendererChain::kStencilAndColorAntiAlias_DrawType :
+ GrPathRendererChain::kStencilAndColor_DrawType;
+ *pr = this->getContext()->getPathRenderer(path, stroke, fGpu, false, type);
+ return NULL != *pr;
}
}
@@ -700,18 +698,17 @@
SkRegion::Op op = element->getOp();
GrPathRenderer* pr = NULL;
- SkTCopyOnFirstWrite<SkPath> clipPath;
+ SkPath clipPath;
if (Element::kRect_Type == element->getType()) {
stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
fillInverted = false;
} else {
- SkASSERT(Element::kPath_Type == element->getType());
- clipPath.init(element->getPath());
- fillInverted = clipPath->isInverseFillType();
+ element->asPath(&clipPath);
+ fillInverted = clipPath.isInverseFillType();
if (fillInverted) {
- clipPath.writable()->toggleInverseFillType();
+ clipPath.toggleInverseFillType();
}
- pr = this->getContext()->getPathRenderer(*clipPath,
+ pr = this->getContext()->getPathRenderer(clipPath,
stroke,
fGpu,
false,
@@ -752,13 +749,12 @@
*drawState->stencil() = gDrawToStencil;
fGpu->drawSimpleRect(element->getRect(), NULL);
} else {
- SkASSERT(Element::kPath_Type == element->getType());
- if (!clipPath->isEmpty()) {
+ if (!clipPath.isEmpty()) {
if (canRenderDirectToStencil) {
*drawState->stencil() = gDrawToStencil;
- pr->drawPath(*clipPath, stroke, fGpu, false);
+ pr->drawPath(clipPath, stroke, fGpu, false);
} else {
- pr->stencilPath(*clipPath, stroke, fGpu);
+ pr->stencilPath(clipPath, stroke, fGpu);
}
}
}
@@ -774,9 +770,8 @@
SET_RANDOM_COLOR
fGpu->drawSimpleRect(element->getRect(), NULL);
} else {
- SkASSERT(Element::kPath_Type == element->getType());
SET_RANDOM_COLOR
- pr->drawPath(*clipPath, stroke, fGpu, false);
+ pr->drawPath(clipPath, stroke, fGpu, false);
}
} else {
SET_RANDOM_COLOR
diff --git a/src/gpu/GrReducedClip.cpp b/src/gpu/GrReducedClip.cpp
index 8480e04..6ad9cc6 100644
--- a/src/gpu/GrReducedClip.cpp
+++ b/src/gpu/GrReducedClip.cpp
@@ -72,6 +72,8 @@
*requiresAA = false;
}
} else if (isectRect.intersect(stackBounds, scalarQueryBounds)) {
+ // If the caller asked for tighter integer bounds we may be able to
+ // return kAllIn and give the bounds with no elements
if (NULL != tighterBounds) {
isectRect.roundOut(tighterBounds);
SkRect scalarTighterBounds = SkRect::Make(*tighterBounds);
@@ -83,14 +85,14 @@
*initialState = kAllIn_InitialState;
return;
}
- *initialState = kAllOut_InitialState;
- // iior should only be true if aa/non-aa status matches among all elements.
- SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
- bool doAA = iter.prev()->isAA();
- SkNEW_INSERT_AT_LLIST_HEAD(result, Element, (isectRect, SkRegion::kReplace_Op, doAA));
- if (NULL != requiresAA) {
- *requiresAA = doAA;
- }
+ }
+ *initialState = kAllOut_InitialState;
+ // iior should only be true if aa/non-aa status matches among all elements.
+ SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
+ bool doAA = iter.prev()->isAA();
+ SkNEW_INSERT_AT_LLIST_HEAD(result, Element, (isectRect, SkRegion::kReplace_Op, doAA));
+ if (NULL != requiresAA) {
+ *requiresAA = doAA;
}
} else {
*initialState = kAllOut_InitialState;
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 9487dfd..ce036d1 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -404,10 +404,8 @@
outClipPath->reset();
outClipPath->setFillType(SkPath::kInverseWinding_FillType);
continue;
- } else if (SkClipStack::Element::kRect_Type == clipEntry->getType()) {
- entryPath.addRect(clipEntry->getRect());
- } else if (SkClipStack::Element::kPath_Type == clipEntry->getType()) {
- entryPath = clipEntry->getPath();
+ } else {
+ clipEntry->asPath(&entryPath);
}
entryPath.transform(transform);
diff --git a/src/utils/SkCanvasStateUtils.cpp b/src/utils/SkCanvasStateUtils.cpp
index eb92c37..77b0e20 100644
--- a/src/utils/SkCanvasStateUtils.cpp
+++ b/src/utils/SkCanvasStateUtils.cpp
@@ -130,6 +130,10 @@
fFailed |= antialias;
}
+ virtual void clipRRect(const SkRRect& rrect, SkRegion::Op op, bool antialias) SK_OVERRIDE {
+ fFailed |= antialias;
+ }
+
virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) SK_OVERRIDE {
fFailed |= antialias;
}