Implement various vulkan stencil clears and fix various stenciling bugs.

src/gpu/vk/GrVkGpu.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 "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 502 matching lines @@
     imageDesc.fLevels = 1;
     imageDesc.fSamples = 1;
     imageDesc.fImageTiling = linearTiling ? VK_IMAGE_TILING_LINEAR : VK_IMAGE_TILING_OPTIMAL;
     imageDesc.fUsageFlags = usageFlags;
     imageDesc.fMemProps = memProps;
 
     GrVkTexture* tex;
     if (renderTarget) {
         tex = GrVkTextureRenderTarget::CreateNewTextureRenderTarget(this, desc, lifeCycle,
                                                                     imageDesc);
+#if 0
+        // This clear can be included to fix warning described in htttps://bugs.skia.org/5045
+        // Obviously we do not want to be clearling needlessly every time we create a render target.
+        SkIRect rect = SkIRect::MakeWH(tex->width(), tex->height());
+        this->clear(rect, GrColor_TRANSPARENT_BLACK, tex->asRenderTarget());
+#endif
     } else {
         tex = GrVkTexture::CreateNewTexture(this, desc, lifeCycle, imageDesc);
     }
 
     if (!tex) {
         return nullptr;
     }
 
     if (srcData) {
         if (!this->uploadTexData(tex, 0, 0, desc.fWidth, desc.fHeight, desc.fConfig, srcData,
@@ skipping 342 matching lines @@
                                        byRegion,
                                        GrVkCommandBuffer::kImageMemory_BarrierType,
                                        barrier);
 }
 
 void GrVkGpu::finishDrawTarget() {
     // Submit the current command buffer to the Queue
     this->submitCommandBuffer(kSkip_SyncQueue);
 }
 
+void GrVkGpu::clearStencil(GrRenderTarget* target) {
+    if (nullptr == target) {
+        return;
+    }
+    GrStencilAttachment* stencil = target->renderTargetPriv().getStencilAttachment();
+    GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
+
+
+    VkClearDepthStencilValue vkStencilColor;
+    memset(&vkStencilColor, 0, sizeof(VkClearDepthStencilValue));
+
+    VkImageLayout origDstLayout = vkStencil->currentLayout();
+
+    VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
+    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+
+    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);;
+    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+
+    vkStencil->setImageLayout(this,
+                              VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                              srcAccessMask,
+                              dstAccessMask,
+                              srcStageMask,
+                              dstStageMask,
+                              false);
+
+
+    VkImageSubresourceRange subRange;
+    memset(&subRange, 0, sizeof(VkImageSubresourceRange));
+    subRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+    subRange.baseMipLevel = 0;
+    subRange.levelCount = 1;
+    subRange.baseArrayLayer = 0;
+    subRange.layerCount = 1;
+
+    // TODO: I imagine that most times we want to clear a stencil it will be at the beginning of a
+    // draw. Thus we should look into using the load op functions on the render pass to clear out
+    // the stencil there.
+    fCurrentCmdBuffer->clearStencilImage(this, vkStencil, &vkStencilColor, 1, &subRange);
+}
+
+void GrVkGpu::onClearStencilClip(GrRenderTarget* target, const SkIRect& rect, bool insideClip) {
+    SkASSERT(target);
+
+    GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(target);
+    GrStencilAttachment* sb = target->renderTargetPriv().getStencilAttachment();
+    GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)sb;
+
+    // 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 guarrante that we preserve all bits in the stencil

[jvanverth1, 2016/03/01 18:49:10]

guarantee

[egdaniel, 2016/03/01 20:34:38]

Done.

+    // during this clear. Thus we will clear the entire stencil to the desired value.
+
+    VkClearDepthStencilValue vkStencilColor;
+    memset(&vkStencilColor, 0, sizeof(VkClearDepthStencilValue));
+    if (insideClip) {
+        vkStencilColor.stencil = (1 << (stencilBitCount - 1));
+    } else {
+        vkStencilColor.stencil = 0;
+    }
+
+    VkImageLayout origDstLayout = vkStencil->currentLayout();
+    VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
+    VkAccessFlags dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+    VkPipelineStageFlags srcStageMask =
+        GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
+    VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    vkStencil->setImageLayout(this,
+                              VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+                              srcAccessMask,
+                              dstAccessMask,
+                              srcStageMask,
+                              dstStageMask,
+                              false);
+
+    VkClearRect clearRect;
+    // Flip rect if necessary
+    SkIRect vkRect = rect;
+
+    if (kBottomLeft_GrSurfaceOrigin == vkRT->origin()) {
+        vkRect.fTop = vkRT->height() - rect.fBottom;
+        vkRect.fBottom = vkRT->height() - rect.fTop;
+    }
+
+    clearRect.rect.offset = { vkRect.fLeft, vkRect.fTop };
+    clearRect.rect.extent = { (uint32_t)vkRect.width(), (uint32_t)vkRect.height() };
+
+    clearRect.baseArrayLayer = 0;
+    clearRect.layerCount = 1;
+
+    const GrVkRenderPass* renderPass = vkRT->simpleRenderPass();
+    SkASSERT(renderPass);
+    fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
+
+    uint32_t stencilIndex;
+    SkAssertResult(renderPass->stencilAttachmentIndex(&stencilIndex));
+
+    VkClearAttachment attachment;
+    attachment.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+    attachment.colorAttachment = 0; // this value shouldn't matter
+    attachment.clearValue.depthStencil = vkStencilColor;
+
+    fCurrentCmdBuffer->clearAttachments(this, 1, &attachment, 1, &clearRect);
+    fCurrentCmdBuffer->endRenderPass(this);
+
+    return;
+}
+
 void GrVkGpu::onClear(GrRenderTarget* target, const SkIRect& rect, 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);
     VkImageLayout origDstLayout = vkRT->currentLayout();
 
     if (rect.width() != target->width() || rect.height() != target->height()) {
         VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
         VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
         VkPipelineStageFlags srcStageMask =
-            GrVkMemory::LayoutToPipelineStageFlags(vkRT->currentLayout());
+            GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
         VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
         vkRT->setImageLayout(this,
                              VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                              srcAccessMask,
                              dstAccessMask,
                              srcStageMask,
                              dstStageMask,
                              false);
 
         VkClearRect clearRect;
-        clearRect.rect.offset = { rect.fLeft, rect.fTop };
-        clearRect.rect.extent = { (uint32_t)rect.width(), (uint32_t)rect.height() };
-        clearRect.baseArrayLayer = 0;
-        clearRect.layerCount = 1;
-
-
+        // Flip rect if necessary
+        SkIRect vkRect = rect;
+        if (kBottomLeft_GrSurfaceOrigin == vkRT->origin()) {
+            vkRect.fTop = vkRT->height() - rect.fBottom;
+            vkRect.fBottom = vkRT->height() - rect.fTop;
+        }
+        clearRect.rect.offset = { vkRect.fLeft, vkRect.fTop };
+        clearRect.rect.extent = { (uint32_t)vkRect.width(), (uint32_t)vkRect.height() };
 
         const GrVkRenderPass* renderPass = vkRT->simpleRenderPass();
         SkASSERT(renderPass);
         fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
 
         uint32_t colorIndex;
         SkAssertResult(renderPass->colorAttachmentIndex(&colorIndex));
 
         VkClearAttachment attachment;
         attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
@@ skipping 268 matching lines @@
 
     return true;
 }
 
 void GrVkGpu::onDraw(const DrawArgs& args, const GrNonInstancedVertices& vertices) {
     GrRenderTarget* rt = args.fPipeline->getRenderTarget();
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
     const GrVkRenderPass* renderPass = vkRT->simpleRenderPass();
     SkASSERT(renderPass);
 
-
     GrVkProgram* program = GrVkProgramBuilder::CreateProgram(this, args,
                                                              vertices.primitiveType(),
                                                              *renderPass);
 
     if (!program) {
         return;
     }
 
     program->setData(this, *args.fPrimitiveProcessor, *args.fPipeline);
 
@@ skipping 12 matching lines @@
     VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
     VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
     vkRT->setImageLayout(this,
                          VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                          srcAccessMask,
                          dstAccessMask,
                          srcStageMask,
                          dstStageMask,
                          false);
 
+    // If we are using a stencil attachment we also need to update its layout
+    if (!args.fPipeline->getStencil().isDisabled()) {
+        GrStencilAttachment* stencil = vkRT->renderTargetPriv().getStencilAttachment();
+        GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
+        VkImageLayout origDstLayout = vkStencil->currentLayout();
+        VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
+        VkAccessFlags dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+        VkPipelineStageFlags srcStageMask =
+            GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
+        VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+        vkStencil->setImageLayout(this,
+                                  VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+                                  srcAccessMask,
+                                  dstAccessMask,
+                                  srcStageMask,
+                                  dstStageMask,
+                                  false);
+    }
+
     if (vertices.isIndexed()) {
         fCurrentCmdBuffer->drawIndexed(this,
                                        vertices.indexCount(),
                                        1,
                                        vertices.startIndex(),
                                        vertices.startVertex(),
                                        0);
     } else {
         fCurrentCmdBuffer->draw(this, vertices.vertexCount(), 1, vertices.startVertex(),  0);
     }
@@ skipping 16 matching lines @@
     int set_a_break_pt_here = 9;
     aglSwapBuffers(aglGetCurrentContext());
 #elif defined(SK_BUILD_FOR_WIN32)
     SwapBuf();
     int set_a_break_pt_here = 9;
     SwapBuf();
 #endif
 #endif
 }