Define clear regions in terms of GrFixedClip

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 "GrAppliedClip.h"
@@ skipping 471 matching lines @@
                                                      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());
+    GrFixedClip clip(maskSpaceIBounds);
 
     // 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, InitialState::kAllIn == reducedClip.initialState() ? -1 : 0, true);
+    GrColor initialCoverage = InitialState::kAllIn == reducedClip.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.
     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.
 
     // walk through each clip element and perform its set op
     for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
-            GrFixedClip 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>()
@@ skipping 18 matching lines @@
                                                           translate,
                                                           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);
+            draw_element(dc.get(), clip, paint, translate, element);
         }
     }
 
     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
+// 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; }
+
+private:
+    bool quickContains(const SkRect&) const final {
+        return false;
+    }
+    void getConservativeBounds(int width, int height, SkIRect* devResult, bool* iior) const final {
+        fFixedClip.getConservativeBounds(width, height, devResult, iior);
+    }
+    bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const final {
+        return false;
+    }
+    bool apply(GrContext* context, GrDrawContext* drawContext, bool useHWAA,
+               bool hasUserStencilSettings, GrAppliedClip* out) const final {
+        if (!fFixedClip.apply(context, drawContext, useHWAA, hasUserStencilSettings, out)) {
+            return false;
+        }
+        out->addStencilClip();
+        return true;
+    }
+
+    GrFixedClip fFixedClip;
+
+    typedef GrClip INHERITED;
+};
+
 bool GrClipStackClip::CreateStencilClipMask(GrContext* context,
                                             GrDrawContext* drawContext,
                                             const GrReducedClip& reducedClip,
                                             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.elementsGenID(), reducedClip.ibounds(),
                                           clipSpaceToStencilOffset)) {
         stencilAttachment->setLastClip(reducedClip.elementsGenID(), 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());
         stencilSpaceIBounds.offset(clipSpaceToStencilOffset);
-        GrFixedClip clip(stencilSpaceIBounds);
+        StencilClip stencilClip(stencilSpaceIBounds);
 
-        bool insideClip = InitialState::kAllIn == reducedClip.initialState();
-        drawContext->drawContextPriv().clearStencilClip(stencilSpaceIBounds, insideClip);
+        bool initialState = InitialState::kAllIn == reducedClip.initialState();
+        drawContext->drawContextPriv().clearStencilClip(stencilClip.fixedClip(), initialState);
 
         // 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
-            clip.disableStencilClip();
 
             // This will be used to determine whether the clip shape can be rendered into the
             // stencil with arbitrary stencil settings.
             GrPathRenderer::StencilSupport stencilSupport;
 
             SkRegion::Op op = element->getOp();
 
             GrPathRenderer* pr = nullptr;
             SkPath clipPath;
             if (Element::kRect_Type == element->getType()) {
@@ skipping 39 matching lines @@
                 static constexpr GrUserStencilSettings kDrawToStencil(
                      GrUserStencilSettings::StaticInit<
                          0x0000,
                          GrUserStencilTest::kAlways,
                          0xffff,
                          GrUserStencilOp::kIncMaybeClamp,
                          GrUserStencilOp::kIncMaybeClamp,
                          0xffff>()
                 );
                 if (Element::kRect_Type == element->getType()) {
-                    drawContext->drawContextPriv().stencilRect(clip, &kDrawToStencil, useHWAA,
+                    drawContext->drawContextPriv().stencilRect(stencilClip.fixedClip(),
+                                                               &kDrawToStencil, useHWAA,
                                                                viewMatrix, element->getRect());
                 } else {
                     if (!clipPath.isEmpty()) {
                         GrShape shape(clipPath, GrStyle::SimpleFill());
                         if (canRenderDirectToStencil) {
                             GrPaint paint;
                             paint.setXPFactory(GrDisableColorXPFactory::Make());
                             paint.setAntiAlias(element->isAA());
 
                             GrPathRenderer::DrawPathArgs args;
                             args.fResourceProvider = context->resourceProvider();
                             args.fPaint = &paint;
                             args.fUserStencilSettings = &kDrawToStencil;
                             args.fDrawContext = drawContext;
-                            args.fClip = &clip;
+                            args.fClip = &stencilClip.fixedClip();
                             args.fViewMatrix = &viewMatrix;
                             args.fShape = &shape;
                             args.fAntiAlias = false;
                             args.fGammaCorrect = false;
                             pr->drawPath(args);
                         } else {
                             GrPathRenderer::StencilPathArgs args;
                             args.fResourceProvider = context->resourceProvider();
                             args.fDrawContext = drawContext;
-                            args.fClip = &clip;
+                            args.fClip = &stencilClip.fixedClip();
                             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()) {
-                        drawContext->drawContextPriv().stencilRect(clip, *pass, useHWAA, viewMatrix,
-                                                                   element->getRect());
+                        drawContext->drawContextPriv().stencilRect(stencilClip, *pass, useHWAA,
+                                                                   viewMatrix, element->getRect());
                     } else {
                         GrShape shape(clipPath, GrStyle::SimpleFill());
                         GrPaint paint;
                         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.fClip = &stencilClip;
                         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.
-                    drawContext->drawContextPriv().stencilRect(clip, *pass, false, viewMatrix,
+                    drawContext->drawContextPriv().stencilRect(stencilClip, *pass,
+                                                               false, viewMatrix,
                                                                SkRect::Make(reducedClip.ibounds()));
                 }
             }
         }
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texProvider,
@@ skipping 62 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }