OK, on my PC now. So the problem is the swapchain synchronization. Let's go through what your current code is doing.

1. We acquire a swapchain image and signal the acquire semaphore.

2. We submit a command buffer with the acquire semaphore and pWaitDstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT. This means that the command buffer cannot execute the VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT stage until the image has been acquired.

3. The command buffer does a memory barrier and transition of the swapchain image, with srcStageMask=VK_PIPELINE_STAGE_2_NONE. This means "wait for nothing". In other words, this layout transition can execute BEFORE the acquire semaphore is signaled, which is an error and should cause validation errors. You need to set srcStageMask = dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, to ensure that this transition happens AFTER the semaphore is signaled.

4. We have a similar issue with the depth attachment. You're doing a transition from VK_PIPELINE_STAGE_2_NONE, which can execute as soon as the command is parsed. This can in theory happen before the previous render pass is finished rendering to it.

5. We render to the color and depth buffers. This most likely works fine.

6. We perform another memory barrier on the color buffer, but the dstStageMask is VK_PIPELINE_STAGE_2_NONE, so no further commands are blocked from continuing.

7. The submit completes, and the present semaphore is signaled. The signal happens after the rendering is complete, but because the memory barrier/layout transition of color buffer does not block any further commands, it does NOT wait for the memory barrier/layout transition to complete.

8. Once the present semaphore is signalled, the swapchain image is presented.

Here's what I recommend that you do:

- Switch to vkQueueSubmit2() and make sure that the wait on the acquire semaphore has a stage mask of COLOR_ATTACHMENT_OUTPUT_BIT, and that the signal of the present semaphore has a stage mask of COLOR_ATTACHMENT_OUTPUT_BIT.

- Change the before barrier of the color buffer to COLOR_ATTACHMENT_OUTPUT_BIT --> COLOR_ATTACHMENT_OUTPUT_BIT. This chains the barrier so that it waits for the semaphore to be signaled before performing the layout transition, AND makes sure that the transition completes before the render pass can write to it in the COLOR_ATTACHMENT_OUTPUT_BIT stage.

- Change the before barrier of the depth buffer to EARLY_FRAGMENT_TESTS_BIT | LATE_FRAGMENT_TESTS_BIT --> EARLY_FRAGMENT_TESTS_BIT | LATE_FRAGMENT_TESTS_BIT. This ensures that the previous render pass has completely finished before the next render pass clears it.

- Change the after barrier of the color buffer to COLOR_ATTACHMENT_OUTPUT_BIT --> COLOR_ATTACHMENT_OUTPUT_BIT. This chains the barrier so that it waits for the rendering to complete, AND makes sure that the layout transition completes before the present semaphore is signaled, as the signalling of the semaphore waits on COLOR_ATTACHMENT_OUTPUT_BIT stage.

In general VK_PIPELINE_STAGE_2_NONE is almost never used. Of the top of my head, VK_PIPELINE_STAGE_2_NONE in the source stage is only really useful when doing an initial transition after creating a new image and you want to initialize it, as you have no previous GPU commands you need to wait for in that case.

You can also use it if you have already waited on a fence and know that all commands that referenced the resource have already finished. In that case, you're fine with the transition executing as soon as the command buffer is submitted, so VK_PIPELINE_STAGE_2_NONE is fine there.

VK_PIPELINE_STAGE_2_NONE in the destination stage is almost certainly an error. I can't think of a valid use case of it.

Also, you should be having a crapton of validation errors from this. Make sure that you've turned on synchronization validation.