[PATCH v2 0/1] MR9151: winevulkan: Update to VK spec version 1.4.329

[Georg Lehmann (＠DadSchoorse)]

--
  v2: winevulkan: Update to VK spec version 1.4.329.

https://gitlab.winehq.org/wine/wine/-/merge_requests/9151

[PATCH v2 1/1] winevulkan: Update to VK spec version 1.4.329.

[Georg Lehmann]

From: Georg Lehmann

---
 dlls/winevulkan/loader_thunks.c |  18 ++
 dlls/winevulkan/loader_thunks.h |  14 ++
 dlls/winevulkan/make_vulkan     |   2 +-
 dlls/winevulkan/vulkan_thunks.c | 386 +++++++++++++++++++++++++++++++-
 dlls/winevulkan/winevulkan.json |   2 +-
 include/wine/vulkan.h           | 162 +++++++++++++-
 6 files changed, 563 insertions(+), 21 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
index 17783925979..12ed1a87846 100644
--- a/dlls/winevulkan/loader_thunks.c
+++ b/dlls/winevulkan/loader_thunks.c
@@ -861,6 +861,14 @@ void WINAPI vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCo
     UNIX_CALL(vkCmdCopyImageToBuffer2KHR, &params);
 }

+void WINAPI vkCmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR *pCopyMemoryIndirectInfo)
+{
+    struct vkCmdCopyMemoryIndirectKHR_params params;
+    params.commandBuffer = commandBuffer;
+    params.pCopyMemoryIndirectInfo = pCopyMemoryIndirectInfo;
+    UNIX_CALL(vkCmdCopyMemoryIndirectKHR, &params);
+}
+
 void WINAPI vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
 {
     struct vkCmdCopyMemoryIndirectNV_params params;
@@ -879,6 +887,14 @@ void WINAPI vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuf
     UNIX_CALL(vkCmdCopyMemoryToAccelerationStructureKHR, &params);
 }

+void WINAPI vkCmdCopyMemoryToImageIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR *pCopyMemoryToImageIndirectInfo)
+{
+    struct vkCmdCopyMemoryToImageIndirectKHR_params params;
+    params.commandBuffer = commandBuffer;
+    params.pCopyMemoryToImageIndirectInfo = pCopyMemoryToImageIndirectInfo;
+    UNIX_CALL(vkCmdCopyMemoryToImageIndirectKHR, &params);
+}
+
 void WINAPI vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
 {
     struct vkCmdCopyMemoryToImageIndirectNV_params params;
@@ -7211,8 +7227,10 @@ static const struct vulkan_func vk_device_dispatch_table[] =
     {"vkCmdCopyImageToBuffer", vkCmdCopyImageToBuffer},
     {"vkCmdCopyImageToBuffer2", vkCmdCopyImageToBuffer2},
     {"vkCmdCopyImageToBuffer2KHR", vkCmdCopyImageToBuffer2KHR},
+    {"vkCmdCopyMemoryIndirectKHR", vkCmdCopyMemoryIndirectKHR},
     {"vkCmdCopyMemoryIndirectNV", vkCmdCopyMemoryIndirectNV},
     {"vkCmdCopyMemoryToAccelerationStructureKHR", vkCmdCopyMemoryToAccelerationStructureKHR},
+    {"vkCmdCopyMemoryToImageIndirectKHR", vkCmdCopyMemoryToImageIndirectKHR},
     {"vkCmdCopyMemoryToImageIndirectNV", vkCmdCopyMemoryToImageIndirectNV},
     {"vkCmdCopyMemoryToMicromapEXT", vkCmdCopyMemoryToMicromapEXT},
     {"vkCmdCopyMicromapEXT", vkCmdCopyMicromapEXT},
diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h
index db5b588afba..a928a1bf07d 100644
--- a/dlls/winevulkan/loader_thunks.h
+++ b/dlls/winevulkan/loader_thunks.h
@@ -105,8 +105,10 @@ enum unix_call
     unix_vkCmdCopyImageToBuffer,
     unix_vkCmdCopyImageToBuffer2,
     unix_vkCmdCopyImageToBuffer2KHR,
+    unix_vkCmdCopyMemoryIndirectKHR,
     unix_vkCmdCopyMemoryIndirectNV,
     unix_vkCmdCopyMemoryToAccelerationStructureKHR,
+    unix_vkCmdCopyMemoryToImageIndirectKHR,
     unix_vkCmdCopyMemoryToImageIndirectNV,
     unix_vkCmdCopyMemoryToMicromapEXT,
     unix_vkCmdCopyMicromapEXT,
@@ -1336,6 +1338,12 @@ struct vkCmdCopyImageToBuffer2KHR_params
     const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo;
 };

+struct vkCmdCopyMemoryIndirectKHR_params
+{
+    VkCommandBuffer commandBuffer;
+    const VkCopyMemoryIndirectInfoKHR *pCopyMemoryIndirectInfo;
+};
+
 struct vkCmdCopyMemoryIndirectNV_params
 {
     VkCommandBuffer commandBuffer;
@@ -1350,6 +1358,12 @@ struct vkCmdCopyMemoryToAccelerationStructureKHR_params
     const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo;
 };

+struct vkCmdCopyMemoryToImageIndirectKHR_params
+{
+    VkCommandBuffer commandBuffer;
+    const VkCopyMemoryToImageIndirectInfoKHR *pCopyMemoryToImageIndirectInfo;
+};
+
 struct vkCmdCopyMemoryToImageIndirectNV_params
 {
     VkCommandBuffer commandBuffer;
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 2ccbc3a4b17..22cca40f15b 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.4.325"
+VK_XML_VERSION = "1.4.329"
 WINE_VK_VERSION = (1, 4)

# Filenames to create.
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index de26841399d..f2ceb7b7fed 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -1433,6 +1433,13 @@ typedef struct VkSparseImageOpaqueMemoryBindInfo32
     PTR32 pBinds;
 } VkSparseImageOpaqueMemoryBindInfo32;

+typedef struct VkStridedDeviceAddressRangeKHR32
+{
+    VkDeviceAddress DECLSPEC_ALIGN(8) address;
+    VkDeviceSize DECLSPEC_ALIGN(8) size;
+    VkDeviceSize DECLSPEC_ALIGN(8) stride;
+} VkStridedDeviceAddressRangeKHR32;
+
 typedef struct VkStridedDeviceAddressRegionKHR32
 {
     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
@@ -2385,6 +2392,16 @@ typedef struct VkCopyImageToMemoryInfo32
 } VkCopyImageToMemoryInfo32;
 typedef VkCopyImageToMemoryInfo32 VkCopyImageToMemoryInfoEXT32;

+typedef struct VkCopyMemoryIndirectInfoKHR32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkAddressCopyFlagsKHR srcCopyFlags;
+    VkAddressCopyFlagsKHR dstCopyFlags;
+    uint32_t copyCount;
+    VkStridedDeviceAddressRangeKHR32 DECLSPEC_ALIGN(8) copyAddressRange;
+} VkCopyMemoryIndirectInfoKHR32;
+
 typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 {
     VkStructureType sType;
@@ -2394,6 +2411,18 @@ typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
     VkCopyAccelerationStructureModeKHR mode;
 } VkCopyMemoryToAccelerationStructureInfoKHR32;

+typedef struct VkCopyMemoryToImageIndirectInfoKHR32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkAddressCopyFlagsKHR srcCopyFlags;
+    uint32_t copyCount;
+    VkStridedDeviceAddressRangeKHR32 DECLSPEC_ALIGN(8) copyAddressRange;
+    VkImage DECLSPEC_ALIGN(8) dstImage;
+    VkImageLayout dstImageLayout;
+    PTR32 pImageSubresources;
+} VkCopyMemoryToImageIndirectInfoKHR32;
+
 typedef struct VkCopyMemoryToImageInfo32
 {
     VkStructureType sType;
@@ -4455,6 +4484,14 @@ typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV32
     uint32_t maxCooperativeVectorComponents;
 } VkPhysicalDeviceCooperativeVectorPropertiesNV32;

+typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 indirectMemoryCopy;
+    VkBool32 indirectMemoryToImageCopy;
+} VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR32;
+
 typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
 {
     VkStructureType sType;
@@ -4462,12 +4499,13 @@ typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
     VkBool32 indirectCopy;
 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;

-typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
+typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR32
 {
     VkStructureType sType;
     PTR32 pNext;
     VkQueueFlags supportedQueues;
-} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;
+} VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR32;
+typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR32 VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;

typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
 {
@@ -6455,6 +6493,15 @@ typedef struct VkPhysicalDeviceShaderFloatControls2Features32
 } VkPhysicalDeviceShaderFloatControls2Features32;
 typedef VkPhysicalDeviceShaderFloatControls2Features32 VkPhysicalDeviceShaderFloatControls2FeaturesKHR32;

+typedef struct VkPhysicalDeviceShaderFmaFeaturesKHR32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 shaderFmaFloat16;
+    VkBool32 shaderFmaFloat32;
+    VkBool32 shaderFmaFloat64;
+} VkPhysicalDeviceShaderFmaFeaturesKHR32;
+
 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
 {
     VkStructureType sType;
@@ -7018,6 +7065,13 @@ typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32
     VkBool32 videoEncodeQuantizationMap;
 } VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32;

+typedef struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 videoEncodeRgbConversion;
+} VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE32;
+
 typedef struct VkPhysicalDeviceVideoFormatInfoKHR32
 {
     VkStructureType sType;
@@ -9333,6 +9387,13 @@ typedef struct VkVideoEncodeIntraRefreshInfoKHR32
     uint32_t intraRefreshIndex;
 } VkVideoEncodeIntraRefreshInfoKHR32;

+typedef struct VkVideoEncodeProfileRgbConversionInfoVALVE32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkBool32 performEncodeRgbConversion;
+} VkVideoEncodeProfileRgbConversionInfoVALVE32;
+
 typedef struct VkVideoEncodeQualityLevelInfoKHR32
 {
     VkStructureType sType;
@@ -9382,6 +9443,16 @@ typedef struct VkVideoEncodeRateControlInfoKHR32
     uint32_t initialVirtualBufferSizeInMs;
 } VkVideoEncodeRateControlInfoKHR32;

