Pre-crop filled rects to avoid scissor

src/gpu/GrDrawContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
@@ skipping 256 matching lines @@
         }
         return false;
     } else {
         if (useHWAA) {
             *useHWAA = rt->isUnifiedMultisampled();
         }
         return !rt->isUnifiedMultisampled();
     }
 }
 
-GrDrawBatch* GrDrawContext::getFillRectBatch(const GrPaint& paint,
-                                             const SkMatrix& viewMatrix,
-                                             const SkRect& rect,
-                                             bool* useHWAA) {
+enum class TrimResult {
+    kSkipDraw,
+    kDidTrim,
+    kDidNotTrim
+};
+
+static TrimResult trim_fill_rect(const GrClip& clip, const GrRenderTarget* rt,
+                                 const SkMatrix& viewMatrix, SkRect* rect) {
+    SkMatrix inverseVM;
+    if (viewMatrix.rectStaysRect() && viewMatrix.invert(&inverseVM)) {
+        SkASSERT(inverseVM.rectStaysRect());
+        SkIRect clipDevBounds;
+        clip.getConservativeBounds(rt->width(), rt->height(), &clipDevBounds);
+        SkRect clipUserSpaceBounds;
+        inverseVM.mapRect(&clipUserSpaceBounds, SkRect::Make(clipDevBounds));
+        if (!rect->intersect(clipUserSpaceBounds)) {
+            return TrimResult::kSkipDraw;
+        }
+        return TrimResult::kDidTrim;
+    }
+    return TrimResult::kDidNotTrim;
+}
+
+bool GrDrawContext::getFillRectBatch(const GrClip& clip,
+                                     const GrPaint& paint,
+                                     const SkMatrix& viewMatrix,
+                                     const SkRect& rect,
+                                     SkAutoTUnref<GrDrawBatch>* batch,
+                                     bool* useHWAA) {
+    SkRect trimRect = rect;
+    if (TrimResult::kSkipDraw == trim_fill_rect(clip, fRenderTarget.get(), viewMatrix, &trimRect)) {
+        return false;
+    }
+
     if (InstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
-        if (GrDrawBatch* batch = ir->recordRect(rect, viewMatrix, paint.getColor(),
-                                                paint.isAntiAlias(), fInstancedPipelineInfo,
-                                                useHWAA)) {
-            return batch;
+        batch->reset(ir->recordRect(trimRect, viewMatrix, paint.getColor(), paint.isAntiAlias(),
+                                    fInstancedPipelineInfo, useHWAA));
+        if (batch) {
+            return true;
         }
     }
 
     if (should_apply_coverage_aa(paint, fRenderTarget.get(), useHWAA)) {
         // The fill path can handle rotation but not skew.
         if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
             SkRect devBoundRect;
-            viewMatrix.mapRect(&devBoundRect, rect);
-            return GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix,
-                                                    rect, devBoundRect);
+            viewMatrix.mapRect(&devBoundRect, trimRect);
+            batch->reset(GrRectBatchFactory::CreateAAFill(paint.getColor(), viewMatrix, trimRect,
+                                                          devBoundRect));
         }
     } else {
         // filled BW rect
-        return GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect,
-                                                   nullptr, nullptr);
+        batch->reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, trimRect,
+                                                         nullptr, nullptr));
     }
 
-    return nullptr;
+    return true;
 }
 
 void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
                              const GrStyle* style) {
     if (!style) {
         style = &GrStyle::SimpleFill();
     }
@@ skipping 30 matching lines @@
                 rect_contains_inclusive(rect, srcSpaceRTQuad[2]) &&
                 rect_contains_inclusive(rect, srcSpaceRTQuad[3])) {
                 // Will it blend?
                 GrColor clearColor;
                 if (paint.isConstantBlendedColor(&clearColor)) {
                     this->getDrawTarget()->clear(nullptr, clearColor, true, this);
                     return;
                 }
             }
         }
-        batch.reset(this->getFillRectBatch(paint, viewMatrix, rect, &useHWAA));
+        if (!this->getFillRectBatch(clip, paint, viewMatrix, rect, &batch, &useHWAA)) {
+            return;
+        }
     } else if (stroke.getStyle() == SkStrokeRec::kStroke_Style ||
                stroke.getStyle() == SkStrokeRec::kHairline_Style) {
         if ((!rect.width() || !rect.height()) &&
             SkStrokeRec::kHairline_Style != stroke.getStyle()) {
             SkScalar r = stroke.getWidth() / 2;
             // TODO: Move these stroke->fill fallbacks to GrShape?
             switch (stroke.getJoin()) {
                 case SkPaint::kMiter_Join:
                     this->drawRect(clip, paint, viewMatrix,
                                    {rect.fLeft - r, rect.fTop - r,
@@ skipping 114 matching lines @@
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::drawAndStencilRect");
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     GrPaint paint;
     paint.setAntiAlias(doAA);
     paint.setCoverageSetOpXPFactory(op, invert);
 
     bool useHWAA;
-    SkAutoTUnref<GrDrawBatch> batch(
-        fDrawContext->getFillRectBatch(paint, viewMatrix, rect, &useHWAA));
+    SkAutoTUnref<GrDrawBatch> batch;
+    if (!fDrawContext->getFillRectBatch(clip, paint, viewMatrix, rect, &batch, &useHWAA)) {
+        return true;
+    }
     if (batch) {
         GrPipelineBuilder pipelineBuilder(paint, useHWAA);
         pipelineBuilder.setUserStencil(ss);
 
         fDrawContext->getDrawTarget()->drawBatch(pipelineBuilder, fDrawContext, clip, batch);
         return true;
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRect(rect);
     return this->drawAndStencilPath(clip, ss, op, invert, doAA, viewMatrix, path);
 }
 
 void GrDrawContext::fillRectToRect(const GrClip& clip,
                                    const GrPaint& paint,
                                    const SkMatrix& viewMatrix,
                                    const SkRect& rectToDraw,
                                    const SkRect& localRect) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::fillRectToRect");
 
     AutoCheckFlush acf(fDrawingManager);
     SkAutoTUnref<GrDrawBatch> batch;
     bool useHWAA;
 
+    SkRect trimRect = rectToDraw;
+    TrimResult trimResult = trim_fill_rect(clip, fRenderTarget.get(), viewMatrix, &trimRect);
+    if (TrimResult::kSkipDraw == trimResult) {
+        return;
+    }
+    SkRect trimLocalRect = localRect;
+    if (TrimResult::kDidTrim == trimResult) {
+        SkScalar dx = localRect.width() / rectToDraw.width();
+        SkScalar dy = localRect.height() / rectToDraw.height();
+        trimLocalRect.fLeft += (trimRect.fLeft - rectToDraw.fLeft) * dx;
+        trimLocalRect.fTop += (trimRect.fTop - rectToDraw.fTop) * dy;
+        trimLocalRect.fRight -= (rectToDraw.fRight - trimRect.fRight) * dx;
+        trimLocalRect.fTop -= (rectToDraw.fTop - trimRect.fTop) * dy;
+    }
+
     if (InstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
-        batch.reset(ir->recordRect(rectToDraw, viewMatrix, paint.getColor(), localRect,
+        batch.reset(ir->recordRect(trimRect, viewMatrix, paint.getColor(), trimLocalRect,
                                    paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA));
         if (batch) {
             GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
             return;
         }
     }
 
     if (should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
-        batch.reset(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix, rectToDraw,
-                                                           localRect));
+        batch.reset(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix, trimRect,
+                                                           trimLocalRect));
     } else {
-        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
-                                                        &localRect, nullptr));
+        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, trimRect,
+                                                        &trimLocalRect, nullptr));
     }
 
     if (batch) {
         GrPipelineBuilder pipelineBuilder(paint, useHWAA);
         this->drawBatch(pipelineBuilder, clip, batch);
     }
 }
 
 void GrDrawContext::fillRectWithLocalMatrix(const GrClip& clip,
                                             const GrPaint& paint,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& rectToDraw,
                                             const SkMatrix& localMatrix) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::fillRectWithLocalMatrix");
 
     AutoCheckFlush acf(fDrawingManager);
     SkAutoTUnref<GrDrawBatch> batch;
     bool useHWAA;
 
+    SkRect trimRect = rectToDraw;
+    if (TrimResult::kSkipDraw == trim_fill_rect(clip, fRenderTarget.get(), viewMatrix, &trimRect)) {
+        return;
+    }
+
     if (InstancedRendering* ir = this->getDrawTarget()->instancedRendering()) {
-        batch.reset(ir->recordRect(rectToDraw, viewMatrix, paint.getColor(), localMatrix,
+        batch.reset(ir->recordRect(trimRect, viewMatrix, paint.getColor(), localMatrix,
                                    paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA));
         if (batch) {
             GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
             return;
         }
     }
 
     if (should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
-        batch.reset(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix,
-                                              rectToDraw));
+        batch.reset(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix, trimRect));
     } else {
-        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
+        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, trimRect,
                                                         nullptr, &localMatrix));
     }
 
     GrPipelineBuilder pipelineBuilder(paint, useHWAA);
     this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
 }
 
 void GrDrawContext::drawVertices(const GrClip& clip,
                                  const GrPaint& paint,
                                  const SkMatrix& viewMatrix,
@@ skipping 534 matching lines @@
 
 void GrDrawContext::drawBatch(const GrPipelineBuilder& pipelineBuilder, const GrClip& clip,
                               GrDrawBatch* batch) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch");
 
     this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
 }