Remove clip from GrPipelineBuilder

src/gpu/GrClipMaskManager.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 "GrCaps.h"
 #include "GrDrawingManager.h"
@@ skipping 32 matching lines @@
     return GrTextureDomainEffect::Create(result,
                                          mat,
                                          GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                          GrTextureDomain::kDecal_Mode,
                                          GrTextureParams::kNone_FilterMode,
                                          kDevice_GrCoordSet);
 }
 
 static void draw_non_aa_rect(GrDrawTarget* drawTarget,
                              const GrPipelineBuilder& pipelineBuilder,
+                             const GrClip& clip,
                              GrColor color,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect) {
     SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(color, viewMatrix, rect,
                                                                         nullptr, nullptr));
-    drawTarget->drawBatch(pipelineBuilder, batch);
+    drawTarget->drawBatch(pipelineBuilder, clip, batch);
 }
 
 // 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 hasUserStencilSettings,
                                             const GrRenderTarget* rt,
                                             const SkMatrix& viewMatrix,
                                             const Element* element,
@@ skipping 60 matching lines @@
     PathNeedsSWRenderer(context,
                         kHasUserStencilSettings,
                         texture->asRenderTarget(),
                         viewMatrix,
                         element,
                         &pr,
                         kNeedsStencil);
     return pr;
 }
 
-GrClipMaskManager::GrClipMaskManager(GrDrawTarget* drawTarget, bool debugClipBatchToBounds)
+GrClipMaskManager::GrClipMaskManager(GrDrawTarget* drawTarget)
     : fDrawTarget(drawTarget)
-    , fClipMode(kIgnoreClip_StencilClipMode)
-    , fDebugClipBatchToBounds(debugClipBatchToBounds) {
+    , fClipMode(kIgnoreClip_StencilClipMode) {
 }
 
 GrContext* GrClipMaskManager::getContext() {
     return fDrawTarget->cmmAccess().context();
 }
 
 const GrCaps* GrClipMaskManager::caps() const {
     return fDrawTarget->caps();
 }
 
@@ skipping 124 matching lines @@
     *resultFP = nullptr;
     if (!failed && fpCnt) {
         *resultFP = GrFragmentProcessor::RunInSeries(fps, fpCnt);
     }
     for (int i = 0; i < fpCnt; ++i) {
         fps[i]->unref();
     }
     return !failed;
 }
 
-static void add_rect_to_clip(const GrClip& clip, const SkRect& devRect, GrClip* out) {
-    switch (clip.clipType()) {
-        case GrClip::kClipStack_ClipType: {
-            SkClipStack* stack = new SkClipStack;
-            *stack = *clip.clipStack();
-            // The stack is actually in clip space not device space.
-            SkRect clipRect = devRect;
-            SkPoint origin = { SkIntToScalar(clip.origin().fX), SkIntToScalar(clip.origin().fY) };
-            clipRect.offset(origin);
-            SkIRect iclipRect;
-            clipRect.roundOut(&iclipRect);
-            clipRect = SkRect::Make(iclipRect);
-            stack->clipDevRect(clipRect, SkRegion::kIntersect_Op, false);
-            out->setClipStack(stack, &clip.origin());
-            break;
-        }
-        case GrClip::kWideOpen_ClipType:
-            *out = GrClip(devRect);
-            break;
-        case GrClip::kIRect_ClipType: {
-            SkIRect intersect;
-            devRect.roundOut(&intersect);
-            if (intersect.intersect(clip.irect())) {
-                *out = GrClip(intersect);
-            } else {
-                *out = clip;
-            }
-            break;
-        }
-    }
-}
-
-bool GrClipMaskManager::setupScissorClip(const GrPipelineBuilder& pipelineBuilder,
-                                         const SkIRect& clipScissor,
-                                         const SkRect* devBounds,
-                                         GrAppliedClip* out) {
-    SkASSERT(kModifyClip_StencilClipMode != fClipMode); // TODO: Remove fClipMode.
-    fClipMode = kIgnoreClip_StencilClipMode;
-
-    GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
-
-    SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height());
-    SkIRect devBoundsScissor;
-    const SkIRect* scissor = &clipScissor;
-    bool doDevBoundsClip = fDebugClipBatchToBounds && devBounds;
-    if (doDevBoundsClip) {
-        devBounds->roundOut(&devBoundsScissor);
-        if (devBoundsScissor.intersect(clipScissor)) {
-            scissor = &devBoundsScissor;
-        }
-    }
-
-    if (scissor->contains(clipSpaceRTIBounds)) {
-        // This counts as wide open
-        return true;
-    }
-
-    if (clipSpaceRTIBounds.intersect(*scissor)) {
-        out->fScissorState.set(clipSpaceRTIBounds);
-        return true;
-    }
-    return false;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
 bool GrClipMaskManager::setupClipping(const GrPipelineBuilder& pipelineBuilder,
+                                      const GrClip& clip,
                                       const SkRect* devBounds,
                                       GrAppliedClip* out) {
     if (kRespectClip_StencilClipMode == fClipMode) {
         fClipMode = kIgnoreClip_StencilClipMode;
     }
 
     GrReducedClip::ElementList elements;
     int32_t genID = 0;
     GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
     SkIRect clipSpaceIBounds;
     bool requiresAA = false;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
 
     // GrDrawTarget should have filtered this for us
     SkASSERT(rt);
 
     SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height());
-    GrClip devBoundsClip;
-    bool doDevBoundsClip = fDebugClipBatchToBounds && devBounds;
-    if (doDevBoundsClip) {
-        add_rect_to_clip(pipelineBuilder.clip(), *devBounds, &devBoundsClip);
-    }
-    const GrClip& clip = doDevBoundsClip ? devBoundsClip : pipelineBuilder.clip();
-
     if (clip.isWideOpen(clipSpaceRTIBounds)) {
         return true;
     }
 
     // The clip mask manager always draws with a single IRect so we special case that logic here
     // Image filters just use a rect, so we also special case that logic
     switch (clip.clipType()) {
         case GrClip::kWideOpen_ClipType:
             SkFAIL("Should have caught this with clip.isWideOpen()");
             return true;
@@ skipping 132 matching lines @@
     // use both stencil and scissor test to the bounds for the final draw.
     SkIRect scissorSpaceIBounds(clipSpaceIBounds);
     scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
     out->fScissorState.set(scissorSpaceIBounds);
     SkASSERT(kRespectClip_StencilClipMode == fClipMode); // TODO: Remove fClipMode.
     out->fHasStencilClip = true;
     return true;
 }
 
 static bool stencil_element(GrDrawContext* dc,
-                            const SkIRect* scissorRect,
+                            const GrClip& 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.");
             break;
         case Element::kRect_Type:
-            return dc->drawContextPriv().drawAndStencilRect(scissorRect, ss,
+            return dc->drawContextPriv().drawAndStencilRect(clip, ss,
                                                             element->getOp(),
                                                             element->isInverseFilled(),
                                                             element->isAA(),
                                                             viewMatrix, element->getRect());
             break;
         default: {
             SkPath path;
             element->asPath(&path);
             if (path.isInverseFillType()) {
                 path.toggleInverseFillType();
             }
 
-            return dc->drawContextPriv().drawAndStencilPath(scissorRect, ss,
+            return dc->drawContextPriv().drawAndStencilPath(clip, ss,
                                                             element->getOp(),
                                                             element->isInverseFilled(),
                                                             element->isAA(), viewMatrix, path);
             break;
         }
     }
 
     return false;
 }
 
@@ skipping 100 matching lines @@
             GrPathRenderer* pr = GetPathRenderer(context,
                                                  texture, translate, element);
             if (Element::kRect_Type != element->getType() && !pr) {
                 // UseSWOnlyPath should now filter out all cases where gpu-side mask merging would
                 // be performed (i.e., pr would be NULL for a non-rect path).
                 // See https://bug.skia.org/4519 for rationale and details.
                 SkASSERT(0);
             }
 #endif
 
+            GrClip clip(maskSpaceIBounds);
+
             // draw directly into the result with the stencil set to make the pixels affected
             // by the clip shape be non-zero.
             static constexpr GrUserStencilSettings kStencilInElement(
                  GrUserStencilSettings::StaticInit<
                      0xffff,
                      GrUserStencilTest::kAlways,
                      0xffff,
                      GrUserStencilOp::kReplace,
                      GrUserStencilOp::kReplace,
                      0xffff>()
             );
-            if (!stencil_element(dc.get(), &maskSpaceIBounds, &kStencilInElement,
+            if (!stencil_element(dc.get(), clip, &kStencilInElement,
                                  translate, element)) {
                 texture->resourcePriv().removeUniqueKey();
                 return nullptr;
             }
 
             // Draw to the exterior pixels (those with a zero stencil value).
             static constexpr GrUserStencilSettings kDrawOutsideElement(
                  GrUserStencilSettings::StaticInit<
                      0x0000,
                      GrUserStencilTest::kEqual,
                      0xffff,
                      GrUserStencilOp::kZero,
                      GrUserStencilOp::kZero,
                      0xffff>()
             );
-            if (!dc->drawContextPriv().drawAndStencilRect(&maskSpaceIBounds, &kDrawOutsideElement,
+            if (!dc->drawContextPriv().drawAndStencilRect(clip, &kDrawOutsideElement,
                                                           op, !invert, false,
                                                           translate,
                                                           SkRect::Make(clipSpaceIBounds))) {
                 texture->resourcePriv().removeUniqueKey();
                 return nullptr;
             }
         } else {
             // all the remaining ops can just be directly draw into the accumulation buffer
             GrPaint paint;
             paint.setAntiAlias(element->isAA());
@@ skipping 39 matching lines @@
 
         fDrawTarget->cmmAccess().clearStencilClip(stencilSpaceIBounds,
             GrReducedClip::kAllIn_InitialState == initialState, rt);
 
         // walk through each clip element and perform its set op
         // with the existing clip.
         for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
             const Element* element = iter.get();
 
             GrPipelineBuilder pipelineBuilder;
-            pipelineBuilder.setClip(clip);
             pipelineBuilder.setRenderTarget(rt);
 
             pipelineBuilder.setDisableColorXPFactory();
 
             // if the target is MSAA then we want MSAA enabled when the clip is soft
             if (rt->isStencilBufferMultisampled()) {
                 pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, element->isAA());
             }
 
             bool fillInverted = false;
@@ skipping 54 matching lines @@
                          0x0000,
                          GrUserStencilTest::kAlways,
                          0xffff,
                          GrUserStencilOp::kIncMaybeClamp,
                          GrUserStencilOp::kIncMaybeClamp,
                          0xffff>()
                 );
                 if (Element::kRect_Type == element->getType()) {
                     pipelineBuilder.setUserStencil(&kDrawToStencil);
 
-                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, GrColor_WHITE, viewMatrix,
+                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, clip, GrColor_WHITE, viewMatrix,
                                      element->getRect());
                 } else {
                     if (!clipPath.isEmpty()) {
                         if (canRenderDirectToStencil) {
                             pipelineBuilder.setUserStencil(&kDrawToStencil);
 
                             GrPathRenderer::DrawPathArgs args;
                             args.fTarget = fDrawTarget;
                             args.fResourceProvider = this->getContext()->resourceProvider();
                             args.fPipelineBuilder = &pipelineBuilder;
+                            args.fClip = &clip;
                             args.fColor = GrColor_WHITE;
                             args.fViewMatrix = &viewMatrix;
                             args.fPath = &clipPath;
                             args.fStyle = &GrStyle::SimpleFill();
                             args.fAntiAlias = false;
                             args.fGammaCorrect = false;
                             pr->drawPath(args);
                         } else {
                             GrPathRenderer::StencilPathArgs args;
                             args.fTarget = fDrawTarget;
                             args.fResourceProvider = this->getContext()->resourceProvider();
                             args.fPipelineBuilder = &pipelineBuilder;
+                            args.fClip = &clip;
                             args.fViewMatrix = &viewMatrix;
                             args.fPath = &clipPath;
                             pr->stencilPath(args);
                         }
                     }
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             fClipMode = kModifyClip_StencilClipMode;
             for (GrUserStencilSettings const* const* pass = stencilPasses; *pass; ++pass) {
                 pipelineBuilder.setUserStencil(*pass);
 
                 if (drawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
-                        draw_non_aa_rect(fDrawTarget, pipelineBuilder, GrColor_WHITE, viewMatrix,
-                                         element->getRect());
+                        draw_non_aa_rect(fDrawTarget, pipelineBuilder, clip, GrColor_WHITE,
+                                         viewMatrix, element->getRect());
                     } else {
                         GrPathRenderer::DrawPathArgs args;
                         args.fTarget = fDrawTarget;
                         args.fResourceProvider = this->getContext()->resourceProvider();
                         args.fPipelineBuilder = &pipelineBuilder;
+                        args.fClip = &clip;
                         args.fColor = GrColor_WHITE;
                         args.fViewMatrix = &viewMatrix;
                         args.fPath = &clipPath;
                         args.fStyle = &GrStyle::SimpleFill();
                         args.fAntiAlias = false;
                         args.fGammaCorrect = false;
                         pr->drawPath(args);
                     }
                 } else {
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
-                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, GrColor_WHITE, viewMatrix,
+                    draw_non_aa_rect(fDrawTarget, pipelineBuilder, clip, GrColor_WHITE, viewMatrix,
                                      SkRect::Make(clipSpaceIBounds));
                 }
             }
         }
     }
     fClipMode = kRespectClip_StencilClipMode;
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 66 matching lines @@
     GrTexture* result = context->resourceProvider()->createApproxTexture(desc, 0);
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result);
 
     return result;
 }