+typedef struct VkVideoEncodeRgbConversionCapabilitiesVALVE32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels;
+    VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges;
+    VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets;
+    VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets;
+} VkVideoEncodeRgbConversionCapabilitiesVALVE32;
+
 typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR32
 {
     VkStructureType sType;
@@ -9403,6 +9474,16 @@ typedef struct VkVideoEncodeSessionParametersGetInfoKHR32
     VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters;
 } VkVideoEncodeSessionParametersGetInfoKHR32;

+typedef struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE32
+{
+    VkStructureType sType;
+    PTR32 pNext;
+    VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel;
+    VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange;
+    VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset;
+    VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset;
+} VkVideoEncodeSessionRgbConversionCreateInfoVALVE32;
+
 typedef struct VkVideoEncodeUsageInfoKHR32
 {
     VkStructureType sType;
@@ -12929,6 +13010,29 @@ static void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_con
         FIXME("Unexpected pNext\n");
 }

+static void convert_VkStridedDeviceAddressRangeKHR_win32_to_host(const VkStridedDeviceAddressRangeKHR32 *in, VkStridedDeviceAddressRangeKHR *out)
+{
+    if (!in) return;
+
+    out->address = in->address;
+    out->size = in->size;
+    out->stride = in->stride;
+}
+
+static void convert_VkCopyMemoryIndirectInfoKHR_win32_to_host(const VkCopyMemoryIndirectInfoKHR32 *in, VkCopyMemoryIndirectInfoKHR *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->srcCopyFlags = in->srcCopyFlags;
+    out->dstCopyFlags = in->dstCopyFlags;
+    out->copyCount = in->copyCount;
+    convert_VkStridedDeviceAddressRangeKHR_win32_to_host(&in->copyAddressRange, &out->copyAddressRange);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
 static void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out)
 {
     if (!in) return;
@@ -12942,6 +13046,22 @@ static void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(con
         FIXME("Unexpected pNext\n");
 }

+static void convert_VkCopyMemoryToImageIndirectInfoKHR_win32_to_host(const VkCopyMemoryToImageIndirectInfoKHR32 *in, VkCopyMemoryToImageIndirectInfoKHR *out)
+{
+    if (!in) return;
+
+    out->sType = in->sType;
+    out->pNext = NULL;
+    out->srcCopyFlags = in->srcCopyFlags;
+    out->copyCount = in->copyCount;
+    convert_VkStridedDeviceAddressRangeKHR_win32_to_host(&in->copyAddressRange, &out->copyAddressRange);
+    out->dstImage = in->dstImage;
+    out->dstImageLayout = in->dstImageLayout;
+    out->pImageSubresources = UlongToPtr(in->pImageSubresources);
+    if (in->pNext)
+        FIXME("Unexpected pNext\n");
+}
+
 static void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out)
 {
     if (!in) return;
@@ -15222,6 +15342,17 @@ static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_contex
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE:
+        {
+            VkVideoEncodeProfileRgbConversionInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeProfileRgbConversionInfoVALVE32 *in_ext = (const VkVideoEncodeProfileRgbConversionInfoVALVE32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE;
+            out_ext->pNext = NULL;
+            out_ext->performEncodeRgbConversion = in_ext->performEncodeRgbConversion;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
         {
             VkVideoEncodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -16182,6 +16313,19 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
+        {
+            VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+            out_ext->pNext = NULL;
+            out_ext->flags = in_ext->flags;
+            out_ext->codeSize = in_ext->codeSize;
+            out_ext->pCode = UlongToPtr(in_ext->pCode);
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -16899,6 +17043,18 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
+        {
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR;
+            out_ext->pNext = NULL;
+            out_ext->indirectMemoryCopy = in_ext->indirectMemoryCopy;
+            out_ext->indirectMemoryToImageCopy = in_ext->indirectMemoryToImageCopy;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -18587,6 +18743,19 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
+        {
+            VkPhysicalDeviceShaderFmaFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFmaFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderFmaFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR;
+            out_ext->pNext = NULL;
+            out_ext->shaderFmaFloat16 = in_ext->shaderFmaFloat16;
+            out_ext->shaderFmaFloat32 = in_ext->shaderFmaFloat32;
+            out_ext->shaderFmaFloat64 = in_ext->shaderFmaFloat64;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -19066,6 +19235,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+        {
+            VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *in_ext = (const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE;
+            out_ext->pNext = NULL;
+            out_ext->videoEncodeRgbConversion = in_ext->videoEncodeRgbConversion;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
             VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -19790,6 +19970,18 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
+        {
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR;
+            out_ext->pNext = NULL;
+            out_ext->indirectMemoryCopy = in_ext->indirectMemoryCopy;
+            out_ext->indirectMemoryToImageCopy = in_ext->indirectMemoryToImageCopy;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -21478,6 +21670,19 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
+        {
+            VkPhysicalDeviceShaderFmaFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFmaFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderFmaFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR;
+            out_ext->pNext = NULL;
+            out_ext->shaderFmaFloat16 = in_ext->shaderFmaFloat16;
+            out_ext->shaderFmaFloat32 = in_ext->shaderFmaFloat32;
+            out_ext->shaderFmaFloat64 = in_ext->shaderFmaFloat64;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -21957,6 +22162,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+        {
+            VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE;
+            out_ext->pNext = NULL;
+            out_ext->videoEncodeRgbConversion = in_ext->videoEncodeRgbConversion;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
             VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -26640,6 +26856,20 @@ static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE:
+        {
+            VkVideoEncodeSessionRgbConversionCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkVideoEncodeSessionRgbConversionCreateInfoVALVE32 *in_ext = (const VkVideoEncodeSessionRgbConversionCreateInfoVALVE32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE;
+            out_ext->pNext = NULL;
+            out_ext->rgbModel = in_ext->rgbModel;
+            out_ext->rgbRange = in_ext->rgbRange;
+            out_ext->xChromaOffset = in_ext->xChromaOffset;
+            out_ext->yChromaOffset = in_ext->yChromaOffset;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -29563,6 +29793,18 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
+        {
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR;
+            out_ext->pNext = NULL;
+            out_ext->indirectMemoryCopy = in_ext->indirectMemoryCopy;
+            out_ext->indirectMemoryToImageCopy = in_ext->indirectMemoryToImageCopy;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -31240,6 +31482,19 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
+        {
+            VkPhysicalDeviceShaderFmaFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceShaderFmaFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderFmaFeaturesKHR32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR;
+            out_ext->pNext = NULL;
+            out_ext->shaderFmaFloat16 = in_ext->shaderFmaFloat16;
+            out_ext->shaderFmaFloat32 = in_ext->shaderFmaFloat32;
+            out_ext->shaderFmaFloat64 = in_ext->shaderFmaFloat64;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -31719,6 +31974,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+        {
+            VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE32 *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE;
+            out_ext->pNext = NULL;
+            out_ext->videoEncodeRgbConversion = in_ext->videoEncodeRgbConversion;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
             VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
@@ -32210,6 +32476,16 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR:
+        {
+            VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR);
+            const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR;
+            out_ext->indirectMemoryCopy = in_ext->indirectMemoryCopy;
+            out_ext->indirectMemoryToImageCopy = in_ext->indirectMemoryToImageCopy;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
         {
             VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV);
@@ -33609,6 +33885,17 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR:
+        {
+            VkPhysicalDeviceShaderFmaFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR);
+            const VkPhysicalDeviceShaderFmaFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderFmaFeaturesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR;
+            out_ext->shaderFmaFloat16 = in_ext->shaderFmaFloat16;
+            out_ext->shaderFmaFloat32 = in_ext->shaderFmaFloat32;
+            out_ext->shaderFmaFloat64 = in_ext->shaderFmaFloat64;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
         {
             VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT);
@@ -34006,6 +34293,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE:
+        {
+            VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE);
+            const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *in_ext = (const VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE;
+            out_ext->videoEncodeRgbConversion = in_ext->videoEncodeRgbConversion;
+            out_header = (void *)out_ext;
+            break;
+        }
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
         {
             VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR);
@@ -35130,10 +35426,10 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
+            VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
             out_ext->pNext = NULL;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -36072,11 +36368,11 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe
             out_header = (void *)out_ext;
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR:
         {
-            VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV);
-            const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header;
-            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
+            VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR);
+            const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
             out_ext->supportedQueues = in_ext->supportedQueues;
             out_header = (void *)out_ext;
             break;
@@ -38151,6 +38447,15 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
+        {
+            VkVideoEncodeRgbConversionCapabilitiesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+            out_ext->pNext = NULL;
+            out_header->pNext = (void *)out_ext;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             FIXME("Unhandled sType %u.\n", in_header->sType);
             break;
@@ -38336,6 +38641,18 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti
             out_header = (void *)out_ext;
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE:
+        {
+            VkVideoEncodeRgbConversionCapabilitiesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE);
+            const VkVideoEncodeRgbConversionCapabilitiesVALVE *in_ext = (const VkVideoEncodeRgbConversionCapabilitiesVALVE *)in_header;
+            out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE;
+            out_ext->rgbModels = in_ext->rgbModels;
+            out_ext->rgbRanges = in_ext->rgbRanges;
+            out_ext->xChromaOffsets = in_ext->xChromaOffsets;
+            out_ext->yChromaOffsets = in_ext->yChromaOffsets;
+            out_header = (void *)out_ext;
+            break;
+        }
         default:
             break;
         }
@@ -43797,6 +44114,28 @@ static void thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
     free_conversion_context(ctx);
 }

+#ifdef _WIN64
+static void thunk64_vkCmdCopyMemoryIndirectKHR(void *args)
+{
+    struct vkCmdCopyMemoryIndirectKHR_params *params = args;
+
+    vulkan_command_buffer_from_handle(params->commandBuffer)->device->p_vkCmdCopyMemoryIndirectKHR(vulkan_command_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->pCopyMemoryIndirectInfo);
+}
+#endif /* _WIN64 */
+
+static void thunk32_vkCmdCopyMemoryIndirectKHR(void *args)
+{
+    struct
+    {
+        PTR32 commandBuffer;
+        PTR32 pCopyMemoryIndirectInfo;
+    } *params = args;
+    VkCopyMemoryIndirectInfoKHR pCopyMemoryIndirectInfo_host;
+
+    convert_VkCopyMemoryIndirectInfoKHR_win32_to_host((const VkCopyMemoryIndirectInfoKHR32 *)UlongToPtr(params->pCopyMemoryIndirectInfo), &pCopyMemoryIndirectInfo_host);
+    vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdCopyMemoryIndirectKHR(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, &pCopyMemoryIndirectInfo_host);
+}
+
 #ifdef _WIN64
 static void thunk64_vkCmdCopyMemoryIndirectNV(void *args)
 {
@@ -43841,6 +44180,28 @@ static void thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
     vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdCopyMemoryToAccelerationStructureKHR(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, &pInfo_host);
 }

+#ifdef _WIN64
+static void thunk64_vkCmdCopyMemoryToImageIndirectKHR(void *args)
+{
+    struct vkCmdCopyMemoryToImageIndirectKHR_params *params = args;
+
+    vulkan_command_buffer_from_handle(params->commandBuffer)->device->p_vkCmdCopyMemoryToImageIndirectKHR(vulkan_command_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->pCopyMemoryToImageIndirectInfo);
+}
+#endif /* _WIN64 */
+
+static void thunk32_vkCmdCopyMemoryToImageIndirectKHR(void *args)
+{
+    struct
+    {
+        PTR32 commandBuffer;
+        PTR32 pCopyMemoryToImageIndirectInfo;
+    } *params = args;
+    VkCopyMemoryToImageIndirectInfoKHR pCopyMemoryToImageIndirectInfo_host;
+
+    convert_VkCopyMemoryToImageIndirectInfoKHR_win32_to_host((const VkCopyMemoryToImageIndirectInfoKHR32 *)UlongToPtr(params->pCopyMemoryToImageIndirectInfo), &pCopyMemoryToImageIndirectInfo_host);
+    vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdCopyMemoryToImageIndirectKHR(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, &pCopyMemoryToImageIndirectInfo_host);
+}
+
 #ifdef _WIN64
 static void thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
 {
@@ -60797,6 +61158,7 @@ static const char * const vk_device_extensions[] =
     "VK_KHR_compute_shader_derivatives",
     "VK_KHR_cooperative_matrix",
     "VK_KHR_copy_commands2",
+    "VK_KHR_copy_memory_indirect",
     "VK_KHR_create_renderpass2",
     "VK_KHR_dedicated_allocation",
     "VK_KHR_deferred_host_operations",
@@ -60862,6 +61224,7 @@ static const char * const vk_device_extensions[] =
     "VK_KHR_shader_float16_int8",
     "VK_KHR_shader_float_controls",
     "VK_KHR_shader_float_controls2",
+    "VK_KHR_shader_fma",
     "VK_KHR_shader_integer_dot_product",
     "VK_KHR_shader_maximal_reconvergence",
     "VK_KHR_shader_non_semantic_info",
@@ -60972,6 +61335,7 @@ static const char * const vk_device_extensions[] =
     "VK_VALVE_descriptor_set_host_mapping",
     "VK_VALVE_fragment_density_map_layered",
     "VK_VALVE_mutable_descriptor_type",
+    "VK_VALVE_video_encode_rgb_conversion",
 };

static const char * const vk_instance_extensions[] =
@@ -61154,8 +61518,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk64_vkCmdCopyImageToBuffer,
     (void *)thunk64_vkCmdCopyImageToBuffer2,
     (void *)thunk64_vkCmdCopyImageToBuffer2KHR,
+    (void *)thunk64_vkCmdCopyMemoryIndirectKHR,
     (void *)thunk64_vkCmdCopyMemoryIndirectNV,
     (void *)thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
+    (void *)thunk64_vkCmdCopyMemoryToImageIndirectKHR,
     (void *)thunk64_vkCmdCopyMemoryToImageIndirectNV,
     (void *)thunk64_vkCmdCopyMemoryToMicromapEXT,
     (void *)thunk64_vkCmdCopyMicromapEXT,
@@ -61832,8 +62198,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     (void *)thunk32_vkCmdCopyImageToBuffer,
     (void *)thunk32_vkCmdCopyImageToBuffer2,
     (void *)thunk32_vkCmdCopyImageToBuffer2KHR,
+    (void *)thunk32_vkCmdCopyMemoryIndirectKHR,
     (void *)thunk32_vkCmdCopyMemoryIndirectNV,
     (void *)thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
+    (void *)thunk32_vkCmdCopyMemoryToImageIndirectKHR,
     (void *)thunk32_vkCmdCopyMemoryToImageIndirectNV,
     (void *)thunk32_vkCmdCopyMemoryToMicromapEXT,
     (void *)thunk32_vkCmdCopyMicromapEXT,
diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json
index 8a7269fa919..3d062341125 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.4.325"
+        "api_version": "1.4.329"
     }
 }
diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h
index e4a71a38bb8..a6138d23213 100644
--- a/include/wine/vulkan.h
+++ b/include/wine/vulkan.h
@@ -514,7 +514,7 @@ typedef struct _XDisplay Display;
 #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config"
 #define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2
 #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops"
-#define VK_QCOM_TILE_SHADING_SPEC_VERSION 1
+#define VK_QCOM_TILE_SHADING_SPEC_VERSION 2
 #define VK_QCOM_TILE_SHADING_EXTENSION_NAME "VK_QCOM_tile_shading"
 #define VK_NV_LOW_LATENCY_SPEC_VERSION 1
 #define VK_NV_LOW_LATENCY_EXTENSION_NAME "VK_NV_low_latency"
@@ -597,6 +597,8 @@ typedef struct _XDisplay Display;
 #define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE
 #define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1
 #define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query"
+#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION 1
+#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME "VK_VALVE_video_encode_rgb_conversion"
 #define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1
 #define VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME "VK_EXT_image_view_min_lod"
 #define VK_EXT_MULTI_DRAW_SPEC_VERSION 1
@@ -767,6 +769,8 @@ typedef struct _XDisplay Display;
 #define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation"
 #define VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION 1
 #define VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME "VK_QCOM_tile_memory_heap"
+#define VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION 1
+#define VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_KHR_copy_memory_indirect"
 #define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION 1
 #define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME "VK_KHR_video_encode_intra_refresh"
 #define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION 2
@@ -795,6 +799,8 @@ typedef struct _XDisplay Display;
 #define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8"
 #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1
 #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control"
+#define VK_KHR_SHADER_FMA_SPEC_VERSION 1
+#define VK_KHR_SHADER_FMA_EXTENSION_NAME "VK_KHR_shader_fma"
 #define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1
 #define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control"
 #define VK_KHR_MAINTENANCE_9_SPEC_VERSION 1
@@ -929,7 +935,7 @@ typedef struct _XDisplay Display;
 #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)
 #define VK_API_VERSION_1_4 VK_MAKE_API_VERSION(0, 1, 4, 0)
 #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)
-#define VK_HEADER_VERSION 325
+#define VK_HEADER_VERSION 329
 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
 #define VK_USE_64_BIT_PTR_DEFINES 0
@@ -1073,6 +1079,7 @@ typedef VkFlags64 VkAccessFlags2;
 typedef VkAccessFlags2 VkAccessFlags2KHR;
 typedef VkFlags64 VkAccessFlags3KHR;
 typedef VkFlags VkAcquireProfilingLockFlagsKHR;
+typedef VkFlags VkAddressCopyFlagsKHR;
 typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
 typedef VkFlags VkAttachmentDescriptionFlags;
 typedef VkFlags VkBufferCreateFlags;
@@ -1300,6 +1307,9 @@ typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR;
 typedef VkFlags VkVideoEncodeIntraRefreshModeFlagsKHR;
 typedef VkFlags VkVideoEncodeRateControlFlagsKHR;
 typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR;
+typedef VkFlags VkVideoEncodeRgbChromaOffsetFlagsVALVE;
+typedef VkFlags VkVideoEncodeRgbModelConversionFlagsVALVE;
+typedef VkFlags VkVideoEncodeRgbRangeCompressionFlagsVALVE;
 typedef VkFlags VkVideoEncodeUsageFlagsKHR;
 typedef VkFlags VkVideoEndCodingFlagsKHR;
 typedef VkFlags VkVideoSessionCreateFlagsKHR;
@@ -1940,6 +1950,14 @@ typedef enum VkAcquireProfilingLockFlagBitsKHR
     VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkAcquireProfilingLockFlagBitsKHR;

+typedef enum VkAddressCopyFlagBitsKHR
+{
+    VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR = 0x00000001,
+    VK_ADDRESS_COPY_SPARSE_BIT_KHR = 0x00000002,
+    VK_ADDRESS_COPY_PROTECTED_BIT_KHR = 0x00000004,
+    VK_ADDRESS_COPY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
+} VkAddressCopyFlagBitsKHR;
+
 typedef enum VkAntiLagModeAMD
 {
     VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD = 0,
@@ -3509,6 +3527,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ull;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ull;
 static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV = 0x8000000000000ull;
+static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 0x800000000000000ull;
 typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;

typedef enum VkFragmentShadingRateCombinerOpKHR
@@ -4680,6 +4699,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HU
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM = 0x40000000000ull;
 static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 0x100000000000ull;
+static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR = 0x400000000000ull;
 typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR;

typedef enum VkPointClippingBehavior
@@ -5907,6 +5927,10 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES = 1000388000,
     VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES = 1000388001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE = 1000390000,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE = 1000390001,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE = 1000390002,
+    VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE = 1000390003,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000,
     VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,
@@ -5955,7 +5979,7 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001,
     VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR = 1000426001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000,
@@ -6152,6 +6176,9 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002,
     VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003,
     VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR = 1000549000,
+    VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR = 1000549002,
+    VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR = 1000549003,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR = 1000552000,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR = 1000552001,
     VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR = 1000552002,
@@ -6207,6 +6234,7 @@ typedef enum VkStructureType
     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_SHADER_FMA_FEATURES_KHR = 1000579000,
     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_MAINTENANCE_9_FEATURES_KHR = 1000584000,
@@ -6450,6 +6478,7 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT,
     VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES,
@@ -6940,6 +6969,30 @@ typedef enum VkVideoEncodeRateControlModeFlagBitsKHR
     VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff,
 } VkVideoEncodeRateControlModeFlagBitsKHR;

+typedef enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE
+{
+    VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE = 0x00000001,
+    VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE = 0x00000002,
+    VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_FLAG_BITS_VALVE_MAX_ENUM = 0x7fffffff,
+} VkVideoEncodeRgbChromaOffsetFlagBitsVALVE;
+
+typedef enum VkVideoEncodeRgbModelConversionFlagBitsVALVE
+{
+    VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE = 0x00000001,
+    VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE = 0x00000002,
+    VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE = 0x00000004,
+    VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE = 0x00000008,
+    VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE = 0x00000010,
+    VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_FLAG_BITS_VALVE_MAX_ENUM = 0x7fffffff,
+} VkVideoEncodeRgbModelConversionFlagBitsVALVE;
+
+typedef enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE
+{
+    VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE = 0x00000001,
+    VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE = 0x00000002,
+    VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FLAG_BITS_VALVE_MAX_ENUM = 0x7fffffff,
+} VkVideoEncodeRgbRangeCompressionFlagBitsVALVE;
+
 typedef enum VkVideoEncodeTuningModeKHR
 {
     VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0,
@@ -9950,6 +10003,13 @@ typedef struct VkStridedDeviceAddressNV
     VkDeviceSize WINE_VK_ALIGN(8) strideInBytes;
 } VkStridedDeviceAddressNV;

+typedef struct VkStridedDeviceAddressRangeKHR
+{
+    VkDeviceAddress WINE_VK_ALIGN(8) address;
+    VkDeviceSize WINE_VK_ALIGN(8) size;
+    VkDeviceSize WINE_VK_ALIGN(8) stride;
+} VkStridedDeviceAddressRangeKHR;
+
 typedef struct VkStridedDeviceAddressRegionKHR
 {
     VkDeviceAddress WINE_VK_ALIGN(8) deviceAddress;
@@ -11184,12 +11244,23 @@ typedef struct VkCopyImageToMemoryInfo
 } VkCopyImageToMemoryInfo;
 typedef VkCopyImageToMemoryInfo VkCopyImageToMemoryInfoEXT;

-typedef struct VkCopyMemoryIndirectCommandNV
+typedef struct VkCopyMemoryIndirectCommandKHR
 {
     VkDeviceAddress WINE_VK_ALIGN(8) srcAddress;
     VkDeviceAddress WINE_VK_ALIGN(8) dstAddress;
     VkDeviceSize WINE_VK_ALIGN(8) size;
-} VkCopyMemoryIndirectCommandNV;
+} VkCopyMemoryIndirectCommandKHR;
+typedef VkCopyMemoryIndirectCommandKHR VkCopyMemoryIndirectCommandNV;
+
+typedef struct VkCopyMemoryIndirectInfoKHR
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkAddressCopyFlagsKHR srcCopyFlags;
+    VkAddressCopyFlagsKHR dstCopyFlags;
+    uint32_t copyCount;
+    VkStridedDeviceAddressRangeKHR WINE_VK_ALIGN(8) copyAddressRange;
+} VkCopyMemoryIndirectInfoKHR;

typedef struct VkCopyMemoryToAccelerationStructureInfoKHR
 {
@@ -11200,7 +11271,7 @@ typedef struct VkCopyMemoryToAccelerationStructureInfoKHR
     VkCopyAccelerationStructureModeKHR mode;
 } VkCopyMemoryToAccelerationStructureInfoKHR;

-typedef struct VkCopyMemoryToImageIndirectCommandNV
+typedef struct VkCopyMemoryToImageIndirectCommandKHR
 {
     VkDeviceAddress WINE_VK_ALIGN(8) srcAddress;
     uint32_t bufferRowLength;
@@ -11208,7 +11279,20 @@ typedef struct VkCopyMemoryToImageIndirectCommandNV
     VkImageSubresourceLayers imageSubresource;
     VkOffset3D imageOffset;
     VkExtent3D imageExtent;
-} VkCopyMemoryToImageIndirectCommandNV;
+} VkCopyMemoryToImageIndirectCommandKHR;
+typedef VkCopyMemoryToImageIndirectCommandKHR VkCopyMemoryToImageIndirectCommandNV;
+
+typedef struct VkCopyMemoryToImageIndirectInfoKHR
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkAddressCopyFlagsKHR srcCopyFlags;
+    uint32_t copyCount;
+    VkStridedDeviceAddressRangeKHR WINE_VK_ALIGN(8) copyAddressRange;
+    VkImage WINE_VK_ALIGN(8) dstImage;
+    VkImageLayout dstImageLayout;
+    const VkImageSubresourceLayers *pImageSubresources;
+} VkCopyMemoryToImageIndirectInfoKHR;

typedef struct VkCopyMemoryToImageInfo
 {
@@ -13571,6 +13655,14 @@ typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV
     uint32_t maxCooperativeVectorComponents;
 } VkPhysicalDeviceCooperativeVectorPropertiesNV;

+typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 indirectMemoryCopy;
+    VkBool32 indirectMemoryToImageCopy;
+} VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR;
+
 typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV
 {
     VkStructureType sType;
@@ -13578,12 +13670,13 @@ typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV
     VkBool32 indirectCopy;
 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV;

-typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV
+typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR
 {
     VkStructureType sType;
     void *pNext;
     VkQueueFlags supportedQueues;
-} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV;
+} VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR;
+typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR VkPhysicalDeviceCopyMemoryIndirectPropertiesNV;

typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV
 {
@@ -15598,6 +15691,15 @@ typedef struct VkPhysicalDeviceShaderFloatControls2Features
 } VkPhysicalDeviceShaderFloatControls2Features;
 typedef VkPhysicalDeviceShaderFloatControls2Features VkPhysicalDeviceShaderFloatControls2FeaturesKHR;

+typedef struct VkPhysicalDeviceShaderFmaFeaturesKHR
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 shaderFmaFloat16;
+    VkBool32 shaderFmaFloat32;
+    VkBool32 shaderFmaFloat64;
+} VkPhysicalDeviceShaderFmaFeaturesKHR;
+
 typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
 {
     VkStructureType sType;
@@ -16162,6 +16264,13 @@ typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR
     VkBool32 videoEncodeQuantizationMap;
 } VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR;

+typedef struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE
+{
+    VkStructureType sType;
+    void *pNext;
+    VkBool32 videoEncodeRgbConversion;
+} VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE;
+
 typedef struct VkPhysicalDeviceVideoFormatInfoKHR
 {
     VkStructureType sType;
@@ -16822,7 +16931,7 @@ typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT
 typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo
 {
     VkStructureType sType;
-    void *pNext;
+    const void *pNext;
     uint32_t requiredSubgroupSize;
 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
@@ -18533,6 +18642,13 @@ typedef struct VkVideoEncodeIntraRefreshInfoKHR
     uint32_t intraRefreshIndex;
 } VkVideoEncodeIntraRefreshInfoKHR;

+typedef struct VkVideoEncodeProfileRgbConversionInfoVALVE
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkBool32 performEncodeRgbConversion;
+} VkVideoEncodeProfileRgbConversionInfoVALVE;
+
 typedef struct VkVideoEncodeQualityLevelInfoKHR
 {
     VkStructureType sType;
@@ -18582,6 +18698,16 @@ typedef struct VkVideoEncodeRateControlInfoKHR
     uint32_t initialVirtualBufferSizeInMs;
 } VkVideoEncodeRateControlInfoKHR;

+typedef struct VkVideoEncodeRgbConversionCapabilitiesVALVE
+{
+    VkStructureType sType;
+    void *pNext;
+    VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels;
+    VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges;
+    VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets;
+    VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets;
+} VkVideoEncodeRgbConversionCapabilitiesVALVE;
+
 typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR
 {
     VkStructureType sType;
@@ -18603,6 +18729,16 @@ typedef struct VkVideoEncodeSessionParametersGetInfoKHR
     VkVideoSessionParametersKHR WINE_VK_ALIGN(8) videoSessionParameters;
 } VkVideoEncodeSessionParametersGetInfoKHR;

+typedef struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE
+{
+    VkStructureType sType;
+    const void *pNext;
+    VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel;
+    VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange;
+    VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset;
+    VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset;
+} VkVideoEncodeSessionRgbConversionCreateInfoVALVE;
+
 typedef struct VkVideoEncodeUsageInfoKHR
 {
     VkStructureType sType;
@@ -18894,8 +19030,10 @@ typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer, const VkCopyIm
 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer, VkImage, VkImageLayout, VkBuffer, uint32_t, const VkBufferImageCopy *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer, const VkCopyImageToBufferInfo2 *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer, const VkCopyImageToBufferInfo2 *);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectKHR)(VkCommandBuffer, const VkCopyMemoryIndirectInfoKHR *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer, VkDeviceAddress, uint32_t, uint32_t);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectKHR)(VkCommandBuffer, const VkCopyMemoryToImageIndirectInfoKHR *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer, VkDeviceAddress, uint32_t, uint32_t, VkImage, VkImageLayout, const VkImageSubresourceLayers *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer, const VkCopyMemoryToMicromapInfoEXT *);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer, const VkCopyMicromapInfoEXT *);
@@ -19579,8 +19717,10 @@ void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyIm
 void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions);
 void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo);
 void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo);
+void VKAPI_CALL vkCmdCopyMemoryIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR *pCopyMemoryIndirectInfo);
 void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride);
 void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo);
+void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR *pCopyMemoryToImageIndirectInfo);
 void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources);
 void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo);
 void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo);
@@ -20265,8 +20405,10 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr
     USE_VK_FUNC(vkCmdCopyImageToBuffer) \
     USE_VK_FUNC(vkCmdCopyImageToBuffer2) \
     USE_VK_FUNC(vkCmdCopyImageToBuffer2KHR) \
+    USE_VK_FUNC(vkCmdCopyMemoryIndirectKHR) \
     USE_VK_FUNC(vkCmdCopyMemoryIndirectNV) \
     USE_VK_FUNC(vkCmdCopyMemoryToAccelerationStructureKHR) \
+    USE_VK_FUNC(vkCmdCopyMemoryToImageIndirectKHR) \
     USE_VK_FUNC(vkCmdCopyMemoryToImageIndirectNV) \
     USE_VK_FUNC(vkCmdCopyMemoryToMicromapEXT) \
     USE_VK_FUNC(vkCmdCopyMicromapEXT) \

[PATCH v2 0/1] MR9151: winevulkan: Update to VK spec version 1.4.329 - approved

[Rémi Bernon (＠rbernon)]

This merge request was approved by Rémi Bernon.