[PATCH 2/2] winevulkan: Update to VK spec version 1.3.296.

[Georg Lehmann]

From: Georg Lehmann

---
 dlls/winevulkan/loader_thunks.c | 120 ++++
 dlls/winevulkan/loader_thunks.h |  86 +++
 dlls/winevulkan/make_vulkan     |   2 +-
 dlls/winevulkan/vulkan_thunks.c | 983 ++++++++++++++++++++++++++++++++
 dlls/winevulkan/vulkan_thunks.h |  20 +
 dlls/winevulkan/winevulkan.json |   2 +-
 include/wine/vulkan.h           | 323 ++++++++++-
 7 files changed, 1533 insertions(+), 3 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
index 5b6e3d9339c..a427006cac1 100644
--- a/dlls/winevulkan/loader_thunks.c
+++ b/dlls/winevulkan/loader_thunks.c
@@ -1310,6 +1310,15 @@ void WINAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t command
     UNIX_CALL(vkCmdExecuteCommands, &params);
 }

+void WINAPI vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo)
+{
+    struct vkCmdExecuteGeneratedCommandsEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.isPreprocessed = isPreprocessed;
+    params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
+    UNIX_CALL(vkCmdExecuteGeneratedCommandsEXT, &params);
+}
+
 void WINAPI vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
     struct vkCmdExecuteGeneratedCommandsNV_params params;
@@ -1405,6 +1414,15 @@ void WINAPI vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDepe
     UNIX_CALL(vkCmdPipelineBarrier2KHR, &params);
 }

+void WINAPI vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer)
+{
+    struct vkCmdPreprocessGeneratedCommandsEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
+    params.stateCommandBuffer = stateCommandBuffer;
+    UNIX_CALL(vkCmdPreprocessGeneratedCommandsEXT, &params);
+}
+
 void WINAPI vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
     struct vkCmdPreprocessGeneratedCommandsNV_params params;
@@ -1777,6 +1795,15 @@ void WINAPI vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32
     UNIX_CALL(vkCmdSetDepthClampEnableEXT, &params);
 }

+void WINAPI vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT *pDepthClampRange)
+{
+    struct vkCmdSetDepthClampRangeEXT_params params;
+    params.commandBuffer = commandBuffer;
+    params.depthClampMode = depthClampMode;
+    params.pDepthClampRange = pDepthClampRange;
+    UNIX_CALL(vkCmdSetDepthClampRangeEXT, &params);
+}
+
 void WINAPI vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
 {
     struct vkCmdSetDepthClipEnableEXT_params params;
@@ -3030,6 +3057,19 @@ VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *
     return params.result;
 }

+VkResult WINAPI vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutEXT *pIndirectCommandsLayout)
+{
+    struct vkCreateIndirectCommandsLayoutEXT_params params;
+    NTSTATUS status;
+    params.device = device;
+    params.pCreateInfo = pCreateInfo;
+    params.pAllocator = pAllocator;
+    params.pIndirectCommandsLayout = pIndirectCommandsLayout;
+    status = UNIX_CALL(vkCreateIndirectCommandsLayoutEXT, &params);
+    assert(!status && "vkCreateIndirectCommandsLayoutEXT");
+    return params.result;
+}
+
 VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
 {
     struct vkCreateIndirectCommandsLayoutNV_params params;
@@ -3043,6 +3083,19 @@ VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndire
     return params.result;
 }

+VkResult WINAPI vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectExecutionSetEXT *pIndirectExecutionSet)
+{
+    struct vkCreateIndirectExecutionSetEXT_params params;
+    NTSTATUS status;
+    params.device = device;
+    params.pCreateInfo = pCreateInfo;
+    params.pAllocator = pAllocator;
+    params.pIndirectExecutionSet = pIndirectExecutionSet;
+    status = UNIX_CALL(vkCreateIndirectExecutionSetEXT, &params);
+    assert(!status && "vkCreateIndirectExecutionSetEXT");
+    return params.result;
+}
+
 VkResult WINAPI vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
 {
     struct vkCreateMicromapEXT_params params;
@@ -3630,6 +3683,17 @@ void WINAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkA
     assert(!status && "vkDestroyImageView");
 }

+void WINAPI vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
+{
+    struct vkDestroyIndirectCommandsLayoutEXT_params params;
+    NTSTATUS status;
+    params.device = device;
+    params.indirectCommandsLayout = indirectCommandsLayout;
+    params.pAllocator = pAllocator;
+    status = UNIX_CALL(vkDestroyIndirectCommandsLayoutEXT, &params);
+    assert(!status && "vkDestroyIndirectCommandsLayoutEXT");
+}
+
 void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyIndirectCommandsLayoutNV_params params;
@@ -3641,6 +3705,17 @@ void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommand
     assert(!status && "vkDestroyIndirectCommandsLayoutNV");
 }

+void WINAPI vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks *pAllocator)
+{
+    struct vkDestroyIndirectExecutionSetEXT_params params;
+    NTSTATUS status;
+    params.device = device;
+    params.indirectExecutionSet = indirectExecutionSet;
+    params.pAllocator = pAllocator;
+    status = UNIX_CALL(vkDestroyIndirectExecutionSetEXT, &params);
+    assert(!status && "vkDestroyIndirectExecutionSetEXT");
+}
+
 void WINAPI vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyMicromapEXT_params params;
@@ -4594,6 +4669,17 @@ VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffe
     return params.result;
 }

+void WINAPI vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+{
+    struct vkGetGeneratedCommandsMemoryRequirementsEXT_params params;
+    NTSTATUS status;
+    params.device = device;
+    params.pInfo = pInfo;
+    params.pMemoryRequirements = pMemoryRequirements;
+    status = UNIX_CALL(vkGetGeneratedCommandsMemoryRequirementsEXT, &params);
+    assert(!status && "vkGetGeneratedCommandsMemoryRequirementsEXT");
+}
+
 void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetGeneratedCommandsMemoryRequirementsNV_params params;
@@ -6311,6 +6397,30 @@ void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCoun
     UNIX_CALL(vkUpdateDescriptorSets, &params);
 }

+void WINAPI vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites)
+{
+    struct vkUpdateIndirectExecutionSetPipelineEXT_params params;
+    NTSTATUS status;
+    params.device = device;
+    params.indirectExecutionSet = indirectExecutionSet;
+    params.executionSetWriteCount = executionSetWriteCount;
+    params.pExecutionSetWrites = pExecutionSetWrites;
+    status = UNIX_CALL(vkUpdateIndirectExecutionSetPipelineEXT, &params);
+    assert(!status && "vkUpdateIndirectExecutionSetPipelineEXT");
+}
+
+void WINAPI vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites)
+{
+    struct vkUpdateIndirectExecutionSetShaderEXT_params params;
+    NTSTATUS status;
+    params.device = device;
+    params.indirectExecutionSet = indirectExecutionSet;
+    params.executionSetWriteCount = executionSetWriteCount;
+    params.pExecutionSetWrites = pExecutionSetWrites;
+    status = UNIX_CALL(vkUpdateIndirectExecutionSetShaderEXT, &params);
+    assert(!status && "vkUpdateIndirectExecutionSetShaderEXT");
+}
+
 VkResult WINAPI vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
 {
     struct vkUpdateVideoSessionParametersKHR_params params;
@@ -6534,6 +6644,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdEndTransformFeedbackEXT", vkCmdEndTransformFeedbackEXT},
     {"vkCmdEndVideoCodingKHR", vkCmdEndVideoCodingKHR},
     {"vkCmdExecuteCommands", vkCmdExecuteCommands},
+    {"vkCmdExecuteGeneratedCommandsEXT", vkCmdExecuteGeneratedCommandsEXT},
     {"vkCmdExecuteGeneratedCommandsNV", vkCmdExecuteGeneratedCommandsNV},
     {"vkCmdFillBuffer", vkCmdFillBuffer},
     {"vkCmdInsertDebugUtilsLabelEXT", vkCmdInsertDebugUtilsLabelEXT},
@@ -6544,6 +6655,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdPipelineBarrier", vkCmdPipelineBarrier},
     {"vkCmdPipelineBarrier2", vkCmdPipelineBarrier2},
     {"vkCmdPipelineBarrier2KHR", vkCmdPipelineBarrier2KHR},
+    {"vkCmdPreprocessGeneratedCommandsEXT", vkCmdPreprocessGeneratedCommandsEXT},
     {"vkCmdPreprocessGeneratedCommandsNV", vkCmdPreprocessGeneratedCommandsNV},
     {"vkCmdPushConstants", vkCmdPushConstants},
     {"vkCmdPushConstants2KHR", vkCmdPushConstants2KHR},
@@ -6586,6 +6698,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdSetDepthBoundsTestEnable", vkCmdSetDepthBoundsTestEnable},
     {"vkCmdSetDepthBoundsTestEnableEXT", vkCmdSetDepthBoundsTestEnableEXT},
     {"vkCmdSetDepthClampEnableEXT", vkCmdSetDepthClampEnableEXT},
+    {"vkCmdSetDepthClampRangeEXT", vkCmdSetDepthClampRangeEXT},
     {"vkCmdSetDepthClipEnableEXT", vkCmdSetDepthClipEnableEXT},
     {"vkCmdSetDepthClipNegativeOneToOneEXT", vkCmdSetDepthClipNegativeOneToOneEXT},
     {"vkCmdSetDepthCompareOp", vkCmdSetDepthCompareOp},
@@ -6708,7 +6821,9 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCreateGraphicsPipelines", vkCreateGraphicsPipelines},
     {"vkCreateImage", vkCreateImage},
     {"vkCreateImageView", vkCreateImageView},
+    {"vkCreateIndirectCommandsLayoutEXT", vkCreateIndirectCommandsLayoutEXT},
     {"vkCreateIndirectCommandsLayoutNV", vkCreateIndirectCommandsLayoutNV},
+    {"vkCreateIndirectExecutionSetEXT", vkCreateIndirectExecutionSetEXT},
     {"vkCreateMicromapEXT", vkCreateMicromapEXT},
     {"vkCreateOpticalFlowSessionNV", vkCreateOpticalFlowSessionNV},
     {"vkCreatePipelineBinariesKHR", vkCreatePipelineBinariesKHR},
@@ -6755,7 +6870,9 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkDestroyFramebuffer", vkDestroyFramebuffer},
     {"vkDestroyImage", vkDestroyImage},
     {"vkDestroyImageView", vkDestroyImageView},
+    {"vkDestroyIndirectCommandsLayoutEXT", vkDestroyIndirectCommandsLayoutEXT},
     {"vkDestroyIndirectCommandsLayoutNV", vkDestroyIndirectCommandsLayoutNV},
+    {"vkDestroyIndirectExecutionSetEXT", vkDestroyIndirectExecutionSetEXT},
     {"vkDestroyMicromapEXT", vkDestroyMicromapEXT},
     {"vkDestroyOpticalFlowSessionNV", vkDestroyOpticalFlowSessionNV},
     {"vkDestroyPipeline", vkDestroyPipeline},
@@ -6834,6 +6951,7 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkGetEventStatus", vkGetEventStatus},
     {"vkGetFenceStatus", vkGetFenceStatus},
     {"vkGetFramebufferTilePropertiesQCOM", vkGetFramebufferTilePropertiesQCOM},
+    {"vkGetGeneratedCommandsMemoryRequirementsEXT", vkGetGeneratedCommandsMemoryRequirementsEXT},
     {"vkGetGeneratedCommandsMemoryRequirementsNV", vkGetGeneratedCommandsMemoryRequirementsNV},
     {"vkGetImageMemoryRequirements", vkGetImageMemoryRequirements},
     {"vkGetImageMemoryRequirements2", vkGetImageMemoryRequirements2},
@@ -6931,6 +7049,8 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkUpdateDescriptorSetWithTemplate", vkUpdateDescriptorSetWithTemplate},
     {"vkUpdateDescriptorSetWithTemplateKHR", vkUpdateDescriptorSetWithTemplateKHR},
     {"vkUpdateDescriptorSets", vkUpdateDescriptorSets},
+    {"vkUpdateIndirectExecutionSetPipelineEXT", vkUpdateIndirectExecutionSetPipelineEXT},
+    {"vkUpdateIndirectExecutionSetShaderEXT", vkUpdateIndirectExecutionSetShaderEXT},
     {"vkUpdateVideoSessionParametersKHR", vkUpdateVideoSessionParametersKHR},
     {"vkWaitForFences", vkWaitForFences},
     {"vkWaitForPresentKHR", vkWaitForPresentKHR},
diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h
index bf175374b5d..8ab16eebdf4 100644
--- a/dlls/winevulkan/loader_thunks.h
+++ b/dlls/winevulkan/loader_thunks.h
@@ -149,6 +149,7 @@ enum unix_call
     unix_vkCmdEndTransformFeedbackEXT,
     unix_vkCmdEndVideoCodingKHR,
     unix_vkCmdExecuteCommands,
+    unix_vkCmdExecuteGeneratedCommandsEXT,
     unix_vkCmdExecuteGeneratedCommandsNV,
     unix_vkCmdFillBuffer,
     unix_vkCmdInsertDebugUtilsLabelEXT,
@@ -159,6 +160,7 @@ enum unix_call
     unix_vkCmdPipelineBarrier,
     unix_vkCmdPipelineBarrier2,
     unix_vkCmdPipelineBarrier2KHR,
+    unix_vkCmdPreprocessGeneratedCommandsEXT,
     unix_vkCmdPreprocessGeneratedCommandsNV,
     unix_vkCmdPushConstants,
     unix_vkCmdPushConstants2KHR,
@@ -201,6 +203,7 @@ enum unix_call
     unix_vkCmdSetDepthBoundsTestEnable,
     unix_vkCmdSetDepthBoundsTestEnableEXT,
     unix_vkCmdSetDepthClampEnableEXT,
+    unix_vkCmdSetDepthClampRangeEXT,
     unix_vkCmdSetDepthClipEnableEXT,
     unix_vkCmdSetDepthClipNegativeOneToOneEXT,
     unix_vkCmdSetDepthCompareOp,
@@ -326,7 +329,9 @@ enum unix_call
     unix_vkCreateGraphicsPipelines,
     unix_vkCreateImage,
     unix_vkCreateImageView,
+    unix_vkCreateIndirectCommandsLayoutEXT,
     unix_vkCreateIndirectCommandsLayoutNV,
+    unix_vkCreateIndirectExecutionSetEXT,
     unix_vkCreateInstance,
     unix_vkCreateMicromapEXT,
     unix_vkCreateOpticalFlowSessionNV,
@@ -378,7 +383,9 @@ enum unix_call
     unix_vkDestroyFramebuffer,
     unix_vkDestroyImage,
     unix_vkDestroyImageView,
+    unix_vkDestroyIndirectCommandsLayoutEXT,
     unix_vkDestroyIndirectCommandsLayoutNV,
+    unix_vkDestroyIndirectExecutionSetEXT,
     unix_vkDestroyInstance,
     unix_vkDestroyMicromapEXT,
     unix_vkDestroyOpticalFlowSessionNV,
@@ -466,6 +473,7 @@ enum unix_call
     unix_vkGetEventStatus,
     unix_vkGetFenceStatus,
     unix_vkGetFramebufferTilePropertiesQCOM,
+    unix_vkGetGeneratedCommandsMemoryRequirementsEXT,
     unix_vkGetGeneratedCommandsMemoryRequirementsNV,
     unix_vkGetImageMemoryRequirements,
     unix_vkGetImageMemoryRequirements2,
@@ -613,6 +621,8 @@ enum unix_call
     unix_vkUpdateDescriptorSetWithTemplate,
     unix_vkUpdateDescriptorSetWithTemplateKHR,
     unix_vkUpdateDescriptorSets,
+    unix_vkUpdateIndirectExecutionSetPipelineEXT,
+    unix_vkUpdateIndirectExecutionSetShaderEXT,
     unix_vkUpdateVideoSessionParametersKHR,
     unix_vkWaitForFences,
     unix_vkWaitForPresentKHR,
@@ -1634,6 +1644,13 @@ struct vkCmdExecuteCommands_params
     const VkCommandBuffer *pCommandBuffers;
 };

+struct vkCmdExecuteGeneratedCommandsEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkBool32 isPreprocessed;
+    const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo;
+};
+
 struct vkCmdExecuteGeneratedCommandsNV_params
 {
     VkCommandBuffer commandBuffer;
@@ -1709,6 +1726,13 @@ struct vkCmdPipelineBarrier2KHR_params
     const VkDependencyInfo *pDependencyInfo;
 };

+struct vkCmdPreprocessGeneratedCommandsEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo;
+    VkCommandBuffer stateCommandBuffer;
+};
+
 struct vkCmdPreprocessGeneratedCommandsNV_params
 {
     VkCommandBuffer commandBuffer;
@@ -1997,6 +2021,13 @@ struct vkCmdSetDepthClampEnableEXT_params
     VkBool32 depthClampEnable;
 };

+struct vkCmdSetDepthClampRangeEXT_params
+{
+    VkCommandBuffer commandBuffer;
+    VkDepthClampModeEXT depthClampMode;
+    const VkDepthClampRangeEXT *pDepthClampRange;
+};
+
 struct vkCmdSetDepthClipEnableEXT_params
 {
     VkCommandBuffer commandBuffer;
@@ -2954,6 +2985,15 @@ struct vkCreateImageView_params
     VkResult result;
 };

+struct vkCreateIndirectCommandsLayoutEXT_params
+{
+    VkDevice device;
+    const VkIndirectCommandsLayoutCreateInfoEXT *pCreateInfo;
+    const VkAllocationCallbacks *pAllocator;
+    VkIndirectCommandsLayoutEXT *pIndirectCommandsLayout;
+    VkResult result;
+};
+
 struct vkCreateIndirectCommandsLayoutNV_params
 {
     VkDevice device;
@@ -2963,6 +3003,15 @@ struct vkCreateIndirectCommandsLayoutNV_params
     VkResult result;
 };

+struct vkCreateIndirectExecutionSetEXT_params
+{
+    VkDevice device;
+    const VkIndirectExecutionSetCreateInfoEXT *pCreateInfo;
+    const VkAllocationCallbacks *pAllocator;
+    VkIndirectExecutionSetEXT *pIndirectExecutionSet;
+    VkResult result;
+};
+
 struct vkCreateInstance_params
 {
     const VkInstanceCreateInfo *pCreateInfo;
@@ -3380,6 +3429,13 @@ struct vkDestroyImageView_params
     const VkAllocationCallbacks *pAllocator;
 };

+struct vkDestroyIndirectCommandsLayoutEXT_params
+{
+    VkDevice device;
+    VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
+    const VkAllocationCallbacks *pAllocator;
+};
+
 struct vkDestroyIndirectCommandsLayoutNV_params
 {
     VkDevice device;
@@ -3387,6 +3443,13 @@ struct vkDestroyIndirectCommandsLayoutNV_params
     const VkAllocationCallbacks *pAllocator;
 };

+struct vkDestroyIndirectExecutionSetEXT_params
+{
+    VkDevice device;
+    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+    const VkAllocationCallbacks *pAllocator;
+};
+
 struct vkDestroyInstance_params
 {
     VkInstance instance;
@@ -4038,6 +4101,13 @@ struct vkGetFramebufferTilePropertiesQCOM_params
     VkResult result;
 };

+struct vkGetGeneratedCommandsMemoryRequirementsEXT_params
+{
+    VkDevice device;
+    const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo;
+    VkMemoryRequirements2 *pMemoryRequirements;
+};
+
 struct vkGetGeneratedCommandsMemoryRequirementsNV_params
 {
     VkDevice device;
@@ -5191,6 +5261,22 @@ struct vkUpdateDescriptorSets_params
     const VkCopyDescriptorSet *pDescriptorCopies;
 };

+struct vkUpdateIndirectExecutionSetPipelineEXT_params
+{
+    VkDevice device;
+    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+    uint32_t executionSetWriteCount;
+    const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites;
+};
+
+struct vkUpdateIndirectExecutionSetShaderEXT_params
+{
+    VkDevice device;
+    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+    uint32_t executionSetWriteCount;
+    const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites;
+};
+
 struct vkUpdateVideoSessionParametersKHR_params
 {
     VkDevice device;
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 288fa1fd11a..8978766189c 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -64,7 +64,7 @@ from enum import Enum
 LOGGER = logging.Logger("vulkan")
 LOGGER.addHandler(logging.StreamHandler())

-VK_XML_VERSION = "1.3.295"
+VK_XML_VERSION = "1.3.296"
 WINE_VK_VERSION = (1, 3)

# Filenames to create.
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 76bc26b53fd..1a2d2487a4c 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -1402,6 +1402,37 @@ typedef struct VkVideoEndCodingInfoKHR32
     VkVideoEndCodingFlagsKHR flags;
 } VkVideoEndCodingInfoKHR32;

+typedef struct VkGeneratedCommandsPipelineInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+} VkGeneratedCommandsPipelineInfoEXT32;
+
+typedef struct VkGeneratedCommandsShaderInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t shaderCount;
+    PTR32 pShaders;
+} VkGeneratedCommandsShaderInfoEXT32;
+
+typedef struct VkGeneratedCommandsInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkShaderStageFlags shaderStages;
+    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
+    VkDeviceAddress DECLSPEC_ALIGN(8) indirectAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) indirectAddressSize;
+    VkDeviceAddress DECLSPEC_ALIGN(8) preprocessAddress;
+    VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize;
+    uint32_t maxSequenceCount;
+    VkDeviceAddress DECLSPEC_ALIGN(8) sequenceCountAddress;
+    uint32_t maxDrawCount;
+} VkGeneratedCommandsInfoEXT32;
+
 typedef struct VkIndirectCommandsStreamNV32
 {
     VkBuffer DECLSPEC_ALIGN(8) buffer;
@@ -3311,6 +3342,21 @@ typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
     VkBool32 depthClipControl;
 } VkPhysicalDeviceDepthClipControlFeaturesEXT32;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 deviceGeneratedCommands;
+    VkBool32 dynamicGeneratedPipelineLayout;
+} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32;
+
+typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 depthClampControl;
+} VkPhysicalDeviceDepthClampControlFeaturesEXT32;
+
 typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
 {
     VkStructureType sType;
@@ -4087,6 +4133,14 @@ typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
     VkBool32 negativeOneToOne;
 } VkPipelineViewportDepthClipControlCreateInfoEXT32;

+typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkDepthClampModeEXT depthClampMode;
+    PTR32 pDepthClampRange;
+} VkPipelineViewportDepthClampControlCreateInfoEXT32;
+
 typedef struct VkPipelineViewportStateCreateInfo32
 {
     VkStructureType sType;
@@ -4502,6 +4556,35 @@ typedef struct VkImageViewCreateInfo32
     VkImageSubresourceRange subresourceRange;
 } VkImageViewCreateInfo32;

+typedef union VkIndirectCommandsTokenDataEXT32
+{
+    PTR32 pPushConstant;
+    PTR32 pVertexBuffer;
+    PTR32 pIndexBuffer;
+    PTR32 pExecutionSet;
+} VkIndirectCommandsTokenDataEXT32;
+
+typedef struct VkIndirectCommandsLayoutTokenEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkIndirectCommandsTokenTypeEXT type;
+    VkIndirectCommandsTokenDataEXT32 data;
+    uint32_t offset;
+} VkIndirectCommandsLayoutTokenEXT32;
+
+typedef struct VkIndirectCommandsLayoutCreateInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkIndirectCommandsLayoutUsageFlagsEXT flags;
+    VkShaderStageFlags shaderStages;
+    uint32_t indirectStride;
+    VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
+    uint32_t tokenCount;
+    PTR32 pTokens;
+} VkIndirectCommandsLayoutCreateInfoEXT32;
+
 typedef struct VkIndirectCommandsLayoutTokenNV32
 {
     VkStructureType sType;
@@ -4533,6 +4616,48 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV32
     PTR32 pStreamStrides;
 } VkIndirectCommandsLayoutCreateInfoNV32;

+typedef struct VkIndirectExecutionSetPipelineInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkPipeline DECLSPEC_ALIGN(8) initialPipeline;
+    uint32_t maxPipelineCount;
+} VkIndirectExecutionSetPipelineInfoEXT32;
+
+typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t setLayoutCount;
+    PTR32 pSetLayouts;
+} VkIndirectExecutionSetShaderLayoutInfoEXT32;
+
+typedef struct VkIndirectExecutionSetShaderInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t shaderCount;
+    PTR32 pInitialShaders;
+    PTR32 pSetLayoutInfos;
+    uint32_t maxShaderCount;
+    uint32_t pushConstantRangeCount;
+    PTR32 pPushConstantRanges;
+} VkIndirectExecutionSetShaderInfoEXT32;
+
+typedef union VkIndirectExecutionSetInfoEXT32
+{
+    PTR32 pPipelineInfo;
+    PTR32 pShaderInfo;
+} VkIndirectExecutionSetInfoEXT32;
+
+typedef struct VkIndirectExecutionSetCreateInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkIndirectExecutionSetInfoTypeEXT type;
+    VkIndirectExecutionSetInfoEXT32 info;
+} VkIndirectExecutionSetCreateInfoEXT32;
+
 typedef struct VkLayerSettingEXT32
 {
     PTR32 pLayerName;
@@ -5970,6 +6095,16 @@ typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR32
     VkBool32 hasOverrides;
 } VkVideoEncodeSessionParametersFeedbackInfoKHR32;

+typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
+    uint32_t maxSequenceCount;
+    uint32_t maxDrawCount;
+} VkGeneratedCommandsMemoryRequirementsInfoEXT32;
+
 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
 {
     VkStructureType sType;
@@ -7209,6 +7344,24 @@ typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32
     VkBool32 nativeUnalignedPerformance;
 } VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t maxIndirectPipelineCount;
+    uint32_t maxIndirectShaderObjectCount;
+    uint32_t maxIndirectSequenceCount;
+    uint32_t maxIndirectCommandsTokenCount;
+    uint32_t maxIndirectCommandsTokenOffset;
+    uint32_t maxIndirectCommandsIndirectStride;
+    VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes;
+    VkShaderStageFlags supportedIndirectCommandsShaderStages;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding;
+    VkBool32 deviceGeneratedCommandsTransformFeedback;
+    VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount;
+} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32;
+
 typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT32
 {
     VkStructureType sType;
@@ -8348,6 +8501,22 @@ typedef struct VkCopyDescriptorSet32
     uint32_t descriptorCount;
 } VkCopyDescriptorSet32;

+typedef struct VkWriteIndirectExecutionSetPipelineEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t index;
+    VkPipeline DECLSPEC_ALIGN(8) pipeline;
+} VkWriteIndirectExecutionSetPipelineEXT32;
+
+typedef struct VkWriteIndirectExecutionSetShaderEXT32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    uint32_t index;
+    VkShaderEXT DECLSPEC_ALIGN(8) shader;
+} VkWriteIndirectExecutionSetShaderEXT32;
+
 typedef struct VkVideoSessionParametersUpdateInfoKHR32
 {
     VkStructureType sType;
@@ -11524,6 +11693,60 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host
     return out;
 }

+static inline void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoEXT32 *in, VkGeneratedCommandsInfoEXT *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->shaderStages = in->shaderStages;
+    out->indirectExecutionSet = in->indirectExecutionSet;
+    out->indirectCommandsLayout = in->indirectCommandsLayout;
+    out->indirectAddress = in->indirectAddress;
+    out->indirectAddressSize = in->indirectAddressSize;
+    out->preprocessAddress = in->preprocessAddress;
+    out->preprocessSize = in->preprocessSize;
+    out->maxSequenceCount = in->maxSequenceCount;
+    out->sequenceCountAddress = in->sequenceCountAddress;
+    out->maxDrawCount = in->maxDrawCount;
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
+        {
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
+        {
+            VkGeneratedCommandsPipelineInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGeneratedCommandsPipelineInfoEXT32 *in_ext = (const VkGeneratedCommandsPipelineInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->pipeline = in_ext->pipeline;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
+        {
+            VkGeneratedCommandsShaderInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGeneratedCommandsShaderInfoEXT32 *in_ext = (const VkGeneratedCommandsShaderInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->shaderCount = in_ext->shaderCount;
+            out_ext->pShaders = UlongToPtr(in_ext->pShaders);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
+    }
+}
+
 static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out)
 {
     if (!in) return;
@@ -15293,6 +15516,29 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->depthClampControl = in_ext->depthClampControl;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -17697,6 +17943,29 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->depthClampControl = in_ext->depthClampControl;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -19072,6 +19341,18 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+        {
+            VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->depthClampMode = in_ext->depthClampMode;
+            out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -20442,6 +20723,91 @@ static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion
     }
 }

+static inline void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const VkIndirectCommandsTokenDataEXT32 *in, VkIndirectCommandsTokenDataEXT *out, VkFlags selector)
+{
+    if (!in) return;
+
+    if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT)
+        out->pPushConstant = UlongToPtr(in->pPushConstant);
+    if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT)
+        out->pVertexBuffer = UlongToPtr(in->pVertexBuffer);
+    if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT)
+        out->pIndexBuffer = UlongToPtr(in->pIndexBuffer);
+    if (selector == VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT)
+        out->pExecutionSet = UlongToPtr(in->pExecutionSet);
+}
+
+static inline void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const VkIndirectCommandsLayoutTokenEXT32 *in, VkIndirectCommandsLayoutTokenEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->type = in->type;
+    convert_VkIndirectCommandsTokenDataEXT_win32_to_host(&in->data, &out->data, in->type);
+    out->offset = in->offset;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static inline const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenEXT32 *in, uint32_t count)
+{
+    VkIndirectCommandsLayoutTokenEXT *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static inline void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoEXT32 *in, VkIndirectCommandsLayoutCreateInfoEXT *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->flags = in->flags;
+    out->shaderStages = in->shaderStages;
+    out->indirectStride = in->indirectStride;
+    out->pipelineLayout = in->pipelineLayout;
+    out->tokenCount = in->tokenCount;
+    out->pTokens = convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(ctx, (const VkIndirectCommandsLayoutTokenEXT32 *)UlongToPtr(in->pTokens), in->tokenCount);
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
+        {
+        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
+        {
+            VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->setLayoutCount = in_ext->setLayoutCount;
+            out_ext->pSetLayouts = UlongToPtr(in_ext->pSetLayouts);
+            out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount;
+            out_ext->pPushConstantRanges = UlongToPtr(in_ext->pPushConstantRanges);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
+    }
+}
+
 static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out)
 {
     if (!in) return;
@@ -20497,6 +20863,116 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(st
         FIXME("Unexpected pNext\n");
 }

+static inline void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(const VkIndirectExecutionSetPipelineInfoEXT32 *in, VkIndirectExecutionSetPipelineInfoEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->initialPipeline = in->initialPipeline;
+    out->maxPipelineCount = in->maxPipelineCount;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static inline const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetPipelineInfoEXT32 *in, uint32_t count)
+{
+    VkIndirectExecutionSetPipelineInfoEXT *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static inline void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, VkIndirectExecutionSetShaderLayoutInfoEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->setLayoutCount = in->setLayoutCount;
+    out->pSetLayouts = UlongToPtr(in->pSetLayouts);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static inline const VkIndirectExecutionSetShaderLayoutInfoEXT *convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, uint32_t count)
+{
+    VkIndirectExecutionSetShaderLayoutInfoEXT *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static inline void convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, VkIndirectExecutionSetShaderInfoEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->shaderCount = in->shaderCount;
+    out->pInitialShaders = UlongToPtr(in->pInitialShaders);
+    out->pSetLayoutInfos = convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderLayoutInfoEXT32 *)UlongToPtr(in->pSetLayoutInfos), in->shaderCount);
+    out->maxShaderCount = in->maxShaderCount;
+    out->pushConstantRangeCount = in->pushConstantRangeCount;
+    out->pPushConstantRanges = UlongToPtr(in->pPushConstantRanges);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static inline const VkIndirectExecutionSetShaderInfoEXT *convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, uint32_t count)
+{
+    VkIndirectExecutionSetShaderInfoEXT *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(ctx, &in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static inline void convert_VkIndirectExecutionSetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetInfoEXT32 *in, VkIndirectExecutionSetInfoEXT *out, VkFlags selector)
+{
+    if (!in) return;
+
+    if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT)
+        out->pPipelineInfo = convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetPipelineInfoEXT32 *)UlongToPtr(in->pPipelineInfo), 1);
+    if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT)
+        out->pShaderInfo = convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderInfoEXT32 *)UlongToPtr(in->pShaderInfo), 1);
+}
+
+static inline void convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetCreateInfoEXT32 *in, VkIndirectExecutionSetCreateInfoEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->type = in->type;
+    convert_VkIndirectExecutionSetInfoEXT_win32_to_host(ctx, &in->info, &out->info, in->type);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
 static inline void convert_VkLayerSettingEXT_win32_to_host(const VkLayerSettingEXT32 *in, VkLayerSettingEXT *out)
 {
     if (!in) return;
@@ -24481,6 +24957,60 @@ static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTile
     }
 }

+static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *in, VkGeneratedCommandsMemoryRequirementsInfoEXT *out)
+{
+    const VkBaseInStructure32 *in_header;
+    VkBaseOutStructure *out_header = (void *)out;
+
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->indirectExecutionSet = in->indirectExecutionSet;
+    out->indirectCommandsLayout = in->indirectCommandsLayout;
+    out->maxSequenceCount = in->maxSequenceCount;
+    out->maxDrawCount = in->maxDrawCount;
+
+    for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
+    {
+        switch (in_header->sType)
+        {
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
+        {
+            VkGeneratedCommandsPipelineInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGeneratedCommandsPipelineInfoEXT32 *in_ext = (const VkGeneratedCommandsPipelineInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->pipeline = in_ext->pipeline;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
+        {
+            VkGeneratedCommandsShaderInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkGeneratedCommandsShaderInfoEXT32 *in_ext = (const VkGeneratedCommandsShaderInfoEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT;
+            out_ext->pNext = NULL;
+            out_ext->shaderCount = in_ext->shaderCount;
+            out_ext->pShaders = UlongToPtr(in_ext->pShaders);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        default:
+            FIXME("Unhandled sType %u.\n", in_header->sType);
+            break;
+        }
+    }
+}
+
+static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_host_to_win32(const VkGeneratedCommandsMemoryRequirementsInfoEXT *in, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *out)
+{
+    if (!in) return;
+
+}
+
 static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out)
 {
     if (!in) return;
@@ -26391,6 +26921,29 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+            out_ext->pNext = NULL;
+            out_ext->depthClampControl = in_ext->depthClampControl;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -28482,6 +29035,25 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT);
+            const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT;
+            out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands;
+            out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout;
+            out_header = (void *)out_ext;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+        {
+            VkPhysicalDeviceDepthClampControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT);
+            const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT;
+            out_ext->depthClampControl = in_ext->depthClampControl;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
         {
             VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT);
@@ -30467,6 +31039,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+        {
+            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
         {
             VkPhysicalDeviceHostImageCopyPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -31613,6 +32194,26 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+        {
+            VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT);
+            const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT;
+            out_ext->maxIndirectPipelineCount = in_ext->maxIndirectPipelineCount;
+            out_ext->maxIndirectShaderObjectCount = in_ext->maxIndirectShaderObjectCount;
+            out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount;
+            out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount;
+            out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset;
+            out_ext->maxIndirectCommandsIndirectStride = in_ext->maxIndirectCommandsIndirectStride;
+            out_ext->supportedIndirectCommandsInputModes = in_ext->supportedIndirectCommandsInputModes;
+            out_ext->supportedIndirectCommandsShaderStages = in_ext->supportedIndirectCommandsShaderStages;
+            out_ext->supportedIndirectCommandsShaderStagesPipelineBinding = in_ext->supportedIndirectCommandsShaderStagesPipelineBinding;
+            out_ext->supportedIndirectCommandsShaderStagesShaderBinding = in_ext->supportedIndirectCommandsShaderStagesShaderBinding;
+            out_ext->deviceGeneratedCommandsTransformFeedback = in_ext->deviceGeneratedCommandsTransformFeedback;
+            out_ext->deviceGeneratedCommandsMultiDrawIndirectCount = in_ext->deviceGeneratedCommandsMultiDrawIndirectCount;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
         {
             VkPhysicalDeviceHostImageCopyPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT);
@@ -34737,6 +35338,62 @@ static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32
     return out;
 }

+static inline void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(const VkWriteIndirectExecutionSetPipelineEXT32 *in, VkWriteIndirectExecutionSetPipelineEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->index = in->index;
+    out->pipeline = in->pipeline;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static inline const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetPipelineEXT32 *in, uint32_t count)
+{
+    VkWriteIndirectExecutionSetPipelineEXT *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
+static inline void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(const VkWriteIndirectExecutionSetShaderEXT32 *in, VkWriteIndirectExecutionSetShaderEXT *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->index = in->index;
+    out->shader = in->shader;
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
+static inline const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetShaderEXT32 *in, uint32_t count)
+{
+    VkWriteIndirectExecutionSetShaderEXT *out;
+    unsigned int i;
+
+    if (!in || !count) return NULL;
+
+    out = conversion_context_alloc(ctx, count * sizeof(*out));
+    for (i = 0; i < count; i++)
+    {
+        convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(&in[i], &out[i]);
+    }
+
+    return out;
+}
+
 static inline void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersUpdateInfoKHR32 *in, VkVideoSessionParametersUpdateInfoKHR *out)
 {
     const VkBaseInStructure32 *in_header;
@@ -38099,6 +38756,33 @@ static void thunk32_vkCmdExecuteCommands(void *args)
     free_conversion_context(ctx);
 }

+#ifdef _WIN64
+static void thunk64_vkCmdExecuteGeneratedCommandsEXT(void *args)
+{
+    struct vkCmdExecuteGeneratedCommandsEXT_params *params = args;
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
+}
+#endif /* _WIN64 */
+
+static void thunk32_vkCmdExecuteGeneratedCommandsEXT(void *args)
+{
+    struct
+    {
+        PTR32 commandBuffer;
+        VkBool32 isPreprocessed;
+        PTR32 pGeneratedCommandsInfo;
+    } *params = args;
+    VkGeneratedCommandsInfoEXT pGeneratedCommandsInfo_host;
+    struct conversion_context local_ctx;
+    struct conversion_context *ctx = &local_ctx;
+
+    init_conversion_context(ctx);
+    convert_VkGeneratedCommandsInfoEXT_win32_to_host(ctx, (const VkGeneratedCommandsInfoEXT32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteGeneratedCommandsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
+    free_conversion_context(ctx);
+}
+
 #ifdef _WIN64
 static void thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
 {
@@ -38362,6 +39046,33 @@ static void thunk32_vkCmdPipelineBarrier2KHR(void *args)
     free_conversion_context(ctx);
 }

+#ifdef _WIN64
+static void thunk64_vkCmdPreprocessGeneratedCommandsEXT(void *args)
+{
+    struct vkCmdPreprocessGeneratedCommandsEXT_params *params = args;
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pGeneratedCommandsInfo, wine_cmd_buffer_from_handle(params->stateCommandBuffer)->host_command_buffer);
+}
+#endif /* _WIN64 */
+
+static void thunk32_vkCmdPreprocessGeneratedCommandsEXT(void *args)
+{
+    struct
+    {
+        PTR32 commandBuffer;
+        PTR32 pGeneratedCommandsInfo;
+        PTR32 stateCommandBuffer;
+    } *params = args;
+    VkGeneratedCommandsInfoEXT pGeneratedCommandsInfo_host;
+    struct conversion_context local_ctx;
+    struct conversion_context *ctx = &local_ctx;
+
+    init_conversion_context(ctx);
+    convert_VkGeneratedCommandsInfoEXT_win32_to_host(ctx, (const VkGeneratedCommandsInfoEXT32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPreprocessGeneratedCommandsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pGeneratedCommandsInfo_host, wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->stateCommandBuffer))->host_command_buffer);
+    free_conversion_context(ctx);
+}
+
 #ifdef _WIN64
 static void thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
 {
@@ -39292,6 +40003,27 @@ static void thunk32_vkCmdSetDepthClampEnableEXT(void *args)
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->depthClampEnable);
 }

+#ifdef _WIN64
+static void thunk64_vkCmdSetDepthClampRangeEXT(void *args)
+{
+    struct vkCmdSetDepthClampRangeEXT_params *params = args;
+
+    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampRangeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->depthClampMode, params->pDepthClampRange);
+}
+#endif /* _WIN64 */
+
+static void thunk32_vkCmdSetDepthClampRangeEXT(void *args)
+{
+    struct
+    {
+        PTR32 commandBuffer;
+        VkDepthClampModeEXT depthClampMode;
+        PTR32 pDepthClampRange;
+    } *params = args;
+
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampRangeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->depthClampMode, (const VkDepthClampRangeEXT *)UlongToPtr(params->pDepthClampRange));
+}
+
 #ifdef _WIN64
 static void thunk64_vkCmdSetDepthClipEnableEXT(void *args)
 {
@@ -42468,6 +43200,41 @@ static NTSTATUS thunk32_vkCreateImageView(void *args)
     return STATUS_SUCCESS;
 }

+#ifdef _WIN64
+static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutEXT(void *args)
+{
+    struct vkCreateIndirectCommandsLayoutEXT_params *params = args;
+
+    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutEXT(wine_device_from_handle(params->device)->host_device, params->pCreateInfo, NULL, params->pIndirectCommandsLayout);
+    return STATUS_SUCCESS;
+}
+#endif /* _WIN64 */
+
+static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutEXT(void *args)
+{
+    struct
+    {
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pIndirectCommandsLayout;
+        VkResult result;
+    } *params = args;
+    VkIndirectCommandsLayoutCreateInfoEXT pCreateInfo_host;
+    struct conversion_context local_ctx;
+    struct conversion_context *ctx = &local_ctx;
+
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
+
+    init_conversion_context(ctx);
+    convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(ctx, (const VkIndirectCommandsLayoutCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateIndirectCommandsLayoutEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, (VkIndirectCommandsLayoutEXT *)UlongToPtr(params->pIndirectCommandsLayout));
+    free_conversion_context(ctx);
+    return STATUS_SUCCESS;
+}
+
 #ifdef _WIN64
 static NTSTATUS thunk64_vkCreateIndirectCommandsLayoutNV(void *args)
 {
@@ -42503,6 +43270,41 @@ static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
     return STATUS_SUCCESS;
 }

+#ifdef _WIN64
+static NTSTATUS thunk64_vkCreateIndirectExecutionSetEXT(void *args)
+{
+    struct vkCreateIndirectExecutionSetEXT_params *params = args;
+
+    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectExecutionSet);
+
+    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectExecutionSetEXT(wine_device_from_handle(params->device)->host_device, params->pCreateInfo, NULL, params->pIndirectExecutionSet);
+    return STATUS_SUCCESS;
+}
+#endif /* _WIN64 */
+
+static NTSTATUS thunk32_vkCreateIndirectExecutionSetEXT(void *args)
+{
+    struct
+    {
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pIndirectExecutionSet;
+        VkResult result;
+    } *params = args;
+    VkIndirectExecutionSetCreateInfoEXT pCreateInfo_host;
+    struct conversion_context local_ctx;
+    struct conversion_context *ctx = &local_ctx;
+
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectExecutionSet);
+
+    init_conversion_context(ctx);
+    convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(ctx, (const VkIndirectExecutionSetCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateIndirectExecutionSetEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, (VkIndirectExecutionSetEXT *)UlongToPtr(params->pIndirectExecutionSet));
+    free_conversion_context(ctx);
+    return STATUS_SUCCESS;
+}
+
 #ifdef _WIN64
 static NTSTATUS thunk64_vkCreateInstance(void *args)
 {
@@ -44110,6 +44912,33 @@ static NTSTATUS thunk32_vkDestroyImageView(void *args)
     return STATUS_SUCCESS;
 }

+#ifdef _WIN64
+static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutEXT(void *args)
+{
+    struct vkDestroyIndirectCommandsLayoutEXT_params *params = args;
+
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
+
+    wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutEXT(wine_device_from_handle(params->device)->host_device, params->indirectCommandsLayout, NULL);
+    return STATUS_SUCCESS;
+}
+#endif /* _WIN64 */
+
+static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutEXT(void *args)
+{
+    struct
+    {
+        PTR32 device;
+        VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout;
+        PTR32 pAllocator;
+    } *params = args;
+
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
+
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectCommandsLayoutEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectCommandsLayout, NULL);
+    return STATUS_SUCCESS;
+}
+
 #ifdef _WIN64
 static NTSTATUS thunk64_vkDestroyIndirectCommandsLayoutNV(void *args)
 {
@@ -44137,6 +44966,33 @@ static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
     return STATUS_SUCCESS;
 }

+#ifdef _WIN64
+static NTSTATUS thunk64_vkDestroyIndirectExecutionSetEXT(void *args)
+{
+    struct vkDestroyIndirectExecutionSetEXT_params *params = args;
+
+    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->pAllocator);
+
+    wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectExecutionSetEXT(wine_device_from_handle(params->device)->host_device, params->indirectExecutionSet, NULL);
+    return STATUS_SUCCESS;
+}
+#endif /* _WIN64 */
+
+static NTSTATUS thunk32_vkDestroyIndirectExecutionSetEXT(void *args)
+{
+    struct
+    {
+        PTR32 device;
+        VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+        PTR32 pAllocator;
+    } *params = args;
+
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->pAllocator);
+
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectExecutionSetEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectExecutionSet, NULL);
+    return STATUS_SUCCESS;
+}
+
 #ifdef _WIN64
 static NTSTATUS thunk64_vkDestroyInstance(void *args)
 {
@@ -46836,6 +47692,43 @@ static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
     return STATUS_SUCCESS;
 }

