Enable support for vulkan 1.4. Closes #3625

renderdoc/driver/vulkan/renderdoc.json

@@ -4,7 +4,7 @@
     "name": "VK_LAYER_RENDERDOC_Capture",
     "type": "GLOBAL",
     "library_path": "@VULKAN_LAYER_MODULE_PATH@",
-    "api_version": "1.3.131",
+    "api_version": "1.4.324",
     "implementation_version": "@RENDERDOC_VERSION_MINOR@",
     "description": "Debugging capture layer for RenderDoc",
     "functions": {

renderdoc/driver/vulkan/vk_common.cpp

@@ -1816,7 +1816,7 @@ void DynamicRenderingLocalRead::SetLocations(VkCommandBuffer cmd)
   attachmentLocations.colorAttachmentCount = colorAttachmentLocations.count();
   attachmentLocations.pColorAttachmentLocations = colorAttachmentLocations.data();
 
-  ObjDisp(cmd)->CmdSetRenderingAttachmentLocationsKHR(Unwrap(cmd), &attachmentLocations);
+  ObjDisp(cmd)->CmdSetRenderingAttachmentLocations(Unwrap(cmd), &attachmentLocations);
 }
 
 void DynamicRenderingLocalRead::SetInputIndices(VkCommandBuffer cmd)
@@ -1830,7 +1830,7 @@ void DynamicRenderingLocalRead::SetInputIndices(VkCommandBuffer cmd)
   inputIndices.pStencilInputAttachmentIndex =
       isStencilInputAttachmentIndexImplicit ? NULL : &stencilInputAttachmentIndex;
 
-  ObjDisp(cmd)->CmdSetRenderingInputAttachmentIndicesKHR(Unwrap(cmd), &inputIndices);
+  ObjDisp(cmd)->CmdSetRenderingInputAttachmentIndices(Unwrap(cmd), &inputIndices);
 }
 
 #if ENABLED(ENABLE_UNIT_TESTS)

renderdoc/driver/vulkan/vk_common.h

@@ -1266,8 +1266,8 @@ enum class VulkanChunk : uint32_t
   vkRegisterDeviceEventEXT,
   vkRegisterDisplayEventEXT,
   vkCmdIndirectSubCommand,
-  vkCmdPushDescriptorSetKHR,
-  vkCmdPushDescriptorSetWithTemplateKHR,
+  vkCmdPushDescriptorSet,
+  vkCmdPushDescriptorSetWithTemplate,
   vkCreateDescriptorUpdateTemplate,
   vkUpdateDescriptorSetWithTemplate,
   vkBindBufferMemory2,
@@ -1303,7 +1303,7 @@ enum class VulkanChunk : uint32_t
   DeviceMemoryRefs,
   vkResetQueryPool,
   ImageRefs,
-  vkCmdSetLineStippleKHR,
+  vkCmdSetLineStipple,
   vkGetSemaphoreCounterValue,
   vkWaitSemaphores,
   vkSignalSemaphore,
@@ -1381,11 +1381,11 @@ enum class VulkanChunk : uint32_t
   vkCmdTraceRaysIndirectKHR,
   vkCmdTraceRaysKHR,
   vkCreateRayTracingPipelinesKHR,
-  vkCmdSetRenderingAttachmentLocationsKHR,
-  vkCmdSetRenderingInputAttachmentIndicesKHR,
+  vkCmdSetRenderingAttachmentLocations,
+  vkCmdSetRenderingInputAttachmentIndices,
   vkCmdTraceRaysIndirect2KHR,
   vkCmdWriteAccelerationStructuresPropertiesKHR,
-  vkCmdBindIndexBuffer2KHR,
+  vkCmdBindIndexBuffer2,
   vkGetDescriptorEXT,
   vkCmdBindDescriptorBuffersEXT,
   vkCmdSetDescriptorBufferOffsetsEXT,
@@ -1394,13 +1394,13 @@ enum class VulkanChunk : uint32_t
   vkCopyImageToMemory,
   vkCopyMemoryToImage,
   vkTransitionImageLayout,
-  vkUnmapMemory2KHR,
-  vkCmdBindDescriptorSets2KHR,
-  vkCmdPushConstants2KHR,
+  vkUnmapMemory2,
+  vkCmdBindDescriptorSets2,
+  vkCmdPushConstants2,
   vkCmdBindDescriptorBufferEmbeddedSamplers2EXT,
   vkCmdSetDescriptorBufferOffsets2EXT,
-  vkCmdPushDescriptorSet2KHR,
-  vkCmdPushDescriptorSetWithTemplate2KHR,
+  vkCmdPushDescriptorSet2,
+  vkCmdPushDescriptorSetWithTemplate2,
   Max,
 };
 
@@ -1472,12 +1472,12 @@ DECLARE_REFLECTION_STRUCT(VkAttachmentSampleLocationsEXT);
 DECLARE_REFLECTION_STRUCT(VkBindBufferMemoryDeviceGroupInfo);
 DECLARE_REFLECTION_STRUCT(VkBindBufferMemoryInfo);
 DECLARE_REFLECTION_STRUCT(VkBindDescriptorBufferEmbeddedSamplersInfoEXT)
-DECLARE_REFLECTION_STRUCT(VkBindDescriptorSetsInfoKHR)
+DECLARE_REFLECTION_STRUCT(VkBindDescriptorSetsInfo)
 DECLARE_REFLECTION_STRUCT(VkBindImageMemoryDeviceGroupInfo);
 DECLARE_REFLECTION_STRUCT(VkBindImageMemoryInfo);
 DECLARE_REFLECTION_STRUCT(VkBindImageMemorySwapchainInfoKHR);
 DECLARE_REFLECTION_STRUCT(VkBindImagePlaneMemoryInfo);
-DECLARE_REFLECTION_STRUCT(VkBindMemoryStatusKHR)
+DECLARE_REFLECTION_STRUCT(VkBindMemoryStatus)
 DECLARE_REFLECTION_STRUCT(VkBindSparseInfo);
 DECLARE_REFLECTION_STRUCT(VkBlitImageInfo2);
 DECLARE_REFLECTION_STRUCT(VkBufferCaptureDescriptorDataInfoEXT);
@@ -1692,8 +1692,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFloatControlsProperties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR);
@@ -1730,8 +1730,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance4Features);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance4Properties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance5Features);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance5Properties);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance6FeaturesKHR);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance6PropertiesKHR);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance6Features);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance6Properties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance7FeaturesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance7PropertiesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceMaintenance8FeaturesKHR);
@@ -1756,8 +1756,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePerformanceQueryPropertiesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePipelineCreationCacheControlFeatures);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePipelineProtectedAccessFeatures);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePipelineRobustnessFeaturesEXT);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePipelineRobustnessPropertiesEXT);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePipelineRobustnessFeatures);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePipelineRobustnessProperties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePointClippingProperties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePresentId2FeaturesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDevicePresentIdFeaturesKHR);
@@ -1780,8 +1780,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRayTracingPipelineFeaturesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRayTracingPipelinePropertiesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRobustness2FeaturesEXT);
-DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRobustness2PropertiesEXT);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRobustness2FeaturesKHR);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceRobustness2PropertiesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceSampleLocationsPropertiesEXT);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceSamplerFilterMinmaxProperties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceSamplerYcbcrConversionFeatures);
@@ -1839,6 +1839,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan12Features);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan12Properties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan13Features);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan13Properties);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan14Features);
+DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkan14Properties);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceVulkanMemoryModelFeatures);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
 DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT);
@@ -1888,9 +1890,9 @@ DECLARE_REFLECTION_STRUCT(VkPresentTimesInfoGOOGLE);
 DECLARE_REFLECTION_STRUCT(VkPresentWait2InfoKHR);
 DECLARE_REFLECTION_STRUCT(VkPrivateDataSlotCreateInfo);
 DECLARE_REFLECTION_STRUCT(VkProtectedSubmitInfo);
-DECLARE_REFLECTION_STRUCT(VkPushConstantsInfoKHR)
-DECLARE_REFLECTION_STRUCT(VkPushDescriptorSetInfoKHR)
-DECLARE_REFLECTION_STRUCT(VkPushDescriptorSetWithTemplateInfoKHR)
+DECLARE_REFLECTION_STRUCT(VkPushConstantsInfo)
+DECLARE_REFLECTION_STRUCT(VkPushDescriptorSetInfo)
+DECLARE_REFLECTION_STRUCT(VkPushDescriptorSetWithTemplateInfo)
 DECLARE_REFLECTION_STRUCT(VkQueryPoolCreateInfo);
 DECLARE_REFLECTION_STRUCT(VkQueryPoolPerformanceCreateInfoKHR);
 DECLARE_REFLECTION_STRUCT(VkQueueFamilyGlobalPriorityProperties);
@@ -1913,6 +1915,7 @@ DECLARE_REFLECTION_STRUCT(VkRenderPassBeginInfo);
 DECLARE_REFLECTION_STRUCT(VkRenderPassCreateInfo);
 DECLARE_REFLECTION_STRUCT(VkRenderPassCreateInfo2);
 DECLARE_REFLECTION_STRUCT(VkRenderPassFragmentDensityMapCreateInfoEXT);
+DECLARE_REFLECTION_STRUCT(VkRenderPassFragmentDensityMapOffsetEndInfoEXT);
 DECLARE_REFLECTION_STRUCT(VkRenderPassInputAttachmentAspectCreateInfo);
 DECLARE_REFLECTION_STRUCT(VkRenderPassMultiviewCreateInfo);
 DECLARE_REFLECTION_STRUCT(VkRenderPassSampleLocationsBeginInfoEXT);
@@ -1946,7 +1949,6 @@ DECLARE_REFLECTION_STRUCT(VkSubpassDependency2);
 DECLARE_REFLECTION_STRUCT(VkSubpassDescription2);
 DECLARE_REFLECTION_STRUCT(VkSubpassDescriptionDepthStencilResolve);
 DECLARE_REFLECTION_STRUCT(VkSubpassEndInfo);
-DECLARE_REFLECTION_STRUCT(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
 DECLARE_REFLECTION_STRUCT(VkSubpassResolvePerformanceQueryEXT);
 DECLARE_REFLECTION_STRUCT(VkSubpassSampleLocationsEXT);
 DECLARE_REFLECTION_STRUCT(VkSubresourceHostMemcpySize);
@@ -2000,12 +2002,12 @@ DECLARE_DESERIALISE_TYPE(VkAttachmentSampleLocationsEXT);
 DECLARE_DESERIALISE_TYPE(VkBindBufferMemoryDeviceGroupInfo);
 DECLARE_DESERIALISE_TYPE(VkBindBufferMemoryInfo);
 DECLARE_DESERIALISE_TYPE(VkBindDescriptorBufferEmbeddedSamplersInfoEXT)
-DECLARE_DESERIALISE_TYPE(VkBindDescriptorSetsInfoKHR)
+DECLARE_DESERIALISE_TYPE(VkBindDescriptorSetsInfo)
 DECLARE_DESERIALISE_TYPE(VkBindImageMemoryDeviceGroupInfo);
 DECLARE_DESERIALISE_TYPE(VkBindImageMemoryInfo);
 DECLARE_DESERIALISE_TYPE(VkBindImageMemorySwapchainInfoKHR);
 DECLARE_DESERIALISE_TYPE(VkBindImagePlaneMemoryInfo);
-DECLARE_DESERIALISE_TYPE(VkBindMemoryStatusKHR)
+DECLARE_DESERIALISE_TYPE(VkBindMemoryStatus)
 DECLARE_DESERIALISE_TYPE(VkBindSparseInfo);
 DECLARE_DESERIALISE_TYPE(VkBlitImageInfo2);
 DECLARE_DESERIALISE_TYPE(VkBufferCaptureDescriptorDataInfoEXT);
@@ -2214,8 +2216,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFloatControlsProperties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR);
@@ -2252,8 +2254,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance4Features);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance4Properties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance5Features);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance5Properties);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance6FeaturesKHR);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance6PropertiesKHR);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance6Features);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance6Properties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance7FeaturesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance7PropertiesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceMaintenance8FeaturesKHR);
@@ -2278,8 +2280,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePerformanceQueryPropertiesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePipelineCreationCacheControlFeatures);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePipelineProtectedAccessFeatures);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePipelineRobustnessFeaturesEXT);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePipelineRobustnessPropertiesEXT);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePipelineRobustnessFeatures);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePipelineRobustnessProperties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePointClippingProperties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePresentId2FeaturesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDevicePresentIdFeaturesKHR);
@@ -2302,8 +2304,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRayTracingPipelineFeaturesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRayTracingPipelinePropertiesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRobustness2FeaturesEXT);
-DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRobustness2PropertiesEXT);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRobustness2FeaturesKHR);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceRobustness2PropertiesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceSampleLocationsPropertiesEXT);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceSamplerFilterMinmaxProperties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceSamplerYcbcrConversionFeatures);
@@ -2361,6 +2363,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan12Features);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan12Properties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan13Features);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan13Properties);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan14Features);
+DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkan14Properties);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceVulkanMemoryModelFeatures);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
 DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT);
@@ -2409,9 +2413,9 @@ DECLARE_DESERIALISE_TYPE(VkPresentTimesInfoGOOGLE);
 DECLARE_DESERIALISE_TYPE(VkPresentWait2InfoKHR);
 DECLARE_DESERIALISE_TYPE(VkPrivateDataSlotCreateInfo);
 DECLARE_DESERIALISE_TYPE(VkProtectedSubmitInfo);
-DECLARE_DESERIALISE_TYPE(VkPushConstantsInfoKHR)
-DECLARE_DESERIALISE_TYPE(VkPushDescriptorSetInfoKHR)
-DECLARE_DESERIALISE_TYPE(VkPushDescriptorSetWithTemplateInfoKHR)
+DECLARE_DESERIALISE_TYPE(VkPushConstantsInfo)
+DECLARE_DESERIALISE_TYPE(VkPushDescriptorSetInfo)
+DECLARE_DESERIALISE_TYPE(VkPushDescriptorSetWithTemplateInfo)
 DECLARE_DESERIALISE_TYPE(VkQueryPoolCreateInfo);
 DECLARE_DESERIALISE_TYPE(VkQueryPoolPerformanceCreateInfoKHR);
 DECLARE_DESERIALISE_TYPE(VkQueueFamilyGlobalPriorityProperties);
@@ -2432,6 +2436,8 @@ DECLARE_DESERIALISE_TYPE(VkRenderPassAttachmentBeginInfo);
 DECLARE_DESERIALISE_TYPE(VkRenderPassBeginInfo);
 DECLARE_DESERIALISE_TYPE(VkRenderPassCreateInfo);
 DECLARE_DESERIALISE_TYPE(VkRenderPassCreateInfo2);
+DECLARE_DESERIALISE_TYPE(VkRenderPassFragmentDensityMapCreateInfoEXT);
+DECLARE_DESERIALISE_TYPE(VkRenderPassFragmentDensityMapOffsetEndInfoEXT);
 DECLARE_DESERIALISE_TYPE(VkRenderPassInputAttachmentAspectCreateInfo);
 DECLARE_DESERIALISE_TYPE(VkRenderPassMultiviewCreateInfo);
 DECLARE_DESERIALISE_TYPE(VkRenderPassSampleLocationsBeginInfoEXT);
@@ -2465,7 +2471,6 @@ DECLARE_DESERIALISE_TYPE(VkSubpassDependency2);
 DECLARE_DESERIALISE_TYPE(VkSubpassDescription2);
 DECLARE_DESERIALISE_TYPE(VkSubpassDescriptionDepthStencilResolve);
 DECLARE_DESERIALISE_TYPE(VkSubpassEndInfo);
-DECLARE_DESERIALISE_TYPE(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
 DECLARE_DESERIALISE_TYPE(VkSubpassResolvePerformanceQueryEXT);
 DECLARE_DESERIALISE_TYPE(VkSubpassSampleLocationsEXT);
 DECLARE_DESERIALISE_TYPE(VkSubresourceHostMemcpySize);

renderdoc/driver/vulkan/vk_core.cpp

@@ -4398,13 +4398,13 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk)
       // Just in case it gets exported and imported, completely ignore it.
       return true;
 
-    case VulkanChunk::vkCmdPushDescriptorSetKHR:
-      return Serialise_vkCmdPushDescriptorSetKHR(
-          ser, VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_GRAPHICS, VK_NULL_HANDLE, 0, 0, NULL);
+    case VulkanChunk::vkCmdPushDescriptorSet:
+      return Serialise_vkCmdPushDescriptorSet(ser, VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                              VK_NULL_HANDLE, 0, 0, NULL);
 
-    case VulkanChunk::vkCmdPushDescriptorSetWithTemplateKHR:
-      return Serialise_vkCmdPushDescriptorSetWithTemplateKHR(ser, VK_NULL_HANDLE, VK_NULL_HANDLE,
-                                                             VK_NULL_HANDLE, 0, NULL);
+    case VulkanChunk::vkCmdPushDescriptorSetWithTemplate:
+      return Serialise_vkCmdPushDescriptorSetWithTemplate(ser, VK_NULL_HANDLE, VK_NULL_HANDLE,
+                                                          VK_NULL_HANDLE, 0, NULL);
 
     case VulkanChunk::vkCreateDescriptorUpdateTemplate:
       return Serialise_vkCreateDescriptorUpdateTemplate(ser, VK_NULL_HANDLE, NULL, NULL, NULL);
@@ -4491,17 +4491,17 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk)
       return GetResourceManager()->Serialise_DeviceMemoryRefs(ser, data);
     }
     case VulkanChunk::vkCopyImageToImage:
-      return Serialise_vkCopyImageToImageEXT(ser, VK_NULL_HANDLE, NULL);
+      return Serialise_vkCopyImageToImage(ser, VK_NULL_HANDLE, NULL);
     case VulkanChunk::vkCopyImageToMemory:
-      return Serialise_vkCopyImageToMemoryEXT(ser, VK_NULL_HANDLE, NULL);
+      return Serialise_vkCopyImageToMemory(ser, VK_NULL_HANDLE, NULL);
     case VulkanChunk::vkCopyMemoryToImage:
-      return Serialise_vkCopyMemoryToImageEXT(ser, VK_NULL_HANDLE, NULL);
+      return Serialise_vkCopyMemoryToImage(ser, VK_NULL_HANDLE, NULL);
     case VulkanChunk::vkTransitionImageLayout:
-      return Serialise_vkTransitionImageLayoutEXT(ser, VK_NULL_HANDLE, 0, NULL);
+      return Serialise_vkTransitionImageLayout(ser, VK_NULL_HANDLE, 0, NULL);
     case VulkanChunk::vkResetQueryPool:
       return Serialise_vkResetQueryPool(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0);
-    case VulkanChunk::vkCmdSetLineStippleKHR:
-      return Serialise_vkCmdSetLineStippleKHR(ser, VK_NULL_HANDLE, 0, 0);
+    case VulkanChunk::vkCmdSetLineStipple:
+      return Serialise_vkCmdSetLineStipple(ser, VK_NULL_HANDLE, 0, 0);
     case VulkanChunk::ImageRefs:
     {
       SCOPED_LOCK(m_ImageStatesLock);
@@ -4591,10 +4591,10 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk)
     case VulkanChunk::vkCmdBeginRendering:
       return Serialise_vkCmdBeginRendering(ser, VK_NULL_HANDLE, NULL);
     case VulkanChunk::vkCmdEndRendering: return Serialise_vkCmdEndRendering(ser, VK_NULL_HANDLE);
-    case VulkanChunk::vkCmdSetRenderingAttachmentLocationsKHR:
-      return Serialise_vkCmdSetRenderingAttachmentLocationsKHR(ser, VK_NULL_HANDLE, NULL);
-    case VulkanChunk::vkCmdSetRenderingInputAttachmentIndicesKHR:
-      return Serialise_vkCmdSetRenderingInputAttachmentIndicesKHR(ser, VK_NULL_HANDLE, NULL);
+    case VulkanChunk::vkCmdSetRenderingAttachmentLocations:
+      return Serialise_vkCmdSetRenderingAttachmentLocations(ser, VK_NULL_HANDLE, NULL);
+    case VulkanChunk::vkCmdSetRenderingInputAttachmentIndices:
+      return Serialise_vkCmdSetRenderingInputAttachmentIndices(ser, VK_NULL_HANDLE, NULL);
 
     case VulkanChunk::vkCmdSetFragmentShadingRateKHR:
       return Serialise_vkCmdSetFragmentShadingRateKHR(ser, VK_NULL_HANDLE, NULL, NULL);
@@ -4703,25 +4703,25 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk)
     case VulkanChunk::vkCmdWriteAccelerationStructuresPropertiesKHR:
       return Serialise_vkCmdWriteAccelerationStructuresPropertiesKHR(
           ser, VK_NULL_HANDLE, 0, NULL, VK_QUERY_TYPE_MAX_ENUM, VK_NULL_HANDLE, 0);
-    case VulkanChunk::vkCmdBindIndexBuffer2KHR:
-      return Serialise_vkCmdBindIndexBuffer2KHR(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0,
-                                                VK_INDEX_TYPE_MAX_ENUM);
+    case VulkanChunk::vkCmdBindIndexBuffer2:
+      return Serialise_vkCmdBindIndexBuffer2(ser, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0,
+                                             VK_INDEX_TYPE_MAX_ENUM);
 
-    case VulkanChunk::vkUnmapMemory2KHR:
-      return Serialise_vkUnmapMemory2KHR(ser, VK_NULL_HANDLE, VK_NULL_HANDLE);
+    case VulkanChunk::vkUnmapMemory2:
+      return Serialise_vkUnmapMemory2(ser, VK_NULL_HANDLE, VK_NULL_HANDLE);
 
-    case VulkanChunk::vkCmdBindDescriptorSets2KHR:
-      return Serialise_vkCmdBindDescriptorSets2KHR(ser, VK_NULL_HANDLE, NULL);
-    case VulkanChunk::vkCmdPushConstants2KHR:
-      return Serialise_vkCmdPushConstants2KHR(ser, VK_NULL_HANDLE, NULL);
+    case VulkanChunk::vkCmdBindDescriptorSets2:
+      return Serialise_vkCmdBindDescriptorSets2(ser, VK_NULL_HANDLE, NULL);
+    case VulkanChunk::vkCmdPushConstants2:
+      return Serialise_vkCmdPushConstants2(ser, VK_NULL_HANDLE, NULL);
     case VulkanChunk::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT:
       return Serialise_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(ser, VK_NULL_HANDLE, NULL);
     case VulkanChunk::vkCmdSetDescriptorBufferOffsets2EXT:
       return Serialise_vkCmdSetDescriptorBufferOffsets2EXT(ser, VK_NULL_HANDLE, NULL);
-    case VulkanChunk::vkCmdPushDescriptorSet2KHR:
-      return Serialise_vkCmdPushDescriptorSet2KHR(ser, VK_NULL_HANDLE, NULL);
-    case VulkanChunk::vkCmdPushDescriptorSetWithTemplate2KHR:
-      return Serialise_vkCmdPushDescriptorSetWithTemplate2KHR(ser, VK_NULL_HANDLE, NULL);
+    case VulkanChunk::vkCmdPushDescriptorSet2:
+      return Serialise_vkCmdPushDescriptorSet2(ser, VK_NULL_HANDLE, NULL);
+    case VulkanChunk::vkCmdPushDescriptorSetWithTemplate2:
+      return Serialise_vkCmdPushDescriptorSetWithTemplate2(ser, VK_NULL_HANDLE, NULL);
 
     // chunks that are reserved but not yet serialised
     case VulkanChunk::vkResetCommandPool:

renderdoc/driver/vulkan/vk_core.h

@@ -2443,12 +2443,12 @@ public:
                                  uint32_t set, uint32_t descriptorWriteCount,
                                  const VkWriteDescriptorSet *pDescriptorWrites);
 
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSetKHR, VkCommandBuffer commandBuffer,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSet, VkCommandBuffer commandBuffer,
                                 VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
                                 uint32_t set, uint32_t descriptorWriteCount,
                                 const VkWriteDescriptorSet *pDescriptorWrites);
 
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSetWithTemplateKHR,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSetWithTemplate,
                                 VkCommandBuffer commandBuffer,
                                 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
                                 VkPipelineLayout layout, uint32_t set, const void *pData);
@@ -2698,13 +2698,13 @@ public:
 
   // VK_EXT_host_image_copy
 
-  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCopyImageToImageEXT, VkDevice device,
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCopyImageToImage, VkDevice device,
                                 const VkCopyImageToImageInfo *pCopyImageToImageInfo);
-  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCopyImageToMemoryEXT, VkDevice device,
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCopyImageToMemory, VkDevice device,
                                 const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo);
-  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCopyMemoryToImageEXT, VkDevice device,
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCopyMemoryToImage, VkDevice device,
                                 const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo);
-  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkTransitionImageLayoutEXT, VkDevice device,
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkTransitionImageLayout, VkDevice device,
                                 uint32_t transitionCount,
                                 const VkHostImageLayoutTransitionInfo *pTransitions);
 
@@ -2772,7 +2772,7 @@ public:
 
   // VK_KHR_line_rasterization
 
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetLineStippleKHR, VkCommandBuffer commandBuffer,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetLineStipple, VkCommandBuffer commandBuffer,
                                 uint32_t lineStippleFactor, uint16_t lineStipplePattern);
 
   // VK_GOOGLE_display_timing
@@ -2970,10 +2970,10 @@ public:
 
   // VK_KHR_dynamic_rendering_local_read
 
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetRenderingAttachmentLocationsKHR,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetRenderingAttachmentLocations,
                                 VkCommandBuffer commandBuffer,
                                 const VkRenderingAttachmentLocationInfo *pLocationInfo);
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetRenderingInputAttachmentIndicesKHR,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetRenderingInputAttachmentIndices,
                                 VkCommandBuffer commandBuffer,
                                 const VkRenderingInputAttachmentIndexInfo *pLocationInfo);
 
@@ -3000,7 +3000,7 @@ public:
 
   // VK_EXT_swapchain_maintenance1
   VkResult vkReleaseSwapchainImagesEXT(VkDevice device,
-                                       const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo);
+                                       const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo);
 
   // VK_KHR_swapchain_maintenance1
   VkResult vkReleaseSwapchainImagesKHR(VkDevice device,
@@ -3215,18 +3215,16 @@ public:
                                 VkDeviceAddress indirectDeviceAddress);
 
   // VK_KHR_maintenance5
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer2KHR, VkCommandBuffer commandBuffer,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer2, VkCommandBuffer commandBuffer,
                                 VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
                                 VkIndexType indexType);
-  void vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
-                                            const VkDeviceImageSubresourceInfo *pInfo,
-                                            VkSubresourceLayout2 *pLayout);
-  void vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
-                                       const VkImageSubresource2 *pSubresource,
-                                       VkSubresourceLayout2 *pLayout);
-  void vkGetRenderingAreaGranularityKHR(VkDevice device,
-                                        const VkRenderingAreaInfo *pRenderingAreaInfo,
-                                        VkExtent2D *pGranularity);
+  void vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo *pInfo,
+                                         VkSubresourceLayout2 *pLayout);
+  void vkGetImageSubresourceLayout2(VkDevice device, VkImage image,
+                                    const VkImageSubresource2 *pSubresource,
+                                    VkSubresourceLayout2 *pLayout);
+  void vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo *pRenderingAreaInfo,
+                                     VkExtent2D *pGranularity);
 
   // VK_EXT_image_compression_control, VK_EXT_host_image_copy
   void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
@@ -3265,9 +3263,9 @@ public:
                                 VkPipelineLayout layout, uint32_t set);
 
   // VK_KHR_map_memory2
-  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkMapMemory2KHR, VkDevice device,
+  IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkMapMemory2, VkDevice device,
                                 const VkMemoryMapInfo *pMemoryMapInfo, void **ppData);
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkUnmapMemory2KHR, VkDevice device,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkUnmapMemory2, VkDevice device,
                                 const VkMemoryUnmapInfo *pMemoryUnmapInfo);
 
   // VK_KHR_present_wait2
@@ -3277,9 +3275,9 @@ public:
                                 const VkPresentWait2InfoKHR *pPresentWait2Info);
 
   // VK_KHR_maintenance5
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets2KHR, VkCommandBuffer commandBuffer,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets2, VkCommandBuffer commandBuffer,
                                 const VkBindDescriptorSetsInfo *pBindDescriptorSetsInfo);
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushConstants2KHR, VkCommandBuffer commandBuffer,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushConstants2, VkCommandBuffer commandBuffer,
                                 const VkPushConstantsInfo *pPushConstantsInfo);
   // VK_KHR_maintenance5+VK_EXT_descriptor_buffer
   IMPLEMENT_FUNCTION_SERIALISED(
@@ -3289,9 +3287,9 @@ public:
       void, vkCmdSetDescriptorBufferOffsets2EXT, VkCommandBuffer commandBuffer,
       const VkSetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo);
   // VK_KHR_maintenance5+VK_KHR_push_descriptor
-  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSet2KHR, VkCommandBuffer commandBuffer,
+  IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSet2, VkCommandBuffer commandBuffer,
                                 const VkPushDescriptorSetInfo *pPushDescriptorSetInfo);
   IMPLEMENT_FUNCTION_SERIALISED(
-      void, vkCmdPushDescriptorSetWithTemplate2KHR, VkCommandBuffer commandBuffer,
+      void, vkCmdPushDescriptorSetWithTemplate2, VkCommandBuffer commandBuffer,
       const VkPushDescriptorSetWithTemplateInfo *pPushDescriptorSetWithTemplateInfo);
 };

renderdoc/driver/vulkan/vk_debug.cpp

@@ -2688,7 +2688,7 @@ void VulkanDebugManager::FillWithDiscardPatternOnHost(VkDevice device, DiscardTy
     hostCopy.imageOffset = copy.imageOffset;
     hostCopy.imageExtent = copy.imageExtent;
 
-    ObjDisp(device)->CopyMemoryToImageEXT(Unwrap(device), &info);
+    ObjDisp(device)->CopyMemoryToImage(Unwrap(device), &info);
   }
 
   // For stencil, the pattern data is found after depth.
@@ -2702,7 +2702,7 @@ void VulkanDebugManager::FillWithDiscardPatternOnHost(VkDevice device, DiscardTy
     hostCopy.imageOffset = copy.imageOffset;
     hostCopy.imageExtent = copy.imageExtent;
 
-    ObjDisp(device)->CopyMemoryToImageEXT(Unwrap(device), &info);
+    ObjDisp(device)->CopyMemoryToImage(Unwrap(device), &info);
   }
 }
 

renderdoc/driver/vulkan/vk_hookset_defs.h

@@ -33,6 +33,9 @@
 // extensions made core in 1.3
 #define VK13 VK_MAKE_VERSION(1, 3, 0)
 
+// extensions made core in 1.4
+#define VK14 VK_MAKE_VERSION(1, 4, 0)
+
 // extensions that are not core in any version
 #define VKXX VK_MAKE_VERSION(99, 99, 0)
 
@@ -613,7 +616,7 @@
   CheckExt(KHR_external_fence_fd, VKXX);                      \
   CheckExt(KHR_get_memory_requirements2, VK11);               \
   CheckExt(AMD_shader_info, VKXX);                            \
-  CheckExt(KHR_push_descriptor, VKXX);                        \
+  CheckExt(KHR_push_descriptor, VK14);                        \
   CheckExt(KHR_descriptor_update_template, VK11);             \
   CheckExt(KHR_bind_memory2, VK11);                           \
   CheckExt(EXT_conservative_rasterization, VKXX);             \
@@ -632,7 +635,7 @@
   CheckExt(EXT_sample_locations, VKXX);                       \
   CheckExt(EXT_discard_rectangles, VKXX);                     \
   CheckExt(EXT_calibrated_timestamps, VKXX);                  \
-  CheckExt(EXT_host_image_copy, VKXX);                        \
+  CheckExt(EXT_host_image_copy, VK14);                        \
   CheckExt(EXT_host_query_reset, VK12);                       \
   CheckExt(EXT_buffer_device_address, VKXX);                  \
   CheckExt(EXT_hdr_metadata, VKXX);                           \
@@ -667,7 +670,7 @@
   CheckExt(EXT_multisampled_render_to_single_sampled, VKXX);  \
   CheckExt(EXT_vertex_input_dynamic_state, VKXX);             \
   CheckExt(KHR_dynamic_rendering, VK13);                      \
-  CheckExt(KHR_dynamic_rendering_local_read, VKXX);           \
+  CheckExt(KHR_dynamic_rendering_local_read, VK14);           \
   CheckExt(KHR_fragment_shading_rate, VKXX);                  \
   CheckExt(EXT_attachment_feedback_loop_layout, VKXX);        \
   CheckExt(EXT_pageable_device_local_memory, VKXX);           \
@@ -679,8 +682,8 @@
   CheckExt(EXT_extended_dynamic_state3, VKXX);                \
   CheckExt(EXT_mesh_shader, VKXX);                            \
   CheckExt(EXT_scalar_block_layout, VK12);                    \
-  CheckExt(KHR_vertex_attribute_divisor, VKXX);               \
-  CheckExt(KHR_line_rasterization, VKXX);                     \
+  CheckExt(KHR_vertex_attribute_divisor, VK14);               \
+  CheckExt(KHR_line_rasterization, VK14);                     \
   CheckExt(KHR_calibrated_timestamps, VKXX);                  \
   CheckExt(KHR_deferred_host_operations, VKXX);               \
   CheckExt(KHR_acceleration_structure, VKXX);                 \
@@ -692,12 +695,12 @@
   CheckExt(EXT_shader_subgroup_vote, VK11);                   \
   CheckExt(KHR_shader_subgroup_uniform_control_flow, VKXX);   \
   CheckExt(KHR_ray_tracing_maintenance1, VKXX);               \
-  CheckExt(KHR_maintenance5, VKXX);                           \
-  CheckExt(KHR_maintenance6, VKXX);                           \
+  CheckExt(KHR_maintenance5, VK14);                           \
+  CheckExt(KHR_maintenance6, VK14);                           \
   CheckExt(EXT_image_compression_control, VKXX);              \
   CheckExt(EXT_image_compression_control_swapchain, VKXX);    \
   CheckExt(EXT_descriptor_buffer, VKXX);                      \
-  CheckExt(KHR_map_memory2, VKXX);                            \
+  CheckExt(KHR_map_memory2, VK14);                            \
   CheckExt(KHR_present_wait2, VKXX);
 
 #define HookInitVulkanInstanceExts_PhysDev()                                                         \
@@ -848,12 +851,12 @@
   HookInitPromotedExtension(KHR_get_memory_requirements2, GetImageMemoryRequirements2, KHR);         \
   HookInitPromotedExtension(KHR_get_memory_requirements2, GetImageSparseMemoryRequirements2, KHR);   \
   HookInitExtension(AMD_shader_info, GetShaderInfoAMD);                                              \
-  HookInitExtension(KHR_push_descriptor, CmdPushDescriptorSetKHR);                                   \
+  HookInitPromotedExtension(KHR_push_descriptor, CmdPushDescriptorSet, KHR);                         \
   HookInitPromotedExtension(KHR_descriptor_update_template, CreateDescriptorUpdateTemplate, KHR);    \
   HookInitPromotedExtension(KHR_descriptor_update_template, DestroyDescriptorUpdateTemplate, KHR);   \
   HookInitPromotedExtension(KHR_descriptor_update_template, UpdateDescriptorSetWithTemplate, KHR);   \
-  HookInitExtension(KHR_push_descriptor &&KHR_descriptor_update_template,                            \
-                    CmdPushDescriptorSetWithTemplateKHR);                                            \
+  HookInitPromotedExtension(KHR_push_descriptor &&KHR_descriptor_update_template,                    \
+                            CmdPushDescriptorSetWithTemplate, KHR);                                  \
   HookInitPromotedExtension(KHR_bind_memory2, BindBufferMemory2, KHR);                               \
   HookInitPromotedExtension(KHR_bind_memory2, BindImageMemory2, KHR);                                \
   HookInitPromotedExtension(KHR_maintenance3, GetDescriptorSetLayoutSupport, KHR);                   \
@@ -897,10 +900,10 @@
   HookInitExtension(EXT_sample_locations, CmdSetSampleLocationsEXT);                                 \
   HookInitExtension(EXT_discard_rectangles, CmdSetDiscardRectangleEXT);                              \
   HookInitExtension(EXT_calibrated_timestamps, GetCalibratedTimestampsEXT);                          \
-  HookInitExtension(EXT_host_image_copy, CopyImageToImageEXT);                                       \
-  HookInitExtension(EXT_host_image_copy, CopyImageToMemoryEXT);                                      \
-  HookInitExtension(EXT_host_image_copy, CopyMemoryToImageEXT);                                      \
-  HookInitExtension(EXT_host_image_copy, TransitionImageLayoutEXT);                                  \
+  HookInitPromotedExtension(EXT_host_image_copy, CopyImageToImage, EXT);                             \
+  HookInitPromotedExtension(EXT_host_image_copy, CopyImageToMemory, EXT);                            \
+  HookInitPromotedExtension(EXT_host_image_copy, CopyMemoryToImage, EXT);                            \
+  HookInitPromotedExtension(EXT_host_image_copy, TransitionImageLayout, EXT);                        \
   HookInitPromotedExtension(EXT_host_query_reset, ResetQueryPool, EXT);                              \
   HookInitExtension(EXT_buffer_device_address, GetBufferDeviceAddressEXT);                           \
   HookInitExtension(EXT_hdr_metadata, SetHdrMetadataEXT);                                            \
@@ -975,8 +978,10 @@
   HookInitExtension(EXT_vertex_input_dynamic_state || EXT_shader_object, CmdSetVertexInputEXT);      \
   HookInitPromotedExtension(KHR_dynamic_rendering, CmdBeginRendering, KHR);                          \
   HookInitPromotedExtension(KHR_dynamic_rendering, CmdEndRendering, KHR);                            \
-  HookInitExtension(KHR_dynamic_rendering_local_read, CmdSetRenderingAttachmentLocationsKHR);        \
-  HookInitExtension(KHR_dynamic_rendering_local_read, CmdSetRenderingInputAttachmentIndicesKHR);     \
+  HookInitPromotedExtension(KHR_dynamic_rendering_local_read, CmdSetRenderingAttachmentLocations,    \
+                            KHR);                                                                    \
+  HookInitPromotedExtension(KHR_dynamic_rendering_local_read,                                        \
+                            CmdSetRenderingInputAttachmentIndices, KHR);                             \
   HookInitExtension(KHR_fragment_shading_rate, CmdSetFragmentShadingRateKHR);                        \
   HookInitExtension(EXT_pageable_device_local_memory, SetDeviceMemoryPriorityEXT);                   \
   HookInitExtension(EXT_swapchain_maintenance1, ReleaseSwapchainImagesEXT);                          \
@@ -1036,7 +1041,7 @@
   HookInitExtension(EXT_mesh_shader, CmdDrawMeshTasksIndirectEXT);                                   \
   HookInitExtension(EXT_mesh_shader, CmdDrawMeshTasksIndirectCountEXT);                              \
   HookInitExtension(KHR_calibrated_timestamps, GetCalibratedTimestampsKHR);                          \
-  HookInitExtension(KHR_line_rasterization, CmdSetLineStippleKHR);                                   \
+  HookInitPromotedExtension(KHR_line_rasterization, CmdSetLineStipple, KHR);                         \
   HookInitExtensionEXTtoKHR(CmdSetLineStipple);                                                      \
   HookInitExtension(KHR_deferred_host_operations, CreateDeferredOperationKHR);                       \
   HookInitExtension(KHR_deferred_host_operations, DeferredOperationJoinKHR);                         \
@@ -1071,17 +1076,18 @@
   HookInitExtension(KHR_ray_tracing_pipeline, GetRayTracingShaderGroupHandlesKHR);                   \
   HookInitExtension(KHR_ray_tracing_pipeline, GetRayTracingShaderGroupStackSizeKHR);                 \
   HookInitExtension(KHR_ray_tracing_maintenance1, CmdTraceRaysIndirect2KHR);                         \
-  HookInitExtension(KHR_maintenance5, CmdBindIndexBuffer2KHR);                                       \
-  HookInitExtension(KHR_maintenance5, GetDeviceImageSubresourceLayoutKHR);                           \
-  HookInitExtension(KHR_maintenance5, GetImageSubresourceLayout2KHR);                                \
-  HookInitExtension(KHR_maintenance5, GetRenderingAreaGranularityKHR);                               \
-  HookInitExtension(KHR_maintenance6, CmdBindDescriptorSets2KHR);                                    \
-  HookInitExtension(KHR_maintenance6, CmdPushConstants2KHR);                                         \
+  HookInitPromotedExtension(KHR_maintenance5, CmdBindIndexBuffer2, KHR);                             \
+  HookInitPromotedExtension(KHR_maintenance5, GetDeviceImageSubresourceLayout, KHR);                 \
+  HookInitPromotedExtension(KHR_maintenance5, GetImageSubresourceLayout2, KHR);                      \
+  HookInitPromotedExtension(KHR_maintenance5, GetRenderingAreaGranularity, KHR);                     \
+  HookInitPromotedExtension(KHR_maintenance6, CmdBindDescriptorSets2, KHR);                          \
+  HookInitPromotedExtension(KHR_maintenance6, CmdPushConstants2, KHR);                               \
   HookInitExtension(KHR_maintenance6 &&EXT_descriptor_buffer,                                        \
                     CmdBindDescriptorBufferEmbeddedSamplers2EXT);                                    \
   HookInitExtension(KHR_maintenance6 &&EXT_descriptor_buffer, CmdSetDescriptorBufferOffsets2EXT);    \
-  HookInitExtension(KHR_maintenance6 &&KHR_push_descriptor, CmdPushDescriptorSet2KHR);               \
-  HookInitExtension(KHR_maintenance6 &&KHR_push_descriptor, CmdPushDescriptorSetWithTemplate2KHR);   \
+  HookInitPromotedExtension(KHR_maintenance6 &&KHR_push_descriptor, CmdPushDescriptorSet2, KHR);     \
+  HookInitPromotedExtension(KHR_maintenance6 &&KHR_push_descriptor,                                  \
+                            CmdPushDescriptorSetWithTemplate2, KHR);                                 \
   HookInitExtension(EXT_image_compression_control || EXT_host_image_copy,                            \
                     GetImageSubresourceLayout2EXT);                                                  \
   HookInitExtension(EXT_descriptor_buffer, CmdBindDescriptorBufferEmbeddedSamplersEXT);              \
@@ -1095,8 +1101,8 @@
   HookInitExtension(EXT_descriptor_buffer, GetImageViewOpaqueCaptureDescriptorDataEXT);              \
   HookInitExtension(EXT_descriptor_buffer, GetSamplerOpaqueCaptureDescriptorDataEXT);                \
   HookInitExtension(EXT_descriptor_buffer, GetAccelerationStructureOpaqueCaptureDescriptorDataEXT);  \
-  HookInitExtension(KHR_map_memory2, MapMemory2KHR);                                                 \
-  HookInitExtension(KHR_map_memory2, UnmapMemory2KHR);                                               \
+  HookInitPromotedExtension(KHR_map_memory2, MapMemory2, KHR);                                       \
+  HookInitPromotedExtension(KHR_map_memory2, UnmapMemory2, KHR);                                     \
   HookInitExtension(KHR_present_wait, WaitForPresent2KHR);                                           \
   HookInitExtension_Device_Win32();                                                                  \
   HookInitExtension_Device_Linux();                                                                  \
@@ -1520,9 +1526,9 @@
   HookDefine6(VkResult, vkGetShaderInfoAMD, VkDevice, device, VkPipeline, pipeline,                  \
               VkShaderStageFlagBits, shaderStage, VkShaderInfoTypeAMD, infoType, size_t *,           \
               pInfoSize, void *, pInfo);                                                             \
-  HookDefine6(void, vkCmdPushDescriptorSetKHR, VkCommandBuffer, commandBuffer,                       \
-              VkPipelineBindPoint, pipelineBindPoint, VkPipelineLayout, layout, uint32_t, set,       \
-              uint32_t, descriptorWriteCount, const VkWriteDescriptorSet *, pDescriptorWrites);      \
+  HookDefine6(void, vkCmdPushDescriptorSet, VkCommandBuffer, commandBuffer, VkPipelineBindPoint,     \
+              pipelineBindPoint, VkPipelineLayout, layout, uint32_t, set, uint32_t,                  \
+              descriptorWriteCount, const VkWriteDescriptorSet *, pDescriptorWrites);                \
   HookDefine4(VkResult, vkCreateDescriptorUpdateTemplate, VkDevice, device,                          \
               const VkDescriptorUpdateTemplateCreateInfo *, pCreateInfo,                             \
               const VkAllocationCallbacks *, pAllocator, VkDescriptorUpdateTemplate *,               \
@@ -1532,7 +1538,7 @@
   HookDefine4(void, vkUpdateDescriptorSetWithTemplate, VkDevice, device, VkDescriptorSet,            \
               descriptorSet, VkDescriptorUpdateTemplate, descriptorUpdateTemplate, const void *,     \
               pData);                                                                                \
-  HookDefine5(void, vkCmdPushDescriptorSetWithTemplateKHR, VkCommandBuffer, commandBuffer,           \
+  HookDefine5(void, vkCmdPushDescriptorSetWithTemplate, VkCommandBuffer, commandBuffer,              \
               VkDescriptorUpdateTemplate, descriptorUpdateTemplate, VkPipelineLayout, layout,        \
               uint32_t, set, const void *, pData);                                                   \
   HookDefine3(VkResult, vkBindBufferMemory2, VkDevice, device, uint32_t, bindInfoCount,              \
@@ -1667,13 +1673,13 @@
   HookDefine5(VkResult, vkGetCalibratedTimestampsEXT, VkDevice, device, uint32_t, timestampCount,    \
               const VkCalibratedTimestampInfoKHR *, pTimestampInfos, uint64_t *, pTimestamps,        \
               uint64_t *, pMaxDeviation);                                                            \
-  HookDefine2(VkResult, vkCopyImageToImageEXT, VkDevice, device, const VkCopyImageToImageInfo *,     \
+  HookDefine2(VkResult, vkCopyImageToImage, VkDevice, device, const VkCopyImageToImageInfo *,        \
               pCopyImageToImageInfo);                                                                \
-  HookDefine2(VkResult, vkCopyImageToMemoryEXT, VkDevice, device, const VkCopyImageToMemoryInfo *,   \
+  HookDefine2(VkResult, vkCopyImageToMemory, VkDevice, device, const VkCopyImageToMemoryInfo *,      \
               pCopyImageToMemoryInfo);                                                               \
-  HookDefine2(VkResult, vkCopyMemoryToImageEXT, VkDevice, device, const VkCopyMemoryToImageInfo *,   \
+  HookDefine2(VkResult, vkCopyMemoryToImage, VkDevice, device, const VkCopyMemoryToImageInfo *,      \
               pCopyMemoryToImageInfo);                                                               \
-  HookDefine3(VkResult, vkTransitionImageLayoutEXT, VkDevice, device, uint32_t, transitionCount,     \
+  HookDefine3(VkResult, vkTransitionImageLayout, VkDevice, device, uint32_t, transitionCount,        \
               const VkHostImageLayoutTransitionInfo *, pTransitions);                                \
   HookDefine4(void, vkResetQueryPool, VkDevice, device, VkQueryPool, queryPool, uint32_t,            \
               firstQuery, uint32_t, queryCount);                                                     \
@@ -1817,9 +1823,9 @@
   HookDefine2(void, vkCmdBeginRendering, VkCommandBuffer, commandBuffer, const VkRenderingInfo *,    \
               pRenderingInfo);                                                                       \
   HookDefine1(void, vkCmdEndRendering, VkCommandBuffer, commandBuffer);                              \
-  HookDefine2(void, vkCmdSetRenderingAttachmentLocationsKHR, VkCommandBuffer, commandBuffer,         \
+  HookDefine2(void, vkCmdSetRenderingAttachmentLocations, VkCommandBuffer, commandBuffer,            \
               const VkRenderingAttachmentLocationInfo *, pLocationInfo);                             \
-  HookDefine2(void, vkCmdSetRenderingInputAttachmentIndicesKHR, VkCommandBuffer, commandBuffer,      \
+  HookDefine2(void, vkCmdSetRenderingInputAttachmentIndices, VkCommandBuffer, commandBuffer,         \
               const VkRenderingInputAttachmentIndexInfo *, pInputAttachmentIndexInfo);               \
   HookDefine3(void, vkCmdSetFragmentShadingRateKHR, VkCommandBuffer, commandBuffer,                  \
               const VkExtent2D *, pFragmentSize, const VkFragmentShadingRateCombinerOpKHR *,         \
@@ -1834,7 +1840,7 @@
   HookDefine4(VkResult, vkGetDrmDisplayEXT, VkPhysicalDevice, physicalDevice, int32_t, drmFd,        \
               uint32_t, connectorId, VkDisplayKHR *, display);                                       \
   HookDefine2(VkResult, vkReleaseSwapchainImagesEXT, VkDevice, device,                               \
-              const VkReleaseSwapchainImagesInfoEXT *, pReleaseInfo);                                \
+              const VkReleaseSwapchainImagesInfoKHR *, pReleaseInfo);                                \
   HookDefine2(VkResult, vkReleaseSwapchainImagesKHR, VkDevice, device,                               \
               const VkReleaseSwapchainImagesInfoKHR *, pReleaseInfo);                                \
   HookDefine2(void, vkCmdSetAttachmentFeedbackLoopEnableEXT, VkCommandBuffer, commandBuffer,         \
@@ -1917,7 +1923,7 @@
   HookDefine5(VkResult, vkGetCalibratedTimestampsKHR, VkDevice, device, uint32_t, timestampCount,    \
               const VkCalibratedTimestampInfoKHR *, pTimestampInfos, uint64_t *, pTimestamps,        \
               uint64_t *, pMaxDeviation);                                                            \
-  HookDefine3(void, vkCmdSetLineStippleKHR, VkCommandBuffer, commandBuffer, uint32_t,                \
+  HookDefine3(void, vkCmdSetLineStipple, VkCommandBuffer, commandBuffer, uint32_t,                   \
               lineStippleFactor, uint16_t, lineStipplePattern);                                      \
   HookDefine3(VkResult, vkCreateDeferredOperationKHR, VkDevice, device,                              \
               const VkAllocationCallbacks *, pAllocator, VkDeferredOperationKHR *,                   \
@@ -2015,14 +2021,14 @@
               uint32_t, pipelineStackSize);                                                          \
   HookDefine2(void, vkCmdTraceRaysIndirect2KHR, VkCommandBuffer, commandBuffer, VkDeviceAddress,     \
               indirectDeviceAddress);                                                                \
-  HookDefine5(void, vkCmdBindIndexBuffer2KHR, VkCommandBuffer, commandBuffer, VkBuffer, buffer,      \
+  HookDefine5(void, vkCmdBindIndexBuffer2, VkCommandBuffer, commandBuffer, VkBuffer, buffer,         \
               VkDeviceSize, offset, VkDeviceSize, size, VkIndexType, indexType);                     \
-  HookDefine3(void, vkGetDeviceImageSubresourceLayoutKHR, VkDevice, device,                          \
+  HookDefine3(void, vkGetDeviceImageSubresourceLayout, VkDevice, device,                             \
               const VkDeviceImageSubresourceInfo *, pInfo, VkSubresourceLayout2 *, pLayout);         \
-  HookDefine4(void, vkGetImageSubresourceLayout2KHR, VkDevice, device, VkImage, image,               \
+  HookDefine4(void, vkGetImageSubresourceLayout2, VkDevice, device, VkImage, image,                  \
               const VkImageSubresource2 *, pSubresource, VkSubresourceLayout2 *, pLayout);           \
-  HookDefine3(void, vkGetRenderingAreaGranularityKHR, VkDevice, device,                              \
-              const VkRenderingAreaInfo *, pRenderingAreaInfo, VkExtent2D *, pGranularity);          \
+  HookDefine3(void, vkGetRenderingAreaGranularity, VkDevice, device, const VkRenderingAreaInfo *,    \
+              pRenderingAreaInfo, VkExtent2D *, pGranularity);                                       \
   HookDefine4(void, vkGetImageSubresourceLayout2EXT, VkDevice, device, VkImage, image,               \
               const VkImageSubresource2 *, pSubresource, VkSubresourceLayout2 *, pLayout);           \
   HookDefine3(void, vkGetDescriptorSetLayoutSizeEXT, VkDevice, device, VkDescriptorSetLayout,        \
@@ -2048,19 +2054,18 @@
               const VkSamplerCaptureDescriptorDataInfoEXT *, pInfo, void *, pData);                  \
   HookDefine3(VkResult, vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, VkDevice, device,  \
               const VkAccelerationStructureCaptureDescriptorDataInfoEXT *, pInfo, void *, pData);    \
-  HookDefine3(VkResult, vkMapMemory2KHR, VkDevice, device, const VkMemoryMapInfo *,                  \
-              pMemoryMapInfo, void **, ppData);                                                      \
-  HookDefine2(void, vkUnmapMemory2KHR, VkDevice, device, const VkMemoryUnmapInfo *,                  \
-              pMemoryUnmapInfo);                                                                     \
+  HookDefine3(VkResult, vkMapMemory2, VkDevice, device, const VkMemoryMapInfo *, pMemoryMapInfo,     \
+              void **, ppData);                                                                      \
+  HookDefine2(void, vkUnmapMemory2, VkDevice, device, const VkMemoryUnmapInfo *, pMemoryUnmapInfo);  \
   HookDefine3(VkResult, vkWaitForPresent2KHR, VkDevice, device, VkSwapchainKHR, swapchain,           \
               const VkPresentWait2InfoKHR *, pPresentWait2Info);                                     \
-  HookDefine2(void, vkCmdBindDescriptorSets2KHR, VkCommandBuffer, commandBuffer,                     \
+  HookDefine2(void, vkCmdBindDescriptorSets2, VkCommandBuffer, commandBuffer,                        \
               const VkBindDescriptorSetsInfo *, pBindDescriptorSetsInfo);                            \
-  HookDefine2(void, vkCmdPushConstants2KHR, VkCommandBuffer, commandBuffer,                          \
+  HookDefine2(void, vkCmdPushConstants2, VkCommandBuffer, commandBuffer,                             \
               const VkPushConstantsInfo *, pPushConstantsInfo);                                      \
-  HookDefine2(void, vkCmdPushDescriptorSet2KHR, VkCommandBuffer, commandBuffer,                      \
+  HookDefine2(void, vkCmdPushDescriptorSet2, VkCommandBuffer, commandBuffer,                         \
               const VkPushDescriptorSetInfo *, pPushDescriptorSetInfo);                              \
-  HookDefine2(void, vkCmdPushDescriptorSetWithTemplate2KHR, VkCommandBuffer, commandBuffer,          \
+  HookDefine2(void, vkCmdPushDescriptorSetWithTemplate2, VkCommandBuffer, commandBuffer,             \
               const VkPushDescriptorSetWithTemplateInfo *, pPushDescriptorSetWithTemplateInfo);      \
   HookDefine2(void, vkCmdSetDescriptorBufferOffsets2EXT, VkCommandBuffer, commandBuffer,             \
               const VkSetDescriptorBufferOffsetsInfoEXT *, pSetDescriptorBufferOffsetsInfo);         \

renderdoc/driver/vulkan/vk_info.cpp

@@ -919,7 +919,7 @@ static void ProcessStaticDescriptorAccess(VulkanResourceManager *resourceMan,
         continue;
 
       if((setLayout->flags & (VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT |
-                              VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR |
+                              VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT |
                               VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT)) ==
          VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT)
       {
@@ -980,7 +980,7 @@ static void ProcessStaticDescriptorAccess(VulkanResourceManager *resourceMan,
     access.index = i;
 
     if((setLayout->flags & (VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT |
-                            VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR |
+                            VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT |
                             VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT)) ==
        VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT)
     {
@@ -1034,7 +1034,7 @@ static void ProcessStaticDescriptorAccess(VulkanResourceManager *resourceMan,
     access.index = i;
 
     if((setLayout->flags & (VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT |
-                            VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR |
+                            VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT |
                             VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT)) ==
        VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT)
     {
@@ -1082,7 +1082,7 @@ static void ProcessStaticDescriptorAccess(VulkanResourceManager *resourceMan,
     access.index = i;
 
     if((setLayout->flags & (VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT |
-                            VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR |
+                            VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT |
                             VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT)) ==
        VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT)
     {

renderdoc/driver/vulkan/vk_next_chains.cpp

@@ -330,10 +330,10 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
               VkPhysicalDeviceFragmentDensityMap2FeaturesEXT);                                        \
   COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,                \
               VkPhysicalDeviceFragmentDensityMap2PropertiesEXT);                                      \
-  COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,            \
-              VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM);                                  \
-  COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,          \
-              VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM);                                \
+  COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,             \
+              VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT);                                   \
+  COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,           \
+              VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT);                                 \
   COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,               \
               VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT);                                    \
   COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,                   \
@@ -607,6 +607,10 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
               VkPhysicalDeviceVulkan13Features);                                                      \
   COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES,                                \
               VkPhysicalDeviceVulkan13Properties);                                                    \
+  COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES,                                  \
+              VkPhysicalDeviceVulkan14Features);                                                      \
+  COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES,                                \
+              VkPhysicalDeviceVulkan14Properties);                                                    \
   COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,                         \
               VkPhysicalDeviceVulkanMemoryModelFeatures);                                             \
   COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,        \
@@ -694,6 +698,8 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
   COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, VkRenderPassCreateInfo2);                  \
   COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,                     \
               VkRenderPassFragmentDensityMapCreateInfoEXT);                                           \
+  COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,                 \
+              VkRenderPassFragmentDensityMapOffsetEndInfoEXT);                                        \
   COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,                      \
               VkRenderPassInputAttachmentAspectCreateInfo);                                           \
   COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, VkRenderPassMultiviewCreateInfo);  \
@@ -724,8 +730,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
   COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, VkSubpassDescription2);                        \
   COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,                            \
               VkSubpassDescriptionDepthStencilResolve);                                               \
-  COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,                    \
-              VkSubpassFragmentDensityMapOffsetEndInfoQCOM);                                          \
   COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_END_INFO, VkSubpassEndInfo);                                  \
   COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT,                                \
               VkSubpassResolvePerformanceQueryEXT);                                                   \
@@ -1290,8 +1294,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
   case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:                                 \
   case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:                      \
   case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:                      \
-  case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:                                   \
-  case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:                                 \
   case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:                           \
   case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:            \
   case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR:                                       \
@@ -1529,11 +1531,11 @@ size_t GetNextPatchSize(const void *pNext)
           memSize += info->pImageBinds[i].bindCount * sizeof(VkSparseImageMemoryBind);
         break;
       }
-      case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR:
+      case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
       {
-        memSize += sizeof(VkBindDescriptorSetsInfoKHR);
+        memSize += sizeof(VkBindDescriptorSetsInfo);
 
-        VkBindDescriptorSetsInfoKHR *info = (VkBindDescriptorSetsInfoKHR *)next;
+        VkBindDescriptorSetsInfo *info = (VkBindDescriptorSetsInfo *)next;
         memSize += info->descriptorSetCount * sizeof(VkDescriptorSet);
         break;
       }
@@ -1798,7 +1800,7 @@ size_t GetNextPatchSize(const void *pNext)
         memSize += info->colorAttachmentCount * sizeof(VkFormat);
         break;
       }
-      case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR:
+      case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
       {
         memSize += sizeof(VkPushDescriptorSetInfo);
 
@@ -2311,10 +2313,10 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
 
         break;
       }
-      case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR:
+      case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
       {
-        const VkBindDescriptorSetsInfoKHR *in = (const VkBindDescriptorSetsInfoKHR *)nextInput;
-        VkBindDescriptorSetsInfoKHR *out = (VkBindDescriptorSetsInfoKHR *)tempMem;
+        const VkBindDescriptorSetsInfo *in = (const VkBindDescriptorSetsInfo *)nextInput;
+        VkBindDescriptorSetsInfo *out = (VkBindDescriptorSetsInfo *)tempMem;
 
         // append immediately so tempMem is incremented
         AppendModifiedChainedStruct(tempMem, out, nextChainTail);
@@ -2925,7 +2927,7 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
 
         break;
       }
-      case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR:
+      case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
       {
         const VkPushDescriptorSetInfo *in = (const VkPushDescriptorSetInfo *)nextInput;
         VkPushDescriptorSetInfo *out = (VkPushDescriptorSetInfo *)tempMem;
@@ -3590,8 +3592,8 @@ void CopyNextChainForPatching(const char *structName, byte *&tempMem, VkBaseInSt
       case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
         CopyNextChainedStruct(sizeof(VkBindSparseInfo), tempMem, nextInput, nextChainTail);
         break;
-      case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR:
-        CopyNextChainedStruct(sizeof(VkBindDescriptorSetsInfoKHR), tempMem, nextInput, nextChainTail);
+      case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
+        CopyNextChainedStruct(sizeof(VkBindDescriptorSetsInfo), tempMem, nextInput, nextChainTail);
         break;
       case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
         CopyNextChainedStruct(sizeof(VkBlitImageInfo2), tempMem, nextInput, nextChainTail);
@@ -3670,7 +3672,7 @@ void CopyNextChainForPatching(const char *structName, byte *&tempMem, VkBaseInSt
         CopyNextChainedStruct(sizeof(VkPipelineRenderingCreateInfo), tempMem, nextInput,
                               nextChainTail);
         break;
-      case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR:
+      case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
         CopyNextChainedStruct(sizeof(VkPushDescriptorSetInfo), tempMem, nextInput, nextChainTail);
         break;
       case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:

renderdoc/driver/vulkan/vk_overlay.cpp

@@ -385,14 +385,14 @@ struct VulkanQuadOverdrawCallback : public VulkanActionCallback
       {
         VkRenderingAttachmentLocationInfo attachmentLocations = {};
         attachmentLocations.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
-        m_pDriver->vkCmdSetRenderingAttachmentLocationsKHR(cmd, &attachmentLocations);
+        m_pDriver->vkCmdSetRenderingAttachmentLocations(cmd, &attachmentLocations);
       }
       if(m_PrevState.dynamicRendering.localRead.AreInputIndicesNonDefault())
       {
         VkRenderingInputAttachmentIndexInfo inputIndices = {};
         inputIndices.sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
 
-        m_pDriver->vkCmdSetRenderingInputAttachmentIndicesKHR(cmd, &inputIndices);
+        m_pDriver->vkCmdSetRenderingInputAttachmentIndices(cmd, &inputIndices);
       }
     }
   }

renderdoc/driver/vulkan/vk_serialise.cpp

@@ -523,6 +523,12 @@ SERIALISE_VK_HANDLES();
   PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES,                                \
                VkPhysicalDeviceVulkan13Properties)                                                     \
                                                                                                        \
+  /* Vulkan 1.4 only, no extension */                                                                  \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES,                                  \
+               VkPhysicalDeviceVulkan14Features)                                                       \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES,                                \
+               VkPhysicalDeviceVulkan14Properties)                                                     \
+                                                                                                       \
   /* VK_AMD_device_coherent_memory */                                                                  \
   PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,                         \
                VkPhysicalDeviceCoherentMemoryFeaturesAMD)                                              \
@@ -1298,16 +1304,16 @@ SERIALISE_VK_HANDLES();
                                                                                                        \
   /* VK_KHR_maintenance6 */                                                                            \
   PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES,                               \
-               VkPhysicalDeviceMaintenance6FeaturesKHR)                                                \
+               VkPhysicalDeviceMaintenance6Features)                                                   \
   PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES,                             \
-               VkPhysicalDeviceMaintenance6PropertiesKHR)                                              \
-  PNEXT_STRUCT(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, VkBindMemoryStatusKHR)                            \
-  PNEXT_STRUCT(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, VkBindDescriptorSetsInfoKHR)               \
-  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, VkPushConstantsInfoKHR)                          \
+               VkPhysicalDeviceMaintenance6Properties)                                                 \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, VkBindMemoryStatus)                               \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, VkBindDescriptorSetsInfo)                  \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, VkPushConstantsInfo)                             \
   /* VK_KHR_push_descriptor interactions */                                                            \
-  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, VkPushDescriptorSetInfoKHR)                 \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, VkPushDescriptorSetInfo)                    \
   PNEXT_STRUCT(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO,                               \
-               VkPushDescriptorSetWithTemplateInfoKHR)                                                 \
+               VkPushDescriptorSetWithTemplateInfo)                                                    \
   /* VK_EXT_descriptor_buffer interactions */                                                          \
   PNEXT_STRUCT(VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT,                               \
                VkSetDescriptorBufferOffsetsInfoEXT)                                                    \
@@ -1643,13 +1649,13 @@ SERIALISE_VK_HANDLES();
   PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,                   \
                VkPhysicalDeviceShaderImageFootprintFeaturesNV)                                         \
                                                                                                        \
-  /* VK_QCOM_fragment_density_map_offset */                                                            \
-  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,            \
-               VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM)                                   \
-  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,          \
-               VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM)                                 \
-  PNEXT_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,                    \
-               VkSubpassFragmentDensityMapOffsetEndInfoQCOM)                                           \
+  /* VK_EXT_fragment_density_map_offset */                                                             \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,             \
+               VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT)                                    \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,           \
+               VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT)                                  \
+  PNEXT_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,                 \
+               VkRenderPassFragmentDensityMapOffsetEndInfoEXT)                                         \
                                                                                                        \
   /* Surface creation structs. These would pull in dependencies on OS-specific includes. */            \
   /* So treat them as unsupported. */                                                                  \
@@ -1671,10 +1677,6 @@ SERIALISE_VK_HANDLES();
   PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR)                                     \
   PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR)                                    \
                                                                                                        \
-  /* Vulkan 1.4 only, no extension */                                                                  \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES)                             \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES)                           \
-                                                                                                       \
   /* VK_ARM_data_graph     */                                                                          \
   PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM)                             \
   PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM)                     \
@@ -2243,7 +2245,7 @@ SERIALISE_VK_HANDLES();
   /* VK_NV_framebuffer_mixed_samples */                                                                \
   PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV)               \
   /* Interaction with VK_KHR_dynamic_rendering */                                                      \
-  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV)                                 \
+  PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD)                                \
                                                                                                        \
   /* VK_NV_inherited_viewport_scissor */                                                               \
   PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV)          \
@@ -5410,6 +5412,80 @@ void Deserialise(const VkPhysicalDeviceVulkan13Properties &el)
   DeserialiseNext(el.pNext);
 }
 
+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceVulkan14Features &el)
+{
+  RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(globalPriorityQuery);
+  SERIALISE_MEMBER(shaderSubgroupRotate);
+  SERIALISE_MEMBER(shaderSubgroupRotateClustered);
+  SERIALISE_MEMBER(shaderFloatControls2);
+  SERIALISE_MEMBER(shaderExpectAssume);
+  SERIALISE_MEMBER(rectangularLines);
+  SERIALISE_MEMBER(bresenhamLines);
+  SERIALISE_MEMBER(smoothLines);
+  SERIALISE_MEMBER(stippledRectangularLines);
+  SERIALISE_MEMBER(stippledBresenhamLines);
+  SERIALISE_MEMBER(stippledSmoothLines);
+  SERIALISE_MEMBER(vertexAttributeInstanceRateDivisor);
+  SERIALISE_MEMBER(vertexAttributeInstanceRateZeroDivisor);
+  SERIALISE_MEMBER(indexTypeUint8);
+  SERIALISE_MEMBER(dynamicRenderingLocalRead);
+  SERIALISE_MEMBER(maintenance5);
+  SERIALISE_MEMBER(maintenance6);
+  SERIALISE_MEMBER(pipelineProtectedAccess);
+  SERIALISE_MEMBER(pipelineRobustness);
+  SERIALISE_MEMBER(hostImageCopy);
+  SERIALISE_MEMBER(pushDescriptor);
+}
+
+template <>
+void Deserialise(const VkPhysicalDeviceVulkan14Features &el)
+{
+  DeserialiseNext(el.pNext);
+}
+
+template <typename SerialiserType>
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceVulkan14Properties &el)
+{
+  RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES);
+  SerialiseNext(ser, el.sType, el.pNext);
+
+  SERIALISE_MEMBER(lineSubPixelPrecisionBits);
+  SERIALISE_MEMBER(maxVertexAttribDivisor);
+  SERIALISE_MEMBER(supportsNonZeroFirstInstance);
+  SERIALISE_MEMBER(maxPushDescriptors);
+  SERIALISE_MEMBER(dynamicRenderingLocalReadDepthStencilAttachments);
+  SERIALISE_MEMBER(dynamicRenderingLocalReadMultisampledAttachments);
+  SERIALISE_MEMBER(earlyFragmentMultisampleCoverageAfterSampleCounting);
+  SERIALISE_MEMBER(earlyFragmentSampleMaskTestBeforeSampleCounting);
+  SERIALISE_MEMBER(depthStencilSwizzleOneSupport);
+  SERIALISE_MEMBER(polygonModePointSize);
+  SERIALISE_MEMBER(nonStrictSinglePixelWideLinesUseParallelogram);
+  SERIALISE_MEMBER(nonStrictWideLinesUseParallelogram);
+  SERIALISE_MEMBER(blockTexelViewCompatibleMultipleLayers);
+  SERIALISE_MEMBER(maxCombinedImageSamplerDescriptorCount);
+  SERIALISE_MEMBER(fragmentShadingRateClampCombinerInputs);
+  SERIALISE_MEMBER(defaultRobustnessStorageBuffers);
+  SERIALISE_MEMBER(defaultRobustnessUniformBuffers);
+  SERIALISE_MEMBER(defaultRobustnessVertexInputs);
+  SERIALISE_MEMBER(defaultRobustnessImages);
+  SERIALISE_MEMBER(copySrcLayoutCount);
+  SERIALISE_MEMBER_ARRAY(pCopySrcLayouts, copySrcLayoutCount);
+  SERIALISE_MEMBER(copyDstLayoutCount);
+  SERIALISE_MEMBER_ARRAY(pCopyDstLayouts, copyDstLayoutCount);
+  SERIALISE_MEMBER(optimalTilingLayoutUUID);
+  SERIALISE_MEMBER(identicalMemoryTypeRequirements);
+}
+
+template <>
+void Deserialise(const VkPhysicalDeviceVulkan14Properties &el)
+{
+  DeserialiseNext(el.pNext);
+}
+
 template <typename SerialiserType>
 void DoSerialise(SerialiserType &ser, VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR &el)
 {
@@ -7177,42 +7253,42 @@ void Deserialise(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &el)
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &el)
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &el)
 {
   RDCASSERT(ser.IsReading() ||
-            el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM);
+            el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT);
   SerialiseNext(ser, el.sType, el.pNext);
 
   SERIALISE_MEMBER(fragmentDensityMapOffset);
 }
 
 template <>
-void Deserialise(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM &el)
+void Deserialise(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &el)
 {
   DeserialiseNext(el.pNext);
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &el)
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &el)
 {
   RDCASSERT(ser.IsReading() ||
-            el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM);
+            el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT);
   SerialiseNext(ser, el.sType, el.pNext);
 
   SERIALISE_MEMBER(fragmentDensityOffsetGranularity);
 }
 
 template <>
-void Deserialise(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM &el)
+void Deserialise(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &el)
 {
   DeserialiseNext(el.pNext);
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkSubpassFragmentDensityMapOffsetEndInfoQCOM &el)
+void DoSerialise(SerialiserType &ser, VkRenderPassFragmentDensityMapOffsetEndInfoEXT &el)
 {
   RDCASSERT(ser.IsReading() ||
-            el.sType == VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM);
+            el.sType == VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT);
   SerialiseNext(ser, el.sType, el.pNext);
 
   SERIALISE_MEMBER(fragmentDensityOffsetCount);
@@ -7220,7 +7296,7 @@ void DoSerialise(SerialiserType &ser, VkSubpassFragmentDensityMapOffsetEndInfoQC
 }
 
 template <>
-void Deserialise(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM &el)
+void Deserialise(const VkRenderPassFragmentDensityMapOffsetEndInfoEXT &el)
 {
   DeserialiseNext(el.pNext);
   delete[] el.pFragmentDensityOffsets;
@@ -8625,7 +8701,7 @@ void DoSerialise(SerialiserType &ser, VkPhysicalDeviceRobustness2PropertiesKHR &
 }
 
 template <>
-void Deserialise(const VkPhysicalDeviceRobustness2PropertiesEXT &el)
+void Deserialise(const VkPhysicalDeviceRobustness2PropertiesKHR &el)
 {
   DeserialiseNext(el.pNext);
 }
@@ -13710,7 +13786,7 @@ void Deserialise(const VkPhysicalDeviceMaintenance5Properties &el)
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance6FeaturesKHR &el)
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance6Features &el)
 {
   RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES);
   SerialiseNext(ser, el.sType, el.pNext);
@@ -13719,13 +13795,13 @@ void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance6FeaturesKHR &e
 }
 
 template <>
-void Deserialise(const VkPhysicalDeviceMaintenance6FeaturesKHR &el)
+void Deserialise(const VkPhysicalDeviceMaintenance6Features &el)
 {
   DeserialiseNext(el.pNext);
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance6PropertiesKHR &el)
+void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance6Properties &el)
 {
   RDCASSERT(ser.IsReading() ||
             el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES);
@@ -13737,13 +13813,13 @@ void DoSerialise(SerialiserType &ser, VkPhysicalDeviceMaintenance6PropertiesKHR
 }
 
 template <>
-void Deserialise(const VkPhysicalDeviceMaintenance6PropertiesKHR &el)
+void Deserialise(const VkPhysicalDeviceMaintenance6Properties &el)
 {
   DeserialiseNext(el.pNext);
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkBindMemoryStatusKHR &el)
+void DoSerialise(SerialiserType &ser, VkBindMemoryStatus &el)
 {
   RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS);
   SerialiseNext(ser, el.sType, el.pNext);
@@ -13753,13 +13829,13 @@ void DoSerialise(SerialiserType &ser, VkBindMemoryStatusKHR &el)
 }
 
 template <>
-void Deserialise(const VkBindMemoryStatusKHR &el)
+void Deserialise(const VkBindMemoryStatus &el)
 {
   DeserialiseNext(el.pNext);
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkBindDescriptorSetsInfoKHR &el)
+void DoSerialise(SerialiserType &ser, VkBindDescriptorSetsInfo &el)
 {
   RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO);
   SerialiseNext(ser, el.sType, el.pNext);
@@ -13774,7 +13850,7 @@ void DoSerialise(SerialiserType &ser, VkBindDescriptorSetsInfoKHR &el)
 }
 
 template <>
-void Deserialise(const VkBindDescriptorSetsInfoKHR &el)
+void Deserialise(const VkBindDescriptorSetsInfo &el)
 {
   DeserialiseNext(el.pNext);
   delete[] el.pDescriptorSets;
@@ -13782,7 +13858,7 @@ void Deserialise(const VkBindDescriptorSetsInfoKHR &el)
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkPushConstantsInfoKHR &el)
+void DoSerialise(SerialiserType &ser, VkPushConstantsInfo &el)
 {
   RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO);
   SerialiseNext(ser, el.sType, el.pNext);
@@ -13795,14 +13871,14 @@ void DoSerialise(SerialiserType &ser, VkPushConstantsInfoKHR &el)
 }
 
 template <>
-void Deserialise(const VkPushConstantsInfoKHR &el)
+void Deserialise(const VkPushConstantsInfo &el)
 {
   DeserialiseNext(el.pNext);
   FreeAlignedBuffer((byte *)el.pValues);
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkPushDescriptorSetInfoKHR &el)
+void DoSerialise(SerialiserType &ser, VkPushDescriptorSetInfo &el)
 {
   RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO);
   SerialiseNext(ser, el.sType, el.pNext);
@@ -13815,14 +13891,14 @@ void DoSerialise(SerialiserType &ser, VkPushDescriptorSetInfoKHR &el)
 }
 
 template <>
-void Deserialise(const VkPushDescriptorSetInfoKHR &el)
+void Deserialise(const VkPushDescriptorSetInfo &el)
 {
   DeserialiseNext(el.pNext);
   delete[] el.pDescriptorWrites;
 }
 
 template <typename SerialiserType>
-void DoSerialise(SerialiserType &ser, VkPushDescriptorSetWithTemplateInfoKHR &el)
+void DoSerialise(SerialiserType &ser, VkPushDescriptorSetWithTemplateInfo &el)
 {
   RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO);
   SerialiseNext(ser, el.sType, el.pNext);
@@ -13836,7 +13912,7 @@ void DoSerialise(SerialiserType &ser, VkPushDescriptorSetWithTemplateInfoKHR &el
 }
 
 template <>
-void Deserialise(const VkPushDescriptorSetWithTemplateInfoKHR &el)
+void Deserialise(const VkPushDescriptorSetWithTemplateInfo &el)
 {
   DeserialiseNext(el.pNext);
 }
@@ -14419,12 +14495,12 @@ INSTANTIATE_SERIALISE_TYPE(VkAttachmentSampleLocationsEXT);
 INSTANTIATE_SERIALISE_TYPE(VkBindBufferMemoryDeviceGroupInfo);
 INSTANTIATE_SERIALISE_TYPE(VkBindBufferMemoryInfo);
 INSTANTIATE_SERIALISE_TYPE(VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
-INSTANTIATE_SERIALISE_TYPE(VkBindDescriptorSetsInfoKHR);
+INSTANTIATE_SERIALISE_TYPE(VkBindDescriptorSetsInfo);
 INSTANTIATE_SERIALISE_TYPE(VkBindImageMemoryDeviceGroupInfo);
 INSTANTIATE_SERIALISE_TYPE(VkBindImageMemoryInfo);
 INSTANTIATE_SERIALISE_TYPE(VkBindImageMemorySwapchainInfoKHR);
 INSTANTIATE_SERIALISE_TYPE(VkBindImagePlaneMemoryInfo);
-INSTANTIATE_SERIALISE_TYPE(VkBindMemoryStatusKHR);
+INSTANTIATE_SERIALISE_TYPE(VkBindMemoryStatus);
 INSTANTIATE_SERIALISE_TYPE(VkBindSparseInfo);
 INSTANTIATE_SERIALISE_TYPE(VkBlitImageInfo2);
 INSTANTIATE_SERIALISE_TYPE(VkBufferCaptureDescriptorDataInfoEXT);
@@ -14637,8 +14713,8 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFloatControlsProperties);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapFeaturesEXT);
-INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM);
-INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentDensityMapPropertiesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR);
@@ -14674,8 +14750,8 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance4Features);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance4Properties);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance5Features);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance5Properties);
-INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance6FeaturesKHR);
-INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance6PropertiesKHR);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance6Features);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance6Properties);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance7FeaturesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance7PropertiesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceMaintenance8FeaturesKHR);
@@ -14723,8 +14799,8 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRayTracingPipelineFeaturesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRayTracingPipelinePropertiesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
-INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRobustness2FeaturesEXT);
-INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRobustness2PropertiesEXT);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRobustness2FeaturesKHR);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceRobustness2PropertiesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceSampleLocationsPropertiesEXT);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceSamplerFilterMinmaxProperties);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceSamplerYcbcrConversionFeatures);
@@ -14782,6 +14858,8 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan12Features);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan12Properties);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan13Features);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan13Properties);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan14Features);
+INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkan14Properties);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceVulkanMemoryModelFeatures);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT);
@@ -14831,9 +14909,9 @@ INSTANTIATE_SERIALISE_TYPE(VkPresentTimesInfoGOOGLE);
 INSTANTIATE_SERIALISE_TYPE(VkPresentWait2InfoKHR);
 INSTANTIATE_SERIALISE_TYPE(VkPrivateDataSlotCreateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkProtectedSubmitInfo);
-INSTANTIATE_SERIALISE_TYPE(VkPushConstantsInfoKHR);
-INSTANTIATE_SERIALISE_TYPE(VkPushDescriptorSetInfoKHR);
-INSTANTIATE_SERIALISE_TYPE(VkPushDescriptorSetWithTemplateInfoKHR);
+INSTANTIATE_SERIALISE_TYPE(VkPushConstantsInfo);
+INSTANTIATE_SERIALISE_TYPE(VkPushDescriptorSetInfo);
+INSTANTIATE_SERIALISE_TYPE(VkPushDescriptorSetWithTemplateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkQueryPoolCreateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkQueryPoolPerformanceCreateInfoKHR);
 INSTANTIATE_SERIALISE_TYPE(VkQueueFamilyGlobalPriorityProperties);
@@ -14856,6 +14934,7 @@ INSTANTIATE_SERIALISE_TYPE(VkRenderPassBeginInfo);
 INSTANTIATE_SERIALISE_TYPE(VkRenderPassCreateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkRenderPassCreateInfo2);
 INSTANTIATE_SERIALISE_TYPE(VkRenderPassFragmentDensityMapCreateInfoEXT);
+INSTANTIATE_SERIALISE_TYPE(VkRenderPassFragmentDensityMapOffsetEndInfoEXT);
 INSTANTIATE_SERIALISE_TYPE(VkRenderPassInputAttachmentAspectCreateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkRenderPassMultiviewCreateInfo);
 INSTANTIATE_SERIALISE_TYPE(VkRenderPassSampleLocationsBeginInfoEXT);
@@ -14889,7 +14968,6 @@ INSTANTIATE_SERIALISE_TYPE(VkSubpassDependency2);
 INSTANTIATE_SERIALISE_TYPE(VkSubpassDescription2);
 INSTANTIATE_SERIALISE_TYPE(VkSubpassDescriptionDepthStencilResolve);
 INSTANTIATE_SERIALISE_TYPE(VkSubpassEndInfo);
-INSTANTIATE_SERIALISE_TYPE(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
 INSTANTIATE_SERIALISE_TYPE(VkSubpassResolvePerformanceQueryEXT);
 INSTANTIATE_SERIALISE_TYPE(VkSubpassSampleLocationsEXT);
 INSTANTIATE_SERIALISE_TYPE(VkSubresourceHostMemcpySize);

renderdoc/driver/vulkan/vk_state.cpp

@@ -785,7 +785,7 @@ void VulkanRenderState::BindDynamicState(WrappedVulkan *vk, VkCommandBuffer cmd)
       type = VK_INDEX_TYPE_UINT8;
 
     if(vk->Maintenance5() && ibuffer.size != VK_WHOLE_SIZE)
-      ObjDisp(cmd)->CmdBindIndexBuffer2KHR(
+      ObjDisp(cmd)->CmdBindIndexBuffer2(
           Unwrap(cmd), Unwrap(vk->GetResourceManager()->GetCurrentHandle<VkBuffer>(ibuffer.buf)),
           ibuffer.offs, ibuffer.size, type);
     else
@@ -802,8 +802,8 @@ void VulkanRenderState::BindDynamicState(WrappedVulkan *vk, VkCommandBuffer cmd)
       type = VK_INDEX_TYPE_UINT8;
 
     if(vk->Maintenance5() && ibuffer.size != VK_WHOLE_SIZE)
-      ObjDisp(cmd)->CmdBindIndexBuffer2KHR(Unwrap(cmd), VK_NULL_HANDLE, ibuffer.offs, ibuffer.size,
-                                           type);
+      ObjDisp(cmd)->CmdBindIndexBuffer2(Unwrap(cmd), VK_NULL_HANDLE, ibuffer.offs, ibuffer.size,
+                                        type);
     else
       ObjDisp(cmd)->CmdBindIndexBuffer(Unwrap(cmd), VK_NULL_HANDLE, ibuffer.offs, type);
   }
@@ -1375,8 +1375,8 @@ void VulkanRenderState::BindDescriptorSet(WrappedVulkan *vk, const DescSetLayout
       push.pTexelBufferView = NULL;
     }
 
-    ObjDisp(cmd)->CmdPushDescriptorSetKHR(Unwrap(cmd), bindPoint, Unwrap(layout), setIndex,
-                                          (uint32_t)writes.size(), writes.data());
+    ObjDisp(cmd)->CmdPushDescriptorSet(Unwrap(cmd), bindPoint, Unwrap(layout), setIndex,
+                                       (uint32_t)writes.size(), writes.data());
 
     // delete allocated arrays for descriptor writes
     for(VkDescriptorBufferInfo *a : allocBufWrites)

renderdoc/driver/vulkan/vk_stringise.cpp

@@ -130,8 +130,8 @@ rdcstr DoStringise(const VulkanChunk &el)
     STRINGISE_ENUM_CLASS(vkRegisterDeviceEventEXT);
     STRINGISE_ENUM_CLASS(vkRegisterDisplayEventEXT);
     STRINGISE_ENUM_CLASS_NAMED(vkCmdIndirectSubCommand, "Indirect sub-command");
-    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSetKHR);
-    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSetWithTemplateKHR);
+    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSet);
+    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSetWithTemplate);
     STRINGISE_ENUM_CLASS(vkCreateDescriptorUpdateTemplate);
     STRINGISE_ENUM_CLASS(vkUpdateDescriptorSetWithTemplate);
     STRINGISE_ENUM_CLASS(vkBindBufferMemory2);
@@ -167,7 +167,7 @@ rdcstr DoStringise(const VulkanChunk &el)
     STRINGISE_ENUM_CLASS_NAMED(DeviceMemoryRefs, "Internal::Device Memory References")
     STRINGISE_ENUM_CLASS(vkResetQueryPool);
     STRINGISE_ENUM_CLASS_NAMED(ImageRefs, "Internal::Image References")
-    STRINGISE_ENUM_CLASS(vkCmdSetLineStippleKHR);
+    STRINGISE_ENUM_CLASS(vkCmdSetLineStipple);
     STRINGISE_ENUM_CLASS(vkGetSemaphoreCounterValue);
     STRINGISE_ENUM_CLASS(vkWaitSemaphores);
     STRINGISE_ENUM_CLASS(vkSignalSemaphore);
@@ -245,11 +245,11 @@ rdcstr DoStringise(const VulkanChunk &el)
     STRINGISE_ENUM_CLASS(vkCmdTraceRaysIndirectKHR)
     STRINGISE_ENUM_CLASS(vkCmdTraceRaysKHR)
     STRINGISE_ENUM_CLASS(vkCreateRayTracingPipelinesKHR)
-    STRINGISE_ENUM_CLASS(vkCmdSetRenderingAttachmentLocationsKHR)
-    STRINGISE_ENUM_CLASS(vkCmdSetRenderingInputAttachmentIndicesKHR)
+    STRINGISE_ENUM_CLASS(vkCmdSetRenderingAttachmentLocations)
+    STRINGISE_ENUM_CLASS(vkCmdSetRenderingInputAttachmentIndices)
     STRINGISE_ENUM_CLASS(vkCmdTraceRaysIndirect2KHR)
     STRINGISE_ENUM_CLASS(vkCmdWriteAccelerationStructuresPropertiesKHR)
-    STRINGISE_ENUM_CLASS(vkCmdBindIndexBuffer2KHR)
+    STRINGISE_ENUM_CLASS(vkCmdBindIndexBuffer2)
     STRINGISE_ENUM_CLASS(vkGetDescriptorEXT)
     STRINGISE_ENUM_CLASS(vkCmdBindDescriptorBuffersEXT)
     STRINGISE_ENUM_CLASS(vkCmdSetDescriptorBufferOffsetsEXT)
@@ -258,13 +258,13 @@ rdcstr DoStringise(const VulkanChunk &el)
     STRINGISE_ENUM_CLASS(vkCopyImageToMemory)
     STRINGISE_ENUM_CLASS(vkCopyMemoryToImage)
     STRINGISE_ENUM_CLASS(vkTransitionImageLayout)
-    STRINGISE_ENUM_CLASS(vkUnmapMemory2KHR)
-    STRINGISE_ENUM_CLASS(vkCmdBindDescriptorSets2KHR)
-    STRINGISE_ENUM_CLASS(vkCmdPushConstants2KHR)
+    STRINGISE_ENUM_CLASS(vkUnmapMemory2)
+    STRINGISE_ENUM_CLASS(vkCmdBindDescriptorSets2)
+    STRINGISE_ENUM_CLASS(vkCmdPushConstants2)
     STRINGISE_ENUM_CLASS(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)
     STRINGISE_ENUM_CLASS(vkCmdSetDescriptorBufferOffsets2EXT)
-    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSet2KHR)
-    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSetWithTemplate2KHR)
+    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSet2)
+    STRINGISE_ENUM_CLASS(vkCmdPushDescriptorSetWithTemplate2)
     STRINGISE_ENUM_CLASS_NAMED(Max, "Max Chunk");
   }
   END_ENUM_STRINGISE()
@@ -612,7 +612,7 @@ rdcstr DoStringise(const VkImageCreateFlagBits &el)
     STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT);
     STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT);
     STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT);
-    STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM);
+    STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT);
     STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR);
   }
   END_BITFIELD_STRINGISE();
@@ -4490,10 +4490,10 @@ rdcstr DoStringise(const VkBuildAccelerationStructureFlagBitsKHR &el)
     STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR)
     STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR)
     STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV)
-    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT)
-    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT)
-    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT)
-    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR)
+    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT)
+    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT)
+    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT)
+    STRINGISE_ENUM(VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR)
   }
   END_ENUM_STRINGISE();
 }
@@ -4552,8 +4552,8 @@ rdcstr DoStringise(const VkGeometryInstanceFlagBitsKHR &el)
     STRINGISE_ENUM(VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR)
     STRINGISE_ENUM(VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR)
     STRINGISE_ENUM(VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR)
-    STRINGISE_ENUM(VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT)
-    STRINGISE_ENUM(VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT)
+    STRINGISE_ENUM(VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT)
+    STRINGISE_ENUM(VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT)
   }
   END_ENUM_STRINGISE();
 }

renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp

@@ -3326,10 +3326,10 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass2(SerialiserType &ser, VkCommand
         m_BakedCmdBufferInfo[m_LastCmdBufferID].renderPassOpen = false;
         m_BakedCmdBufferInfo[m_LastCmdBufferID].endBarriers.append(GetImplicitRenderPassBarriers(~0U));
 
-        const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *fragmentDensityOffsetStruct =
-            (const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *)FindNextStruct(
+        const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *fragmentDensityOffsetStruct =
+            (const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *)FindNextStruct(
                 &unwrappedEndInfo,
-                VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM);
+                VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT);
 
         if(fragmentDensityOffsetStruct)
         {
@@ -3986,7 +3986,7 @@ void WrappedVulkan::vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets2KHR(
+bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets2(
     SerialiserType &ser, VkCommandBuffer commandBuffer,
     const VkBindDescriptorSetsInfo *pBindDescriptorSetsInfo)
 {
@@ -4014,7 +4014,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets2KHR(
       {
         commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
 
-        ObjDisp(commandBuffer)->CmdBindDescriptorSets2KHR(Unwrap(commandBuffer), unwrappedInfo);
+        ObjDisp(commandBuffer)->CmdBindDescriptorSets2(Unwrap(commandBuffer), unwrappedInfo);
 
         {
           VulkanRenderState &renderstate = GetCmdRenderState();
@@ -4093,15 +4093,15 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets2KHR(
         }
       }
 
-      ObjDisp(commandBuffer)->CmdBindDescriptorSets2KHR(Unwrap(commandBuffer), unwrappedInfo);
+      ObjDisp(commandBuffer)->CmdBindDescriptorSets2(Unwrap(commandBuffer), unwrappedInfo);
     }
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer,
-                                                const VkBindDescriptorSetsInfo *pBindDescriptorSetsInfo)
+void WrappedVulkan::vkCmdBindDescriptorSets2(VkCommandBuffer commandBuffer,
+                                             const VkBindDescriptorSetsInfo *pBindDescriptorSetsInfo)
 {
   SCOPED_DBG_SINK();
 
@@ -4110,7 +4110,7 @@ void WrappedVulkan::vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer,
       UnwrapStructAndChain(m_State, tempMem, pBindDescriptorSetsInfo);
 
   SERIALISE_TIME_CALL(
-      ObjDisp(commandBuffer)->CmdBindDescriptorSets2KHR(Unwrap(commandBuffer), unwrappedInfo));
+      ObjDisp(commandBuffer)->CmdBindDescriptorSets2(Unwrap(commandBuffer), unwrappedInfo));
 
   if(IsCaptureMode(m_State))
   {
@@ -4118,8 +4118,8 @@ void WrappedVulkan::vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer,
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdBindDescriptorSets2KHR);
-    Serialise_vkCmdBindDescriptorSets2KHR(ser, commandBuffer, pBindDescriptorSetsInfo);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdBindDescriptorSets2);
+    Serialise_vkCmdBindDescriptorSets2(ser, commandBuffer, pBindDescriptorSetsInfo);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
     record->MarkResourceFrameReferenced(GetResID(pBindDescriptorSetsInfo->layout), eFrameRef_Read);
@@ -4502,9 +4502,8 @@ void WrappedVulkan::vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipeline
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdPushConstants2KHR(SerialiserType &ser,
-                                                     VkCommandBuffer commandBuffer,
-                                                     const VkPushConstantsInfo *pPushConstantsInfo)
+bool WrappedVulkan::Serialise_vkCmdPushConstants2(SerialiserType &ser, VkCommandBuffer commandBuffer,
+                                                  const VkPushConstantsInfo *pPushConstantsInfo)
 {
   SERIALISE_ELEMENT(commandBuffer);
   SERIALISE_ELEMENT_LOCAL(PushConstantsInfo, *pPushConstantsInfo);
@@ -4525,7 +4524,7 @@ bool WrappedVulkan::Serialise_vkCmdPushConstants2KHR(SerialiserType &ser,
       if(InRerecordRange(m_LastCmdBufferID))
       {
         commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
-        ObjDisp(commandBuffer)->CmdPushConstants2KHR(Unwrap(commandBuffer), unwrappedInfo);
+        ObjDisp(commandBuffer)->CmdPushConstants2(Unwrap(commandBuffer), unwrappedInfo);
 
         {
           VulkanRenderState &renderstate = GetCmdRenderState();
@@ -4545,23 +4544,22 @@ bool WrappedVulkan::Serialise_vkCmdPushConstants2KHR(SerialiserType &ser,
     }
     else
     {
-      ObjDisp(commandBuffer)->CmdPushConstants2KHR(Unwrap(commandBuffer), unwrappedInfo);
+      ObjDisp(commandBuffer)->CmdPushConstants2(Unwrap(commandBuffer), unwrappedInfo);
     }
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer,
-                                           const VkPushConstantsInfo *pPushConstantsInfo)
+void WrappedVulkan::vkCmdPushConstants2(VkCommandBuffer commandBuffer,
+                                        const VkPushConstantsInfo *pPushConstantsInfo)
 {
   SCOPED_DBG_SINK();
 
   byte *tempMem = GetTempMemory(GetNextPatchSize(pPushConstantsInfo));
   VkPushConstantsInfo *unwrappedInfo = UnwrapStructAndChain(m_State, tempMem, pPushConstantsInfo);
 
-  SERIALISE_TIME_CALL(
-      ObjDisp(commandBuffer)->CmdPushConstants2KHR(Unwrap(commandBuffer), unwrappedInfo));
+  SERIALISE_TIME_CALL(ObjDisp(commandBuffer)->CmdPushConstants2(Unwrap(commandBuffer), unwrappedInfo));
 
   if(IsCaptureMode(m_State))
   {
@@ -4569,8 +4567,8 @@ void WrappedVulkan::vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer,
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushConstants2KHR);
-    Serialise_vkCmdPushConstants2KHR(ser, commandBuffer, pPushConstantsInfo);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushConstants2);
+    Serialise_vkCmdPushConstants2(ser, commandBuffer, pPushConstantsInfo);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
     record->MarkResourceFrameReferenced(GetResID(pPushConstantsInfo->layout), eFrameRef_Read);
@@ -6149,12 +6147,12 @@ void WrappedVulkan::ApplyPushDescriptorWrites(VkPipelineBindPoint pipelineBindPo
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetKHR(SerialiserType &ser,
-                                                        VkCommandBuffer commandBuffer,
-                                                        VkPipelineBindPoint pipelineBindPoint,
-                                                        VkPipelineLayout layout, uint32_t set,
-                                                        uint32_t descriptorWriteCount,
-                                                        const VkWriteDescriptorSet *pDescriptorWrites)
+bool WrappedVulkan::Serialise_vkCmdPushDescriptorSet(SerialiserType &ser,
+                                                     VkCommandBuffer commandBuffer,
+                                                     VkPipelineBindPoint pipelineBindPoint,
+                                                     VkPipelineLayout layout, uint32_t set,
+                                                     uint32_t descriptorWriteCount,
+                                                     const VkWriteDescriptorSet *pDescriptorWrites)
 {
   SERIALISE_ELEMENT(commandBuffer);
   SERIALISE_ELEMENT(pipelineBindPoint);
@@ -6232,19 +6230,19 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetKHR(SerialiserType &ser,
       UnwrapDescriptorWritesInPlace((VkWriteDescriptorSet *)pDescriptorWrites, descriptorWriteCount);
 
       ObjDisp(commandBuffer)
-          ->CmdPushDescriptorSetKHR(Unwrap(commandBuffer), pipelineBindPoint, Unwrap(layout), set,
-                                    descriptorWriteCount, pDescriptorWrites);
+          ->CmdPushDescriptorSet(Unwrap(commandBuffer), pipelineBindPoint, Unwrap(layout), set,
+                                 descriptorWriteCount, pDescriptorWrites);
     }
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
-                                              VkPipelineBindPoint pipelineBindPoint,
-                                              VkPipelineLayout layout, uint32_t set,
-                                              uint32_t descriptorWriteCount,
-                                              const VkWriteDescriptorSet *pDescriptorWrites)
+void WrappedVulkan::vkCmdPushDescriptorSet(VkCommandBuffer commandBuffer,
+                                           VkPipelineBindPoint pipelineBindPoint,
+                                           VkPipelineLayout layout, uint32_t set,
+                                           uint32_t descriptorWriteCount,
+                                           const VkWriteDescriptorSet *pDescriptorWrites)
 {
   SCOPED_DBG_SINK();
 
@@ -6385,9 +6383,9 @@ void WrappedVulkan::vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
     }
 
     SERIALISE_TIME_CALL(ObjDisp(commandBuffer)
-                            ->CmdPushDescriptorSetKHR(Unwrap(commandBuffer), pipelineBindPoint,
-                                                      Unwrap(layout), set, descriptorWriteCount,
-                                                      unwrappedWrites));
+                            ->CmdPushDescriptorSet(Unwrap(commandBuffer), pipelineBindPoint,
+                                                   Unwrap(layout), set, descriptorWriteCount,
+                                                   unwrappedWrites));
   }
 
   if(IsCaptureMode(m_State))
@@ -6403,9 +6401,9 @@ void WrappedVulkan::vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
     for(uint32_t i = 0; i < descriptorWriteCount; i++)
       sanitised[i].dstSet = VK_NULL_HANDLE;
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSetKHR);
-    Serialise_vkCmdPushDescriptorSetKHR(ser, commandBuffer, pipelineBindPoint, layout, set,
-                                        descriptorWriteCount, sanitised);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSet);
+    Serialise_vkCmdPushDescriptorSet(ser, commandBuffer, pipelineBindPoint, layout, set,
+                                     descriptorWriteCount, sanitised);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
     record->MarkResourceFrameReferenced(GetResID(layout), eFrameRef_Read);
@@ -6414,7 +6412,7 @@ void WrappedVulkan::vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplateKHR(
+bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplate(
     SerialiserType &ser, VkCommandBuffer commandBuffer,
     VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set,
     const void *pData)
@@ -6508,15 +6506,15 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplateKHR(
                                     apply.writes.count());
 
       ObjDisp(commandBuffer)
-          ->CmdPushDescriptorSetKHR(Unwrap(commandBuffer), bindPoint, Unwrap(layout), set,
-                                    (uint32_t)apply.writes.size(), apply.writes.data());
+          ->CmdPushDescriptorSet(Unwrap(commandBuffer), bindPoint, Unwrap(layout), set,
+                                 (uint32_t)apply.writes.size(), apply.writes.data());
     }
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdPushDescriptorSetWithTemplateKHR(
+void WrappedVulkan::vkCmdPushDescriptorSetWithTemplate(
     VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
     VkPipelineLayout layout, uint32_t set, const void *pData)
 {
@@ -6535,9 +6533,9 @@ void WrappedVulkan::vkCmdPushDescriptorSetWithTemplateKHR(
     refs.UnwrapAndGatherRefs(tempInfo, tempMem, pData);
 
     SERIALISE_TIME_CALL(ObjDisp(commandBuffer)
-                            ->CmdPushDescriptorSetWithTemplateKHR(Unwrap(commandBuffer),
-                                                                  Unwrap(descriptorUpdateTemplate),
-                                                                  Unwrap(layout), set, tempMem));
+                            ->CmdPushDescriptorSetWithTemplate(Unwrap(commandBuffer),
+                                                               Unwrap(descriptorUpdateTemplate),
+                                                               Unwrap(layout), set, tempMem));
   }
 
   if(IsCaptureMode(m_State))
@@ -6546,9 +6544,9 @@ void WrappedVulkan::vkCmdPushDescriptorSetWithTemplateKHR(
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSetWithTemplateKHR);
-    Serialise_vkCmdPushDescriptorSetWithTemplateKHR(ser, commandBuffer, descriptorUpdateTemplate,
-                                                    layout, set, pData);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSetWithTemplate);
+    Serialise_vkCmdPushDescriptorSetWithTemplate(ser, commandBuffer, descriptorUpdateTemplate,
+                                                 layout, set, pData);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
     record->MarkResourceFrameReferenced(GetResID(descriptorUpdateTemplate), eFrameRef_Read);
@@ -8924,10 +8922,10 @@ void WrappedVulkan::vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2KHR(SerialiserType &ser,
-                                                       VkCommandBuffer commandBuffer,
-                                                       VkBuffer buffer, VkDeviceSize offset,
-                                                       VkDeviceSize size, VkIndexType indexType)
+bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2(SerialiserType &ser,
+                                                    VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                    VkDeviceSize offset, VkDeviceSize size,
+                                                    VkIndexType indexType)
 {
   SERIALISE_ELEMENT(commandBuffer);
   SERIALISE_ELEMENT(buffer).Important();
@@ -8949,7 +8947,7 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2KHR(SerialiserType &ser,
       {
         commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
         ObjDisp(commandBuffer)
-            ->CmdBindIndexBuffer2KHR(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType);
+            ->CmdBindIndexBuffer2(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType);
 
         {
           VulkanRenderState &renderstate = GetCmdRenderState();
@@ -8959,7 +8957,7 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2KHR(SerialiserType &ser,
 
           if(indexType == VK_INDEX_TYPE_UINT32)
             renderstate.ibuffer.bytewidth = 4;
-          else if(indexType == VK_INDEX_TYPE_UINT8_KHR)
+          else if(indexType == VK_INDEX_TYPE_UINT8)
             renderstate.ibuffer.bytewidth = 1;
           else
             renderstate.ibuffer.bytewidth = 2;
@@ -8971,7 +8969,7 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2KHR(SerialiserType &ser,
       // track while reading, as we need to bind current topology & index byte width in AddAction
       if(indexType == VK_INDEX_TYPE_UINT32)
         m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 4;
-      else if(indexType == VK_INDEX_TYPE_UINT8_KHR)
+      else if(indexType == VK_INDEX_TYPE_UINT8)
         m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 1;
       else
         m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.bytewidth = 2;
@@ -8980,22 +8978,22 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer2KHR(SerialiserType &ser,
       m_BakedCmdBufferInfo[m_LastCmdBufferID].state.ibuffer.buf = GetResID(buffer);
 
       ObjDisp(commandBuffer)
-          ->CmdBindIndexBuffer2KHR(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType);
+          ->CmdBindIndexBuffer2(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType);
     }
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                             VkDeviceSize offset, VkDeviceSize size,
-                                             VkIndexType indexType)
+void WrappedVulkan::vkCmdBindIndexBuffer2(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                          VkDeviceSize offset, VkDeviceSize size,
+                                          VkIndexType indexType)
 {
   SCOPED_DBG_SINK();
 
   SERIALISE_TIME_CALL(
       ObjDisp(commandBuffer)
-          ->CmdBindIndexBuffer2KHR(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType));
+          ->CmdBindIndexBuffer2(Unwrap(commandBuffer), Unwrap(buffer), offset, size, indexType));
 
   if(IsCaptureMode(m_State))
   {
@@ -9003,8 +9001,8 @@ void WrappedVulkan::vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBu
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdBindIndexBuffer2KHR);
-    Serialise_vkCmdBindIndexBuffer2KHR(ser, commandBuffer, buffer, offset, size, indexType);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdBindIndexBuffer2);
+    Serialise_vkCmdBindIndexBuffer2(ser, commandBuffer, buffer, offset, size, indexType);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
     record->MarkBufferFrameReferenced(GetRecord(buffer), offset, size, eFrameRef_Read);
@@ -9627,7 +9625,7 @@ void WrappedVulkan::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdPushDescriptorSet2KHR(
+bool WrappedVulkan::Serialise_vkCmdPushDescriptorSet2(
     SerialiserType &ser, VkCommandBuffer commandBuffer,
     const VkPushDescriptorSetInfo *pPushDescriptorSetInfo)
 {
@@ -9723,15 +9721,15 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSet2KHR(
       UnwrapNextChain(m_State, "VkPushDescriptorSetInfo", tempMem,
                       (VkBaseInStructure *)&unwrappedInfo);
 
-      ObjDisp(commandBuffer)->CmdPushDescriptorSet2KHR(Unwrap(commandBuffer), &unwrappedInfo);
+      ObjDisp(commandBuffer)->CmdPushDescriptorSet2(Unwrap(commandBuffer), &unwrappedInfo);
     }
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer,
-                                               const VkPushDescriptorSetInfo *pPushDescriptorSetInfo)
+void WrappedVulkan::vkCmdPushDescriptorSet2(VkCommandBuffer commandBuffer,
+                                            const VkPushDescriptorSetInfo *pPushDescriptorSetInfo)
 {
   SCOPED_DBG_SINK();
 
@@ -9740,7 +9738,7 @@ void WrappedVulkan::vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer,
       UnwrapStructAndChain(m_State, tempMem, pPushDescriptorSetInfo);
 
   SERIALISE_TIME_CALL(
-      ObjDisp(commandBuffer)->CmdPushDescriptorSet2KHR(Unwrap(commandBuffer), unwrappedInfo));
+      ObjDisp(commandBuffer)->CmdPushDescriptorSet2(Unwrap(commandBuffer), unwrappedInfo));
 
   if(IsCaptureMode(m_State))
   {
@@ -9759,8 +9757,8 @@ void WrappedVulkan::vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer,
     VkPushDescriptorSetInfo sanitisedInfo = *pPushDescriptorSetInfo;
     sanitisedInfo.pDescriptorWrites = sanitised;
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSet2KHR);
-    Serialise_vkCmdPushDescriptorSet2KHR(ser, commandBuffer, &sanitisedInfo);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSet2);
+    Serialise_vkCmdPushDescriptorSet2(ser, commandBuffer, &sanitisedInfo);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
     record->MarkResourceFrameReferenced(GetResID(pPushDescriptorSetInfo->layout), eFrameRef_Read);
@@ -9770,7 +9768,7 @@ void WrappedVulkan::vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer,
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplate2KHR(
+bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplate2(
     SerialiserType &ser, VkCommandBuffer commandBuffer,
     const VkPushDescriptorSetWithTemplateInfo *pPushDescriptorSetWithTemplateInfo)
 {
@@ -9885,14 +9883,14 @@ bool WrappedVulkan::Serialise_vkCmdPushDescriptorSetWithTemplate2KHR(
       UnwrapNextChain(m_State, "VkPushDescriptorSetInfo", tempMem,
                       (VkBaseInStructure *)&unwrappedInfo);
 
-      ObjDisp(commandBuffer)->CmdPushDescriptorSet2KHR(Unwrap(commandBuffer), &unwrappedInfo);
+      ObjDisp(commandBuffer)->CmdPushDescriptorSet2(Unwrap(commandBuffer), &unwrappedInfo);
     }
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdPushDescriptorSetWithTemplate2KHR(
+void WrappedVulkan::vkCmdPushDescriptorSetWithTemplate2(
     VkCommandBuffer commandBuffer,
     const VkPushDescriptorSetWithTemplateInfo *pPushDescriptorSetWithTemplateInfo)
 {
@@ -9919,8 +9917,7 @@ void WrappedVulkan::vkCmdPushDescriptorSetWithTemplate2KHR(
     unwrappedInfo.pData = tempMem;
 
     SERIALISE_TIME_CALL(
-        ObjDisp(commandBuffer)
-            ->CmdPushDescriptorSetWithTemplate2KHR(Unwrap(commandBuffer), &unwrappedInfo));
+        ObjDisp(commandBuffer)->CmdPushDescriptorSetWithTemplate2(Unwrap(commandBuffer), &unwrappedInfo));
   }
 
   if(IsCaptureMode(m_State))
@@ -9929,9 +9926,9 @@ void WrappedVulkan::vkCmdPushDescriptorSetWithTemplate2KHR(
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSetWithTemplate2KHR);
-    Serialise_vkCmdPushDescriptorSetWithTemplate2KHR(ser, commandBuffer,
-                                                     pPushDescriptorSetWithTemplateInfo);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdPushDescriptorSetWithTemplate2);
+    Serialise_vkCmdPushDescriptorSetWithTemplate2(ser, commandBuffer,
+                                                  pPushDescriptorSetWithTemplateInfo);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
     record->MarkResourceFrameReferenced(
@@ -9982,7 +9979,7 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets, VkCommandBuffer c
                                 const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
                                 const uint32_t *pDynamicOffsets);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets2KHR, VkCommandBuffer commandBuffer,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets2, VkCommandBuffer commandBuffer,
                                 const VkBindDescriptorSetsInfo *pBindDescriptorSetsInfo);
 
 INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer, VkCommandBuffer commandBuffer,
@@ -9996,7 +9993,7 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushConstants, VkCommandBuffer comman
                                 VkPipelineLayout layout, VkShaderStageFlags stageFlags,
                                 uint32_t offset, uint32_t size, const void *pValues);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushConstants2KHR, VkCommandBuffer commandBuffer,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushConstants2, VkCommandBuffer commandBuffer,
                                 const VkPushConstantsInfo *pPushConstantsInfo);
 
 INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPipelineBarrier, VkCommandBuffer commandBuffer,
@@ -10037,12 +10034,12 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDebugMarkerEndEXT, VkCommandBuffer co
 INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDebugMarkerInsertEXT, VkCommandBuffer commandBuffer,
                                 const VkDebugMarkerMarkerInfoEXT *pMarker);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSetKHR, VkCommandBuffer commandBuffer,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSet, VkCommandBuffer commandBuffer,
                                 VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
                                 uint32_t set, uint32_t descriptorWriteCount,
                                 const VkWriteDescriptorSet *pDescriptorWrites);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSetWithTemplateKHR,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSetWithTemplate,
                                 VkCommandBuffer commandBuffer,
                                 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
                                 VkPipelineLayout layout, uint32_t set, const void *pData);
@@ -10140,7 +10137,7 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindShadersEXT, VkCommandBuffer comma
                                 uint32_t stageCount, const VkShaderStageFlagBits *pStages,
                                 const VkShaderEXT *pShaders);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer2KHR, VkCommandBuffer commandBuffer,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer2, VkCommandBuffer commandBuffer,
                                 VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
                                 VkIndexType indexType);
 
@@ -10162,8 +10159,8 @@ INSTANTIATE_FUNCTION_SERIALISED(
     void, vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, VkCommandBuffer commandBuffer,
     const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSet2KHR, VkCommandBuffer commandBuffer,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdPushDescriptorSet2, VkCommandBuffer commandBuffer,
                                 const VkPushDescriptorSetInfo *pPushDescriptorSetInfo);
 INSTANTIATE_FUNCTION_SERIALISED(
-    void, vkCmdPushDescriptorSetWithTemplate2KHR, VkCommandBuffer commandBuffer,
+    void, vkCmdPushDescriptorSetWithTemplate2, VkCommandBuffer commandBuffer,
     const VkPushDescriptorSetWithTemplateInfo *pPushDescriptorSetWithTemplateInfo);

renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp

@@ -1776,7 +1776,7 @@ bool WrappedVulkan::Serialise_vkCreateDescriptorSetLayout(
                                                   &CreateInfo);
 
         if((CreateInfo.flags & (VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT |
-                                VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR)) ==
+                                VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT)) ==
            VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT)
         {
           // fetch actual offsets. Sizes we defer due to possible mutable descriptors

renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp

@@ -2366,6 +2366,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
     VkPhysicalDeviceDescriptorIndexingFeatures descIndexingFeatures = {};
     VkPhysicalDeviceVulkan12Features vulkan12Features = {};
     VkPhysicalDeviceVulkan13Features vulkan13Features = {};
+    VkPhysicalDeviceVulkan14Features vulkan14Features = {};
     VkPhysicalDeviceSynchronization2Features sync2 = {};
 
     if(ObjDisp(physicalDevice)->GetPhysicalDeviceFeatures2)
@@ -2482,6 +2483,38 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
       }
       END_PHYS_EXT_CHECK();
 
+      BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceVulkan14Features,
+                           VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES);
+      {
+        vulkan14Features = *ext;
+
+        CHECK_PHYS_EXT_FEATURE(globalPriorityQuery);
+        CHECK_PHYS_EXT_FEATURE(shaderSubgroupRotate);
+        CHECK_PHYS_EXT_FEATURE(shaderSubgroupRotateClustered);
+        CHECK_PHYS_EXT_FEATURE(shaderFloatControls2);
+        CHECK_PHYS_EXT_FEATURE(shaderExpectAssume);
+        CHECK_PHYS_EXT_FEATURE(rectangularLines);
+        CHECK_PHYS_EXT_FEATURE(bresenhamLines);
+        CHECK_PHYS_EXT_FEATURE(smoothLines);
+        CHECK_PHYS_EXT_FEATURE(stippledRectangularLines);
+        CHECK_PHYS_EXT_FEATURE(stippledBresenhamLines);
+        CHECK_PHYS_EXT_FEATURE(stippledSmoothLines);
+        CHECK_PHYS_EXT_FEATURE(vertexAttributeInstanceRateDivisor);
+        CHECK_PHYS_EXT_FEATURE(vertexAttributeInstanceRateZeroDivisor);
+        CHECK_PHYS_EXT_FEATURE(indexTypeUint8);
+        CHECK_PHYS_EXT_FEATURE(dynamicRenderingLocalRead);
+        CHECK_PHYS_EXT_FEATURE(maintenance5);
+        CHECK_PHYS_EXT_FEATURE(maintenance6);
+        CHECK_PHYS_EXT_FEATURE(pipelineProtectedAccess);
+        CHECK_PHYS_EXT_FEATURE(pipelineRobustness);
+        CHECK_PHYS_EXT_FEATURE(hostImageCopy);
+        CHECK_PHYS_EXT_FEATURE(pushDescriptor);
+
+        m_Maintenance5 |= ext->maintenance5 != VK_FALSE;
+        m_Maintenance6 |= ext->maintenance6 != VK_FALSE;
+      }
+      END_PHYS_EXT_CHECK();
+
       BEGIN_PHYS_EXT_CHECK(VkPhysicalDevice8BitStorageFeatures,
                            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES);
       {
@@ -2552,8 +2585,8 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
       END_PHYS_EXT_CHECK();
 
       BEGIN_PHYS_EXT_CHECK(
-          VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM,
-          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM);
+          VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT,
+          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT);
       {
         CHECK_PHYS_EXT_FEATURE(fragmentDensityMapOffset);
       }
@@ -3480,7 +3513,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
                            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
       {
         CHECK_PHYS_EXT_FEATURE(maintenance5);
-        m_Maintenance5 = ext->maintenance5 != VK_FALSE;
+        m_Maintenance5 |= ext->maintenance5 != VK_FALSE;
       }
       END_PHYS_EXT_CHECK();
 
@@ -3547,7 +3580,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi
                            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES);
       {
         CHECK_PHYS_EXT_FEATURE(maintenance6);
-        m_Maintenance6 = ext->maintenance6 != VK_FALSE;
+        m_Maintenance6 |= ext->maintenance6 != VK_FALSE;
       }
       END_PHYS_EXT_CHECK();
 

renderdoc/driver/vulkan/wrappers/vk_dynamic_funcs.cpp

@@ -911,10 +911,9 @@ void WrappedVulkan::vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdSetLineStippleKHR(SerialiserType &ser,
-                                                     VkCommandBuffer commandBuffer,
-                                                     uint32_t lineStippleFactor,
-                                                     uint16_t lineStipplePattern)
+bool WrappedVulkan::Serialise_vkCmdSetLineStipple(SerialiserType &ser, VkCommandBuffer commandBuffer,
+                                                  uint32_t lineStippleFactor,
+                                                  uint16_t lineStipplePattern)
 {
   SERIALISE_ELEMENT(commandBuffer);
   SERIALISE_ELEMENT(lineStippleFactor).Important();
@@ -953,14 +952,14 @@ bool WrappedVulkan::Serialise_vkCmdSetLineStippleKHR(SerialiserType &ser,
     // other since it's a straight promotion. This allows us to share implementation between the two
     if(commandBuffer != VK_NULL_HANDLE)
       ObjDisp(commandBuffer)
-          ->CmdSetLineStippleKHR(Unwrap(commandBuffer), lineStippleFactor, lineStipplePattern);
+          ->CmdSetLineStipple(Unwrap(commandBuffer), lineStippleFactor, lineStipplePattern);
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer,
-                                           uint32_t lineStippleFactor, uint16_t lineStipplePattern)
+void WrappedVulkan::vkCmdSetLineStipple(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                        uint16_t lineStipplePattern)
 {
   SCOPED_DBG_SINK();
 
@@ -968,7 +967,7 @@ void WrappedVulkan::vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer,
   // other since it's a straight promotion. This allows us to share implementation between the two
   SERIALISE_TIME_CALL(
       ObjDisp(commandBuffer)
-          ->CmdSetLineStippleKHR(Unwrap(commandBuffer), lineStippleFactor, lineStipplePattern));
+          ->CmdSetLineStipple(Unwrap(commandBuffer), lineStippleFactor, lineStipplePattern));
 
   if(IsCaptureMode(m_State))
   {
@@ -976,8 +975,8 @@ void WrappedVulkan::vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer,
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetLineStippleKHR);
-    Serialise_vkCmdSetLineStippleKHR(ser, commandBuffer, lineStippleFactor, lineStipplePattern);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetLineStipple);
+    Serialise_vkCmdSetLineStipple(ser, commandBuffer, lineStippleFactor, lineStipplePattern);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
   }
@@ -989,7 +988,7 @@ void WrappedVulkan::vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer,
 void WrappedVulkan::vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,
                                            uint32_t lineStippleFactor, uint16_t lineStipplePattern)
 {
-  return vkCmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern);
+  return vkCmdSetLineStipple(commandBuffer, lineStippleFactor, lineStipplePattern);
 }
 
 template <typename SerialiserType>
@@ -3566,7 +3565,7 @@ void WrappedVulkan::vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer comma
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdSetRenderingAttachmentLocationsKHR(
+bool WrappedVulkan::Serialise_vkCmdSetRenderingAttachmentLocations(
     SerialiserType &ser, VkCommandBuffer commandBuffer,
     const VkRenderingAttachmentLocationInfo *pLocationInfo)
 {
@@ -3600,20 +3599,19 @@ bool WrappedVulkan::Serialise_vkCmdSetRenderingAttachmentLocationsKHR(
     }
 
     if(commandBuffer != VK_NULL_HANDLE)
-      ObjDisp(commandBuffer)->CmdSetRenderingAttachmentLocationsKHR(Unwrap(commandBuffer), &locationInfo);
+      ObjDisp(commandBuffer)->CmdSetRenderingAttachmentLocations(Unwrap(commandBuffer), &locationInfo);
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdSetRenderingAttachmentLocationsKHR(
+void WrappedVulkan::vkCmdSetRenderingAttachmentLocations(
     VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo *pLocationInfo)
 {
   SCOPED_DBG_SINK();
 
   SERIALISE_TIME_CALL(
-      ObjDisp(commandBuffer)
-          ->CmdSetRenderingAttachmentLocationsKHR(Unwrap(commandBuffer), pLocationInfo));
+      ObjDisp(commandBuffer)->CmdSetRenderingAttachmentLocations(Unwrap(commandBuffer), pLocationInfo));
 
   if(IsCaptureMode(m_State))
   {
@@ -3621,15 +3619,15 @@ void WrappedVulkan::vkCmdSetRenderingAttachmentLocationsKHR(
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetRenderingAttachmentLocationsKHR);
-    Serialise_vkCmdSetRenderingAttachmentLocationsKHR(ser, commandBuffer, pLocationInfo);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetRenderingAttachmentLocations);
+    Serialise_vkCmdSetRenderingAttachmentLocations(ser, commandBuffer, pLocationInfo);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
   }
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCmdSetRenderingInputAttachmentIndicesKHR(
+bool WrappedVulkan::Serialise_vkCmdSetRenderingInputAttachmentIndices(
     SerialiserType &ser, VkCommandBuffer commandBuffer,
     const VkRenderingInputAttachmentIndexInfo *pInputAttachmentIndexInfo)
 {
@@ -3666,22 +3664,21 @@ bool WrappedVulkan::Serialise_vkCmdSetRenderingInputAttachmentIndicesKHR(
 
     if(commandBuffer != VK_NULL_HANDLE)
       ObjDisp(commandBuffer)
-          ->CmdSetRenderingInputAttachmentIndicesKHR(Unwrap(commandBuffer),
-                                                     &inputAttachmentIndexInfo);
+          ->CmdSetRenderingInputAttachmentIndices(Unwrap(commandBuffer), &inputAttachmentIndexInfo);
   }
 
   return true;
 }
 
-void WrappedVulkan::vkCmdSetRenderingInputAttachmentIndicesKHR(
+void WrappedVulkan::vkCmdSetRenderingInputAttachmentIndices(
     VkCommandBuffer commandBuffer,
     const VkRenderingInputAttachmentIndexInfo *pInputAttachmentIndexInfo)
 {
   SCOPED_DBG_SINK();
 
   SERIALISE_TIME_CALL(ObjDisp(commandBuffer)
-                          ->CmdSetRenderingInputAttachmentIndicesKHR(Unwrap(commandBuffer),
-                                                                     pInputAttachmentIndexInfo));
+                          ->CmdSetRenderingInputAttachmentIndices(Unwrap(commandBuffer),
+                                                                  pInputAttachmentIndexInfo));
 
   if(IsCaptureMode(m_State))
   {
@@ -3689,9 +3686,8 @@ void WrappedVulkan::vkCmdSetRenderingInputAttachmentIndicesKHR(
 
     CACHE_THREAD_SERIALISER();
 
-    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetRenderingInputAttachmentIndicesKHR);
-    Serialise_vkCmdSetRenderingInputAttachmentIndicesKHR(ser, commandBuffer,
-                                                         pInputAttachmentIndexInfo);
+    SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdSetRenderingInputAttachmentIndices);
+    Serialise_vkCmdSetRenderingInputAttachmentIndices(ser, commandBuffer, pInputAttachmentIndexInfo);
 
     record->AddChunk(scope.Get(&record->cmdInfo->alloc));
   }
@@ -3734,7 +3730,7 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetDiscardRectangleEXT, VkCommandBuff
                                 uint32_t firstDiscardRectangle, uint32_t discardRectangleCount,
                                 const VkRect2D *pDiscardRectangles);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetLineStippleKHR, VkCommandBuffer commandBuffer,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetLineStipple, VkCommandBuffer commandBuffer,
                                 uint32_t lineStippleFactor, uint16_t lineStipplePattern);
 
 INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetCullMode, VkCommandBuffer commandBuffer,
@@ -3839,9 +3835,9 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetTessellationDomainOriginEXT,
 INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetRayTracingPipelineStackSizeKHR,
                                 VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetRenderingAttachmentLocationsKHR,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetRenderingAttachmentLocations,
                                 VkCommandBuffer commandBuffer,
                                 const VkRenderingAttachmentLocationInfo *pLocationInfo);
-INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetRenderingInputAttachmentIndicesKHR,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdSetRenderingInputAttachmentIndices,
                                 VkCommandBuffer commandBuffer,
                                 const VkRenderingInputAttachmentIndexInfo *pInputAttachmentIndexInfo);

renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp

@@ -881,8 +881,10 @@ void WrappedVulkan::vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevi
   VkPhysicalDeviceHostImageCopyProperties *hostImageCopy =
       (VkPhysicalDeviceHostImageCopyProperties *)FindNextStruct(
           pProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES);
+  VkPhysicalDeviceVulkan14Properties *vulkan14 = (VkPhysicalDeviceVulkan14Properties *)FindNextStruct(
+      pProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES);
 
-  if(shaderObject || hostImageCopy)
+  if(shaderObject || hostImageCopy || vulkan14)
   {
     MakeFakeUUID();
   }
@@ -895,6 +897,10 @@ void WrappedVulkan::vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevi
   {
     memcpy(hostImageCopy->optimalTilingLayoutUUID, fakeRenderDocUUID, VK_UUID_SIZE);
   }
+  if(vulkan14)
+  {
+    memcpy(vulkan14->optimalTilingLayoutUUID, fakeRenderDocUUID, VK_UUID_SIZE);
+  }
 
   VkPhysicalDeviceDescriptorBufferPropertiesEXT *descBufferProperties =
       (VkPhysicalDeviceDescriptorBufferPropertiesEXT *)FindNextStruct(
@@ -1348,9 +1354,9 @@ VkDeviceSize WrappedVulkan::vkGetRayTracingShaderGroupStackSizeKHR(
                                                                group, groupShader);
 }
 
-void WrappedVulkan::vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
-                                                         const VkDeviceImageSubresourceInfo *pInfo,
-                                                         VkSubresourceLayout2 *pLayout)
+void WrappedVulkan::vkGetDeviceImageSubresourceLayout(VkDevice device,
+                                                      const VkDeviceImageSubresourceInfo *pInfo,
+                                                      VkSubresourceLayout2 *pLayout)
 {
   size_t tempMemSize = GetNextPatchSize(pInfo);
 
@@ -1370,15 +1376,14 @@ void WrappedVulkan::vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
 
   PatchImageCreateInfo((VkImageCreateInfo *)unwrappedInfo->pCreateInfo, (VkFormat *)tempMem);
 
-  ObjDisp(device)->GetDeviceImageSubresourceLayoutKHR(Unwrap(device), unwrappedInfo, pLayout);
+  ObjDisp(device)->GetDeviceImageSubresourceLayout(Unwrap(device), unwrappedInfo, pLayout);
 }
 
-void WrappedVulkan::vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
-                                                    const VkImageSubresource2 *pSubresource,
-                                                    VkSubresourceLayout2 *pLayout)
+void WrappedVulkan::vkGetImageSubresourceLayout2(VkDevice device, VkImage image,
+                                                 const VkImageSubresource2 *pSubresource,
+                                                 VkSubresourceLayout2 *pLayout)
 {
-  ObjDisp(device)->GetImageSubresourceLayout2KHR(Unwrap(device), Unwrap(image), pSubresource,
-                                                 pLayout);
+  ObjDisp(device)->GetImageSubresourceLayout2(Unwrap(device), Unwrap(image), pSubresource, pLayout);
 
   // RenderDoc removes calls with VK_HOST_IMAGE_COPY_MEMCPY_BIT flag, so the
   // VkSubresourceHostMemcpySize struct chained to VkSubresourceLayout2 is overriden to
@@ -1389,19 +1394,18 @@ void WrappedVulkan::vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage ima
     memcpySize->size = 64;
 }
 
-void WrappedVulkan::vkGetRenderingAreaGranularityKHR(VkDevice device,
-                                                     const VkRenderingAreaInfo *pRenderingAreaInfo,
-                                                     VkExtent2D *pGranularity)
+void WrappedVulkan::vkGetRenderingAreaGranularity(VkDevice device,
+                                                  const VkRenderingAreaInfo *pRenderingAreaInfo,
+                                                  VkExtent2D *pGranularity)
 {
-  ObjDisp(device)->GetRenderingAreaGranularityKHR(Unwrap(device), pRenderingAreaInfo, pGranularity);
+  ObjDisp(device)->GetRenderingAreaGranularity(Unwrap(device), pRenderingAreaInfo, pGranularity);
 }
 
 void WrappedVulkan::vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
                                                     const VkImageSubresource2 *pSubresource,
                                                     VkSubresourceLayout2 *pLayout)
 {
-  ObjDisp(device)->GetImageSubresourceLayout2EXT(Unwrap(device), Unwrap(image), pSubresource,
-                                                 pLayout);
+  ObjDisp(device)->GetImageSubresourceLayout2(Unwrap(device), Unwrap(image), pSubresource, pLayout);
 
   // RenderDoc removes calls with VK_HOST_IMAGE_COPY_MEMCPY_BIT flag, so the
   // VkSubresourceHostMemcpySize struct chained to VkSubresourceLayout2 is overriden to

renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp

@@ -1902,8 +1902,8 @@ VkResult WrappedVulkan::vkGetQueryPoolResults(VkDevice device, VkQueryPool query
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCopyImageToImageEXT(SerialiserType &ser, VkDevice device,
-                                                    const VkCopyImageToImageInfo *pCopyImageToImageInfo)
+bool WrappedVulkan::Serialise_vkCopyImageToImage(SerialiserType &ser, VkDevice device,
+                                                 const VkCopyImageToImageInfo *pCopyImageToImageInfo)
 {
   SERIALISE_ELEMENT(device);
   SERIALISE_ELEMENT_LOCAL(CopyImageToImageInfo, *pCopyImageToImageInfo).Important();
@@ -1917,7 +1917,7 @@ bool WrappedVulkan::Serialise_vkCopyImageToImageEXT(SerialiserType &ser, VkDevic
     CopyImageToImageInfo.srcImage = Unwrap(CopyImageToImageInfo.srcImage);
     CopyImageToImageInfo.dstImage = Unwrap(CopyImageToImageInfo.dstImage);
 
-    ObjDisp(device)->CopyImageToImageEXT(Unwrap(device), &CopyImageToImageInfo);
+    ObjDisp(device)->CopyImageToImage(Unwrap(device), &CopyImageToImageInfo);
 
     if(!IsActiveReplaying(m_State))
     {
@@ -1968,8 +1968,8 @@ bool WrappedVulkan::Serialise_vkCopyImageToImageEXT(SerialiserType &ser, VkDevic
   return true;
 }
 
-VkResult WrappedVulkan::vkCopyImageToImageEXT(VkDevice device,
-                                              const VkCopyImageToImageInfo *pCopyImageToImageInfo)
+VkResult WrappedVulkan::vkCopyImageToImage(VkDevice device,
+                                           const VkCopyImageToImageInfo *pCopyImageToImageInfo)
 {
   SCOPED_DBG_SINK();
 
@@ -1978,7 +1978,7 @@ VkResult WrappedVulkan::vkCopyImageToImageEXT(VkDevice device,
       UnwrapStructAndChain(m_State, tempMem, pCopyImageToImageInfo);
 
   VkResult ret;
-  SERIALISE_TIME_CALL(ret = ObjDisp(device)->CopyImageToImageEXT(Unwrap(device), unwrappedInfo));
+  SERIALISE_TIME_CALL(ret = ObjDisp(device)->CopyImageToImage(Unwrap(device), unwrappedInfo));
 
   {
     SCOPED_READLOCK(m_CapTransitionLock);
@@ -1989,7 +1989,7 @@ VkResult WrappedVulkan::vkCopyImageToImageEXT(VkDevice device,
 
       ser.SetActionChunk();
       SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCopyImageToImage);
-      Serialise_vkCopyImageToImageEXT(ser, device, pCopyImageToImageInfo);
+      Serialise_vkCopyImageToImage(ser, device, pCopyImageToImageInfo);
 
       m_FrameCaptureRecord->AddChunk(scope.Get());
       GetResourceManager()->MarkResourceFrameReferenced(GetResID(pCopyImageToImageInfo->srcImage),
@@ -2003,8 +2003,8 @@ VkResult WrappedVulkan::vkCopyImageToImageEXT(VkDevice device,
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCopyImageToMemoryEXT(
-    SerialiserType &ser, VkDevice device, const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo)
+bool WrappedVulkan::Serialise_vkCopyImageToMemory(SerialiserType &ser, VkDevice device,
+                                                  const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo)
 {
   SERIALISE_ELEMENT(device);
   SERIALISE_ELEMENT_LOCAL(CopyImageToMemoryInfo, *pCopyImageToMemoryInfo).Important();
@@ -2018,7 +2018,7 @@ bool WrappedVulkan::Serialise_vkCopyImageToMemoryEXT(
     VkImage srcImage = CopyImageToMemoryInfo.srcImage;
     CopyImageToMemoryInfo.srcImage = Unwrap(srcImage);
 
-    ObjDisp(device)->CopyImageToMemoryEXT(Unwrap(device), &CopyImageToMemoryInfo);
+    ObjDisp(device)->CopyImageToMemory(Unwrap(device), &CopyImageToMemoryInfo);
 
     if(!IsActiveReplaying(m_State))
     {
@@ -2050,13 +2050,13 @@ bool WrappedVulkan::Serialise_vkCopyImageToMemoryEXT(
   return true;
 }
 
-VkResult WrappedVulkan::vkCopyImageToMemoryEXT(VkDevice device,
-                                               const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo)
+VkResult WrappedVulkan::vkCopyImageToMemory(VkDevice device,
+                                            const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo)
 {
   SCOPED_DBG_SINK();
 
   // Calls with VK_HOST_IMAGE_COPY_MEMCPY_BIT are not supported, and are not expected from typical
-  // applications. See comment in vkCopyMemoryToImageEXT() for more details.
+  // applications. See comment in vkCopyMemoryToImage() for more details.
   if((pCopyImageToMemoryInfo->flags & VK_HOST_IMAGE_COPY_MEMCPY_BIT) != 0)
   {
     return VK_SUCCESS;
@@ -2067,7 +2067,7 @@ VkResult WrappedVulkan::vkCopyImageToMemoryEXT(VkDevice device,
       UnwrapStructAndChain(m_State, tempMem, pCopyImageToMemoryInfo);
 
   VkResult ret;
-  SERIALISE_TIME_CALL(ret = ObjDisp(device)->CopyImageToMemoryEXT(Unwrap(device), unwrappedInfo));
+  SERIALISE_TIME_CALL(ret = ObjDisp(device)->CopyImageToMemory(Unwrap(device), unwrappedInfo));
 
   {
     SCOPED_READLOCK(m_CapTransitionLock);
@@ -2078,7 +2078,7 @@ VkResult WrappedVulkan::vkCopyImageToMemoryEXT(VkDevice device,
 
       ser.SetActionChunk();
       SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCopyImageToMemory);
-      Serialise_vkCopyImageToMemoryEXT(ser, device, pCopyImageToMemoryInfo);
+      Serialise_vkCopyImageToMemory(ser, device, pCopyImageToMemoryInfo);
 
       m_FrameCaptureRecord->AddChunk(scope.Get());
       GetResourceManager()->MarkResourceFrameReferenced(GetResID(pCopyImageToMemoryInfo->srcImage),
@@ -2090,8 +2090,8 @@ VkResult WrappedVulkan::vkCopyImageToMemoryEXT(VkDevice device,
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkCopyMemoryToImageEXT(
-    SerialiserType &ser, VkDevice device, const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo)
+bool WrappedVulkan::Serialise_vkCopyMemoryToImage(SerialiserType &ser, VkDevice device,
+                                                  const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo)
 {
   SERIALISE_ELEMENT(device);
   SERIALISE_ELEMENT_LOCAL(CopyMemoryToImageInfo, *pCopyMemoryToImageInfo).Important();
@@ -2105,7 +2105,7 @@ bool WrappedVulkan::Serialise_vkCopyMemoryToImageEXT(
     VkImage dstImage = CopyMemoryToImageInfo.dstImage;
     CopyMemoryToImageInfo.dstImage = Unwrap(dstImage);
 
-    ObjDisp(device)->CopyMemoryToImageEXT(Unwrap(device), &CopyMemoryToImageInfo);
+    ObjDisp(device)->CopyMemoryToImage(Unwrap(device), &CopyMemoryToImageInfo);
 
     if(!IsActiveReplaying(m_State))
     {
@@ -2137,8 +2137,8 @@ bool WrappedVulkan::Serialise_vkCopyMemoryToImageEXT(
   return true;
 }
 
-VkResult WrappedVulkan::vkCopyMemoryToImageEXT(VkDevice device,
-                                               const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo)
+VkResult WrappedVulkan::vkCopyMemoryToImage(VkDevice device,
+                                            const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo)
 {
   SCOPED_DBG_SINK();
 
@@ -2165,7 +2165,7 @@ VkResult WrappedVulkan::vkCopyMemoryToImageEXT(VkDevice device,
       UnwrapStructAndChain(m_State, tempMem, pCopyMemoryToImageInfo);
 
   VkResult ret;
-  SERIALISE_TIME_CALL(ret = ObjDisp(device)->CopyMemoryToImageEXT(Unwrap(device), unwrappedInfo));
+  SERIALISE_TIME_CALL(ret = ObjDisp(device)->CopyMemoryToImage(Unwrap(device), unwrappedInfo));
 
   {
     SCOPED_READLOCK(m_CapTransitionLock);
@@ -2176,7 +2176,7 @@ VkResult WrappedVulkan::vkCopyMemoryToImageEXT(VkDevice device,
 
       ser.SetActionChunk();
       SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCopyMemoryToImage);
-      Serialise_vkCopyMemoryToImageEXT(ser, device, pCopyMemoryToImageInfo);
+      Serialise_vkCopyMemoryToImage(ser, device, pCopyMemoryToImageInfo);
 
       m_FrameCaptureRecord->AddChunk(scope.Get());
       GetResourceManager()->MarkResourceFrameReferenced(GetResID(pCopyMemoryToImageInfo->dstImage),
@@ -3125,13 +3125,13 @@ INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCreateSamplerYcbcrConversion, VkDevi
                                 const VkAllocationCallbacks *,
                                 VkSamplerYcbcrConversion *pYcbcrConversion);
 
-INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCopyImageToImageEXT, VkDevice device,
+INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCopyImageToImage, VkDevice device,
                                 const VkCopyImageToImageInfo *pCopyImageToImageInfo);
 
-INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCopyImageToMemoryEXT, VkDevice device,
+INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCopyImageToMemory, VkDevice device,
                                 const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo);
 
-INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCopyMemoryToImageEXT, VkDevice device,
+INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCopyMemoryToImage, VkDevice device,
                                 const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo);
 
 INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkResetQueryPool, VkDevice device, VkQueryPool queryPool,

renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp

@@ -1191,9 +1191,9 @@ void WrappedVulkan::ProcessUnmap(VkDevice device, VkDeviceMemory mem, const VkMe
         {
           CACHE_THREAD_SERIALISER();
 
-          SCOPED_SERIALISE_CHUNK(info ? VulkanChunk::vkUnmapMemory2KHR : VulkanChunk::vkUnmapMemory);
+          SCOPED_SERIALISE_CHUNK(info ? VulkanChunk::vkUnmapMemory2 : VulkanChunk::vkUnmapMemory);
           if(info)
-            Serialise_vkUnmapMemory2KHR(ser, device, info);
+            Serialise_vkUnmapMemory2(ser, device, info);
           else
             Serialise_vkUnmapMemory(ser, device, mem);
 
@@ -1241,8 +1241,8 @@ VkResult WrappedVulkan::vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDe
   return ret;
 }
 
-VkResult WrappedVulkan::vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo *pMemoryMapInfo,
-                                        void **ppData)
+VkResult WrappedVulkan::vkMapMemory2(VkDevice device, const VkMemoryMapInfo *pMemoryMapInfo,
+                                     void **ppData)
 {
   VkMemoryMapInfo unwrapped = *pMemoryMapInfo;
   unwrapped.memory = Unwrap(unwrapped.memory);
@@ -1250,7 +1250,7 @@ VkResult WrappedVulkan::vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo *
   VkDeviceSize misalignedOffset = AlignMapBoundaries(unwrapped.offset, unwrapped.size);
 
   byte *realData = NULL;
-  VkResult ret = ObjDisp(device)->MapMemory2KHR(Unwrap(device), &unwrapped, (void **)&realData);
+  VkResult ret = ObjDisp(device)->MapMemory2(Unwrap(device), &unwrapped, (void **)&realData);
 
   if(ret == VK_SUCCESS && realData)
   {
@@ -1320,8 +1320,8 @@ void WrappedVulkan::vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkUnmapMemory2KHR(SerialiserType &ser, VkDevice device,
-                                                const VkMemoryUnmapInfo *pMemoryUnmapInfo)
+bool WrappedVulkan::Serialise_vkUnmapMemory2(SerialiserType &ser, VkDevice device,
+                                             const VkMemoryUnmapInfo *pMemoryUnmapInfo)
 {
   SERIALISE_ELEMENT(device);
   SERIALISE_ELEMENT_LOCAL(UnmapInfo, *pMemoryUnmapInfo).Important();
@@ -1348,7 +1348,7 @@ bool WrappedVulkan::Serialise_vkUnmapMemory2KHR(SerialiserType &ser, VkDevice de
     VkMemoryMapInfo mapInfo = {
         VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, NULL, 0, Unwrap(UnmapInfo.memory), MapOffset, MapSize,
     };
-    VkResult vkr = ObjDisp(device)->MapMemory2KHR(Unwrap(device), &mapInfo, (void **)&MapData);
+    VkResult vkr = ObjDisp(device)->MapMemory2(Unwrap(device), &mapInfo, (void **)&MapData);
     if(vkr != VK_SUCCESS)
     {
       SET_ERROR_RESULT(m_FailedReplayResult, ResultCode::APIReplayFailed,
@@ -1364,7 +1364,7 @@ bool WrappedVulkan::Serialise_vkUnmapMemory2KHR(SerialiserType &ser, VkDevice de
   {
     VkMemoryUnmapInfo unwrapped = UnmapInfo;
     unwrapped.memory = Unwrap(unwrapped.memory);
-    ObjDisp(device)->UnmapMemory2KHR(Unwrap(device), &unwrapped);
+    ObjDisp(device)->UnmapMemory2(Unwrap(device), &unwrapped);
   }
 
   SERIALISE_CHECK_READ_ERRORS();
@@ -1372,13 +1372,13 @@ bool WrappedVulkan::Serialise_vkUnmapMemory2KHR(SerialiserType &ser, VkDevice de
   return true;
 }
 
-void WrappedVulkan::vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo *pMemoryUnmapInfo)
+void WrappedVulkan::vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo *pMemoryUnmapInfo)
 {
   ProcessUnmap(device, VK_NULL_HANDLE, pMemoryUnmapInfo);
 
   VkMemoryUnmapInfo unwrapped = *pMemoryUnmapInfo;
   unwrapped.memory = Unwrap(unwrapped.memory);
-  ObjDisp(device)->UnmapMemory2KHR(Unwrap(device), &unwrapped);
+  ObjDisp(device)->UnmapMemory2(Unwrap(device), &unwrapped);
 }
 
 template <typename SerialiserType>
@@ -4053,5 +4053,5 @@ INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkCreateAccelerationStructureKHR, VkDe
                                 const VkAllocationCallbacks *,
                                 VkAccelerationStructureKHR *pAccelerationStructure);
 
-INSTANTIATE_FUNCTION_SERIALISED(void, vkUnmapMemory2KHR, VkDevice device,
+INSTANTIATE_FUNCTION_SERIALISED(void, vkUnmapMemory2, VkDevice device,
                                 const VkMemoryUnmapInfo *pMemoryUnmapInfo);

renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp

@@ -1506,9 +1506,9 @@ void WrappedVulkan::vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eve
 }
 
 template <typename SerialiserType>
-bool WrappedVulkan::Serialise_vkTransitionImageLayoutEXT(
-    SerialiserType &ser, VkDevice device, uint32_t transitionCount,
-    const VkHostImageLayoutTransitionInfo *pTransitions)
+bool WrappedVulkan::Serialise_vkTransitionImageLayout(SerialiserType &ser, VkDevice device,
+                                                      uint32_t transitionCount,
+                                                      const VkHostImageLayoutTransitionInfo *pTransitions)
 {
   SERIALISE_ELEMENT(device);
   SERIALISE_ELEMENT(transitionCount);
@@ -1552,15 +1552,15 @@ bool WrappedVulkan::Serialise_vkTransitionImageLayoutEXT(
       }
     }
 
-    ObjDisp(device)->TransitionImageLayoutEXT(Unwrap(device), (uint32_t)imgBarriers.size(),
-                                              imgBarriers.data());
+    ObjDisp(device)->TransitionImageLayout(Unwrap(device), (uint32_t)imgBarriers.size(),
+                                           imgBarriers.data());
   }
 
   return true;
 }
 
-VkResult WrappedVulkan::vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount,
-                                                   const VkHostImageLayoutTransitionInfo *pTransitions)
+VkResult WrappedVulkan::vkTransitionImageLayout(VkDevice device, uint32_t transitionCount,
+                                                const VkHostImageLayoutTransitionInfo *pTransitions)
 {
   SCOPED_DBG_SINK();
 
@@ -1576,7 +1576,7 @@ VkResult WrappedVulkan::vkTransitionImageLayoutEXT(VkDevice device, uint32_t tra
     }
 
     SERIALISE_TIME_CALL(
-        ret = ObjDisp(device)->TransitionImageLayoutEXT(Unwrap(device), transitionCount, im));
+        ret = ObjDisp(device)->TransitionImageLayout(Unwrap(device), transitionCount, im));
   }
 
   if(IsActiveCapturing(m_State))
@@ -1584,7 +1584,7 @@ VkResult WrappedVulkan::vkTransitionImageLayoutEXT(VkDevice device, uint32_t tra
     CACHE_THREAD_SERIALISER();
 
     SCOPED_SERIALISE_CHUNK(VulkanChunk::vkTransitionImageLayout);
-    Serialise_vkTransitionImageLayoutEXT(ser, device, transitionCount, pTransitions);
+    Serialise_vkTransitionImageLayout(ser, device, transitionCount, pTransitions);
 
     m_FrameCaptureRecord->AddChunk(scope.Get());
 
@@ -1715,6 +1715,6 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdWaitEvents2, VkCommandBuffer commandB
                                 uint32_t eventCount, const VkEvent *pEvents,
                                 const VkDependencyInfo *pDependencyInfos);
 
-INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkTransitionImageLayoutEXT, VkDevice device,
+INSTANTIATE_FUNCTION_SERIALISED(VkResult, vkTransitionImageLayout, VkDevice device,
                                 uint32_t transitionCount,
                                 const VkHostImageLayoutTransitionInfo *pTransitions);

renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp

@@ -1819,7 +1819,7 @@ VkResult WrappedVulkan::vkReleaseSwapchainImagesKHR(VkDevice device,
 // EXT is available it will go through to the EXT from the driver, and we would rather merge the
 // EXT/KHR paths and silently promote than keep them separate and maintain two paths.
 VkResult WrappedVulkan::vkReleaseSwapchainImagesEXT(VkDevice device,
-                                                    const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo)
+                                                    const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo)
 {
   return vkReleaseSwapchainImagesKHR(device, pReleaseInfo);
 }