skip call to clip::apply when clip is wide open

src/gpu/GrClipStackClip.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "GrClipMaskManager.h"
+#include "GrClipStackClip.h"
 #include "GrCaps.h"
 #include "GrDrawingManager.h"
 #include "GrDrawContextPriv.h"
 #include "GrGpuResourcePriv.h"
 #include "GrPaint.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceProvider.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
 #include "SkRasterClip.h"
 #include "SkTLazy.h"
 #include "batches/GrRectBatchFactory.h"
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef SkClipStack::Element Element;
 
+bool GrClipStackClip::quickContains(const SkRect& rect) const {
+    if (!fStack) {
+        return true;
+    }
+    return fStack->quickContains(rect.makeOffset(SkIntToScalar(fOrigin.x()),
+                                                 SkIntToScalar(fOrigin.y())));
+}
+
+void GrClipStackClip::getConservativeBounds(int width, int height, SkIRect* devResult,
+                                            bool* isIntersectionOfRects) const {
+    if (!fStack) {
+        devResult->setXYWH(0, 0, width, height);
+        if (isIntersectionOfRects) {
+            *isIntersectionOfRects = true;
+        }
+        return;
+    }
+    SkRect devBounds;
+    fStack->getConservativeBounds(-fOrigin.x(), -fOrigin.y(), width, height, &devBounds,
+                                  isIntersectionOfRects);
+    devBounds.roundOut(devResult);
+}
+
 static const int kMaxAnalyticElements = 4;
 
 ////////////////////////////////////////////////////////////////////////////////
 // set up the draw state to enable the aa clipping mask. Besides setting up the
 // stage matrix this also alters the vertex layout
 static sk_sp<GrFragmentProcessor> create_fp_for_mask(GrTexture* result,
                                                      const SkIRect &devBound) {
     SkMatrix mat;
     // We use device coords to compute the texture coordinates. We set our matrix to be a
     // translation to the devBound, and then a scaling matrix to normalized coords.
     mat.setIDiv(result->width(), result->height());
     mat.preTranslate(SkIntToScalar(-devBound.fLeft),
                      SkIntToScalar(-devBound.fTop));
 
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     return sk_sp<GrFragmentProcessor>(GrTextureDomainEffect::Make(
                                          result,
                                          mat,
                                          GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                          GrTextureDomain::kDecal_Mode,
                                          GrTextureParams::kNone_FilterMode,
                                          kDevice_GrCoordSet));
 }
 
 // Does the path in 'element' require SW rendering? If so, return true (and,
 // optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
 // 'prOut' to the non-SW path renderer that will do the job).
-bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
+bool GrClipStackClip::PathNeedsSWRenderer(GrContext* context,
                                             bool hasUserStencilSettings,
                                             const GrDrawContext* drawContext,
                                             const SkMatrix& viewMatrix,
                                             const Element* element,
                                             GrPathRenderer** prOut,
                                             bool needsStencil) {
     if (Element::kRect_Type == element->getType()) {
         // rects can always be drawn directly w/o using the software path
         // TODO: skip rrects once we're drawing them directly.
         if (prOut) {
@@ skipping 39 matching lines @@
         }
         return SkToBool(!pr);
     }
 }
 
 /*
  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  */
-bool GrClipMaskManager::UseSWOnlyPath(GrContext* context,
-                                      const GrPipelineBuilder& pipelineBuilder,
-                                      const GrDrawContext* drawContext,
-                                      const SkVector& clipToMaskOffset,
-                                      const GrReducedClip::ElementList& elements) {
+bool GrClipStackClip::UseSWOnlyPath(GrContext* context,
+                                    const GrPipelineBuilder& pipelineBuilder,
+                                    const GrDrawContext* drawContext,
+                                    const SkVector& clipToMaskOffset,
+                                    const GrReducedClip::ElementList& elements) {
     // TODO: generalize this function so that when
     // a clip gets complex enough it can just be done in SW regardless
     // of whether it would invoke the GrSoftwarePathRenderer.
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
 
     for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
         const Element* element = iter.get();
@@ skipping 83 matching lines @@
         iter.next();
     }
 
     *resultFP = nullptr;
     if (fps.count()) {
         *resultFP = GrFragmentProcessor::RunInSeries(fps.begin(), fps.count());
     }
     return true;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// sort out what kind of clip mask needs to be created: alpha, stencil,
-// scissor, or entirely software
-bool GrClipMaskManager::SetupClipping(GrContext* context,
-                                      const GrPipelineBuilder& pipelineBuilder,
-                                      GrDrawContext* drawContext,
-                                      const GrClipStackClip& clip,
-                                      const SkRect* origDevBounds,
-                                      GrAppliedClip* out) {
-    if (!clip.clipStack() || clip.clipStack()->isWideOpen()) {
-        return true;
-    }
-
-    GrReducedClip::ElementList elements;
-    int32_t genID = 0;
-    GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
-    SkIRect clipSpaceIBounds;
-    bool requiresAA = false;
-
-    SkIRect clipSpaceReduceQueryBounds;
-    SkRect devBounds;
-    if (origDevBounds) {
-        if (!devBounds.intersect(SkRect::MakeIWH(drawContext->width(), drawContext->height()),
-                                 *origDevBounds)) {
-            return false;
-        }
-        devBounds.roundOut(&clipSpaceReduceQueryBounds);
-        clipSpaceReduceQueryBounds.offset(clip.origin());
-    } else {
-        devBounds = SkRect::MakeIWH(drawContext->width(), drawContext->height());
-        clipSpaceReduceQueryBounds.setXYWH(0, 0, drawContext->width(), drawContext->height());
-        clipSpaceReduceQueryBounds.offset(clip.origin());
-    }
-    GrReducedClip::ReduceClipStack(*clip.clipStack(),
-                                    clipSpaceReduceQueryBounds,
-                                    &elements,
-                                    &genID,
-                                    &initialState,
-                                    &clipSpaceIBounds,
-                                    &requiresAA);
-    if (elements.isEmpty()) {
-        if (GrReducedClip::kAllOut_InitialState == initialState) {
-            return false;
-        } else {
-            SkIRect scissorSpaceIBounds(clipSpaceIBounds);
-            scissorSpaceIBounds.offset(-clip.origin());
-            if (!SkRect::Make(scissorSpaceIBounds).contains(devBounds)) {
-                out->makeScissored(scissorSpaceIBounds);
-            }
-            return true;
-        }
-    }
-
-    // An element count of 4 was chosen because of the common pattern in Blink of:
-    //   isect RR
-    //   diff  RR
-    //   isect convex_poly
-    //   isect convex_poly
-    // when drawing rounded div borders. This could probably be tuned based on a
-    // configuration's relative costs of switching RTs to generate a mask vs
-    // longer shaders.
-    if (elements.count() <= kMaxAnalyticElements) {
-        SkVector clipToRTOffset = { SkIntToScalar(-clip.origin().fX),
-                                    SkIntToScalar(-clip.origin().fY) };
-        // When there are multiple samples we want to do per-sample clipping, not compute a
-        // fractional pixel coverage.
-        bool disallowAnalyticAA = drawContext->isStencilBufferMultisampled();
-        if (disallowAnalyticAA && !drawContext->numColorSamples()) {
-            // With a single color sample, any coverage info is lost from color once it hits the
-            // color buffer anyway, so we may as well use coverage AA if nothing else in the pipe
-            // is multisampled.
-            disallowAnalyticAA = pipelineBuilder.isHWAntialias() ||
-                                 pipelineBuilder.hasUserStencilSettings();
-        }
-        sk_sp<GrFragmentProcessor> clipFP;
-        if (requiresAA &&
-            get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
-                                        &clipFP)) {
-            SkIRect scissorSpaceIBounds(clipSpaceIBounds);
-            scissorSpaceIBounds.offset(-clip.origin());
-            if (!SkRect::Make(scissorSpaceIBounds).contains(devBounds)) {
-                out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
-                return true;
-            }
-            out->makeFPBased(std::move(clipFP), SkRect::Make(scissorSpaceIBounds));
-            return true;
-        }
-    }
-
-    // If the stencil buffer is multisampled we can use it to do everything.
-    if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
-        sk_sp<GrTexture> result;
-
-        // The top-left of the mask corresponds to the top-left corner of the bounds.
-        SkVector clipToMaskOffset = {
-            SkIntToScalar(-clipSpaceIBounds.fLeft),
-            SkIntToScalar(-clipSpaceIBounds.fTop)
-        };
-
-        if (UseSWOnlyPath(context, pipelineBuilder, drawContext,
-                          clipToMaskOffset, elements)) {
-            // The clip geometry is complex enough that it will be more efficient to create it
-            // entirely in software
-            result = CreateSoftwareClipMask(context->textureProvider(),
-                                            genID,
-                                            initialState,
-                                            elements,
-                                            clipToMaskOffset,
-                                            clipSpaceIBounds);
-        } else {
-            result = CreateAlphaClipMask(context,
-                                         genID,
-                                         initialState,
-                                         elements,
-                                         clipToMaskOffset,
-                                         clipSpaceIBounds);
-            // If createAlphaClipMask fails it means UseSWOnlyPath has a bug
-            SkASSERT(result);
-        }
-
-        if (result) {
-            // The mask's top left coord should be pinned to the rounded-out top left corner of
-            // clipSpace bounds. We determine the mask's position WRT to the render target here.
-            SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
-            rtSpaceMaskBounds.offset(-clip.origin());
-            out->makeFPBased(create_fp_for_mask(result.get(), rtSpaceMaskBounds),
-                             SkRect::Make(rtSpaceMaskBounds));
-            return true;
-        }
-        // if alpha clip mask creation fails fall through to the non-AA code paths
-    }
-
-    // use the stencil clip if we can't represent the clip as a rectangle.
-    SkIPoint clipSpaceToStencilSpaceOffset = -clip.origin();
-    CreateStencilClipMask(context,
-                          drawContext,
-                          genID,
-                          initialState,
-                          elements,
-                          clipSpaceIBounds,
-                          clipSpaceToStencilSpaceOffset);
-
-    // This must occur after createStencilClipMask. That function may change the scissor. Also, it
-    // only guarantees that the stencil mask is correct within the bounds it was passed, so we must
-    // use both stencil and scissor test to the bounds for the final draw.
-    SkIRect scissorSpaceIBounds(clipSpaceIBounds);
-    scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
-    out->makeScissoredStencil(scissorSpaceIBounds);
-    return true;
-}
-
 static bool stencil_element(GrDrawContext* dc,
                             const GrFixedClip& clip,
                             const GrUserStencilSettings* ss,
                             const SkMatrix& viewMatrix,
                             const SkClipStack::Element* element) {
 
     // TODO: Draw rrects directly here.
     switch (element->getType()) {
         case Element::kEmpty_Type:
             SkDEBUGFAIL("Should never get here with an empty element.");
@@ skipping 54 matching lines @@
 // Create a 8-bit clip mask in alpha
 
 static void GetClipMaskKey(int32_t clipGenID, const SkIRect& bounds, GrUniqueKey* key) {
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kDomain, 3);
     builder[0] = clipGenID;
     builder[1] = SkToU16(bounds.fLeft) | (SkToU16(bounds.fRight) << 16);
     builder[2] = SkToU16(bounds.fTop) | (SkToU16(bounds.fBottom) << 16);
 }
 
-sk_sp<GrTexture> GrClipMaskManager::CreateAlphaClipMask(GrContext* context,
+sk_sp<GrTexture> CreateAlphaClipMask(GrContext* context,
                                                         int32_t elementsGenID,
                                                         GrReducedClip::InitialState initialState,
                                                         const GrReducedClip::ElementList& elements,
                                                         const SkVector& clipToMaskOffset,
                                                         const SkIRect& clipSpaceIBounds) {
     GrResourceProvider* resourceProvider = context->resourceProvider();
     GrUniqueKey key;
     GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
     if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
         return sk_sp<GrTexture>(texture);
@@ skipping 84 matching lines @@
 
     sk_sp<GrTexture> texture(dc->asTexture());
     SkASSERT(texture);
     texture->resourcePriv().setUniqueKey(key);
     return texture;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
-bool GrClipMaskManager::CreateStencilClipMask(GrContext* context,
-                                              GrDrawContext* drawContext,
-                                              int32_t elementsGenID,
-                                              GrReducedClip::InitialState initialState,
-                                              const GrReducedClip::ElementList& elements,
-                                              const SkIRect& clipSpaceIBounds,
-                                              const SkIPoint& clipSpaceToStencilOffset) {
+bool GrClipStackClip::CreateStencilClipMask(GrContext* context,
+                                            GrDrawContext* drawContext,
+                                            int32_t elementsGenID,
+                                            GrReducedClip::InitialState initialState,
+                                            const GrReducedClip::ElementList& elements,
+                                            const SkIRect& clipSpaceIBounds,
+                                            const SkIPoint& clipSpaceToStencilOffset) {
     SkASSERT(drawContext);
 
     GrStencilAttachment* stencilAttachment = context->resourceProvider()->attachStencilAttachment(
                                                     drawContext->accessRenderTarget());
     if (nullptr == stencilAttachment) {
         return false;
     }
 
     // TODO: these need to be swapped over to using a StencilAttachmentProxy
     if (stencilAttachment->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
@@ skipping 156 matching lines @@
                     drawContext->drawContextPriv().stencilRect(clip, *pass, false, viewMatrix,
                                                                SkRect::Make(clipSpaceIBounds));
                 }
             }
         }
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-sk_sp<GrTexture> GrClipMaskManager::CreateSoftwareClipMask(
+sk_sp<GrTexture> CreateSoftwareClipMask(
                                                     GrTextureProvider* texProvider,
                                                     int32_t elementsGenID,
                                                     GrReducedClip::InitialState initialState,
                                                     const GrReducedClip::ElementList& elements,
                                                     const SkVector& clipToMaskOffset,
                                                     const SkIRect& clipSpaceIBounds) {
     GrUniqueKey key;
     GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
     if (GrTexture* texture = texProvider->findAndRefTextureByUniqueKey(key)) {
         return sk_sp<GrTexture>(texture);
@@ skipping 56 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }
+
+bool GrClipStackClip::apply(GrContext* context,
+                            const GrPipelineBuilder& pipelineBuilder, GrDrawContext* drawContext,
+                            const SkRect* origDevBounds, GrAppliedClip* out) const {
+    ////////////////////////////////////////////////////////////////////////////////
+    // sort out what kind of clip mask needs to be created: alpha, stencil,
+    // scissor, or entirely software
+
+    GrReducedClip::ElementList elements;
+    int32_t genID = 0;
+    GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
+    SkIRect clipSpaceIBounds;
+    bool requiresAA = false;
+
+    SkIRect clipSpaceReduceQueryBounds;
+    SkRect devBounds;
+    if (origDevBounds) {
+        if (!devBounds.intersect(SkRect::MakeIWH(drawContext->width(), drawContext->height()),
+                                 *origDevBounds)) {
+            return false;
+        }
+        devBounds.roundOut(&clipSpaceReduceQueryBounds);
+        clipSpaceReduceQueryBounds.offset(this->origin());
+    } else {
+        devBounds = SkRect::MakeIWH(drawContext->width(), drawContext->height());
+        clipSpaceReduceQueryBounds.setXYWH(0, 0, drawContext->width(), drawContext->height());
+        clipSpaceReduceQueryBounds.offset(this->origin());
+    }
+    GrReducedClip::ReduceClipStack(*this->clipStack(),
+                                   clipSpaceReduceQueryBounds,
+                                   &elements,
+                                   &genID,
+                                   &initialState,
+                                   &clipSpaceIBounds,
+                                   &requiresAA);
+    if (elements.isEmpty()) {
+        if (GrReducedClip::kAllOut_InitialState == initialState) {
+            return false;
+        } else {
+            SkIRect scissorSpaceIBounds(clipSpaceIBounds);
+            scissorSpaceIBounds.offset(-this->origin());
+            if (!SkRect::Make(scissorSpaceIBounds).contains(devBounds)) {
+                out->makeScissored(scissorSpaceIBounds);
+            }
+            return true;
+        }
+    }
+
+    // An element count of 4 was chosen because of the common pattern in Blink of:
+    //   isect RR
+    //   diff  RR
+    //   isect convex_poly
+    //   isect convex_poly
+    // when drawing rounded div borders. This could probably be tuned based on a
+    // configuration's relative costs of switching RTs to generate a mask vs
+    // longer shaders.
+    if (elements.count() <= kMaxAnalyticElements) {
+        SkVector clipToRTOffset = { SkIntToScalar(-this->origin().fX),
+                                    SkIntToScalar(-this->origin().fY) };
+        // When there are multiple samples we want to do per-sample clipping, not compute a
+        // fractional pixel coverage.
+        bool disallowAnalyticAA = drawContext->isStencilBufferMultisampled();
+        if (disallowAnalyticAA && !drawContext->numColorSamples()) {
+            // With a single color sample, any coverage info is lost from color once it hits the
+            // color buffer anyway, so we may as well use coverage AA if nothing else in the pipe
+            // is multisampled.
+            disallowAnalyticAA = pipelineBuilder.isHWAntialias() ||
+                                 pipelineBuilder.hasUserStencilSettings();
+        }
+        sk_sp<GrFragmentProcessor> clipFP;
+        if (requiresAA &&
+            get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
+                                        &clipFP)) {
+            SkIRect scissorSpaceIBounds(clipSpaceIBounds);
+            scissorSpaceIBounds.offset(-this->origin());
+            if (!SkRect::Make(scissorSpaceIBounds).contains(devBounds)) {
+                out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
+                return true;
+            }
+            out->makeFPBased(std::move(clipFP), SkRect::Make(scissorSpaceIBounds));
+            return true;
+        }
+    }
+
+    // If the stencil buffer is multisampled we can use it to do everything.
+    if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
+        sk_sp<GrTexture> result;
+
+        // The top-left of the mask corresponds to the top-left corner of the bounds.
+        SkVector clipToMaskOffset = {
+                SkIntToScalar(-clipSpaceIBounds.fLeft),
+                SkIntToScalar(-clipSpaceIBounds.fTop)
+        };
+
+        if (UseSWOnlyPath(context, pipelineBuilder, drawContext,
+                          clipToMaskOffset, elements)) {
+            // The clip geometry is complex enough that it will be more efficient to create it
+            // entirely in software
+            result = CreateSoftwareClipMask(context->textureProvider(),
+                                            genID,
+                                            initialState,
+                                            elements,
+                                            clipToMaskOffset,
+                                            clipSpaceIBounds);
+        } else {
+            result = CreateAlphaClipMask(context,
+                                         genID,
+                                         initialState,
+                                         elements,
+                                         clipToMaskOffset,
+                                         clipSpaceIBounds);
+            // If createAlphaClipMask fails it means UseSWOnlyPath has a bug
+            SkASSERT(result);
+        }
+
+        if (result) {
+            // The mask's top left coord should be pinned to the rounded-out top left corner of
+            // clipSpace bounds. We determine the mask's position WRT to the render target here.
+            SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
+            rtSpaceMaskBounds.offset(-this->origin());
+            out->makeFPBased(create_fp_for_mask(result.get(), rtSpaceMaskBounds),
+                             SkRect::Make(rtSpaceMaskBounds));
+            return true;
+        }
+        // if alpha clip mask creation fails fall through to the non-AA code paths
+    }
+
+    // use the stencil clip if we can't represent the clip as a rectangle.
+    SkIPoint clipSpaceToStencilSpaceOffset = -this->origin();
+    CreateStencilClipMask(context,
+                          drawContext,
+                          genID,
+                          initialState,
+                          elements,
+                          clipSpaceIBounds,
+                          clipSpaceToStencilSpaceOffset);
+
+    // This must occur after createStencilClipMask. That function may change the scissor. Also, it
+    // only guarantees that the stencil mask is correct within the bounds it was passed, so we must
+    // use both stencil and scissor test to the bounds for the final draw.
+    SkIRect scissorSpaceIBounds(clipSpaceIBounds);
+    scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
+    out->makeScissoredStencil(scissorSpaceIBounds);
+    return true;
+}