Only use scissor state for native clears

This is the first of many CLs that progressively refine the clipping,
scissoring, and clearing APIs.

The series of changes focus on simplifying the clear APIs, consolidating
clip intersection logic, and moving towards a more explicitly sized
render target context (where confusion between approx-fit and exact-fit
is handled externally, although I don't take it that far).

Next step will be to propagate the simpler calls up to GrRTC.

Bug:skia:10205
Change-Id: Idb0c58a63b7a3950a92604dd4c03536d668be7c4
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/290123
Commit-Queue: Michael Ludwig <[email protected]>
Reviewed-by: Chris Dalton <[email protected]>

Author: lhkbob

src/gpu/GrOpsRenderPass.cpp

@@ -11,12 +11,13 @@
 #include "include/gpu/GrContext.h"
 #include "src/gpu/GrCaps.h"
 #include "src/gpu/GrContextPriv.h"
-#include "src/gpu/GrFixedClip.h"
+#include "src/gpu/GrCpuBuffer.h"
 #include "src/gpu/GrGpu.h"
 #include "src/gpu/GrPrimitiveProcessor.h"
 #include "src/gpu/GrProgramInfo.h"
 #include "src/gpu/GrRenderTarget.h"
 #include "src/gpu/GrRenderTargetPriv.h"
+#include "src/gpu/GrScissorState.h"
 #include "src/gpu/GrSimpleMesh.h"
 #include "src/gpu/GrTexturePriv.h"
 
@@ -37,21 +38,22 @@ void GrOpsRenderPass::end() {
     this->resetActiveBuffers();
 }
 
-void GrOpsRenderPass::clear(const GrFixedClip& clip, const SkPMColor4f& color) {
+void GrOpsRenderPass::clear(const GrScissorState& scissor, const SkPMColor4f& color) {
     SkASSERT(fRenderTarget);
     // A clear at this level will always be a true clear, so make sure clears were not supposed to
     // be redirected to draws instead
     SkASSERT(!this->gpu()->caps()->performColorClearsAsDraws());
-    SkASSERT(!clip.scissorEnabled() || !this->gpu()->caps()->performPartialClearsAsDraws());
+    SkASSERT(!scissor.enabled() || !this->gpu()->caps()->performPartialClearsAsDraws());
     fDrawPipelineStatus = DrawPipelineStatus::kNotConfigured;
-    this->onClear(clip, color);
+    this->onClear(scissor, color);
 }
 
-void GrOpsRenderPass::clearStencilClip(const GrFixedClip& clip, bool insideStencilMask) {
+void GrOpsRenderPass::clearStencilClip(const GrScissorState& scissor, bool insideStencilMask) {
     // As above, make sure the stencil clear wasn't supposed to be a draw rect with stencil settings
     SkASSERT(!this->gpu()->caps()->performStencilClearsAsDraws());
+    SkASSERT(!scissor.enabled() || !this->gpu()->caps()->performPartialClearsAsDraws());
     fDrawPipelineStatus = DrawPipelineStatus::kNotConfigured;
-    this->onClearStencilClip(clip, insideStencilMask);
+    this->onClearStencilClip(scissor, insideStencilMask);
 }
 
 void GrOpsRenderPass::executeDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler> drawable) {

src/gpu/GrOpsRenderPass.h

@@ -13,12 +13,12 @@
 #include "src/gpu/ops/GrDrawOp.h"
 
 class GrOpFlushState;
-class GrFixedClip;
 class GrGpu;
 class GrPipeline;
 class GrPrimitiveProcessor;
 class GrProgramInfo;
 class GrRenderTarget;
+class GrScissorState;
 class GrSemaphore;
 struct SkIRect;
 struct SkRect;
@@ -120,11 +120,17 @@ class GrOpsRenderPass {
     virtual void inlineUpload(GrOpFlushState*, GrDeferredTextureUploadFn&) = 0;
 
     /**
-     * Clear the owned render target. Ignores the draw state and clip.
+     * Clear the owned render target. Clears the full target if 'scissor' is disabled, otherwise it
+     * is restricted to 'scissor'. Must check caps.performPartialClearsAsDraws() before using an
+     * enabled scissor test; must check caps.performColorClearsAsDraws() before using this at all.
      */
-    void clear(const GrFixedClip&, const SkPMColor4f&);
+    void clear(const GrScissorState& scissor, const SkPMColor4f&);
 
-    void clearStencilClip(const GrFixedClip&, bool insideStencilMask);
+    /**
+     * Same as clear() but modifies the stencil; check caps.performStencilClearsAsDraws() and
+     * caps.performPartialClearsAsDraws().
+     */
+    void clearStencilClip(const GrScissorState& scissor, bool insideStencilMask);
 
     /**
      * Executes the SkDrawable object for the underlying backend.
@@ -189,8 +195,8 @@ class GrOpsRenderPass {
     virtual void onDrawIndexedIndirect(const GrBuffer*, size_t offset, int drawCount) {
         SK_ABORT("Not implemented.");  // Only called if caps.nativeDrawIndirectSupport().
     }
-    virtual void onClear(const GrFixedClip&, const SkPMColor4f&) = 0;
-    virtual void onClearStencilClip(const GrFixedClip&, bool insideStencilMask) = 0;
+    virtual void onClear(const GrScissorState&, const SkPMColor4f&) = 0;
+    virtual void onClearStencilClip(const GrScissorState&, bool insideStencilMask) = 0;
     virtual void onExecuteDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler>) {}
 
     enum class DrawPipelineStatus {

src/gpu/GrRenderTargetContext.cpp

@@ -558,7 +558,7 @@ void GrRenderTargetContext::internalClear(const GrFixedClip& clip,
                     fContext, SkIRect::MakeEmpty(), color, /* fullscreen */ true));
         }
     } else {
-        if (this->caps()->performPartialClearsAsDraws()) {
+        if (this->caps()->performPartialClearsAsDraws() || clip.hasWindowRectangles()) {
             // performPartialClearsAsDraws() also returns true if any clear has to be a draw.
             GrPaint paint;
             clear_to_grpaint(color, &paint);
@@ -567,7 +567,7 @@ void GrRenderTargetContext::internalClear(const GrFixedClip& clip,
                             GrFillRectOp::MakeNonAARect(fContext, std::move(paint), SkMatrix::I(),
                                                         SkRect::Make(clip.scissorRect())));
         } else {
-            std::unique_ptr<GrOp> op(GrClearOp::Make(fContext, clip, color,
+            std::unique_ptr<GrOp> op(GrClearOp::Make(fContext, clip.scissorState(), color,
                                                      this->asSurfaceProxy()));
             // This version of the clear op factory can return null if the clip doesn't intersect
             // with the surface proxy's boundary
@@ -979,18 +979,23 @@ void GrRenderTargetContextPriv::clearStencilClip(const GrFixedClip& clip, bool i
 void GrRenderTargetContext::internalStencilClear(const GrFixedClip& clip, bool insideStencilMask) {
     this->setNeedsStencil(/* useMixedSamplesIfNotMSAA = */ false);
 
-    if (this->caps()->performStencilClearsAsDraws()) {
+    bool clearWithDraw = this->caps()->performStencilClearsAsDraws() ||
+                         (clip.scissorEnabled() && this->caps()->performPartialClearsAsDraws());
+    // TODO(michaelludwig): internalStencilClear will eventually just take a GrScissorState so
+    // we won't need to check window rectangles here.
+    if (clearWithDraw || clip.hasWindowRectangles()) {
         const GrUserStencilSettings* ss = GrStencilSettings::SetClipBitSettings(insideStencilMask);
-        SkRect rtRect = SkRect::MakeWH(this->width(), this->height());
+        SkRect rect = clip.scissorEnabled() ? SkRect::Make(clip.scissorRect())
+                                            : SkRect::MakeWH(this->width(), this->height());
 
         // Configure the paint to have no impact on the color buffer
         GrPaint paint;
         paint.setXPFactory(GrDisableColorXPFactory::Get());
         this->addDrawOp(clip, GrFillRectOp::MakeNonAARect(fContext, std::move(paint), SkMatrix::I(),
-                                                          rtRect, ss));
+                                                          rect, ss));
     } else {
-        std::unique_ptr<GrOp> op(GrClearStencilClipOp::Make(fContext, clip, insideStencilMask,
-                                                            this->asRenderTargetProxy()));
+        std::unique_ptr<GrOp> op(GrClearStencilClipOp::Make(
+                fContext, clip.scissorState(), insideStencilMask, this->asRenderTargetProxy()));
         if (!op) {
             return;
         }

src/gpu/d3d/GrD3DCommandList.cpp

@@ -7,6 +7,7 @@
 
 #include "src/gpu/d3d/GrD3DCommandList.h"
 
+#include "src/gpu/GrScissorState.h"
 #include "src/gpu/d3d/GrD3DBuffer.h"
 #include "src/gpu/d3d/GrD3DGpu.h"
 #include "src/gpu/d3d/GrD3DPipelineState.h"
@@ -296,12 +297,13 @@ void GrD3DDirectCommandList::drawIndexedInstanced(unsigned int indexCount,
 
 void GrD3DDirectCommandList::clearRenderTargetView(GrD3DRenderTarget* renderTarget,
                                                    const SkPMColor4f& color,
-                                                   const GrFixedClip& clip) {
+                                                   const GrScissorState& scissor) {
+    SkASSERT(!scissor.enabled()); // no cliprects for now
     this->addingWork();
     this->addResource(renderTarget->resource());
     fCommandList->ClearRenderTargetView(renderTarget->colorRenderTargetView(),
                                         color.vec(),
-                                        0, NULL); // no cliprects for now
+                                        0, NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

src/gpu/d3d/GrD3DCommandList.h

@@ -22,7 +22,7 @@ class GrD3DRenderTarget;
 class GrD3DRootSignature;
 class GrD3DTextureResource;
 
-class GrFixedClip;
+class GrScissorState;
 
 class GrD3DCommandList {
 public:
@@ -134,7 +134,7 @@ class GrD3DDirectCommandList : public GrD3DCommandList {
                               unsigned int startInstance);
 
     void clearRenderTargetView(GrD3DRenderTarget* renderTarget, const SkPMColor4f& color,
-                               const GrFixedClip& clip);
+                               const GrScissorState& scissor);
 private:
     GrD3DDirectCommandList(gr_cp<ID3D12CommandAllocator> allocator,
                            gr_cp<ID3D12GraphicsCommandList> commandList);

src/gpu/d3d/GrD3DGpu.cpp

@@ -563,12 +563,12 @@ bool GrD3DGpu::uploadToTexture(GrD3DTexture* tex, int left, int top, int width,
     return true;
 }
 
-void GrD3DGpu::clear(const GrFixedClip& clip, const SkPMColor4f& color, GrRenderTarget* rt) {
+void GrD3DGpu::clear(const GrScissorState& scissor, const SkPMColor4f& color, GrRenderTarget* rt) {
     GrD3DRenderTarget* d3dRT = static_cast<GrD3DRenderTarget*>(rt);
 
     d3dRT->setResourceState(this, D3D12_RESOURCE_STATE_RENDER_TARGET);
 
-    fCurrentDirectCommandList->clearRenderTargetView(d3dRT, color, clip);
+    fCurrentDirectCommandList->clearRenderTargetView(d3dRT, color, scissor);
 }
 
 static bool check_resource_info(const GrD3DTextureResourceInfo& info) {

src/gpu/d3d/GrD3DGpu.h

@@ -99,7 +99,7 @@ class GrD3DGpu : public GrGpu {
         return nullptr;
     }
 
-    void clear(const GrFixedClip& clip, const SkPMColor4f& color, GrRenderTarget*);
+    void clear(const GrScissorState& scissor, const SkPMColor4f& color, GrRenderTarget*);
 
     void submit(GrOpsRenderPass* renderPass) override;
 

src/gpu/d3d/GrD3DOpsRenderPass.cpp

@@ -46,8 +46,7 @@ GrGpu* GrD3DOpsRenderPass::gpu() { return fGpu; }
 
 void GrD3DOpsRenderPass::onBegin() {
     if (GrLoadOp::kClear == fColorLoadOp) {
-        GrFixedClip clip;
-        fGpu->clear(clip, fClearColor, fRenderTarget);
+        fGpu->clear(GrScissorState(), fClearColor, fRenderTarget);
     }
 }
 
@@ -234,6 +233,6 @@ void GrD3DOpsRenderPass::onDrawIndexedInstanced(int indexCount, int baseIndex, i
     fGpu->stats()->incNumDraws();
 }
 
-void GrD3DOpsRenderPass::onClear(const GrFixedClip& clip, const SkPMColor4f& color) {
-    fGpu->clear(clip, color, fRenderTarget);
+void GrD3DOpsRenderPass::onClear(const GrScissorState& scissor, const SkPMColor4f& color) {
+    fGpu->clear(scissor, color, fRenderTarget);
 }

src/gpu/d3d/GrD3DOpsRenderPass.h

@@ -56,9 +56,9 @@ class GrD3DOpsRenderPass : public GrOpsRenderPass {
     void onDrawIndirect(const GrBuffer*, size_t offset, int drawCount) override {}
     void onDrawIndexedIndirect(const GrBuffer*, size_t offset, int drawCount) override {}
 
-    void onClear(const GrFixedClip&, const SkPMColor4f& color) override;
+    void onClear(const GrScissorState& scissor, const SkPMColor4f& color) override;
 
-    void onClearStencilClip(const GrFixedClip&, bool insideStencilMask) override {}
+    void onClearStencilClip(const GrScissorState& scissor, bool insideStencilMask) override {}
 
     GrD3DGpu* fGpu;
 

src/gpu/dawn/GrDawnOpsRenderPass.cpp

@@ -94,12 +94,15 @@ void GrDawnOpsRenderPass::submit() {
     fGpu->appendCommandBuffer(fEncoder.Finish());
 }
 
-void GrDawnOpsRenderPass::onClearStencilClip(const GrFixedClip& clip, bool insideStencilMask) {
+void GrDawnOpsRenderPass::onClearStencilClip(const GrScissorState& scissor,
+                                             bool insideStencilMask) {
+    SkASSERT(!scissor.enabled());
     fPassEncoder.EndPass();
     fPassEncoder = beginRenderPass(wgpu::LoadOp::Load, wgpu::LoadOp::Clear);
 }
 
-void GrDawnOpsRenderPass::onClear(const GrFixedClip& clip, const SkPMColor4f& color) {
+void GrDawnOpsRenderPass::onClear(const GrScissorState& scissor, const SkPMColor4f& color) {
+    SkASSERT(!scissor.enabled());
     fPassEncoder.EndPass();
     fPassEncoder = beginRenderPass(wgpu::LoadOp::Clear, wgpu::LoadOp::Load);
 }