Improve usage of window rectangles

src/gpu/GrReducedClip.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrReducedClip.h"
 
 #include "GrAppliedClip.h"
@@ skipping 10 matching lines @@
 
 typedef SkClipStack::Element Element;
 
 /**
  * There are plenty of optimizations that could be added here. Maybe flips could be folded into
  * earlier operations. Or would inserting flips and reversing earlier ops ever be a win? Perhaps
  * for the case where the bounds are kInsideOut_BoundsType. We could restrict earlier operations
  * based on later intersect operations, and perhaps remove intersect-rects. We could optionally
  * take a rect in case the caller knows a bound on what is to be drawn through this clip.
  */
-GrReducedClip::GrReducedClip(const SkClipStack& stack, const SkRect& queryBounds) {
+GrReducedClip::GrReducedClip(const SkClipStack& stack, const SkRect& queryBounds,
+                             int maxWindowRectangles) {
     SkASSERT(!queryBounds.isEmpty());
     fHasIBounds = false;
 
     if (stack.isWideOpen()) {
         fInitialState = InitialState::kAllIn;
         return;
     }
 
     SkClipStack::BoundsType stackBoundsType;
     SkRect stackBounds;
@@ skipping 45 matching lines @@
         // clip will be enforced by the scissor through fIBounds.)
         SkAssertResult(tighterQuery.intersect(GrClip::GetPixelBounds(stackBounds)));
     }
 
     fIBounds = GrClip::GetPixelIBounds(tighterQuery);
     SkASSERT(!fIBounds.isEmpty()); // Empty should have been blocked by IsOutsideClip above.
     fHasIBounds = true;
 
     // Now that we have determined the bounds to use and filtered out the trivial cases, call the
     // helper that actually walks the stack.
-    this->walkStack(stack, tighterQuery);
+    this->walkStack(stack, tighterQuery, maxWindowRectangles);
+
+    if (fWindowRects.count() < maxWindowRectangles) {
+        this->addInteriorWindowRectangles(maxWindowRectangles);
+    }
 }
 
-void GrReducedClip::walkStack(const SkClipStack& stack, const SkRect& queryBounds) {
+void GrReducedClip::walkStack(const SkClipStack& stack, const SkRect& queryBounds,
+                              int maxWindowRectangles) {
     // walk backwards until we get to:
     //  a) the beginning
     //  b) an operation that is known to make the bounds all inside/outside
     //  c) a replace operation
 
     enum class InitialTriState {
         kUnknown = -1,
         kAllIn = (int)GrReducedClip::InitialState::kAllIn,
         kAllOut = (int)GrReducedClip::InitialState::kAllOut
     } initialTriState = InitialTriState::kUnknown;
@@ skipping 38 matching lines @@
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     }
                 } else {
                     if (element->contains(relaxedQueryBounds)) {
                         initialTriState = InitialTriState::kAllOut;
                         skippable = true;
                     } else if (GrClip::IsOutsideClip(element->getBounds(), queryBounds)) {
                         skippable = true;
+                    } else if (fWindowRects.count() < maxWindowRectangles && !embiggens &&
+                               !element->isAA() && Element::kRect_Type == element->getType()) {
+                        this->addWindowRectangle(element->getRect(), false);
+                        skippable = true;
                     }
                 }
                 if (!skippable) {
                     emsmallens = true;
                 }
                 break;
             case SkRegion::kIntersect_Op:
                 // check if the shape intersected contains the entire bounds and therefore can
                 // be skipped or it is outside the entire bounds and therefore makes the clip
                 // empty.
@@ skipping 244 matching lines @@
                 element = fElements.headIter().get();
             }
         }
     }
     fRequiresAA = numAAElements > 0;
 
     SkASSERT(InitialTriState::kUnknown != initialTriState);
     fInitialState = static_cast<GrReducedClip::InitialState>(initialTriState);
 }
 
+static bool element_is_pure_subtract(SkRegion::Op op) {
+    SkASSERT(op >= 0);
+    return op <= SkRegion::kIntersect_Op;
+
+    GR_STATIC_ASSERT(0 == SkRegion::kDifference_Op);
+    GR_STATIC_ASSERT(1 == SkRegion::kIntersect_Op);
+}
+
+void GrReducedClip::addInteriorWindowRectangles(int maxWindowRectangles) {
+    SkASSERT(fWindowRects.count() < maxWindowRectangles);
+    // Walk backwards through the element list and add window rectangles to the interiors of
+    // "difference" elements. Quit if we encounter an element that may grow the clip.
+    ElementList::Iter iter(fElements, ElementList::Iter::kTail_IterStart);
+    for (; iter.get() && element_is_pure_subtract(iter.get()->getOp()); iter.prev()) {
+        const Element* element = iter.get();
+        if (SkRegion::kDifference_Op != element->getOp()) {
+            continue;
+        }
+
+        if (Element::kRect_Type == element->getType()) {
+            SkASSERT(element->isAA());
+            this->addWindowRectangle(element->getRect(), true);
+            if (fWindowRects.count() >= maxWindowRectangles) {
+                return;
+            }
+            continue;
+        }
+
+        if (Element::kRRect_Type == element->getType()) {
+            // For round rects we add two overlapping windows in the shape of a plus.
+            const SkRRect& clipRRect = element->getRRect();
+            SkVector insetTL = clipRRect.radii(SkRRect::kUpperLeft_Corner);
+            SkVector insetBR = clipRRect.radii(SkRRect::kLowerRight_Corner);
+            if (SkRRect::kComplex_Type == clipRRect.getType()) {
+                const SkVector& insetTR = clipRRect.radii(SkRRect::kUpperRight_Corner);
+                const SkVector& insetBL = clipRRect.radii(SkRRect::kLowerLeft_Corner);
+                insetTL.fX = SkTMax(insetTL.x(), insetBL.x());
+                insetTL.fY = SkTMax(insetTL.y(), insetTR.y());
+                insetBR.fX = SkTMax(insetBR.x(), insetTR.x());
+                insetBR.fY = SkTMax(insetBR.y(), insetBL.y());
+            }
+            const SkRect& bounds = clipRRect.getBounds();
+            if (insetTL.x() + insetBR.x() >= bounds.width() ||
+                insetTL.y() + insetBR.y() >= bounds.height()) {
+                continue; // The interior "plus" is empty.
+            }
+
+            SkRect horzRect = SkRect::MakeLTRB(bounds.left(), bounds.top() + insetTL.y(),
+                                               bounds.right(), bounds.bottom() - insetBR.y());
+            this->addWindowRectangle(horzRect, element->isAA());
+            if (fWindowRects.count() >= maxWindowRectangles) {
+                return;
+            }
+
+            SkRect vertRect = SkRect::MakeLTRB(bounds.left() + insetTL.x(), bounds.top(),
+                                               bounds.right() - insetBR.x(), bounds.bottom());
+            this->addWindowRectangle(vertRect, element->isAA());
+            if (fWindowRects.count() >= maxWindowRectangles) {
+                return;
+            }
+            continue;
+        }
+    }
+}
+
+inline void GrReducedClip::addWindowRectangle(const SkRect& elementInteriorRect, bool elementIsAA) {
+    SkIRect* window = &fWindowRects.addWindow();
+    if (!elementIsAA) {
+        elementInteriorRect.round(window);
+    } else {
+        elementInteriorRect.roundIn(window);
+    }
+}
+
 inline bool GrReducedClip::intersectIBounds(const SkIRect& irect) {
     SkASSERT(fHasIBounds);
     if (!fIBounds.intersect(irect)) {
         fHasIBounds = false;
+        fWindowRects.reset();
         fElements.reset();
         fRequiresAA = false;
         fInitialState = InitialState::kAllOut;
         return false;
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 8-bit clip mask in alpha
@@ skipping 59 matching lines @@
             break;
         }
     }
 }
 
 bool GrReducedClip::drawAlphaClipMask(GrDrawContext* dc) const {
     // The texture may be larger than necessary, this rect represents the part of the texture
     // we populate with a rasterization of the clip.
     GrFixedClip clip(SkIRect::MakeWH(fIBounds.width(), fIBounds.height()));
 
+    if (!fWindowRects.empty()) {
+        clip.windowRectsState().setExclusive(fWindowRects, {fIBounds.left(), fIBounds.top()});
+    }
+
     // The scratch texture that we are drawing into can be substantially larger than the mask. Only
     // clear the part that we care about.
     GrColor initialCoverage = InitialState::kAllIn == this->initialState() ? -1 : 0;
     dc->drawContextPriv().clear(clip, initialCoverage, true);
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip space.
     SkMatrix translate;
     translate.setTranslate(SkIntToScalar(-fIBounds.left()), SkIntToScalar(-fIBounds.top()));
 
     // walk through each clip element and perform its set op
@@ skipping 46 matching lines @@
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer.
 
 class StencilClip final : public GrClip {
 public:
     StencilClip(const SkIRect& scissorRect) : fFixedClip(scissorRect) {}
     const GrFixedClip& fixedClip() const { return fFixedClip; }
+    GrWindowRectsState& windowRectsState() { return fFixedClip.windowRectsState(); }
 
 private:
-    bool quickContains(const SkRect&) const final {
+    bool quickContains(const SkRect&) const override {
         return false;
     }
-    void getConservativeBounds(int width, int height, SkIRect* devResult, bool* iior) const final {
-        fFixedClip.getConservativeBounds(width, height, devResult, iior);
+    void getConservativeBounds(int width, int height, SkIRect* bounds, bool* iior) const override {
+        fFixedClip.getConservativeBounds(width, height, bounds, iior);
     }
-    bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const final {
+    bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const override {
         return false;
     }
     bool apply(GrContext* context, GrDrawContext* drawContext, bool useHWAA,
-               bool hasUserStencilSettings, GrAppliedClip* out) const final {
+               bool hasUserStencilSettings, GrAppliedClip* out) const override {
         if (!fFixedClip.apply(context, drawContext, useHWAA, hasUserStencilSettings, out)) {
             return false;
         }
         out->addStencilClip();
         return true;
     }
 
     GrFixedClip fFixedClip;
 
     typedef GrClip INHERITED;
 };
 
 bool GrReducedClip::drawStencilClipMask(GrContext* context,
                                         GrDrawContext* drawContext,
                                         const SkIPoint& clipOrigin) const {
     // We set the current clip to the bounds so that our recursive draws are scissored to them.
     StencilClip stencilClip(fIBounds.makeOffset(-clipOrigin.x(), -clipOrigin.y()));
 
+    if (!fWindowRects.empty()) {
+        stencilClip.windowRectsState().setExclusive(fWindowRects, clipOrigin);
+    }
+
     bool initialState = InitialState::kAllIn == this->initialState();
     drawContext->drawContextPriv().clearStencilClip(stencilClip.fixedClip(), initialState);
 
     // Set the matrix so that rendered clip elements are transformed from clip to stencil space.
     SkMatrix viewMatrix;
     viewMatrix.setTranslate(SkIntToScalar(-clipOrigin.x()), SkIntToScalar(-clipOrigin.y()));
 
     // walk through each clip element and perform its set op
     // with the existing clip.
     for (ElementList::Iter iter(fElements); iter.get(); iter.next()) {
@@ skipping 124 matching lines @@
                 // The view matrix is setup to do clip space -> stencil space translation, so
                 // draw rect in clip space.
                 drawContext->drawContextPriv().stencilRect(stencilClip, *pass,
                                                            false, viewMatrix,
                                                            SkRect::Make(fIBounds));
             }
         }
     }
     return true;
 }