Allow GrReducedClip to take non-integer query bounds

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"
 #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;
+typedef GrReducedClip::InitialState InitialState;
 
 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
@@ skipping 191 matching lines @@
                                       GrDrawContext* drawContext,
                                       const GrClipStackClip& clip,
                                       const SkRect* origDevBounds,
                                       bool useHWAA,
                                       bool hasUserStencilSettings,
                                       GrAppliedClip* out) {
     if (!clip.clipStack() || clip.clipStack()->isWideOpen()) {
         return true;
     }
 
+    const SkScalar clipX = clip.origin().x(),
+                   clipY = clip.origin().y();
+    SkRect devBounds = SkRect::MakeIWH(drawContext->width(), drawContext->height());
+    if (!devBounds.intersect(devBounds.makeOffset(-clipX, -clipY))) {
+        return false;
+    }
+    if (origDevBounds && !devBounds.intersect(*origDevBounds)) {
+        return false;
+    }
+
     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);
+    InitialState initialState = GrReducedClip::ReduceClipStack(*clip.clipStack(),
+                                                               devBounds.makeOffset(clipX, clipY),
+                                                               &elements,
+                                                               &genID,
+                                                               &clipSpaceIBounds,
+                                                               &requiresAA);
     if (elements.isEmpty()) {
         if (GrReducedClip::kAllOut_InitialState == initialState) {
             return false;
         } else {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
             scissorSpaceIBounds.offset(-clip.origin());
-            if (!GrClip::CanIgnoreScissor(scissorSpaceIBounds, devBounds)) {
+            if (!GrClip::IsInsideClip(scissorSpaceIBounds, 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) };
+        SkVector clipToRTOffset = { SkIntToScalar(-clipX), SkIntToScalar(-clipY) };
         // 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 (requiresAA &&
             get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
                                         &clipFP)) {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
             scissorSpaceIBounds.offset(-clip.origin());
-            if (GrClip::CanIgnoreScissor(scissorSpaceIBounds, devBounds)) {
+            if (GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
                 out->makeFPBased(std::move(clipFP), SkRect::Make(scissorSpaceIBounds));
             } else {
                 out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
             }
             return true;
         }
     }
 
     // If the stencil buffer is multisampled we can use it to do everything.
     if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
@@ skipping 46 matching lines @@
                           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);
-    if (GrClip::CanIgnoreScissor(scissorSpaceIBounds, devBounds)) {
+    if (GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
         out->makeStencil(true, devBounds);
     } else {
         out->makeScissoredStencil(scissorSpaceIBounds);
     }
     return true;
 }
 
 static bool stencil_element(GrDrawContext* dc,
                             const GrFixedClip& clip,
                             const GrUserStencilSettings* ss,
@@ skipping 426 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }