Convert GrAppliedClip interface to builder style

src/gpu/GrClipStackClip.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 "GrClipStackClip.h"
 
 #include "GrDrawingManager.h"
@@ skipping 224 matching lines @@
     *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 GrClipStackClip::apply(GrContext* context,
-                            GrDrawContext* drawContext,
-                            const SkRect* origDevBounds,
-                            bool useHWAA,
-                            bool hasUserStencilSettings,
-                            GrAppliedClip* out) const {
+bool GrClipStackClip::apply(GrContext* context, GrDrawContext* drawContext, bool useHWAA,
+                            bool hasUserStencilSettings, GrAppliedClip* out) const {
     if (!fStack || fStack->isWideOpen()) {
         return true;
     }
 
     SkRect devBounds = SkRect::MakeIWH(drawContext->width(), drawContext->height());
-    if (origDevBounds && !devBounds.intersect(*origDevBounds)) {
+    if (!devBounds.intersect(out->clippedDrawBounds())) {
         return false;
     }
 
     const SkScalar clipX = SkIntToScalar(fOrigin.x()),
                    clipY = SkIntToScalar(fOrigin.y());
 
     SkRect clipSpaceDevBounds = devBounds.makeOffset(clipX, clipY);
     const GrReducedClip reducedClip(*fStack, clipSpaceDevBounds);
 
+    if (reducedClip.hasIBounds() &&
+        !GrClip::IsInsideClip(reducedClip.ibounds(), clipSpaceDevBounds)) {
+        SkIRect scissorSpaceIBounds(reducedClip.ibounds());
+        scissorSpaceIBounds.offset(-fOrigin);
+        out->addScissor(scissorSpaceIBounds);
+    }
+
     if (reducedClip.elements().isEmpty()) {
-        if (GrReducedClip::InitialState::kAllOut == reducedClip.initialState()) {
-            return false;
-        }
-        if (!GrClip::IsInsideClip(reducedClip.iBounds(), clipSpaceDevBounds)) {
-            SkIRect scissorSpaceIBounds(reducedClip.iBounds());
-            scissorSpaceIBounds.offset(-fOrigin);
-            out->makeScissored(scissorSpaceIBounds);
-        }
-        return true;
+        return InitialState::kAllIn == reducedClip.initialState();
     }
 
+    SkASSERT(reducedClip.hasIBounds());
+
     // 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 (reducedClip.elements().count() <= kMaxAnalyticElements) {
         // 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 = useHWAA || hasUserStencilSettings;
         }
         sk_sp<GrFragmentProcessor> clipFP;
         if (reducedClip.requiresAA() &&
             get_analytic_clip_processor(reducedClip.elements(), disallowAnalyticAA,
                                         {-clipX, -clipY}, devBounds, &clipFP)) {
-            SkIRect scissorSpaceIBounds(reducedClip.iBounds());
-            scissorSpaceIBounds.offset(-fOrigin);
-            if (GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
-                out->makeFPBased(std::move(clipFP), SkRect::Make(scissorSpaceIBounds));
-            } else {
-                out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
-            }
+            out->addCoverageFP(std::move(clipFP));
             return true;
         }
     }
 
     // If the stencil buffer is multisampled we can use it to do everything.
     if (!drawContext->isStencilBufferMultisampled() && reducedClip.requiresAA()) {
         sk_sp<GrTexture> result;
 
         // The top-left of the mask corresponds to the top-left corner of the bounds.
         SkVector clipToMaskOffset = {
             SkIntToScalar(-reducedClip.left()),
             SkIntToScalar(-reducedClip.top())
         };
 
         if (UseSWOnlyPath(context, hasUserStencilSettings, drawContext,
                           clipToMaskOffset, reducedClip.elements())) {
             // The clip geometry is complex enough that it will be more efficient to create it
             // entirely in software
             result = CreateSoftwareClipMask(context->textureProvider(), reducedClip,
                                             clipToMaskOffset);
         } else {
             result = CreateAlphaClipMask(context, reducedClip, clipToMaskOffset);
             // 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 = reducedClip.iBounds();
+            SkIRect rtSpaceMaskBounds = reducedClip.ibounds();
             rtSpaceMaskBounds.offset(-fOrigin);
-            out->makeFPBased(create_fp_for_mask(result.get(), rtSpaceMaskBounds),
-                             SkRect::Make(rtSpaceMaskBounds));
+            out->addCoverageFP(create_fp_for_mask(result.get(), 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 = -fOrigin;
     CreateStencilClipMask(context, drawContext, reducedClip, 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.
-    if (GrClip::IsInsideClip(reducedClip.iBounds(), clipSpaceDevBounds)) {
-        out->makeStencil(true, devBounds);
-    } else {
-        SkIRect scissorSpaceIBounds(reducedClip.iBounds());
-        scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
-        out->makeScissoredStencil(scissorSpaceIBounds);
-    }
+    out->addStencilClip();
     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.
@@ skipping 62 matching lines @@
     builder[0] = clipGenID;
     builder[1] = SkToU16(bounds.fLeft) | (SkToU16(bounds.fRight) << 16);
     builder[2] = SkToU16(bounds.fTop) | (SkToU16(bounds.fBottom) << 16);
 }
 
 sk_sp<GrTexture> GrClipStackClip::CreateAlphaClipMask(GrContext* context,
                                                       const GrReducedClip& reducedClip,
                                                       const SkVector& clipToMaskOffset) {
     GrResourceProvider* resourceProvider = context->resourceProvider();
     GrUniqueKey key;
-    GetClipMaskKey(reducedClip.genID(), reducedClip.iBounds(), &key);
+    GetClipMaskKey(reducedClip.genID(), reducedClip.ibounds(), &key);
     if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
         return sk_sp<GrTexture>(texture);
     }
 
     // There's no texture in the cache. Let's try to allocate it then.
     GrPixelConfig config = kRGBA_8888_GrPixelConfig;
     if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
         config = kAlpha_8_GrPixelConfig;
     }
 
     sk_sp<GrDrawContext> dc(context->makeDrawContext(SkBackingFit::kApprox,
                                                      reducedClip.width(),
                                                      reducedClip.height(),
                                                      config, nullptr));
     if (!dc) {
         return nullptr;
     }
     
     // The texture may be larger than necessary, this rect represents the part of the texture
     // we populate with a rasterization of the clip.
     SkIRect maskSpaceIBounds = SkIRect::MakeWH(reducedClip.width(), reducedClip.height());
 
     // The scratch texture that we are drawing into can be substantially larger than the mask. Only
     // clear the part that we care about.
-    dc->clear(&maskSpaceIBounds,
-              GrReducedClip::InitialState::kAllIn == reducedClip.initialState() ? -1 : 0,
-              true);
+    dc->clear(&maskSpaceIBounds, InitialState::kAllIn == reducedClip.initialState() ? -1 : 0, true);
 
     // 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);
 
     // It is important that we use maskSpaceIBounds as the stencil rect in the below loop.
     // The second pass that zeros the stencil buffer renders the rect maskSpaceIBounds so the first
     // pass must not set values outside of this bounds or stencil values outside the rect won't be
     // cleared.
 
@@ skipping 27 matching lines @@
                      0x0000,
                      GrUserStencilTest::kEqual,
                      0xffff,
                      GrUserStencilOp::kZero,
                      GrUserStencilOp::kZero,
                      0xffff>()
             );
             if (!dc->drawContextPriv().drawAndStencilRect(clip, &kDrawOutsideElement,
                                                           op, !invert, false,
                                                           translate,
-                                                          SkRect::Make(reducedClip.iBounds()))) {
+                                                          SkRect::Make(reducedClip.ibounds()))) {
                 return nullptr;
             }
         } else {
             // all the remaining ops can just be directly draw into the accumulation buffer
             GrPaint paint;
             paint.setAntiAlias(element->isAA());
             paint.setCoverageSetOpXPFactory(op, false);
 
             draw_element(dc.get(), GrNoClip(), paint, translate, element);
         }
@@ skipping 14 matching lines @@
                                             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(reducedClip.genID(), reducedClip.iBounds(),
+    if (stencilAttachment->mustRenderClip(reducedClip.genID(), reducedClip.ibounds(),
                                           clipSpaceToStencilOffset)) {
-        stencilAttachment->setLastClip(reducedClip.genID(), reducedClip.iBounds(),
+        stencilAttachment->setLastClip(reducedClip.genID(), reducedClip.ibounds(),
                                        clipSpaceToStencilOffset);
         // Set the matrix so that rendered clip elements are transformed from clip to stencil space.
         SkVector translate = {
             SkIntToScalar(clipSpaceToStencilOffset.fX),
             SkIntToScalar(clipSpaceToStencilOffset.fY)
         };
         SkMatrix viewMatrix;
         viewMatrix.setTranslate(translate);
 
         // We set the current clip to the bounds so that our recursive draws are scissored to them.
-        SkIRect stencilSpaceIBounds(reducedClip.iBounds());
+        SkIRect stencilSpaceIBounds(reducedClip.ibounds());
         stencilSpaceIBounds.offset(clipSpaceToStencilOffset);
         GrFixedClip clip(stencilSpaceIBounds);
 
-        bool insideClip = GrReducedClip::InitialState::kAllIn == reducedClip.initialState();
+        bool insideClip = InitialState::kAllIn == reducedClip.initialState();
         drawContext->drawContextPriv().clearStencilClip(stencilSpaceIBounds, insideClip);
 
         // walk through each clip element and perform its set op
         // with the existing clip.
         for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
             const Element* element = iter.get();
             bool useHWAA = element->isAA() && drawContext->isStencilBufferMultisampled();
 
             bool fillInverted = false;
             // enabled at bottom of loop
@@ skipping 85 matching lines @@
                             args.fClip = &clip;
                             args.fViewMatrix = &viewMatrix;
                             args.fIsAA = element->isAA();
                             args.fShape = &shape;
                             pr->stencilPath(args);
                         }
                     }
                 }
             }
 
+            // Just enable stencil clip. The passes choose whether or not they will actually use it.
+            clip.enableStencilClip();
+
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             for (GrUserStencilSettings const* const* pass = stencilPasses; *pass; ++pass) {
-
                 if (drawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
-                        clip.enableStencilClip(element->getRect().makeOffset(translate.fX,
-                                                                             translate.fY));
                         drawContext->drawContextPriv().stencilRect(clip, *pass, useHWAA, viewMatrix,
                                                                    element->getRect());
                     } else {
                         GrShape shape(clipPath, GrStyle::SimpleFill());
                         GrPaint paint;
-                        SkRect bounds = clipPath.getBounds();
-                        bounds.offset(translate.fX, translate.fY);
-                        clip.enableStencilClip(bounds);
                         paint.setXPFactory(GrDisableColorXPFactory::Make());
                         paint.setAntiAlias(element->isAA());
                         GrPathRenderer::DrawPathArgs args;
                         args.fResourceProvider = context->resourceProvider();
                         args.fPaint = &paint;
                         args.fUserStencilSettings = *pass;
                         args.fDrawContext = drawContext;
                         args.fClip = &clip;
                         args.fViewMatrix = &viewMatrix;
                         args.fShape = &shape;
                         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.
-                    SkRect bounds = SkRect::Make(reducedClip.iBounds());
-                    bounds.offset(translate.fX, translate.fY);
-                    clip.enableStencilClip(bounds);
                     drawContext->drawContextPriv().stencilRect(clip, *pass, false, viewMatrix,
-                                                               SkRect::Make(reducedClip.iBounds()));
+                                                               SkRect::Make(reducedClip.ibounds()));
                 }
             }
         }
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texProvider,
                                                          const GrReducedClip& reducedClip,
                                                          const SkVector& clipToMaskOffset) {
     GrUniqueKey key;
-    GetClipMaskKey(reducedClip.genID(), reducedClip.iBounds(), &key);
+    GetClipMaskKey(reducedClip.genID(), reducedClip.ibounds(), &key);
     if (GrTexture* texture = texProvider->findAndRefTextureByUniqueKey(key)) {
         return sk_sp<GrTexture>(texture);
     }
 
     // The mask texture may be larger than necessary. We round out the clip space bounds and pin
     // the top left corner of the resulting rect to the top left of the texture.
     SkIRect maskSpaceIBounds = SkIRect::MakeWH(reducedClip.width(), reducedClip.height());
 
     GrSWMaskHelper helper(texProvider);
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     SkMatrix translate;
     translate.setTranslate(clipToMaskOffset);
 
     helper.init(maskSpaceIBounds, &translate);
-    helper.clear(GrReducedClip::InitialState::kAllIn == reducedClip.initialState() ? 0xFF : 0x00);
+    helper.clear(InitialState::kAllIn == reducedClip.initialState() ? 0xFF : 0x00);
 
     for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = element->getOp();
 
         if (SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             // Intersect and reverse difference require modifying pixels outside of the geometry
             // that is being "drawn". In both cases we erase all the pixels outside of the geometry
             // but leave the pixels inside the geometry alone. For reverse difference we invert all
             // the pixels before clearing the ones outside the geometry.
             if (SkRegion::kReverseDifference_Op == op) {
-                SkRect temp = SkRect::Make(reducedClip.iBounds());
+                SkRect temp = SkRect::Make(reducedClip.ibounds());
                 // invert the entire scene
                 helper.drawRect(temp, SkRegion::kXOR_Op, false, 0xFF);
             }
             SkPath clipPath;
             element->asPath(&clipPath);
             clipPath.toggleInverseFillType();
             GrShape shape(clipPath, GrStyle::SimpleFill());
             helper.drawShape(shape, SkRegion::kReplace_Op, element->isAA(), 0x00);
             continue;
         }
@@ skipping 19 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }