Define clear regions in terms of GrFixedClip

src/gpu/vk/GrVkGpuCommandBuffer.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 "GrVkGpuCommandBuffer.h"
 
+#include "GrFixedClip.h"
 #include "GrMesh.h"
 #include "GrPipeline.h"
 #include "GrRenderTargetPriv.h"
 #include "GrTextureAccess.h"
 #include "GrTexturePriv.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkPipeline.h"
 #include "GrVkRenderPass.h"
 #include "GrVkRenderTarget.h"
@@ skipping 144 matching lines @@
                                                                   vkResolveOps,
                                                                   vkStencilOps);
         }
 
         SkASSERT(fRenderPass->isCompatible(*oldRP));
         oldRP->unref(fGpu);
     }
 }
 
 void GrVkGpuCommandBuffer::onClearStencilClip(GrRenderTarget* target,
-                                              const SkIRect& rect,
-                                              bool insideClip) {
+                                              const GrFixedClip& clip,
+                                              bool insideStencilMask) {
     SkASSERT(target);
 
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(target);
     GrStencilAttachment* sb = target->renderTargetPriv().getStencilAttachment();
     // this should only be called internally when we know we have a
     // stencil buffer.
     SkASSERT(sb);
     int stencilBitCount = sb->bits();
 
     // The contract with the callers does not guarantee that we preserve all bits in the stencil
     // during this clear. Thus we will clear the entire stencil to the desired value.
 
     VkClearDepthStencilValue vkStencilColor;
     memset(&vkStencilColor, 0, sizeof(VkClearDepthStencilValue));
-    if (insideClip) {
+    if (insideStencilMask) {
         vkStencilColor.stencil = (1 << (stencilBitCount - 1));
     } else {
         vkStencilColor.stencil = 0;
     }
 
     VkClearRect clearRect;
     // Flip rect if necessary
-    SkIRect vkRect = rect;
-
+    SkIRect vkRect = clip.scissorEnabled() ? clip.scissorRect()
+                                           : SkIRect::MakeWH(vkRT->width(), vkRT->height());

[egdaniel, 2016/08/19 20:09:37]

For some minimal optimization, we don't need to do the BottomLeft check and flip
if !clip.scissorEnabled(). Same in onClear.

[csmartdalton, 2016/08/19 20:46:49]

Done. Looks better now.

     if (kBottomLeft_GrSurfaceOrigin == vkRT->origin()) {
-        vkRect.fTop = vkRT->height() - rect.fBottom;
-        vkRect.fBottom = vkRT->height() - rect.fTop;
+        SkTSwap(vkRect.fTop, vkRect.fBottom);
+        vkRect.fTop = vkRT->height() - vkRect.fTop;
+        vkRect.fBottom = vkRT->height() - vkRect.fBottom;
     }
 
     clearRect.rect.offset = { vkRect.fLeft, vkRect.fTop };
     clearRect.rect.extent = { (uint32_t)vkRect.width(), (uint32_t)vkRect.height() };
 
     clearRect.baseArrayLayer = 0;
     clearRect.layerCount = 1;
 
     uint32_t stencilIndex;
     SkAssertResult(fRenderPass->stencilAttachmentIndex(&stencilIndex));
 
     VkClearAttachment attachment;
     attachment.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
     attachment.colorAttachment = 0; // this value shouldn't matter
     attachment.clearValue.depthStencil = vkStencilColor;
 
     fCommandBuffer->clearAttachments(fGpu, 1, &attachment, 1, &clearRect);
     fIsEmpty = false;
 }
 
-void GrVkGpuCommandBuffer::onClear(GrRenderTarget* target, const SkIRect& rect, GrColor color) {
+void GrVkGpuCommandBuffer::onClear(GrRenderTarget* target, const GrFixedClip& clip, GrColor color) {
     // parent class should never let us get here with no RT
     SkASSERT(target);
 
     VkClearColorValue vkColor;
     GrColorToRGBAFloat(color, vkColor.float32);
 
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(target);
 
-    if (fIsEmpty && rect.width() == target->width() && rect.height() == target->height()) {
+    if (fIsEmpty && !clip.scissorEnabled()) {
         // We will change the render pass to do a clear load instead
         GrVkRenderPass::LoadStoreOps vkColorOps(VK_ATTACHMENT_LOAD_OP_CLEAR,
                                                 VK_ATTACHMENT_STORE_OP_STORE);
         GrVkRenderPass::LoadStoreOps vkStencilOps(VK_ATTACHMENT_LOAD_OP_LOAD,
                                                   VK_ATTACHMENT_STORE_OP_STORE);
         GrVkRenderPass::LoadStoreOps vkResolveOps(VK_ATTACHMENT_LOAD_OP_LOAD,
                                                   VK_ATTACHMENT_STORE_OP_STORE);
 
         const GrVkRenderPass* oldRP = fRenderPass;
 
@@ skipping 14 matching lines @@
         SkASSERT(fRenderPass->isCompatible(*oldRP));
         oldRP->unref(fGpu);
 
         GrColorToRGBAFloat(color, fColorClearValue.color.float32);
         return;
     }
 
     // We always do a sub rect clear with clearAttachments since we are inside a render pass
     VkClearRect clearRect;
     // Flip rect if necessary
-    SkIRect vkRect = rect;
+    SkIRect vkRect = clip.scissorEnabled() ? clip.scissorRect()
+                                           : SkIRect::MakeWH(vkRT->width(), vkRT->height());
     if (kBottomLeft_GrSurfaceOrigin == vkRT->origin()) {
-        vkRect.fTop = vkRT->height() - rect.fBottom;
-        vkRect.fBottom = vkRT->height() - rect.fTop;
+        SkTSwap(vkRect.fTop, vkRect.fBottom);
+        vkRect.fTop = vkRT->height() - vkRect.fTop;
+        vkRect.fBottom = vkRT->height() - vkRect.fBottom;
     }
     clearRect.rect.offset = { vkRect.fLeft, vkRect.fTop };
     clearRect.rect.extent = { (uint32_t)vkRect.width(), (uint32_t)vkRect.height() };
     clearRect.baseArrayLayer = 0;
     clearRect.layerCount = 1;
 
     uint32_t colorIndex;
     SkAssertResult(fRenderPass->colorAttachmentIndex(&colorIndex));
 
     VkClearAttachment attachment;
@@ skipping 149 matching lines @@
             fGpu->stats()->incNumDraws();
         } while ((nonIdxMesh = iter.next()));
     }
 
     // Technically we don't have to call this here (since there is a safety check in
     // pipelineState:setData but this will allow for quicker freeing of resources if the
     // pipelineState sits in a cache for a while.
     pipelineState->freeTempResources(fGpu);
 }