Don't scissor draws overlapping the render target's edges

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 128 matching lines @@
                                 drawContext, translate, element, nullptr, needsStencil)) {
             return true;
         }
     }
     return false;
 }
 
 static bool get_analytic_clip_processor(const GrReducedClip::ElementList& elements,
                                         bool abortIfAA,
                                         SkVector& clipToRTOffset,
-                                        const SkRect* drawBounds,
+                                        const SkRect& drawBounds,
                                         sk_sp<GrFragmentProcessor>* resultFP) {
     SkRect boundsInClipSpace;
-    if (drawBounds) {
-        boundsInClipSpace = *drawBounds;
-        boundsInClipSpace.offset(-clipToRTOffset.fX, -clipToRTOffset.fY);
-    }
+    boundsInClipSpace = drawBounds.makeOffset(-clipToRTOffset.fX, -clipToRTOffset.fY);
     SkASSERT(elements.count() <= kMaxAnalyticElements);
     SkSTArray<kMaxAnalyticElements, sk_sp<GrFragmentProcessor>> fps;
     GrReducedClip::ElementList::Iter iter(elements);
     while (iter.get()) {
         SkRegion::Op op = iter.get()->getOp();
         bool invert;
         bool skip = false;
         switch (op) {
             case SkRegion::kReplace_Op:
                 SkASSERT(iter.get() == elements.head());
                 // Fallthrough, handled same as intersect.
             case SkRegion::kIntersect_Op:
                 invert = false;
-                if (drawBounds && iter.get()->contains(boundsInClipSpace)) {
+                if (iter.get()->contains(boundsInClipSpace)) {
                     skip = true;
                 }
                 break;
             case SkRegion::kDifference_Op:
                 invert = true;
                 // We don't currently have a cheap test for whether a rect is fully outside an
                 // element's primitive, so don't attempt to set skip.
                 break;
             default:
                 return false;
@@ skipping 45 matching lines @@
     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* devBounds,
+                                      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 clipSpaceRTIBounds = SkIRect::MakeWH(drawContext->width(), drawContext->height());
-    clipSpaceRTIBounds.offset(clip.origin());
-
     SkIRect clipSpaceReduceQueryBounds;
-#define DISABLE_DEV_BOUNDS_FOR_CLIP_REDUCTION 0
-    if (devBounds && !DISABLE_DEV_BOUNDS_FOR_CLIP_REDUCTION) {
-        SkIRect devIBounds = devBounds->roundOut();
-        devIBounds.offset(clip.origin());
-        if (!clipSpaceReduceQueryBounds.intersect(clipSpaceRTIBounds, devIBounds)) {
+    SkRect devBounds;
+    if (origDevBounds) {

[robertphillips, 2016/07/08 14:21:58]

Are there any issues with this reject and hairlines ?

[bsalomon, 2016/07/08 14:25:56]

Because of 'empty' rects? No, because GrDT bloats them out (either rounding out
or outsetting by 0.5).

+        if (!devBounds.intersect(SkRect::MakeIWH(drawContext->width(), drawContext->height()),
+                                 *origDevBounds)) {
             return false;
         }
+        devBounds.roundOut(&clipSpaceReduceQueryBounds);
+        clipSpaceReduceQueryBounds.offset(clip.origin());
     } else {
-        clipSpaceReduceQueryBounds = clipSpaceRTIBounds;
+        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::kAllIn_InitialState == initialState) {
-            if (clipSpaceIBounds == clipSpaceRTIBounds) {
-                return true;
+        if (GrReducedClip::kAllOut_InitialState == initialState) {
+            return false;
+        } else {
+            SkIRect scissorSpaceIBounds(clipSpaceIBounds);
+            scissorSpaceIBounds.offset(-clip.origin());
+            if (!SkRect::Make(scissorSpaceIBounds).contains(devBounds)) {
+                out->makeScissored(scissorSpaceIBounds);
             }
-        } else {
-            return false;
+            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 (elements.isEmpty() ||
-            (requiresAA &&
-             get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
-                                         &clipFP))) {
+        if (requiresAA &&
+            get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
+                                        &clipFP)) {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
             scissorSpaceIBounds.offset(-clip.origin());
-            if (!devBounds || !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) {
+            if (!SkRect::Make(scissorSpaceIBounds).contains(devBounds)) {
                 out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
                 return true;
             }
             out->makeFPBased(std::move(clipFP));
             return true;
         }
     }
 
     // If the stencil buffer is multisampled we can use it to do everything.
     if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
@@ skipping 481 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }