Added VK_Custom_Resolve test

RenderPass and Dynamic rendering for MSAA 4x target with a custom resolve shader
2026-05-04 09:00:44 +00:00 · 2026-02-12 12:01:31 +00:00
parent bb4baec204
commit 1cd63c2d6c
5 changed files with 633 additions and 0 deletions
@@ -124,6 +124,7 @@ set(VULKAN_SRC
        vk/vk_dynamic_rendering.cpp
        vk/vk_empty_capture.cpp
        vk/vk_ext_buffer_address.cpp
+        vk/vk_custom_resolve.cpp
        vk/vk_extended_dyn_state.cpp
        vk/vk_graphics_pipeline.cpp
        vk/vk_groupshared.cpp
@@ -333,6 +333,7 @@
    <ClCompile Include="vk\vk_dynamic_rendering.cpp" />
    <ClCompile Include="vk\vk_empty_capture.cpp" />
    <ClCompile Include="vk\vk_extended_dyn_state.cpp" />
+    <ClCompile Include="vk\vk_custom_resolve.cpp" />
    <ClCompile Include="vk\vk_graphics_pipeline.cpp" />
    <ClCompile Include="vk\vk_groupshared.cpp" />
    <ClCompile Include="vk\vk_khr_buffer_address.cpp" />
@@ -757,6 +757,9 @@
    <ClCompile Include="d3d12\d3d12_predication.cpp">
      <Filter>D3D12\demos</Filter>
    </ClCompile>
+    <ClCompile Include="vk\vk_custom_resolve.cpp">
+      <Filter>Vulkan\demos</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <Filter Include="D3D11">
@@ -0,0 +1,445 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2026 Baldur Karlsson
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ ******************************************************************************/
+
+#include "vk_test.h"
+
+std::string resolveShader = R"EOSHADER(
+
+#version 460 core
+
+layout (input_attachment_index = 0, binding = 0) uniform subpassInputMS msaaColour;
+
+layout(location = 0, index = 0) out vec4 Color;
+
+void main()
+{
+	Color = vec4(0.0, 0.0, 0.0, 0.0);
+  vec4 s0 = subpassLoad(msaaColour,0);
+  vec4 s1 = subpassLoad(msaaColour,1);
+  vec4 s2 = subpassLoad(msaaColour,2);
+  vec4 s3 = subpassLoad(msaaColour,3);
+  Color = (s0 + s1 + s2 + s3 ) / 16.0;
+  if (s0 != s1)
+    Color = vec4(1.0, 0.0, 0.0, 1.0);
+  if (s0 != s2)
+    Color = vec4(0.0, 1.0, 0.0, 1.0);
+  if (s0 != s3)
+    Color = vec4(0.0, 0.0, 1.0, 1.0);
+  Color.a = 1.0;
+}
+
+)EOSHADER";
+
+RD_TEST(VK_Custom_Resolve, VulkanGraphicsTest)
+{
+  static constexpr const char *Description = "Test capture and replay of VK_EXT_custom_resolve";
+
+  void Prepare(int argc, char **argv)
+  {
+    devExts.push_back(VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME);
+    devExts.push_back(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME);
+
+    VulkanGraphicsTest::Prepare(argc, argv);
+
+    if(!Avail.empty())
+      return;
+
+    // Dynamic rendering without using extension
+    if(devVersion < VK_MAKE_VERSION(1, 3, 0))
+    {
+      Avail = "Vulkan device version isn't 1.3+";
+      return;
+    }
+
+    static VkPhysicalDeviceVulkan13Features vk13feats = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
+    };
+
+    getPhysFeatures2(&vk13feats);
+    if(vk13feats.dynamicRendering == VK_FALSE)
+    {
+      Avail = "Vulkan device doesn't support dynamicRendering";
+      return;
+    }
+
+    vk13feats.dynamicRendering = VK_TRUE;
+    devInfoNext = &vk13feats;
+
+    static VkPhysicalDeviceCustomResolveFeaturesEXT customResolveFeatures = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT};
+
+    getPhysFeatures2(&customResolveFeatures);
+    customResolveFeatures.pNext = (void *)devInfoNext;
+    customResolveFeatures.customResolve = VK_TRUE;
+    devInfoNext = &customResolveFeatures;
+
+    static VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR dynRenderLocalReadFeatures = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR};
+
+    getPhysFeatures2(&dynRenderLocalReadFeatures);
+    dynRenderLocalReadFeatures.pNext = (void *)devInfoNext;
+    dynRenderLocalReadFeatures.dynamicRenderingLocalRead = VK_TRUE;
+    devInfoNext = &dynRenderLocalReadFeatures;
+  }
+
+  int main()
+  {
+    // initialise, create window, create context, etc
+    if(!Init())
+      return 3;
+
+    vkh::RenderPassCreator renderPassCreateInfo;
+    // MSAA Colour pass
+    renderPassCreateInfo.attachments.push_back(vkh::AttachmentDescription(
+        mainWindow->format, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
+        VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_SAMPLE_COUNT_4_BIT));
+    // Resolve output
+    renderPassCreateInfo.attachments.push_back(vkh::AttachmentDescription(
+        mainWindow->format, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
+        VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_STORE));
+
+    renderPassCreateInfo.addSubpass({VkAttachmentReference({0, VK_IMAGE_LAYOUT_GENERAL})},
+                                    VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_UNDEFINED);
+    // Resolve subpass with VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT
+    // Color attachment 1. Input attachment 0
+    renderPassCreateInfo.addSubpass({VkAttachmentReference({1, VK_IMAGE_LAYOUT_GENERAL})},
+                                    VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_UNDEFINED, {},
+                                    {VkAttachmentReference({0, VK_IMAGE_LAYOUT_GENERAL})});
+    renderPassCreateInfo.subpasses.back().flags |= VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT;
+
+    renderPassCreateInfo.dependencies.push_back(vkh::SubpassDependency(
+        VK_SUBPASS_EXTERNAL, 0, VK_PIPELINE_STAGE_NONE, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        VK_ACCESS_NONE, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT));
+    renderPassCreateInfo.dependencies.push_back(vkh::SubpassDependency(
+        0, 1, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        VK_ACCESS_COLOR_ATTACHMENT_READ_BIT));
+
+    VkRenderPass msaaRP = createRenderPass(renderPassCreateInfo);
+
+    VkPipelineLayout layout = createPipelineLayout(vkh::PipelineLayoutCreateInfo());
+    vkh::GraphicsPipelineCreateInfo colPipeCreateInfo;
+
+    colPipeCreateInfo.layout = layout;
+    colPipeCreateInfo.renderPass = msaaRP;
+    colPipeCreateInfo.multisampleState.sampleShadingEnable = VK_FALSE;
+    colPipeCreateInfo.multisampleState.rasterizationSamples = VK_SAMPLE_COUNT_4_BIT;
+
+    colPipeCreateInfo.vertexInputState.vertexBindingDescriptions = {vkh::vertexBind(0, DefaultA2V)};
+    colPipeCreateInfo.vertexInputState.vertexAttributeDescriptions = {
+        vkh::vertexAttr(0, 0, DefaultA2V, pos),
+        vkh::vertexAttr(1, 0, DefaultA2V, col),
+        vkh::vertexAttr(2, 0, DefaultA2V, uv),
+    };
+
+    colPipeCreateInfo.stages = {
+        CompileShaderModule(VKDefaultVertex, ShaderLang::glsl, ShaderStage::vert, "main"),
+        CompileShaderModule(VKDefaultPixel, ShaderLang::glsl, ShaderStage::frag, "main"),
+    };
+
+    VkPipeline pipeCol = createGraphicsPipeline(colPipeCreateInfo);
+
+    VkDescriptorSetLayout resSetlayout =
+        createDescriptorSetLayout(vkh::DescriptorSetLayoutCreateInfo({
+            {0, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1, VK_SHADER_STAGE_FRAGMENT_BIT},
+        }));
+    VkDescriptorSet resDescset = allocateDescriptorSet(resSetlayout);
+    VkDescriptorSet dynResDescset = allocateDescriptorSet(resSetlayout);
+
+    VkPipelineLayout resLayout = createPipelineLayout(vkh::PipelineLayoutCreateInfo({resSetlayout}));
+    vkh::GraphicsPipelineCreateInfo resPipeCreateInfo;
+
+    resPipeCreateInfo.layout = resLayout;
+    resPipeCreateInfo.renderPass = msaaRP;
+    resPipeCreateInfo.multisampleState.sampleShadingEnable = VK_FALSE;
+    resPipeCreateInfo.multisampleState.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+    resPipeCreateInfo.inputAssemblyState.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+    resPipeCreateInfo.stages = {
+        CompileShaderModule(VKFullscreenQuadVertex, ShaderLang::glsl, ShaderStage::vert, "main"),
+        CompileShaderModule(resolveShader, ShaderLang::glsl, ShaderStage::frag, "main"),
+    };
+
+    resPipeCreateInfo.subpass = 1;
+    VkPipeline pipeRes = createGraphicsPipeline(resPipeCreateInfo);
+
+    VkPipelineRenderingCreateInfoKHR dynPipeRendInfo = {};
+    dynPipeRendInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR;
+    dynPipeRendInfo.depthAttachmentFormat = VK_FORMAT_UNDEFINED;
+    dynPipeRendInfo.stencilAttachmentFormat = VK_FORMAT_UNDEFINED;
+    VkFormat outFormats[] = {mainWindow->format};
+    dynPipeRendInfo.pColorAttachmentFormats = outFormats;
+    dynPipeRendInfo.colorAttachmentCount = ARRAY_COUNT(outFormats);
+
+    VkCustomResolveCreateInfoEXT customResolveCreateInfo = {};
+    customResolveCreateInfo.sType = VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT;
+    customResolveCreateInfo.depthAttachmentFormat = VK_FORMAT_UNDEFINED;
+    customResolveCreateInfo.stencilAttachmentFormat = VK_FORMAT_UNDEFINED;
+    VkFormat colourFormats[] = {mainWindow->format};
+    customResolveCreateInfo.pColorAttachmentFormats = colourFormats;
+    customResolveCreateInfo.colorAttachmentCount = ARRAY_COUNT(colourFormats);
+    dynPipeRendInfo.pNext = &customResolveCreateInfo;
+
+    colPipeCreateInfo.pNext = &dynPipeRendInfo;
+    colPipeCreateInfo.renderPass = VK_NULL_HANDLE;
+    customResolveCreateInfo.customResolve = VK_FALSE;
+
+    VkPipeline dynColPipe = createGraphicsPipeline(colPipeCreateInfo);
+
+    resPipeCreateInfo.pNext = &dynPipeRendInfo;
+    resPipeCreateInfo.renderPass = VK_NULL_HANDLE;
+    resPipeCreateInfo.subpass = 0;
+    customResolveCreateInfo.customResolve = VK_TRUE;
+
+    VkPipeline dynResPipe = createGraphicsPipeline(resPipeCreateInfo);
+
+    AllocatedImage msaaImg(
+        this,
+        vkh::ImageCreateInfo(mainWindow->scissor.extent.width, mainWindow->scissor.extent.height, 0,
+                             mainWindow->format,
+                             VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
+                             1, 1, VK_SAMPLE_COUNT_4_BIT),
+        VmaAllocationCreateInfo({0, VMA_MEMORY_USAGE_GPU_ONLY}));
+
+    VkImageView msaaRTV = createImageView(
+        vkh::ImageViewCreateInfo(msaaImg.image, VK_IMAGE_VIEW_TYPE_2D, mainWindow->format));
+    setName(msaaImg.image, "MSAA Image");
+
+    AllocatedImage resImg(
+        this,
+        vkh::ImageCreateInfo(mainWindow->scissor.extent.width, mainWindow->scissor.extent.height, 0,
+                             mainWindow->format,
+                             VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                                 VK_IMAGE_USAGE_TRANSFER_DST_BIT),
+        VmaAllocationCreateInfo({0, VMA_MEMORY_USAGE_GPU_ONLY}));
+    setName(resImg.image, "Resolve Image");
+
+    VkImageView resRTV = createImageView(
+        vkh::ImageViewCreateInfo(resImg.image, VK_IMAGE_VIEW_TYPE_2D, mainWindow->format));
+
+    VkRenderingAttachmentInfo colAtt = {
+        VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
+        NULL,
+        msaaRTV,
+        VK_IMAGE_LAYOUT_GENERAL,
+        VK_RESOLVE_MODE_CUSTOM_BIT_EXT,
+        resRTV,
+        VK_IMAGE_LAYOUT_GENERAL,
+        VK_ATTACHMENT_LOAD_OP_CLEAR,
+        VK_ATTACHMENT_STORE_OP_DONT_CARE,
+        vkh::ClearValue(0.6f, 0.2f, 0.2f, 1.0f),
+    };
+
+    VkRenderingInfo dynRendInfo = {
+        VK_STRUCTURE_TYPE_RENDERING_INFO_KHR,
+        NULL,
+        VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT,
+        mainWindow->scissor,
+        1,
+        0,
+        1,
+        &colAtt,
+        NULL,
+        NULL,
+    };
+
+    VkFramebuffer msaaFB = createFramebuffer(vkh::FramebufferCreateInfo(
+        msaaRP, {msaaRTV, resRTV},
+        {mainWindow->scissor.extent.width, mainWindow->scissor.extent.height}));
+
+    AllocatedBuffer vb(
+        this,
+        vkh::BufferCreateInfo(sizeof(DefaultTri),
+                              VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT),
+        VmaAllocationCreateInfo({0, VMA_MEMORY_USAGE_CPU_TO_GPU}));
+
+    vb.upload(DefaultTri);
+
+    vkh::updateDescriptorSets(
+        device,
+        {
+            vkh::WriteDescriptorSet(resDescset, 0, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+                                    {
+                                        vkh::DescriptorImageInfo(msaaRTV, VK_IMAGE_LAYOUT_GENERAL),
+                                    }),
+            vkh::WriteDescriptorSet(dynResDescset, 0, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+                                    {
+                                        vkh::DescriptorImageInfo(msaaRTV, VK_IMAGE_LAYOUT_GENERAL),
+                                    }),
+        });
+
+    while(Running())
+    {
+      VkCommandBuffer cmd = GetCommandBuffer();
+
+      vkBeginCommandBuffer(cmd, vkh::CommandBufferBeginInfo());
+
+      VkImage swapimg = StartUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT,
+                                             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+      pushMarker(cmd, "RenderPass");
+      pushMarker(cmd, "Clear");
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
+                                           VK_IMAGE_LAYOUT_GENERAL, resImg.image),
+               });
+
+      vkCmdClearColorImage(cmd, resImg.image, VK_IMAGE_LAYOUT_GENERAL,
+                           vkh::ClearColorValue(0.5f, 0.0f, 0.0f, 1.0f), 1,
+                           vkh::ImageSubresourceRange());
+
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(
+                       VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+                       VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, resImg.image),
+               });
+
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
+                                           VK_IMAGE_LAYOUT_GENERAL, msaaImg.image),
+               });
+
+      vkCmdClearColorImage(cmd, msaaImg.image, VK_IMAGE_LAYOUT_GENERAL,
+                           vkh::ClearColorValue(0.2f, 0.5f, 0.2f, 1.0f), 1,
+                           vkh::ImageSubresourceRange());
+
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(
+                       VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
+                       VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, msaaImg.image),
+               });
+
+      popMarker(cmd);
+
+      vkCmdBeginRenderPass(cmd, vkh::RenderPassBeginInfo(msaaRP, msaaFB, mainWindow->scissor),
+                           VK_SUBPASS_CONTENTS_INLINE);
+
+      mainWindow->setViewScissor(cmd);
+      vkh::cmdBindVertexBuffers(cmd, 0, {vb.buffer}, {0});
+      vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeCol);
+      setMarker(cmd, "MSAA Draw");
+      vkCmdDraw(cmd, 3, 1, 0, 0);
+      vkCmdNextSubpass(cmd, VK_SUBPASS_CONTENTS_INLINE);
+      vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, resLayout, 0, {resDescset},
+                                 {});
+      vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeRes);
+      setMarker(cmd, "MSAA Resolve");
+      vkCmdDraw(cmd, 4, 1, 0, 0);
+
+      vkCmdEndRenderPass(cmd);
+      popMarker(cmd);
+
+      pushMarker(cmd, "Dynamic");
+      pushMarker(cmd, "Clear");
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
+                                           VK_IMAGE_LAYOUT_GENERAL, resImg.image),
+               });
+
+      vkCmdClearColorImage(cmd, resImg.image, VK_IMAGE_LAYOUT_GENERAL,
+                           vkh::ClearColorValue(0.0f, 0.0f, 0.5f, 1.0f), 1,
+                           vkh::ImageSubresourceRange());
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(
+                       VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                       VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, resImg.image),
+               });
+
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(0, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
+                                           VK_IMAGE_LAYOUT_GENERAL, msaaImg.image),
+               });
+
+      vkCmdClearColorImage(cmd, msaaImg.image, VK_IMAGE_LAYOUT_GENERAL,
+                           vkh::ClearColorValue(0.2f, 0.2f, 0.5f, 1.0f), 1,
+                           vkh::ImageSubresourceRange());
+
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(
+                       VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                       VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, msaaImg.image),
+               });
+
+      popMarker(cmd);
+      vkCmdBeginRendering(cmd, &dynRendInfo);
+      mainWindow->setViewScissor(cmd);
+      vkh::cmdBindVertexBuffers(cmd, 0, {vb.buffer}, {0});
+      vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, dynColPipe);
+      setMarker(cmd, "MSAA Draw");
+      vkCmdDraw(cmd, 3, 1, 0, 0);
+      vkh::cmdPipelineBarrier(
+          cmd,
+          {
+              vkh::ImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                                      VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL,
+                                      VK_IMAGE_LAYOUT_GENERAL, msaaImg.image),
+          },
+          {}, {}, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+          VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_DEPENDENCY_BY_REGION_BIT);
+      vkh::cmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, resLayout, 0,
+                                 {dynResDescset}, {});
+      vkCmdBeginCustomResolveEXT(cmd, NULL);
+      vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, dynResPipe);
+      setMarker(cmd, "MSAA Resolve");
+      vkCmdDraw(cmd, 4, 1, 0, 0);
+      vkCmdEndRendering(cmd);
+      popMarker(cmd);
+
+      vkh::cmdPipelineBarrier(
+          cmd, {
+                   vkh::ImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 0,
+                                           VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
+                                           msaaImg.image),
+               });
+      vkh::cmdPipelineBarrier(
+          cmd,
+          {vkh::ImageMemoryBarrier(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+                                   VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, resImg.image)});
+
+      blitToSwap(cmd, resImg.image, VK_IMAGE_LAYOUT_GENERAL, swapimg,
+                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+      FinishUsingBackbuffer(cmd, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+
+      vkEndCommandBuffer(cmd);
+
+      Submit(0, 1, {cmd});
+
+      Present();
+    }
+
+    return 0;
+  }
+};
+
+REGISTER_TEST();
@@ -0,0 +1,183 @@
+import renderdoc as rd
+import rdtest
+import rdtest.util
+
+class VK_Custom_Resolve(rdtest.TestCase):
+    demos_test_name = 'VK_Custom_Resolve'
+
+    def check_triangle_draw(self):
+        pipe: rd.PipeState = self.controller.GetPipelineState()
+        out = pipe.GetOutputTargets()[0].resource
+        # centre
+        green = [0.0, 1.0, 0.0, 1.0]
+        self.check_pixel_value(out, 200, 150, green)
+
+    def check_triangle_resolve(self):
+        pipe: rd.PipeState = self.controller.GetPipelineState()
+        out = pipe.GetOutputTargets()[0].resource
+        # left triangle edge
+        left = [0.0, 0.0, 1.0, 1.0]
+        self.check_pixel_value(out, 150, 149, left)
+        # right triangle edge
+        right = [1.0, 0.0, 0.0, 1.0]
+        self.check_pixel_value(out, 249, 149, right)
+        # centre
+        centre = [0.0, 0.25, 0.0, 1.0]
+        self.check_pixel_value(out, 200, 150, centre)
+
+    def check_resource_usage(self, markerName, expectedUsages=[]):
+        action = self.find_action(markerName)
+        self.controller.SetFrameEvent(action.eventId+1, True)
+        pipe: rd.PipeState = self.controller.GetPipelineState()
+        out = pipe.GetOutputTargets()[0].resource
+        usages = self.controller.GetUsage(out)
+        if len(usages) != len(expectedUsages):
+            raise rdtest.TestFailureException(f"Incorrect resource usages count expected:{len(expectedUsages)} actual:{len(usages)}")
+        for i, u in enumerate(usages):
+            if u.usage != expectedUsages[i]:
+                raise rdtest.TestFailureException(f"EID:{u.eventId} Incorrect resource usage expected:{expectedUsages[i].name} actual:{u.usage.name}")
+
+# add shader out values to check also
+    def check_pixel_history(self, passed, shaderOut, preMod, postMod):
+        pipe: rd.PipeState = self.controller.GetPipelineState()
+        rt = pipe.GetOutputTargets()[0]
+        tex = rt.resource
+        sub = rd.Subresource()
+        x = 200
+        y = 150
+        modifs = self.controller.PixelHistory(tex, x, y, sub, rt.format.compType)
+        if len(modifs) != len(passed):
+            raise rdtest.TestFailureException(f"Pixel history incorrect modifications count expected:{len(passed)} actual:{len(modifs)}")
+        for i, m in enumerate(modifs):
+            if m.Passed() != passed[i]:
+                raise rdtest.TestFailureException(f"EID:{m.eventId} Pixel history incorrect passed expected:{passed[i]} actual:{m.Passed()}")
+            if m.shaderOut.IsValid() != shaderOut[i]:
+                raise rdtest.TestFailureException(f"EID:{m.eventId} Pixel history incorrect shader output expected:{shaderOut[i]} actual:{m.shaderOut.IsValid()}")
+            if m.shaderOut.IsValid():
+                if not rdtest.util.value_compare(m.preMod.col.floatValue, preMod[i], eps=1.0/255.0):
+                    raise rdtest.TestFailureException(f"EID:{m.eventId} Pixel history incorrect pre mod expected:{preMod[i]} actual:{m.preMod.col.floatValue}")
+                if not rdtest.util.value_compare(m.postMod.col.floatValue, postMod[i], eps=1.0/255.0):
+                    raise rdtest.TestFailureException(f"EID:{m.eventId} Pixel history incorrect post mod expected:{postMod[i]} actual:{m.postMod.col.floatValue}")
+        rdtest.log.success(f"Pixel History Worked {len(modifs)} modifications found")
+
+    def check_capture(self):
+        markers = ["MSAA Draw", "MSAA Resolve"]
+        msaaTargetUsages = [
+            # RenderPass 
+            # Clear
+            rd.ResourceUsage.Barrier, 
+            rd.ResourceUsage.Discard, 
+            rd.ResourceUsage.Clear, 
+            rd.ResourceUsage.Barrier, 
+            # Draw
+            rd.ResourceUsage.ColorTarget, 
+            # Resolve Draw
+            rd.ResourceUsage.InputTarget,
+            # EndRenderPass
+            rd.ResourceUsage.Discard,
+            # Dynamic
+            # Clear
+            rd.ResourceUsage.Barrier,
+            rd.ResourceUsage.Discard,
+            rd.ResourceUsage.Clear,
+            rd.ResourceUsage.Barrier,
+            # BeginRendering
+            rd.ResourceUsage.Clear,
+            # Draw
+            rd.ResourceUsage.ColorTarget,
+            rd.ResourceUsage.Barrier,
+            # Resolve Draw
+            rd.ResourceUsage.InputTarget,
+            rd.ResourceUsage.Barrier, 
+            ]
+
+        msaaResolveUsages = [
+            # RenderPass 
+            # Clear
+            rd.ResourceUsage.Barrier, 
+            rd.ResourceUsage.Discard, 
+            rd.ResourceUsage.Clear, 
+            rd.ResourceUsage.Barrier, 
+            # BeginRenderPass
+            rd.ResourceUsage.Discard, 
+            # Resolve Draw
+            rd.ResourceUsage.ResolveDst, 
+
+            # Dynamic
+            # Clear
+            rd.ResourceUsage.Barrier,
+            rd.ResourceUsage.Discard,
+            rd.ResourceUsage.Clear,
+            rd.ResourceUsage.Barrier, 
+            # BeginCustomResolve
+            rd.ResourceUsage.Discard,
+            # Resolve Draw
+            rd.ResourceUsage.ResolveDst, 
+            # BlitImage
+            rd.ResourceUsage.Barrier, 
+            rd.ResourceUsage.ResolveSrc,
+            ]
+        usages = {}
+        usages["MSAA Draw"] = msaaTargetUsages
+        usages["MSAA Resolve"] = msaaResolveUsages
+        for marker in markers:
+            with rdtest.log.auto_section(marker):
+                self.check_resource_usage(marker,usages[marker])
+
+        sections = ["RenderPass", "Dynamic"]
+        for sectionName in sections:
+            with rdtest.log.auto_section(sectionName):
+                with rdtest.log.auto_section("MSAA Draw"):
+                    action = self.find_action(sectionName) 
+                    action = self.find_action("MSAA Draw", action.eventId)
+                    rdtest.log.print(f'MSAA Draw: {self.action_name(action)} EID:{action.eventId}')
+                    self.controller.SetFrameEvent(action.eventId+1, True)
+                    self.check_triangle_draw()
+                    self.check_debug_pixel(200, 150)
+                    # Clear : Draw
+                    countMods = 2
+                    # clear: 0.2,0.5,0.2,1
+                    # draw: unknown
+                    passed = [True, True]
+                    shaderOut = [True, False]
+                    preMod = [(0.0,0.0,0.0,0.0), (0,0,0,0)]
+                    postMod = [(0.2,0.5,0.2,1), (0,0,0,0)]
+                    if sectionName == "Dynamic":
+                        # Clear : BeginRendering : Draw
+                        countMods += 3 
+                        # clear 0.2,0.2,0.5,1
+                        # begin: rendering 0.6,0.2,0.2,1
+                        # draw: 0,1,0.1
+                        passed += [True, True, True]
+                        shaderOut += [True, True, True]
+                        preMod += [(0.0,0.0,0.0,0.0), (0.2,0.2,0.5,1), (0.6,0.2,0.2,1)]
+                        postMod += [(0.2,0.2,0.5,1), (0.6,0.2,0.2,1), (0,1,0,1)]
+                    self.check_pixel_history(passed, shaderOut, preMod, postMod)
+
+                with rdtest.log.auto_section("MSAA Resolve"):
+                    action = self.find_action(sectionName) 
+                    action = self.find_action("MSAA Resolve", action.eventId)
+                    rdtest.log.print(f'MSAA Resolve: {self.action_name(action)} EID:{action.eventId}')
+                    self.controller.SetFrameEvent(action.eventId+1, True)
+                    self.check_triangle_resolve()
+                    self.check_debug_pixel(200, 150)
+                    self.check_debug_pixel(150, 149)
+                    self.check_debug_pixel(249, 149)
+                    # Clear : Draw
+                    countMods = 2
+                    # clear 0.5,0,0,1
+                    # draw unknown
+                    passed = [True, True]
+                    shaderOut = [True, False]
+                    preMod = [(0.0,0.0,0.0,0.0), (0,0,0,0)]
+                    postMod = [(0.5,0.0,0.0,1), (0,0,0,0)]
+                    if sectionName == "Dynamic":
+                        # Clear : Draw
+                        countMods = 4
+                        # clear 0.0,0.0,0.5,1
+                        # draw: 0,0.25,0.1
+                        passed += [True, True]
+                        shaderOut += [True, True]
+                        preMod += [(0.0,0.0,0.0,0), (0.0,0.0,0.0,0)]
+                        postMod += [(0.0,0.0,0.5,1), (0,0.25,0,1)]
+                    self.check_pixel_history(passed, shaderOut, preMod, postMod)