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 601 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);
-        }
-
         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);
                 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
 }