+#ifdef _WIN64
+static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsEXT(void *args)
+{
+    struct vkGetGeneratedCommandsMemoryRequirementsEXT_params *params = args;
+
+    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+
+    wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsEXT(wine_device_from_handle(params->device)->host_device, params->pInfo, params->pMemoryRequirements);
+    return STATUS_SUCCESS;
+}
+#endif /* _WIN64 */
+
+static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsEXT(void *args)
+{
+    struct
+    {
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
+    } *params = args;
+    VkGeneratedCommandsMemoryRequirementsInfoEXT pInfo_host;
+    VkMemoryRequirements2 pMemoryRequirements_host;
+    struct conversion_context local_ctx;
+    struct conversion_context *ctx = &local_ctx;
+
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);
+
+    init_conversion_context(ctx);
+    convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(ctx, (const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_host_to_win32(&pInfo_host, (const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *)UlongToPtr(params->pInfo));
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
+    free_conversion_context(ctx);
+    return STATUS_SUCCESS;
+}
+
 #ifdef _WIN64
 static NTSTATUS thunk64_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
 {
@@ -51550,6 +52443,74 @@ static void thunk32_vkUpdateDescriptorSets(void *args)
     free_conversion_context(ctx);
 }

+#ifdef _WIN64
+static NTSTATUS thunk64_vkUpdateIndirectExecutionSetPipelineEXT(void *args)
+{
+    struct vkUpdateIndirectExecutionSetPipelineEXT_params *params = args;
+
+    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites);
+
+    wine_device_from_handle(params->device)->funcs.p_vkUpdateIndirectExecutionSetPipelineEXT(wine_device_from_handle(params->device)->host_device, params->indirectExecutionSet, params->executionSetWriteCount, params->pExecutionSetWrites);
+    return STATUS_SUCCESS;
+}
+#endif /* _WIN64 */
+
+static NTSTATUS thunk32_vkUpdateIndirectExecutionSetPipelineEXT(void *args)
+{
+    struct
+    {
+        PTR32 device;
+        VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+        uint32_t executionSetWriteCount;
+        PTR32 pExecutionSetWrites;
+    } *params = args;
+    const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites_host;
+    struct conversion_context local_ctx;
+    struct conversion_context *ctx = &local_ctx;
+
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites);
+
+    init_conversion_context(ctx);
+    pExecutionSetWrites_host = convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(ctx, (const VkWriteIndirectExecutionSetPipelineEXT32 *)UlongToPtr(params->pExecutionSetWrites), params->executionSetWriteCount);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateIndirectExecutionSetPipelineEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectExecutionSet, params->executionSetWriteCount, pExecutionSetWrites_host);
+    free_conversion_context(ctx);
+    return STATUS_SUCCESS;
+}
+
+#ifdef _WIN64
+static NTSTATUS thunk64_vkUpdateIndirectExecutionSetShaderEXT(void *args)
+{
+    struct vkUpdateIndirectExecutionSetShaderEXT_params *params = args;
+
+    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites);
+
+    wine_device_from_handle(params->device)->funcs.p_vkUpdateIndirectExecutionSetShaderEXT(wine_device_from_handle(params->device)->host_device, params->indirectExecutionSet, params->executionSetWriteCount, params->pExecutionSetWrites);
+    return STATUS_SUCCESS;
+}
+#endif /* _WIN64 */
+
+static NTSTATUS thunk32_vkUpdateIndirectExecutionSetShaderEXT(void *args)
+{
+    struct
+    {
+        PTR32 device;
+        VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet;
+        uint32_t executionSetWriteCount;
+        PTR32 pExecutionSetWrites;
+    } *params = args;
+    const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites_host;
+    struct conversion_context local_ctx;
+    struct conversion_context *ctx = &local_ctx;
+
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->indirectExecutionSet), params->executionSetWriteCount, params->pExecutionSetWrites);
+
+    init_conversion_context(ctx);
+    pExecutionSetWrites_host = convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(ctx, (const VkWriteIndirectExecutionSetShaderEXT32 *)UlongToPtr(params->pExecutionSetWrites), params->executionSetWriteCount);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateIndirectExecutionSetShaderEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->indirectExecutionSet, params->executionSetWriteCount, pExecutionSetWrites_host);
+    free_conversion_context(ctx);
+    return STATUS_SUCCESS;
+}
+
 #ifdef _WIN64
 static NTSTATUS thunk64_vkUpdateVideoSessionParametersKHR(void *args)
 {
@@ -51810,6 +52771,7 @@ static const char * const vk_device_extensions[] =
     "VK_EXT_custom_border_color",
     "VK_EXT_debug_marker",
     "VK_EXT_depth_bias_control",
+    "VK_EXT_depth_clamp_control",
     "VK_EXT_depth_clamp_zero_one",
     "VK_EXT_depth_clip_control",
     "VK_EXT_depth_clip_enable",
@@ -51818,6 +52780,7 @@ static const char * const vk_device_extensions[] =
     "VK_EXT_descriptor_indexing",
     "VK_EXT_device_address_binding_report",
     "VK_EXT_device_fault",
+    "VK_EXT_device_generated_commands",
     "VK_EXT_discard_rectangles",
     "VK_EXT_dynamic_rendering_unused_attachments",
     "VK_EXT_extended_dynamic_state",
@@ -52294,6 +53257,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk64_vkCmdEndTransformFeedbackEXT,
     (void *)thunk64_vkCmdEndVideoCodingKHR,
     (void *)thunk64_vkCmdExecuteCommands,
+    (void *)thunk64_vkCmdExecuteGeneratedCommandsEXT,
     (void *)thunk64_vkCmdExecuteGeneratedCommandsNV,
     (void *)thunk64_vkCmdFillBuffer,
     (void *)thunk64_vkCmdInsertDebugUtilsLabelEXT,
@@ -52304,6 +53268,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk64_vkCmdPipelineBarrier,
     (void *)thunk64_vkCmdPipelineBarrier2,
     (void *)thunk64_vkCmdPipelineBarrier2KHR,
+    (void *)thunk64_vkCmdPreprocessGeneratedCommandsEXT,
     (void *)thunk64_vkCmdPreprocessGeneratedCommandsNV,
     (void *)thunk64_vkCmdPushConstants,
     (void *)thunk64_vkCmdPushConstants2KHR,
@@ -52346,6 +53311,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk64_vkCmdSetDepthBoundsTestEnable,
     (void *)thunk64_vkCmdSetDepthBoundsTestEnableEXT,
     (void *)thunk64_vkCmdSetDepthClampEnableEXT,
+    (void *)thunk64_vkCmdSetDepthClampRangeEXT,
     (void *)thunk64_vkCmdSetDepthClipEnableEXT,
     (void *)thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
     (void *)thunk64_vkCmdSetDepthCompareOp,
@@ -52471,7 +53437,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkCreateGraphicsPipelines,
     thunk64_vkCreateImage,
     thunk64_vkCreateImageView,
+    thunk64_vkCreateIndirectCommandsLayoutEXT,
     thunk64_vkCreateIndirectCommandsLayoutNV,
+    thunk64_vkCreateIndirectExecutionSetEXT,
     thunk64_vkCreateInstance,
     thunk64_vkCreateMicromapEXT,
     thunk64_vkCreateOpticalFlowSessionNV,
@@ -52523,7 +53491,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkDestroyFramebuffer,
     thunk64_vkDestroyImage,
     thunk64_vkDestroyImageView,
+    thunk64_vkDestroyIndirectCommandsLayoutEXT,
     thunk64_vkDestroyIndirectCommandsLayoutNV,
+    thunk64_vkDestroyIndirectExecutionSetEXT,
     thunk64_vkDestroyInstance,
     thunk64_vkDestroyMicromapEXT,
     thunk64_vkDestroyOpticalFlowSessionNV,
@@ -52611,6 +53581,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkGetEventStatus,
     thunk64_vkGetFenceStatus,
     thunk64_vkGetFramebufferTilePropertiesQCOM,
+    thunk64_vkGetGeneratedCommandsMemoryRequirementsEXT,
     thunk64_vkGetGeneratedCommandsMemoryRequirementsNV,
     thunk64_vkGetImageMemoryRequirements,
     thunk64_vkGetImageMemoryRequirements2,
@@ -52758,6 +53729,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk64_vkUpdateDescriptorSetWithTemplate,
     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
     (void *)thunk64_vkUpdateDescriptorSets,
+    thunk64_vkUpdateIndirectExecutionSetPipelineEXT,
+    thunk64_vkUpdateIndirectExecutionSetShaderEXT,
     thunk64_vkUpdateVideoSessionParametersKHR,
     thunk64_vkWaitForFences,
     thunk64_vkWaitForPresentKHR,
@@ -52905,6 +53878,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk32_vkCmdEndTransformFeedbackEXT,
     (void *)thunk32_vkCmdEndVideoCodingKHR,
     (void *)thunk32_vkCmdExecuteCommands,
+    (void *)thunk32_vkCmdExecuteGeneratedCommandsEXT,
     (void *)thunk32_vkCmdExecuteGeneratedCommandsNV,
     (void *)thunk32_vkCmdFillBuffer,
     (void *)thunk32_vkCmdInsertDebugUtilsLabelEXT,
@@ -52915,6 +53889,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk32_vkCmdPipelineBarrier,
     (void *)thunk32_vkCmdPipelineBarrier2,
     (void *)thunk32_vkCmdPipelineBarrier2KHR,
+    (void *)thunk32_vkCmdPreprocessGeneratedCommandsEXT,
     (void *)thunk32_vkCmdPreprocessGeneratedCommandsNV,
     (void *)thunk32_vkCmdPushConstants,
     (void *)thunk32_vkCmdPushConstants2KHR,
@@ -52957,6 +53932,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk32_vkCmdSetDepthBoundsTestEnable,
     (void *)thunk32_vkCmdSetDepthBoundsTestEnableEXT,
     (void *)thunk32_vkCmdSetDepthClampEnableEXT,
+    (void *)thunk32_vkCmdSetDepthClampRangeEXT,
     (void *)thunk32_vkCmdSetDepthClipEnableEXT,
     (void *)thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
     (void *)thunk32_vkCmdSetDepthCompareOp,
@@ -53082,7 +54058,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkCreateGraphicsPipelines,
     thunk32_vkCreateImage,
     thunk32_vkCreateImageView,
+    thunk32_vkCreateIndirectCommandsLayoutEXT,
     thunk32_vkCreateIndirectCommandsLayoutNV,
+    thunk32_vkCreateIndirectExecutionSetEXT,
     thunk32_vkCreateInstance,
     thunk32_vkCreateMicromapEXT,
     thunk32_vkCreateOpticalFlowSessionNV,
@@ -53134,7 +54112,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkDestroyFramebuffer,
     thunk32_vkDestroyImage,
     thunk32_vkDestroyImageView,
+    thunk32_vkDestroyIndirectCommandsLayoutEXT,
     thunk32_vkDestroyIndirectCommandsLayoutNV,
+    thunk32_vkDestroyIndirectExecutionSetEXT,
     thunk32_vkDestroyInstance,
     thunk32_vkDestroyMicromapEXT,
     thunk32_vkDestroyOpticalFlowSessionNV,
@@ -53222,6 +54202,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkGetEventStatus,
     thunk32_vkGetFenceStatus,
     thunk32_vkGetFramebufferTilePropertiesQCOM,
+    thunk32_vkGetGeneratedCommandsMemoryRequirementsEXT,
     thunk32_vkGetGeneratedCommandsMemoryRequirementsNV,
     thunk32_vkGetImageMemoryRequirements,
     thunk32_vkGetImageMemoryRequirements2,
@@ -53369,6 +54350,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk32_vkUpdateDescriptorSetWithTemplate,
     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
     (void *)thunk32_vkUpdateDescriptorSets,
+    thunk32_vkUpdateIndirectExecutionSetPipelineEXT,
+    thunk32_vkUpdateIndirectExecutionSetShaderEXT,
     thunk32_vkUpdateVideoSessionParametersKHR,
     thunk32_vkWaitForFences,
     thunk32_vkWaitForPresentKHR,
diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h
index 547da66da80..82c23d3dde4 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -205,6 +205,7 @@ struct vulkan_device_funcs
     void (*p_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *);
     void (*p_vkCmdEndVideoCodingKHR)(VkCommandBuffer, const VkVideoEndCodingInfoKHR *);
     void (*p_vkCmdExecuteCommands)(VkCommandBuffer, uint32_t, const VkCommandBuffer *);
+    void (*p_vkCmdExecuteGeneratedCommandsEXT)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoEXT *);
     void (*p_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoNV *);
     void (*p_vkCmdFillBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, uint32_t);
     void (*p_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer, const VkDebugUtilsLabelEXT *);
@@ -215,6 +216,7 @@ struct vulkan_device_funcs
     void (*p_vkCmdPipelineBarrier)(VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier *);
     void (*p_vkCmdPipelineBarrier2)(VkCommandBuffer, const VkDependencyInfo *);
     void (*p_vkCmdPipelineBarrier2KHR)(VkCommandBuffer, const VkDependencyInfo *);
+    void (*p_vkCmdPreprocessGeneratedCommandsEXT)(VkCommandBuffer, const VkGeneratedCommandsInfoEXT *, VkCommandBuffer);
     void (*p_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer, const VkGeneratedCommandsInfoNV *);
     void (*p_vkCmdPushConstants)(VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, uint32_t, const void *);
     void (*p_vkCmdPushConstants2KHR)(VkCommandBuffer, const VkPushConstantsInfoKHR *);
@@ -257,6 +259,7 @@ struct vulkan_device_funcs
     void (*p_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer, VkBool32);
+    void (*p_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer, VkDepthClampModeEXT, const VkDepthClampRangeEXT *);
     void (*p_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer, VkBool32);
     void (*p_vkCmdSetDepthCompareOp)(VkCommandBuffer, VkCompareOp);
@@ -379,7 +382,9 @@ struct vulkan_device_funcs
     VkResult (*p_vkCreateGraphicsPipelines)(VkDevice, VkPipelineCache, uint32_t, const VkGraphicsPipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *);
     VkResult (*p_vkCreateImage)(VkDevice, const VkImageCreateInfo *, const VkAllocationCallbacks *, VkImage *);
     VkResult (*p_vkCreateImageView)(VkDevice, const VkImageViewCreateInfo *, const VkAllocationCallbacks *, VkImageView *);
+    VkResult (*p_vkCreateIndirectCommandsLayoutEXT)(VkDevice, const VkIndirectCommandsLayoutCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutEXT *);
     VkResult (*p_vkCreateIndirectCommandsLayoutNV)(VkDevice, const VkIndirectCommandsLayoutCreateInfoNV *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutNV *);
+    VkResult (*p_vkCreateIndirectExecutionSetEXT)(VkDevice, const VkIndirectExecutionSetCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectExecutionSetEXT *);
     VkResult (*p_vkCreateMicromapEXT)(VkDevice, const VkMicromapCreateInfoEXT *, const VkAllocationCallbacks *, VkMicromapEXT *);
     VkResult (*p_vkCreateOpticalFlowSessionNV)(VkDevice, const VkOpticalFlowSessionCreateInfoNV *, const VkAllocationCallbacks *, VkOpticalFlowSessionNV *);
     VkResult (*p_vkCreatePipelineBinariesKHR)(VkDevice, const VkPipelineBinaryCreateInfoKHR *, const VkAllocationCallbacks *, VkPipelineBinaryHandlesInfoKHR *);
@@ -426,7 +431,9 @@ struct vulkan_device_funcs
     void (*p_vkDestroyFramebuffer)(VkDevice, VkFramebuffer, const VkAllocationCallbacks *);
     void (*p_vkDestroyImage)(VkDevice, VkImage, const VkAllocationCallbacks *);
     void (*p_vkDestroyImageView)(VkDevice, VkImageView, const VkAllocationCallbacks *);
+    void (*p_vkDestroyIndirectCommandsLayoutEXT)(VkDevice, VkIndirectCommandsLayoutEXT, const VkAllocationCallbacks *);
     void (*p_vkDestroyIndirectCommandsLayoutNV)(VkDevice, VkIndirectCommandsLayoutNV, const VkAllocationCallbacks *);
+    void (*p_vkDestroyIndirectExecutionSetEXT)(VkDevice, VkIndirectExecutionSetEXT, const VkAllocationCallbacks *);
     void (*p_vkDestroyMicromapEXT)(VkDevice, VkMicromapEXT, const VkAllocationCallbacks *);
     void (*p_vkDestroyOpticalFlowSessionNV)(VkDevice, VkOpticalFlowSessionNV, const VkAllocationCallbacks *);
     void (*p_vkDestroyPipeline)(VkDevice, VkPipeline, const VkAllocationCallbacks *);
@@ -504,6 +511,7 @@ struct vulkan_device_funcs
     VkResult (*p_vkGetEventStatus)(VkDevice, VkEvent);
     VkResult (*p_vkGetFenceStatus)(VkDevice, VkFence);
     VkResult (*p_vkGetFramebufferTilePropertiesQCOM)(VkDevice, VkFramebuffer, uint32_t *, VkTilePropertiesQCOM *);
+    void (*p_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoEXT *, VkMemoryRequirements2 *);
     void (*p_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoNV *, VkMemoryRequirements2 *);
     void (*p_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *);
     void (*p_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *);
@@ -601,6 +609,8 @@ struct vulkan_device_funcs
     void (*p_vkUpdateDescriptorSetWithTemplate)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *);
     void (*p_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *);
     void (*p_vkUpdateDescriptorSets)(VkDevice, uint32_t, const VkWriteDescriptorSet *, uint32_t, const VkCopyDescriptorSet *);
+    void (*p_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetPipelineEXT *);
+    void (*p_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetShaderEXT *);
     VkResult (*p_vkUpdateVideoSessionParametersKHR)(VkDevice, VkVideoSessionParametersKHR, const VkVideoSessionParametersUpdateInfoKHR *);
     VkResult (*p_vkWaitForFences)(VkDevice, uint32_t, const VkFence *, VkBool32, uint64_t);
     VkResult (*p_vkWaitForPresentKHR)(VkDevice, VkSwapchainKHR, uint64_t, uint64_t);
@@ -801,6 +811,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdEndTransformFeedbackEXT) \
     USE_VK_FUNC(vkCmdEndVideoCodingKHR) \
     USE_VK_FUNC(vkCmdExecuteCommands) \
+    USE_VK_FUNC(vkCmdExecuteGeneratedCommandsEXT) \
     USE_VK_FUNC(vkCmdExecuteGeneratedCommandsNV) \
     USE_VK_FUNC(vkCmdFillBuffer) \
     USE_VK_FUNC(vkCmdInsertDebugUtilsLabelEXT) \
@@ -811,6 +822,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdPipelineBarrier) \
     USE_VK_FUNC(vkCmdPipelineBarrier2) \
     USE_VK_FUNC(vkCmdPipelineBarrier2KHR) \
+    USE_VK_FUNC(vkCmdPreprocessGeneratedCommandsEXT) \
     USE_VK_FUNC(vkCmdPreprocessGeneratedCommandsNV) \
     USE_VK_FUNC(vkCmdPushConstants) \
     USE_VK_FUNC(vkCmdPushConstants2KHR) \
@@ -853,6 +865,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCmdSetDepthBoundsTestEnable) \
     USE_VK_FUNC(vkCmdSetDepthBoundsTestEnableEXT) \
     USE_VK_FUNC(vkCmdSetDepthClampEnableEXT) \
+    USE_VK_FUNC(vkCmdSetDepthClampRangeEXT) \
     USE_VK_FUNC(vkCmdSetDepthClipEnableEXT) \
     USE_VK_FUNC(vkCmdSetDepthClipNegativeOneToOneEXT) \
     USE_VK_FUNC(vkCmdSetDepthCompareOp) \
@@ -975,7 +988,9 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkCreateGraphicsPipelines) \
     USE_VK_FUNC(vkCreateImage) \
     USE_VK_FUNC(vkCreateImageView) \
+    USE_VK_FUNC(vkCreateIndirectCommandsLayoutEXT) \
     USE_VK_FUNC(vkCreateIndirectCommandsLayoutNV) \
+    USE_VK_FUNC(vkCreateIndirectExecutionSetEXT) \
     USE_VK_FUNC(vkCreateMicromapEXT) \
     USE_VK_FUNC(vkCreateOpticalFlowSessionNV) \
     USE_VK_FUNC(vkCreatePipelineBinariesKHR) \
@@ -1022,7 +1037,9 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkDestroyFramebuffer) \
     USE_VK_FUNC(vkDestroyImage) \
     USE_VK_FUNC(vkDestroyImageView) \
+    USE_VK_FUNC(vkDestroyIndirectCommandsLayoutEXT) \
     USE_VK_FUNC(vkDestroyIndirectCommandsLayoutNV) \
+    USE_VK_FUNC(vkDestroyIndirectExecutionSetEXT) \
     USE_VK_FUNC(vkDestroyMicromapEXT) \
     USE_VK_FUNC(vkDestroyOpticalFlowSessionNV) \
     USE_VK_FUNC(vkDestroyPipeline) \
@@ -1100,6 +1117,7 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkGetEventStatus) \
     USE_VK_FUNC(vkGetFenceStatus) \
     USE_VK_FUNC(vkGetFramebufferTilePropertiesQCOM) \
+    USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsEXT) \
     USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsNV) \
     USE_VK_FUNC(vkGetImageMemoryRequirements) \
     USE_VK_FUNC(vkGetImageMemoryRequirements2) \
@@ -1197,6 +1215,8 @@ struct vulkan_instance_funcs
     USE_VK_FUNC(vkUpdateDescriptorSetWithTemplate) \
     USE_VK_FUNC(vkUpdateDescriptorSetWithTemplateKHR) \
     USE_VK_FUNC(vkUpdateDescriptorSets) \
+    USE_VK_FUNC(vkUpdateIndirectExecutionSetPipelineEXT) \
+    USE_VK_FUNC(vkUpdateIndirectExecutionSetShaderEXT) \
     USE_VK_FUNC(vkUpdateVideoSessionParametersKHR) \
     USE_VK_FUNC(vkWaitForFences) \
     USE_VK_FUNC(vkWaitForPresentKHR) \
diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json
index 67cee901fd9..2e77e6f042e 100644
--- a/dlls/winevulkan/winevulkan.json
+++ b/dlls/winevulkan/winevulkan.json
@@ -2,6 +2,6 @@
     "file_format_version": "1.0.0",
     "ICD": {
         "library_path": ".\winevulkan.dll",
-        "api_version": "1.3.295"
+        "api_version": "1.3.296"
     }
 }
diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h
index d07d780a7dc..8f1afc519ca 100644
--- a/include/wine/vulkan.h
+++ b/include/wine/vulkan.h
@@ -716,8 +716,12 @@
 #define VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME "VK_EXT_shader_replicated_composites"
 #define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1
 #define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation"
+#define VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1
+#define VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_EXT_device_generated_commands"
 #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1
 #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control"
+#define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1
+#define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control"
 #define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32
 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6
 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16
@@ -808,7 +812,7 @@
 #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)
 #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)
 #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)
-#define VK_HEADER_VERSION 295
+#define VK_HEADER_VERSION 296
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)
 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
 #define VK_USE_64_BIT_PTR_DEFINES 0
@@ -867,7 +871,9 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutEXT)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectExecutionSetEXT)
 VK_DEFINE_HANDLE(VkInstance)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV)
@@ -1002,6 +1008,8 @@ typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA;
 typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
 typedef VkFlags VkImageUsageFlags;
 typedef VkFlags VkImageViewCreateFlags;
+typedef VkFlags VkIndirectCommandsInputModeFlagsEXT;
+typedef VkFlags VkIndirectCommandsLayoutUsageFlagsEXT;
 typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV;
 typedef VkFlags VkIndirectStateFlagsNV;
 typedef VkFlags VkInstanceCreateFlags;
@@ -1601,6 +1609,8 @@ typedef enum VkAccessFlagBits
     VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,
     VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,
     VK_ACCESS_NONE_KHR = VK_ACCESS_NONE,
+    VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV,
+    VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV,
     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkAccessFlagBits;

@@ -1643,7 +1653,9 @@ static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ull;
+static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT = 0x00020000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ull;
+static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT = 0x00040000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ull;
 static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ull;
@@ -1905,6 +1917,7 @@ static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUF
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ull;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ull;
 static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ull;
+static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ull;

typedef enum VkBuildAccelerationStructureFlagBitsKHR
 {
@@ -2260,6 +2273,13 @@ typedef enum VkDepthBiasRepresentationEXT
     VK_DEPTH_BIAS_REPRESENTATION_EXT_MAX_ENUM = 0x7fffffff,
 } VkDepthBiasRepresentationEXT;

+typedef enum VkDepthClampModeEXT
+{
+    VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT = 0,
+    VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT = 1,
+    VK_DEPTH_CLAMP_MODE_EXT_MAX_ENUM = 0x7fffffff,
+} VkDepthClampModeEXT;
+
 typedef enum VkDescriptorBindingFlagBits
 {
     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001,
@@ -2514,6 +2534,7 @@ typedef enum VkDynamicState
     VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031,
     VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032,
     VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000,
+    VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000,
     VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR,
     VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,
     VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,
@@ -3388,6 +3409,20 @@ typedef enum VkIndexType
     VK_INDEX_TYPE_MAX_ENUM = 0x7fffffff,
 } VkIndexType;

+typedef enum VkIndirectCommandsInputModeFlagBitsEXT
+{
+    VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT = 0x00000001,
+    VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT = 0x00000002,
+    VK_INDIRECT_COMMANDS_INPUT_MODE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
+} VkIndirectCommandsInputModeFlagBitsEXT;
+
+typedef enum VkIndirectCommandsLayoutUsageFlagBitsEXT
+{
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT = 0x00000001,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT = 0x00000002,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
+} VkIndirectCommandsLayoutUsageFlagBitsEXT;
+
 typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV
 {
     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001,
@@ -3396,6 +3431,26 @@ typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV
     VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_NV_MAX_ENUM = 0x7fffffff,
 } VkIndirectCommandsLayoutUsageFlagBitsNV;

+typedef enum VkIndirectCommandsTokenTypeEXT
+{
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT = 0,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT = 1,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT = 2,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT = 3,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT = 4,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT = 5,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT = 6,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = 7,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = 8,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = 9,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = 1000202002,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = 1000202003,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = 1000328000,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT = 1000328001,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT = 1000386004,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXT_MAX_ENUM = 0x7fffffff,
+} VkIndirectCommandsTokenTypeEXT;
+
 typedef enum VkIndirectCommandsTokenTypeNV
 {
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0,
@@ -3412,6 +3467,13 @@ typedef enum VkIndirectCommandsTokenTypeNV
     VK_INDIRECT_COMMANDS_TOKEN_TYPE_NV_MAX_ENUM = 0x7fffffff,
 } VkIndirectCommandsTokenTypeNV;

+typedef enum VkIndirectExecutionSetInfoTypeEXT
+{
+    VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT = 0,
+    VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT = 1,
+    VK_INDIRECT_EXECUTION_SET_INFO_TYPE_EXT_MAX_ENUM = 0x7fffffff,
+} VkIndirectExecutionSetInfoTypeEXT;
+
 typedef enum VkIndirectStateFlagBitsNV
 {
     VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001,
@@ -3622,6 +3684,8 @@ typedef enum VkObjectType
     VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000,
     VK_OBJECT_TYPE_SHADER_EXT = 1000482000,
     VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000,
+    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000,
+    VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001,
     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
     VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
     VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT,
@@ -3928,6 +3992,7 @@ static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ull;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ull;
 static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ull;
+static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ull;

typedef enum VkPipelineCreationFeedbackFlagBits
 {
@@ -4027,6 +4092,7 @@ typedef enum VkPipelineStageFlagBits
     VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT,
     VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT,
     VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE,
+    VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV,
     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff,
 } VkPipelineStageFlagBits;

@@ -4071,6 +4137,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR =
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ull;
+static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT = 0x00020000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ull;
@@ -4538,6 +4605,7 @@ typedef enum VkShaderCreateFlagBitsEXT
     VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010,
     VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020,
     VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040,
+    VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080,
     VK_SHADER_CREATE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff,
 } VkShaderCreateFlagBitsEXT;

@@ -5452,9 +5520,25 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = 1000572000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = 1000572001,
+    VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = 1000572002,
+    VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT = 1000572003,
+    VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT = 1000572004,
+    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT = 1000572006,
+    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT = 1000572007,
+    VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT = 1000572008,
+    VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT = 1000572009,
+    VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT = 1000572010,
+    VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT = 1000572011,
+    VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012,
+    VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013,
+    VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001,
     VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
@@ -6948,6 +7032,13 @@ typedef struct VkBindImagePlaneMemoryInfo
 } VkBindImagePlaneMemoryInfo;
 typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;

+typedef struct VkBindIndexBufferIndirectCommandEXT
+{
+    VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress;
+    uint32_t size;
+    VkIndexType indexType;
+} VkBindIndexBufferIndirectCommandEXT;
+
 typedef struct VkBindIndexBufferIndirectCommandNV
 {
     VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress;
@@ -6972,6 +7063,13 @@ typedef struct VkBindShaderGroupIndirectCommandNV
     uint32_t groupIndex;
 } VkBindShaderGroupIndirectCommandNV;

+typedef struct VkBindVertexBufferIndirectCommandEXT
+{
+    VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress;
+    uint32_t size;
+    uint32_t stride;
+} VkBindVertexBufferIndirectCommandEXT;
+
 typedef struct VkBindVertexBufferIndirectCommandNV
 {
     VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress;
@@ -7559,6 +7657,12 @@ typedef struct VkDepthBiasRepresentationInfoEXT
     VkBool32 depthBiasExact;
 } VkDepthBiasRepresentationInfoEXT;

+typedef struct VkDepthClampRangeEXT
+{
+    float minDepthClamp;
+    float maxDepthClamp;
+} VkDepthClampRangeEXT;
+
 typedef struct VkDescriptorAddressInfoEXT
 {
     VkStructureType sType;
@@ -7925,6 +8029,13 @@ typedef struct VkDrawIndirectCommand
     uint32_t firstInstance;
 } VkDrawIndirectCommand;

+typedef struct VkDrawIndirectCountIndirectCommandEXT
+{
+    VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress;
+    uint32_t stride;
+    uint32_t commandCount;
+} VkDrawIndirectCountIndirectCommandEXT;
+
 typedef struct VkDrawMeshTasksIndirectCommandEXT
 {
     uint32_t groupCountX;
@@ -8157,6 +8268,32 @@ typedef struct VkFramebufferMixedSamplesCombinationNV
     VkSampleCountFlags colorSamples;
 } VkFramebufferMixedSamplesCombinationNV;

+typedef struct VkGeneratedCommandsInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkShaderStageFlags shaderStages;
+    VkIndirectExecutionSetEXT WINE_VK_ALIGN(8) indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT WINE_VK_ALIGN(8) indirectCommandsLayout;
+    VkDeviceAddress WINE_VK_ALIGN(8) indirectAddress;
+    VkDeviceSize WINE_VK_ALIGN(8) indirectAddressSize;
+    VkDeviceAddress WINE_VK_ALIGN(8) preprocessAddress;
+    VkDeviceSize WINE_VK_ALIGN(8) preprocessSize;
+    uint32_t maxSequenceCount;
+    VkDeviceAddress WINE_VK_ALIGN(8) sequenceCountAddress;
+    uint32_t maxDrawCount;
+} VkGeneratedCommandsInfoEXT;
+
+typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkIndirectExecutionSetEXT WINE_VK_ALIGN(8) indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT WINE_VK_ALIGN(8) indirectCommandsLayout;
+    uint32_t maxSequenceCount;
+    uint32_t maxDrawCount;
+} VkGeneratedCommandsMemoryRequirementsInfoEXT;
+
 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV
 {
     VkStructureType sType;
@@ -8167,6 +8304,21 @@ typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV
     uint32_t maxSequencesCount;
 } VkGeneratedCommandsMemoryRequirementsInfoNV;

+typedef struct VkGeneratedCommandsPipelineInfoEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkPipeline WINE_VK_ALIGN(8) pipeline;
+} VkGeneratedCommandsPipelineInfoEXT;
+
+typedef struct VkGeneratedCommandsShaderInfoEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t shaderCount;
+    const VkShaderEXT *pShaders;
+} VkGeneratedCommandsShaderInfoEXT;
+
 typedef struct VkGeometryAABBNV
 {
     VkStructureType sType;
@@ -8439,6 +8591,17 @@ typedef struct VkImportMemoryWin32HandleInfoKHR
     LPCWSTR name;
 } VkImportMemoryWin32HandleInfoKHR;

+typedef struct VkIndirectCommandsExecutionSetTokenEXT
+{
+    VkIndirectExecutionSetInfoTypeEXT type;
+    VkShaderStageFlags shaderStages;
+} VkIndirectCommandsExecutionSetTokenEXT;
+
+typedef struct VkIndirectCommandsIndexBufferTokenEXT
+{
+    VkIndirectCommandsInputModeFlagBitsEXT mode;
+} VkIndirectCommandsIndexBufferTokenEXT;
+
 typedef struct VkIndirectCommandsLayoutTokenNV
 {
     VkStructureType sType;
@@ -8464,6 +8627,27 @@ typedef struct VkIndirectCommandsStreamNV
     VkDeviceSize WINE_VK_ALIGN(8) offset;
 } VkIndirectCommandsStreamNV;

