Update min Vulkan version to 1.0.8.0, and fix various 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 692 matching lines @@
             return nullptr;
         }
     }
     return tgt;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrVkGpu::bindGeometry(const GrPrimitiveProcessor& primProc,
                            const GrNonInstancedMesh& mesh) {
+    // There is no need to put any memory barriers to make sure host writes have finished here.
+    // When a command buffer is submitted to a queue, there is an implicit memory barrier that
+    // occurs for all host writes. Additionally, BufferMemoryBarriers are not allowed inside of
+    // an active RenderPass.
     GrVkVertexBuffer* vbuf;
     vbuf = (GrVkVertexBuffer*)mesh.vertexBuffer();
     SkASSERT(vbuf);
     SkASSERT(!vbuf->isMapped());
 
-    vbuf->addMemoryBarrier(this,
-                           VK_ACCESS_HOST_WRITE_BIT,
-                           VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
-                           VK_PIPELINE_STAGE_HOST_BIT,
-                           VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
-                           false);
-
     fCurrentCmdBuffer->bindVertexBuffer(this, vbuf);
 
     if (mesh.isIndexed()) {
         GrVkIndexBuffer* ibuf = (GrVkIndexBuffer*)mesh.indexBuffer();
         SkASSERT(ibuf);
         SkASSERT(!ibuf->isMapped());
 
-        ibuf->addMemoryBarrier(this,
-                               VK_ACCESS_HOST_WRITE_BIT,
-                               VK_ACCESS_INDEX_READ_BIT,
-                               VK_PIPELINE_STAGE_HOST_BIT,
-                               VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
-                               false);
-
         fCurrentCmdBuffer->bindIndexBuffer(this, ibuf);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrStencilAttachment* GrVkGpu::createStencilAttachmentForRenderTarget(const GrRenderTarget* rt,
                                                                      int width,
                                                                      int height) {
     SkASSERT(width >= rt->width());
@@ skipping 118 matching lines @@
             // TODO: Add support for copying to optimal tiling
             SkASSERT(false);
         }
     }
 
     GrVkTextureInfo* info = new GrVkTextureInfo;
     info->fImage = image;
     info->fAlloc = alloc;
     info->fImageTiling = imageTiling;
     info->fImageLayout = initialLayout;
+    info->fFormat = pixelFormat;
 
     return (GrBackendObject)info;
 }
 
 bool GrVkGpu::isTestingOnlyBackendTexture(GrBackendObject id) const {
     const GrVkTextureInfo* backend = reinterpret_cast<const GrVkTextureInfo*>(id);
 
     if (backend && backend->fImage && backend->fAlloc) {
         VkMemoryRequirements req;
         memset(&req, 0, sizeof(req));
@@ skipping 130 matching lines @@
     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 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);
 
+    // Change layout of our render target so it can be used as the color attachment. This is what
+    // the render pass expects when it begins.
+    VkImageLayout layout = vkRT->currentLayout();
+    srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
+    dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
+    dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+    vkRT->setImageLayout(this,
+                         VK_IMAGE_LAYOUT_COLOR_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 };
@@ skipping 26 matching lines @@
 
     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(origDstLayout);
+        VkPipelineStageFlags srcStageMask = 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);
 
+        // If we are using a stencil attachment we also need to change its layout to what the render
+        // pass is expecting.
+        if (GrStencilAttachment* stencil = vkRT->renderTargetPriv().getStencilAttachment()) {
+            GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
+            origDstLayout = vkStencil->currentLayout();
+            srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
+            dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
+                            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+            srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
+            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;
@@ skipping 462 matching lines @@
                      const GrMesh* meshes,
                      int meshCount) {
     if (!meshCount) {
         return;
     }
     GrRenderTarget* rt = pipeline.getRenderTarget();
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
     const GrVkRenderPass* renderPass = vkRT->simpleRenderPass();
     SkASSERT(renderPass);
 
-    fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
 
     GrPrimitiveType primitiveType = meshes[0].primitiveType();
     sk_sp<GrVkPipelineState> pipelineState = this->prepareDrawState(pipeline,
                                                                     primProc,
                                                                     primitiveType,
                                                                     *renderPass);
     if (!pipelineState) {
         return;
     }
 
     // Change layout of our render target so it can be used as the color attachment
     VkImageLayout layout = vkRT->currentLayout();
-    // Our color attachment is purely a destination and won't be read so don't need to flush or
-    // invalidate any caches
     VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
     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 (!pipeline.getStencil().isDisabled()) {
-        GrStencilAttachment* stencil = vkRT->renderTargetPriv().getStencilAttachment();
+    if (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);
     }
 
+    fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
 
     for (int i = 0; i < meshCount; ++i) {
         if (GrXferBarrierType barrierType = pipeline.xferBarrierType(*this->caps())) {
             this->xferBarrier(pipeline.getRenderTarget(), barrierType);

[jvanverth1, 2016/04/21 13:25:24]

Why are we bothering to call this? It does nothing.

[egdaniel, 2016/04/21 14:09:20]

gone

         }
 
         const GrMesh& mesh = meshes[i];
         GrMesh::Iterator iter;
         const GrNonInstancedMesh* nonIdxMesh = iter.init(mesh);
         do {
             if (nonIdxMesh->primitiveType() != primitiveType) {
                 // 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(this);
                 SkDEBUGCODE(pipelineState = nullptr);
                 primitiveType = nonIdxMesh->primitiveType();
+                // It is illegal for us to have the necessary memory barriers for when we write and
+                // update the uniform buffers in prepareDrawState while in an active render pass.
+                // Thus we must end the current one and then start it up again.
+                fCurrentCmdBuffer->endRenderPass(this);

[jvanverth1, 2016/04/21 13:25:24]

On the first iteration, it doesn't look like we do anything between
beginRenderPass and endRenderPass. Is there a way to avoid this?

[egdaniel, 2016/04/21 14:09:20]

Well we should never get here on the first iteration since we set the primitive
type to be that of the first mesh. In reality we actually never end up in this
if statement since all our flushes currently use the same primitive type for all
meshes. But the api does allow for changing the primitive type so this is here
for future proofing.

                 pipelineState = this->prepareDrawState(pipeline,
                                                        primProc,
                                                        primitiveType,
                                                        *renderPass);
                 if (!pipelineState) {
                     return;
                 }
+                fCurrentCmdBuffer->beginRenderPass(this, renderPass, *vkRT);
             }
             SkASSERT(pipelineState);
             this->bindGeometry(primProc, *nonIdxMesh);
 
             if (nonIdxMesh->isIndexed()) {
                 fCurrentCmdBuffer->drawIndexed(this,
                                                nonIdxMesh->indexCount(),
                                                1,
                                                nonIdxMesh->startIndex(),
                                                nonIdxMesh->startVertex(),
@@ skipping 23 matching lines @@
     aglSwapBuffers(aglGetCurrentContext());
     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
 }