Store SkRRects in SkClipStack

src/core/SkClipStack.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkClipStack.h"
 #include "SkPath.h"
 #include "SkThread.h"
 
 #include <new>
 
 
 // 0-2 are reserved for invalid, empty & wide-open
 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;
+    }
+}
 
 void SkClipStack::Element::checkEmpty() const {
     SkASSERT(fFiniteBound.isEmpty());
     SkASSERT(kNormal_BoundsType == fFiniteBoundType);
     SkASSERT(!fIsIntersectionOfRects);
     SkASSERT(kEmptyGenID == fGenID);
     SkASSERT(fPath.isEmpty());
 }
 
 bool SkClipStack::Element::canBeIntersectedInPlace(int saveCount, SkRegion::Op op) const {
@@ skipping 50 matching lines @@
             // that aren't set are whatever isn't set in the previous
             // clip and whatever this clip carves out
             fFiniteBound.join(prevFinite);
             fFiniteBoundType = kInsideOut_BoundsType;
             break;
         case kPrev_InvCur_FillCombo:
             // In this case everything outside of this clip's bound
             // 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
             // prior clip. This could be wildly incorrect if the
             // second clip either exactly matches the first clip
             // (which should yield the empty set) or reduces the
             // size of the prior bound (e.g., if the second clip
             // exactly matched the bottom half of the prior clip).
             // We ignore these two possibilities.
             fFiniteBound = prevFinite;
@@ skipping 81 matching lines @@
             // are within the current clip
             break;
         case kPrev_InvCur_FillCombo:
             // In this case the only pixels that will remain writeable
             // are with the previous clip
             fFiniteBound = prevFinite;
             fFiniteBoundType = kNormal_BoundsType;
             break;
         case kPrev_Cur_FillCombo:
             if (!fFiniteBound.intersect(prevFinite)) {
-                fFiniteBound.setEmpty();
-                fGenID = kEmptyGenID;
+                this->setEmpty();
             }
             break;
         default:
             SkDEBUGFAIL("SkClipStack::Element::combineBoundsIntersection Invalid fill combination");
             break;
     }
 }
 
 // a mirror of combineBoundsDiff
 void SkClipStack::Element::combineBoundsRevDiff(int combination, const SkRect& prevFinite) {
 
     switch (combination) {
         case kInvPrev_InvCur_FillCombo:
             // The only pixels that can survive are in the
             // previous bound since the extensions to infinity in
             // both clips cancel out
             fFiniteBound = prevFinite;
             fFiniteBoundType = kNormal_BoundsType;
             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);
             fFiniteBoundType = kInsideOut_BoundsType;
             break;
         case kPrev_Cur_FillCombo:
             // Fall through - as with the kDifference_Op case, the
             // most conservative result bound is the bound of the
             // current clip. The prior clip could reduce the size of this
             // bound (as in the kDifference_Op case) but we are ignoring
             // those cases.
             break;
         default:
             SkDEBUGFAIL("SkClipStack::Element::combineBoundsRevDiff Invalid fill combination");
             break;
     }
 }
 
 void SkClipStack::Element::updateBoundAndGenID(const Element* prior) {
     // We set this first here but we may overwrite it later if we determine that the clip is
     // either wide-open or empty.
     fGenID = GetNextGenID();
 
     // 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;
+    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;
-        }
+            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();
 
-    } else {
-        SkASSERT(kPath_Type == fType);
-
-        fFiniteBound = fPath.getBounds();
-
-        if (fPath.isInverseFillType()) {
-            fFiniteBoundType = kInsideOut_BoundsType;
-        } else {
-            fFiniteBoundType = kNormal_BoundsType;
-        }
+            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) {
         // Here we mimic a non-anti-aliased scanline system. If there is
         // no anti-aliasing we can integerize the bounding box to exclude
         // fractional parts that won't be rendered.
         // Note: the left edge is handled slightly differently below. We
         // are a bit more generous in the rounding since we don't want to
         // risk missing the left pixels when fLeft is very close to .5
         fFiniteBound.set(SkScalarFloorToScalar(fFiniteBound.fLeft+0.45f),
@@ skipping 45 matching lines @@
             break;
         case SkRegion::kReverseDifference_Op:
             this->combineBoundsRevDiff(combination, prevFinite);
             break;
         case SkRegion::kReplace_Op:
             // Replace just ignores everything prior
             // The current clip's bound information is already filled in
             // so nothing to do
             break;
         default:
-            SkDebugf("SkRegion::Op error/n");
+            SkDebugf("SkRegion::Op error\n");
             SkASSERT(0);
             break;
     }
 }
 
 // This constant determines how many Element's are allocated together as a block in
 // the deque. As such it needs to balance allocating too much memory vs.
 // incurring allocation/deallocation thrashing. It should roughly correspond to
 // the deepest save/restore stack we expect to see.
 static const int kDefaultElementAllocCnt = 8;
@@ skipping 163 matching lines @@
             }
         }
         if (SkRegion::kReplace_Op == element->getOp()) {
             break;
         }
         element = iter.prev();
     }
     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);
 
     ((Element*)fDeque.back())->fGenID = kEmptyGenID;
 }
 
 bool SkClipStack::isWideOpen() const {
     return this->getTopmostGenID() == kWideOpenGenID;
 }
 
@@ skipping 98 matching lines @@
         return kWideOpenGenID;
     }
 
     const Element* back = static_cast<const Element*>(fDeque.back());
     if (kInsideOut_BoundsType == back->fFiniteBoundType && back->fFiniteBound.isEmpty()) {
         return kWideOpenGenID;
     }
 
     return back->getGenID();
 }