diff --git a/util/test/demos/CMakeLists.txt b/util/test/demos/CMakeLists.txt
index 9f909d652..1e4ecbd03 100644
--- a/util/test/demos/CMakeLists.txt
+++ b/util/test/demos/CMakeLists.txt
@@ -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
diff --git a/util/test/demos/demos.vcxproj b/util/test/demos/demos.vcxproj
index ef70081a3..4097f502c 100644
--- a/util/test/demos/demos.vcxproj
+++ b/util/test/demos/demos.vcxproj
@@ -333,6 +333,7 @@
+
diff --git a/util/test/demos/demos.vcxproj.filters b/util/test/demos/demos.vcxproj.filters
index 09dfebe5f..30c0f7734 100644
--- a/util/test/demos/demos.vcxproj.filters
+++ b/util/test/demos/demos.vcxproj.filters
@@ -757,6 +757,9 @@
D3D12\demos
+
+ Vulkan\demos
+
diff --git a/util/test/demos/vk/vk_custom_resolve.cpp b/util/test/demos/vk/vk_custom_resolve.cpp
new file mode 100644
index 000000000..5f889846f
--- /dev/null
+++ b/util/test/demos/vk/vk_custom_resolve.cpp
@@ -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();
diff --git a/util/test/tests/Vulkan/VK_Custom_Resolve.py b/util/test/tests/Vulkan/VK_Custom_Resolve.py
new file mode 100644
index 000000000..9780cbe95
--- /dev/null
+++ b/util/test/tests/Vulkan/VK_Custom_Resolve.py
@@ -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)