+typedef struct VkIndirectCommandsVertexBufferTokenEXT
+{
+    uint32_t vertexBindingUnit;
+} VkIndirectCommandsVertexBufferTokenEXT;
+
+typedef struct VkIndirectExecutionSetPipelineInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkPipeline WINE_VK_ALIGN(8) initialPipeline;
+    uint32_t maxPipelineCount;
+} VkIndirectExecutionSetPipelineInfoEXT;
+
+typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint32_t setLayoutCount;
+    const VkDescriptorSetLayout *pSetLayouts;
+} VkIndirectExecutionSetShaderLayoutInfoEXT;
+
 typedef struct VkInitializePerformanceApiInfoINTEL
 {
     VkStructureType sType;
@@ -9300,6 +9484,13 @@ typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT
     VkBool32 depthBiasExact;
 } VkPhysicalDeviceDepthBiasControlFeaturesEXT;

+typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 depthClampControl;
+} VkPhysicalDeviceDepthClampControlFeaturesEXT;
+
 typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT
 {
     VkStructureType sType;
@@ -9468,6 +9659,14 @@ typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV
     VkBool32 deviceGeneratedComputeCaptureReplay;
 } VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 deviceGeneratedCommands;
+    VkBool32 dynamicGeneratedPipelineLayout;
+} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT;
+
 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV
 {
     VkStructureType sType;
@@ -9475,6 +9674,24 @@ typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV
     VkBool32 deviceGeneratedCommands;
 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;

+typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT
+{
+    VkStructureType sType;
+    void *pNext;
+    uint32_t maxIndirectPipelineCount;
+    uint32_t maxIndirectShaderObjectCount;
+    uint32_t maxIndirectSequenceCount;
+    uint32_t maxIndirectCommandsTokenCount;
+    uint32_t maxIndirectCommandsTokenOffset;
+    uint32_t maxIndirectCommandsIndirectStride;
+    VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes;
+    VkShaderStageFlags supportedIndirectCommandsShaderStages;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding;
+    VkBool32 deviceGeneratedCommandsTransformFeedback;
+    VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount;
+} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT;
+
 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV
 {
     VkStructureType sType;
@@ -12339,6 +12556,14 @@ typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV
     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders;
 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;

+typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkDepthClampModeEXT depthClampMode;
+    const VkDepthClampRangeEXT *pDepthClampRange;
+} VkPipelineViewportDepthClampControlCreateInfoEXT;
+
 typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT
 {
     VkStructureType sType;
@@ -14031,6 +14256,22 @@ typedef struct VkWriteDescriptorSetInlineUniformBlock
 } VkWriteDescriptorSetInlineUniformBlock;
 typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT;

+typedef struct VkWriteIndirectExecutionSetPipelineEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint32_t index;
+    VkPipeline WINE_VK_ALIGN(8) pipeline;
+} VkWriteIndirectExecutionSetPipelineEXT;
+
+typedef struct VkWriteIndirectExecutionSetShaderEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint32_t index;
+    VkShaderEXT WINE_VK_ALIGN(8) shader;
+} VkWriteIndirectExecutionSetShaderEXT;
+
 typedef struct VkXYColorEXT
 {
     float x;
@@ -15007,6 +15248,31 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV
     const uint32_t *pStreamStrides;
 } VkIndirectCommandsLayoutCreateInfoNV;

+typedef struct VkIndirectCommandsPushConstantTokenEXT
+{
+    VkPushConstantRange updateRange;
+} VkIndirectCommandsPushConstantTokenEXT;
+
+typedef union VkIndirectCommandsTokenDataEXT
+{
+    const VkIndirectCommandsPushConstantTokenEXT *pPushConstant;
+    const VkIndirectCommandsVertexBufferTokenEXT *pVertexBuffer;
+    const VkIndirectCommandsIndexBufferTokenEXT *pIndexBuffer;
+    const VkIndirectCommandsExecutionSetTokenEXT *pExecutionSet;
+} VkIndirectCommandsTokenDataEXT;
+
+typedef struct VkIndirectExecutionSetShaderInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    uint32_t shaderCount;
+    const VkShaderEXT *pInitialShaders;
+    const VkIndirectExecutionSetShaderLayoutInfoEXT *pSetLayoutInfos;
+    uint32_t maxShaderCount;
+    uint32_t pushConstantRangeCount;
+    const VkPushConstantRange *pPushConstantRanges;
+} VkIndirectExecutionSetShaderInfoEXT;
+
 typedef struct VkMemoryToImageCopyEXT
 {
     VkStructureType sType;
@@ -15767,6 +16033,21 @@ typedef struct VkDependencyInfo
 } VkDependencyInfo;
 typedef VkDependencyInfo VkDependencyInfoKHR;

+typedef struct VkIndirectCommandsLayoutTokenEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkIndirectCommandsTokenTypeEXT type;
+    VkIndirectCommandsTokenDataEXT data;
+    uint32_t offset;
+} VkIndirectCommandsLayoutTokenEXT;
+
+typedef union VkIndirectExecutionSetInfoEXT
+{
+    const VkIndirectExecutionSetPipelineInfoEXT *pPipelineInfo;
+    const VkIndirectExecutionSetShaderInfoEXT *pShaderInfo;
+} VkIndirectExecutionSetInfoEXT;
+
 typedef struct VkPipelineShaderStageCreateInfo
 {
     VkStructureType sType;
@@ -16020,6 +16301,26 @@ typedef struct VkGraphicsShaderGroupCreateInfoNV
     const VkPipelineTessellationStateCreateInfo *pTessellationState;
 } VkGraphicsShaderGroupCreateInfoNV;

+typedef struct VkIndirectCommandsLayoutCreateInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkIndirectCommandsLayoutUsageFlagsEXT flags;
+    VkShaderStageFlags shaderStages;
+    uint32_t indirectStride;
+    VkPipelineLayout WINE_VK_ALIGN(8) pipelineLayout;
+    uint32_t tokenCount;
+    const VkIndirectCommandsLayoutTokenEXT *pTokens;
+} VkIndirectCommandsLayoutCreateInfoEXT;
+
+typedef struct VkIndirectExecutionSetCreateInfoEXT
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkIndirectExecutionSetInfoTypeEXT type;
+    VkIndirectExecutionSetInfoEXT info;
+} VkIndirectExecutionSetCreateInfoEXT;
+
 typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV
 {
     VkStructureType sType;
@@ -16156,6 +16457,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer);
 typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *);
 typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer, const VkVideoEndCodingInfoKHR *);
 typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer, uint32_t, const VkCommandBuffer *);
+typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsEXT)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoNV *);
 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer, const VkDebugUtilsLabelEXT *);
@@ -16166,6 +16468,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer, VkOptic
 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer, VkPipelineStageFlags, VkPipelineStageFlags, VkDependencyFlags, uint32_t, const VkMemoryBarrier *, uint32_t, const VkBufferMemoryBarrier *, uint32_t, const VkImageMemoryBarrier *);
 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer, const VkDependencyInfo *);
 typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer, const VkDependencyInfo *);
+typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsEXT)(VkCommandBuffer, const VkGeneratedCommandsInfoEXT *, VkCommandBuffer);
 typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer, const VkGeneratedCommandsInfoNV *);
 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, uint32_t, const void *);
 typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2KHR)(VkCommandBuffer, const VkPushConstantsInfoKHR *);
@@ -16208,6 +16511,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer, float, float)
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer, VkBool32);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer, VkDepthClampModeEXT, const VkDepthClampRangeEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer, VkBool32);
 typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer, VkCompareOp);
@@ -16333,7 +16637,9 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice, const VkFramebuf
 typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice, VkPipelineCache, uint32_t, const VkGraphicsPipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice, const VkImageCreateInfo *, const VkAllocationCallbacks *, VkImage *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice, const VkImageViewCreateInfo *, const VkAllocationCallbacks *, VkImageView *);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutEXT)(VkDevice, const VkIndirectCommandsLayoutCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice, const VkIndirectCommandsLayoutCreateInfoNV *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutNV *);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectExecutionSetEXT)(VkDevice, const VkIndirectExecutionSetCreateInfoEXT *, const VkAllocationCallbacks *, VkIndirectExecutionSetEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo *, const VkAllocationCallbacks *, VkInstance *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice, const VkMicromapCreateInfoEXT *, const VkAllocationCallbacks *, VkMicromapEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice, const VkOpticalFlowSessionCreateInfoNV *, const VkAllocationCallbacks *, VkOpticalFlowSessionNV *);
@@ -16385,7 +16691,9 @@ typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice, VkFence, const VkAllocati
 typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice, VkFramebuffer, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice, VkImage, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice, VkImageView, const VkAllocationCallbacks *);
+typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutEXT)(VkDevice, VkIndirectCommandsLayoutEXT, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice, VkIndirectCommandsLayoutNV, const VkAllocationCallbacks *);
+typedef void (VKAPI_PTR *PFN_vkDestroyIndirectExecutionSetEXT)(VkDevice, VkIndirectExecutionSetEXT, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice, VkMicromapEXT, const VkAllocationCallbacks *);
 typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice, VkOpticalFlowSessionNV, const VkAllocationCallbacks *);
@@ -16475,6 +16783,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice
 typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice, VkEvent);
 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice, VkFence);
 typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice, VkFramebuffer, uint32_t *, VkTilePropertiesQCOM *);
+typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoEXT *, VkMemoryRequirements2 *);
 typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoNV *, VkMemoryRequirements2 *);
 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *);
 typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *);
@@ -16625,6 +16934,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice, const VkMemoryUnma
 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *);
 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice, VkDescriptorSet, VkDescriptorUpdateTemplate, const void *);
 typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice, uint32_t, const VkWriteDescriptorSet *, uint32_t, const VkCopyDescriptorSet *);
+typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetPipelineEXT *);
+typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetShaderEXT *);
 typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice, VkVideoSessionParametersKHR, const VkVideoSessionParametersUpdateInfoKHR *);
 typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice, uint32_t, const VkFence *, VkBool32, uint64_t);
 typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice, VkSwapchainKHR, uint64_t, uint64_t);
@@ -16760,6 +17071,7 @@ void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer);
 void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets);
 void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo);
 void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
+void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo);
 void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo);
 void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
 void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo);
@@ -16770,6 +17082,7 @@ void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOptic
 void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers);
 void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo);
 void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo);
+void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT *pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer);
 void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo);
 void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues);
 void VKAPI_CALL vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR *pPushConstantsInfo);
@@ -16812,6 +17125,7 @@ void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDept
 void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
 void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);
 void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable);
+void VKAPI_CALL vkCmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT *pDepthClampRange);
 void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable);
 void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne);
 void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);
@@ -16937,7 +17251,9 @@ VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCrea
 VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines);
 VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage);
 VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView);
+VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutEXT *pIndirectCommandsLayout);
 VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout);
+VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectExecutionSetEXT *pIndirectExecutionSet);
 VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance);
 VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap);
 VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession);
@@ -16989,7 +17305,9 @@ void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocatio
 void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator);
+void VKAPI_CALL vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator);
 void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator);
@@ -17079,6 +17397,7 @@ VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const
 VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event);
 VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence);
 VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties);
+void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements);
 void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements);
 void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements);
 void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements);
@@ -17229,6 +17548,8 @@ VkResult VKAPI_CALL vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKH
 void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData);
 void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData);
 void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies);
+void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites);
+void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites);
 VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo);
 VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout);
 VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout);