[PATCH 0/1] MR3371: winevulkan: Update to VK spec version 1.3.258.

List overview All Threads

newer

older

Re: [PATCH v2 0/1] MR3312:...

[PATCH 0/1] MR3370: win32u/tests:...

Georg Lehmann (＠DadSchoorse)

21 Jul 2023 21 Jul '23

11:31 a.m.

This does not enable VK_NV_device_generated_commands_compute because the extension will likely see an API breaking naming fix.

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

Show replies by date

Georg Lehmann

21 Jul 21 Jul

11:31 a.m.

New subject: [PATCH 1/1] winevulkan: Update to VK spec version 1.3.258.

From: Georg Lehmann dadschoorse@gmail.com

This does not enable VK_NV_device_generated_commands_compute because the extension will likely see an API breaking naming fix. --- dlls/winevulkan/loader_thunks.c | 62 +++ dlls/winevulkan/loader_thunks.h | 42 ++ dlls/winevulkan/make_vulkan | 5 +- dlls/winevulkan/vulkan_thunks.c | 689 ++++++++++++++++++++++++++++++++ dlls/winevulkan/vulkan_thunks.h | 10 + dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 235 +++++++++-- 7 files changed, 1019 insertions(+), 26 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index ec652ad6db0..c1ff7cd64ba 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -2490,6 +2490,28 @@ VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferr return params.result; }

+VkResult WINAPI vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo) +{ + struct vkCopyImageToImageEXT_params params; + NTSTATUS status; + params.device = device; + params.pCopyImageToImageInfo = pCopyImageToImageInfo; + status = UNIX_CALL(vkCopyImageToImageEXT, &params); + assert(!status && "vkCopyImageToImageEXT"); + return params.result; +} + +VkResult WINAPI vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo) +{ + struct vkCopyImageToMemoryEXT_params params; + NTSTATUS status; + params.device = device; + params.pCopyImageToMemoryInfo = pCopyImageToMemoryInfo; + status = UNIX_CALL(vkCopyImageToMemoryEXT, &params); + assert(!status && "vkCopyImageToMemoryEXT"); + return params.result; +} + VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) { struct vkCopyMemoryToAccelerationStructureKHR_params params; @@ -2502,6 +2524,17 @@ VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferr return params.result; }

+VkResult WINAPI vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo) +{ + struct vkCopyMemoryToImageEXT_params params; + NTSTATUS status; + params.device = device; + params.pCopyMemoryToImageInfo = pCopyMemoryToImageInfo; + status = UNIX_CALL(vkCopyMemoryToImageEXT, &params); + assert(!status && "vkCopyMemoryToImageEXT"); + return params.result; +} + VkResult WINAPI vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo) { struct vkCopyMemoryToMicromapEXT_params params; @@ -4419,6 +4452,18 @@ VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice return params.result; }

+VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties) +{ + struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params params; + NTSTATUS status; + params.physicalDevice = physicalDevice; + params.pPropertyCount = pPropertyCount; + params.pProperties = pProperties; + status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, &params); + assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"); + return params.result; +} + VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties) { struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params params; @@ -5626,6 +5671,18 @@ void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessag assert(!status && "vkSubmitDebugUtilsMessageEXT"); }

+VkResult WINAPI vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT *pTransitions) +{ + struct vkTransitionImageLayoutEXT_params params; + NTSTATUS status; + params.device = device; + params.transitionCount = transitionCount; + params.pTransitions = pTransitions; + status = UNIX_CALL(vkTransitionImageLayoutEXT, &params); + assert(!status && "vkTransitionImageLayoutEXT"); + return params.result; +} + void WINAPI vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { struct vkTrimCommandPool_params params; @@ -6049,7 +6106,10 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCompileDeferredNV", vkCompileDeferredNV}, {"vkCopyAccelerationStructureKHR", vkCopyAccelerationStructureKHR}, {"vkCopyAccelerationStructureToMemoryKHR", vkCopyAccelerationStructureToMemoryKHR}, + {"vkCopyImageToImageEXT", vkCopyImageToImageEXT}, + {"vkCopyImageToMemoryEXT", vkCopyImageToMemoryEXT}, {"vkCopyMemoryToAccelerationStructureKHR", vkCopyMemoryToAccelerationStructureKHR}, + {"vkCopyMemoryToImageEXT", vkCopyMemoryToImageEXT}, {"vkCopyMemoryToMicromapEXT", vkCopyMemoryToMicromapEXT}, {"vkCopyMicromapEXT", vkCopyMicromapEXT}, {"vkCopyMicromapToMemoryEXT", vkCopyMicromapToMemoryEXT}, @@ -6261,6 +6321,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkSetPrivateDataEXT", vkSetPrivateDataEXT}, {"vkSignalSemaphore", vkSignalSemaphore}, {"vkSignalSemaphoreKHR", vkSignalSemaphoreKHR}, + {"vkTransitionImageLayoutEXT", vkTransitionImageLayoutEXT}, {"vkTrimCommandPool", vkTrimCommandPool}, {"vkTrimCommandPoolKHR", vkTrimCommandPoolKHR}, {"vkUninitializePerformanceApiINTEL", vkUninitializePerformanceApiINTEL}, @@ -6284,6 +6345,7 @@ static const struct vulkan_func vk_phys_dev_dispatch_table[] = {"vkEnumerateDeviceLayerProperties", vkEnumerateDeviceLayerProperties}, {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", vkGetPhysicalDeviceCalibrateableTimeDomainsEXT}, + {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixPropertiesNV}, {"vkGetPhysicalDeviceExternalBufferProperties", vkGetPhysicalDeviceExternalBufferProperties}, {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", vkGetPhysicalDeviceExternalBufferPropertiesKHR}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index 7b4d0ccc1a6..f39d6c88256 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -270,7 +270,10 @@ enum unix_call unix_vkCompileDeferredNV, unix_vkCopyAccelerationStructureKHR, unix_vkCopyAccelerationStructureToMemoryKHR, + unix_vkCopyImageToImageEXT, + unix_vkCopyImageToMemoryEXT, unix_vkCopyMemoryToAccelerationStructureKHR, + unix_vkCopyMemoryToImageEXT, unix_vkCopyMemoryToMicromapEXT, unix_vkCopyMicromapEXT, unix_vkCopyMicromapToMemoryEXT, @@ -441,6 +444,7 @@ enum unix_call unix_vkGetMicromapBuildSizesEXT, unix_vkGetPerformanceParameterINTEL, unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, unix_vkGetPhysicalDeviceExternalBufferProperties, unix_vkGetPhysicalDeviceExternalBufferPropertiesKHR, @@ -544,6 +548,7 @@ enum unix_call unix_vkSignalSemaphore, unix_vkSignalSemaphoreKHR, unix_vkSubmitDebugUtilsMessageEXT, + unix_vkTransitionImageLayoutEXT, unix_vkTrimCommandPool, unix_vkTrimCommandPoolKHR, unix_vkUninitializePerformanceApiINTEL, @@ -2496,6 +2501,20 @@ struct vkCopyAccelerationStructureToMemoryKHR_params VkResult result; };

+struct vkCopyImageToImageEXT_params +{ + VkDevice device; + const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo; + VkResult result; +}; + +struct vkCopyImageToMemoryEXT_params +{ + VkDevice device; + const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo; + VkResult result; +}; + struct vkCopyMemoryToAccelerationStructureKHR_params { VkDevice device; @@ -2504,6 +2523,13 @@ struct vkCopyMemoryToAccelerationStructureKHR_params VkResult result; };

+struct vkCopyMemoryToImageEXT_params +{ + VkDevice device; + const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo; + VkResult result; +}; + struct vkCopyMemoryToMicromapEXT_params { VkDevice device; @@ -3849,6 +3875,14 @@ struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params VkResult result; };

+struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params +{ + VkPhysicalDevice physicalDevice; + uint32_t *pPropertyCount; + VkCooperativeMatrixPropertiesKHR *pProperties; + VkResult result; +}; + struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params { VkPhysicalDevice physicalDevice; @@ -4664,6 +4698,14 @@ struct vkSubmitDebugUtilsMessageEXT_params const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData; };

+struct vkTransitionImageLayoutEXT_params +{ + VkDevice device; + uint32_t transitionCount; + const VkHostImageLayoutTransitionInfoEXT *pTransitions; + VkResult result; +}; + struct vkTrimCommandPool_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 75944cdd79f..1130bf1a93e 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -65,7 +65,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler())

-VK_XML_VERSION = "1.3.254" +VK_XML_VERSION = "1.3.258" WINE_VK_VERSION = (1, 3)

# Filenames to create. @@ -123,6 +123,9 @@ UNSUPPORTED_EXTENSIONS = [ # Deprecated extensions "VK_NV_external_memory_capabilities", "VK_NV_external_memory_win32", + + # Likely broken: https://github.com/KhronosGroup/Vulkan-Docs/issues/2171 + "VK_NV_device_generated_commands_compute", ]

# Either internal extensions which aren't present on the win32 platform which diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index b3deb21a518..e521c0db184 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -1160,6 +1160,65 @@ typedef struct VkStridedDeviceAddressRegionKHR32 VkDeviceSize DECLSPEC_ALIGN(8) size; } VkStridedDeviceAddressRegionKHR32;

+typedef struct VkCopyImageToImageInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkHostImageCopyFlagsEXT flags; + VkImage DECLSPEC_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + VkImage DECLSPEC_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyImageToImageInfoEXT32; + +typedef struct VkImageToMemoryCopyEXT32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkImageToMemoryCopyEXT32; + +typedef struct VkCopyImageToMemoryInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkHostImageCopyFlagsEXT flags; + VkImage DECLSPEC_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyImageToMemoryInfoEXT32; + +typedef struct VkMemoryToImageCopyEXT32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkMemoryToImageCopyEXT32; + +typedef struct VkCopyMemoryToImageInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkHostImageCopyFlagsEXT flags; + VkImage DECLSPEC_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyMemoryToImageInfoEXT32; + typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32 { VkStructureType sType; @@ -2543,6 +2602,13 @@ typedef struct VkPhysicalDeviceSynchronization2Features32 } VkPhysicalDeviceSynchronization2Features32; typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;

+typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 hostImageCopy; +} VkPhysicalDeviceHostImageCopyFeaturesEXT32; + typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 { VkStructureType sType; @@ -2881,6 +2947,14 @@ typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32 VkBool32 shaderTileImageStencilReadAccess; } VkPhysicalDeviceShaderTileImageFeaturesEXT32;

+typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesKHR32; + typedef struct VkDeviceCreateInfo32 { VkStructureType sType; @@ -4442,6 +4516,13 @@ typedef struct VkImageSubresource2EXT32 VkImageSubresource imageSubresource; } VkImageSubresource2EXT32;

+typedef struct VkSubresourceHostMemcpySizeEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkSubresourceHostMemcpySizeEXT32; + typedef struct VkImageCompressionPropertiesEXT32 { VkStructureType sType; @@ -4512,6 +4593,21 @@ typedef struct VkPerformanceValueINTEL32 VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data; } VkPerformanceValueINTEL32;

+typedef struct VkCooperativeMatrixPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; +} VkCooperativeMatrixPropertiesKHR32; + typedef struct VkCooperativeMatrixPropertiesNV32 { VkStructureType sType; @@ -4680,6 +4776,14 @@ typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32 VkBool32 filterCubicMinmax; } VkFilterCubicImageViewImageFormatPropertiesEXT32;

+typedef struct VkHostImageCopyDevicePerformanceQueryEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; +} VkHostImageCopyDevicePerformanceQueryEXT32; + typedef struct VkImageFormatProperties232 { VkStructureType sType; @@ -5560,6 +5664,18 @@ typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;

+typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t copySrcLayoutCount; + PTR32 pCopySrcLayouts; + uint32_t copyDstLayoutCount; + PTR32 pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceHostImageCopyPropertiesEXT32; + typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32 { VkStructureType sType; @@ -5760,6 +5876,13 @@ typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32 VkBool32 shaderTileImageReadFromHelperInvocation; } VkPhysicalDeviceShaderTileImagePropertiesEXT32;

+typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesKHR32; + typedef struct VkPhysicalDeviceProperties232 { VkStructureType sType; @@ -6277,6 +6400,16 @@ typedef struct VkDebugUtilsMessengerCallbackDataEXT32 PTR32 pObjects; } VkDebugUtilsMessengerCallbackDataEXT32;

+typedef struct VkHostImageLayoutTransitionInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkImage DECLSPEC_ALIGN(8) image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; +} VkHostImageLayoutTransitionInfoEXT32; + typedef struct VkMemoryUnmapInfoKHR32 { VkStructureType sType; @@ -8950,6 +9083,117 @@ static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_ho return out; }

+static inline void convert_VkCopyImageToImageInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyImageToImageInfoEXT32 *in, VkCopyImageToImageInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->srcImage = in->srcImage; + out->srcImageLayout = in->srcImageLayout; + out->dstImage = in->dstImage; + out->dstImageLayout = in->dstImageLayout; + out->regionCount = in->regionCount; + out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkImageToMemoryCopyEXT_win32_to_host(const VkImageToMemoryCopyEXT32 *in, VkImageToMemoryCopyEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pHostPointer = (void *)UlongToPtr(in->pHostPointer); + out->memoryRowLength = in->memoryRowLength; + out->memoryImageHeight = in->memoryImageHeight; + out->imageSubresource = in->imageSubresource; + out->imageOffset = in->imageOffset; + out->imageExtent = in->imageExtent; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkImageToMemoryCopyEXT *convert_VkImageToMemoryCopyEXT_array_win32_to_host(struct conversion_context *ctx, const VkImageToMemoryCopyEXT32 *in, uint32_t count) +{ + VkImageToMemoryCopyEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkImageToMemoryCopyEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkCopyImageToMemoryInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyImageToMemoryInfoEXT32 *in, VkCopyImageToMemoryInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->srcImage = in->srcImage; + out->srcImageLayout = in->srcImageLayout; + out->regionCount = in->regionCount; + out->pRegions = convert_VkImageToMemoryCopyEXT_array_win32_to_host(ctx, (const VkImageToMemoryCopyEXT32 *)UlongToPtr(in->pRegions), in->regionCount); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkMemoryToImageCopyEXT_win32_to_host(const VkMemoryToImageCopyEXT32 *in, VkMemoryToImageCopyEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pHostPointer = (const void *)UlongToPtr(in->pHostPointer); + out->memoryRowLength = in->memoryRowLength; + out->memoryImageHeight = in->memoryImageHeight; + out->imageSubresource = in->imageSubresource; + out->imageOffset = in->imageOffset; + out->imageExtent = in->imageExtent; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkMemoryToImageCopyEXT *convert_VkMemoryToImageCopyEXT_array_win32_to_host(struct conversion_context *ctx, const VkMemoryToImageCopyEXT32 *in, uint32_t count) +{ + VkMemoryToImageCopyEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkMemoryToImageCopyEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkCopyMemoryToImageInfoEXT_win32_to_host(struct conversion_context *ctx, const VkCopyMemoryToImageInfoEXT32 *in, VkCopyMemoryToImageInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->dstImage = in->dstImage; + out->dstImageLayout = in->dstImageLayout; + out->regionCount = in->regionCount; + out->pRegions = convert_VkMemoryToImageCopyEXT_array_win32_to_host(ctx, (const VkMemoryToImageCopyEXT32 *)UlongToPtr(in->pRegions), in->regionCount); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out) { const VkBaseInStructure32 *in_header; @@ -11394,6 +11638,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: + { + VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostImageCopyFeaturesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -11908,6 +12163,18 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + { + VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -13371,6 +13638,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: + { + VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -13885,6 +14163,18 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + { + VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -18236,6 +18526,15 @@ static inline void convert_VkSubresourceLayout2EXT_win32_to_host(struct conversi { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: + { + VkSubresourceHostMemcpySizeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: { VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -18265,6 +18564,15 @@ static inline void convert_VkSubresourceLayout2EXT_host_to_win32(const VkSubreso { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: + { + VkSubresourceHostMemcpySizeEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT); + const VkSubresourceHostMemcpySizeEXT *in_ext = (const VkSubresourceHostMemcpySizeEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; + out_ext->size = in_ext->size; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: { VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT); @@ -18400,6 +18708,68 @@ static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerform convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type); }

+static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->MSize = in->MSize; + out->NSize = in->NSize; + out->KSize = in->KSize; + out->AType = in->AType; + out->BType = in->BType; + out->CType = in->CType; + out->ResultType = in->ResultType; + out->saturatingAccumulation = in->saturatingAccumulation; + out->scope = in->scope; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out) +{ + if (!in) return; + + out->MSize = in->MSize; + out->NSize = in->NSize; + out->KSize = in->KSize; + out->AType = in->AType; + out->BType = in->BType; + out->CType = in->CType; + out->ResultType = in->ResultType; + out->saturatingAccumulation = in->saturatingAccumulation; + out->scope = in->scope; +} + +static inline VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesKHR32 *in, uint32_t count) +{ + VkCooperativeMatrixPropertiesKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(&in[i], &out[i]); + } +} + static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out) { if (!in) return; @@ -19944,6 +20314,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: + { + VkPhysicalDeviceHostImageCopyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20458,6 +20839,18 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + { + VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -21632,6 +22025,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: + { + VkPhysicalDeviceHostImageCopyFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT); + const VkPhysicalDeviceHostImageCopyFeaturesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT); @@ -22056,6 +22458,16 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + { + VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_header = (void *)out_ext; + break; + } default: break; } @@ -22342,6 +22754,15 @@ static inline void convert_VkImageFormatProperties2_win32_to_host(struct convers out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: + { + VkHostImageCopyDevicePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: { VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22408,6 +22829,16 @@ static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageF out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: + { + VkHostImageCopyDevicePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT); + const VkHostImageCopyDevicePerformanceQueryEXT *in_ext = (const VkHostImageCopyDevicePerformanceQueryEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; + out_ext->optimalDeviceAccess = in_ext->optimalDeviceAccess; + out_ext->identicalMemoryLayout = in_ext->identicalMemoryLayout; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: { VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT); @@ -23217,6 +23648,22 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv 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)); + const VkPhysicalDeviceHostImageCopyPropertiesEXT32 *in_ext = (const VkPhysicalDeviceHostImageCopyPropertiesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; + out_ext->pNext = NULL; + out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; + out_ext->pCopySrcLayouts = (VkImageLayout *)UlongToPtr(in_ext->pCopySrcLayouts); + out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; + out_ext->pCopyDstLayouts = (VkImageLayout *)UlongToPtr(in_ext->pCopyDstLayouts); + memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); + out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: { VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23364,6 +23811,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + { + VkPhysicalDeviceCooperativeMatrixPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + 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; @@ -24183,6 +24639,20 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy 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); + const VkPhysicalDeviceHostImageCopyPropertiesEXT *in_ext = (const VkPhysicalDeviceHostImageCopyPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; + out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; + out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts); + out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; + out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts); + memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); + out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: { VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT); @@ -24414,6 +24884,15 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + { + VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR); + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages; + out_header = (void *)out_ext; + break; + } default: break; } @@ -26369,6 +26848,36 @@ static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(st } }

+static inline void convert_VkHostImageLayoutTransitionInfoEXT_win32_to_host(const VkHostImageLayoutTransitionInfoEXT32 *in, VkHostImageLayoutTransitionInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->image = in->image; + out->oldLayout = in->oldLayout; + out->newLayout = in->newLayout; + out->subresourceRange = in->subresourceRange; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkHostImageLayoutTransitionInfoEXT *convert_VkHostImageLayoutTransitionInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkHostImageLayoutTransitionInfoEXT32 *in, uint32_t count) +{ + VkHostImageLayoutTransitionInfoEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkHostImageLayoutTransitionInfoEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static inline void convert_VkMemoryUnmapInfoKHR_win32_to_unwrapped_host(const VkMemoryUnmapInfoKHR32 *in, VkMemoryUnmapInfoKHR *out) { if (!in) return; @@ -32515,6 +33024,72 @@ static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkCopyImageToImageEXT(void *args) +{ + struct vkCopyImageToImageEXT_params *params = args; + + TRACE("%p, %p\n", params->device, params->pCopyImageToImageInfo); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyImageToImageEXT(wine_device_from_handle(params->device)->device, params->pCopyImageToImageInfo); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCopyImageToImageEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pCopyImageToImageInfo; + VkResult result; + } *params = args; + VkCopyImageToImageInfoEXT pCopyImageToImageInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x\n", params->device, params->pCopyImageToImageInfo); + + init_conversion_context(ctx); + convert_VkCopyImageToImageInfoEXT_win32_to_host(ctx, (const VkCopyImageToImageInfoEXT32 *)UlongToPtr(params->pCopyImageToImageInfo), &pCopyImageToImageInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyImageToImageEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyImageToImageInfo_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkCopyImageToMemoryEXT(void *args) +{ + struct vkCopyImageToMemoryEXT_params *params = args; + + TRACE("%p, %p\n", params->device, params->pCopyImageToMemoryInfo); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyImageToMemoryEXT(wine_device_from_handle(params->device)->device, params->pCopyImageToMemoryInfo); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCopyImageToMemoryEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pCopyImageToMemoryInfo; + VkResult result; + } *params = args; + VkCopyImageToMemoryInfoEXT pCopyImageToMemoryInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x\n", params->device, params->pCopyImageToMemoryInfo); + + init_conversion_context(ctx); + convert_VkCopyImageToMemoryInfoEXT_win32_to_host(ctx, (const VkCopyImageToMemoryInfoEXT32 *)UlongToPtr(params->pCopyImageToMemoryInfo), &pCopyImageToMemoryInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyImageToMemoryEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyImageToMemoryInfo_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCopyMemoryToAccelerationStructureKHR(void *args) { @@ -32545,6 +33120,39 @@ static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkCopyMemoryToImageEXT(void *args) +{ + struct vkCopyMemoryToImageEXT_params *params = args; + + TRACE("%p, %p\n", params->device, params->pCopyMemoryToImageInfo); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToImageEXT(wine_device_from_handle(params->device)->device, params->pCopyMemoryToImageInfo); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCopyMemoryToImageEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pCopyMemoryToImageInfo; + VkResult result; + } *params = args; + VkCopyMemoryToImageInfoEXT pCopyMemoryToImageInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x\n", params->device, params->pCopyMemoryToImageInfo); + + init_conversion_context(ctx); + convert_VkCopyMemoryToImageInfoEXT_win32_to_host(ctx, (const VkCopyMemoryToImageInfoEXT32 *)UlongToPtr(params->pCopyMemoryToImageInfo), &pCopyMemoryToImageInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToImageEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCopyMemoryToImageInfo_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCopyMemoryToMicromapEXT(void *args) { @@ -37896,6 +38504,41 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *arg return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(void *args) +{ + struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params *params = args; + + TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties); + + params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, params->pProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(void *args) +{ + struct + { + PTR32 physicalDevice; + PTR32 pPropertyCount; + PTR32 pProperties; + VkResult result; + } *params = args; + VkCooperativeMatrixPropertiesKHR *pProperties_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties); + + init_conversion_context(ctx); + pProperties_host = convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(ctx, (VkCooperativeMatrixPropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); + params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host); + convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *args) { @@ -41165,6 +41808,40 @@ static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkTransitionImageLayoutEXT(void *args) +{ + struct vkTransitionImageLayoutEXT_params *params = args; + + TRACE("%p, %u, %p\n", params->device, params->transitionCount, params->pTransitions); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkTransitionImageLayoutEXT(wine_device_from_handle(params->device)->device, params->transitionCount, params->pTransitions); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkTransitionImageLayoutEXT(void *args) +{ + struct + { + PTR32 device; + uint32_t transitionCount; + PTR32 pTransitions; + VkResult result; + } *params = args; + const VkHostImageLayoutTransitionInfoEXT *pTransitions_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %u, %#x\n", params->device, params->transitionCount, params->pTransitions); + + init_conversion_context(ctx); + pTransitions_host = convert_VkHostImageLayoutTransitionInfoEXT_array_win32_to_host(ctx, (const VkHostImageLayoutTransitionInfoEXT32 *)UlongToPtr(params->pTransitions), params->transitionCount); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkTransitionImageLayoutEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->transitionCount, pTransitions_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkTrimCommandPool(void *args) { @@ -41626,6 +42303,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_global_priority_query", "VK_EXT_graphics_pipeline_library", "VK_EXT_hdr_metadata", + "VK_EXT_host_image_copy", "VK_EXT_host_query_reset", "VK_EXT_image_2d_view_of_3d", "VK_EXT_image_compression_control", @@ -41705,6 +42383,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_acceleration_structure", "VK_KHR_bind_memory2", "VK_KHR_buffer_device_address", + "VK_KHR_cooperative_matrix", "VK_KHR_copy_commands2", "VK_KHR_create_renderpass2", "VK_KHR_dedicated_allocation", @@ -42136,7 +42815,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCompileDeferredNV, thunk64_vkCopyAccelerationStructureKHR, thunk64_vkCopyAccelerationStructureToMemoryKHR, + thunk64_vkCopyImageToImageEXT, + thunk64_vkCopyImageToMemoryEXT, thunk64_vkCopyMemoryToAccelerationStructureKHR, + thunk64_vkCopyMemoryToImageEXT, thunk64_vkCopyMemoryToMicromapEXT, thunk64_vkCopyMicromapEXT, thunk64_vkCopyMicromapToMemoryEXT, @@ -42307,6 +42989,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetMicromapBuildSizesEXT, thunk64_vkGetPerformanceParameterINTEL, thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, thunk64_vkGetPhysicalDeviceExternalBufferProperties, thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR, @@ -42410,6 +43093,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkSignalSemaphore, thunk64_vkSignalSemaphoreKHR, thunk64_vkSubmitDebugUtilsMessageEXT, + thunk64_vkTransitionImageLayoutEXT, thunk64_vkTrimCommandPool, thunk64_vkTrimCommandPoolKHR, thunk64_vkUninitializePerformanceApiINTEL, @@ -42691,7 +43375,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCompileDeferredNV, thunk32_vkCopyAccelerationStructureKHR, thunk32_vkCopyAccelerationStructureToMemoryKHR, + thunk32_vkCopyImageToImageEXT, + thunk32_vkCopyImageToMemoryEXT, thunk32_vkCopyMemoryToAccelerationStructureKHR, + thunk32_vkCopyMemoryToImageEXT, thunk32_vkCopyMemoryToMicromapEXT, thunk32_vkCopyMicromapEXT, thunk32_vkCopyMicromapToMemoryEXT, @@ -42862,6 +43549,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetMicromapBuildSizesEXT, thunk32_vkGetPerformanceParameterINTEL, thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, thunk32_vkGetPhysicalDeviceExternalBufferProperties, thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR, @@ -42965,6 +43653,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkSignalSemaphore, thunk32_vkSignalSemaphoreKHR, thunk32_vkSubmitDebugUtilsMessageEXT, + thunk32_vkTransitionImageLayoutEXT, thunk32_vkTrimCommandPool, thunk32_vkTrimCommandPoolKHR, thunk32_vkUninitializePerformanceApiINTEL, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 11ec01b0ed9..210da8b1209 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -317,7 +317,10 @@ struct vulkan_device_funcs VkResult (*p_vkCompileDeferredNV)(VkDevice, VkPipeline, uint32_t); VkResult (*p_vkCopyAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureInfoKHR *); VkResult (*p_vkCopyAccelerationStructureToMemoryKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureToMemoryInfoKHR *); + VkResult (*p_vkCopyImageToImageEXT)(VkDevice, const VkCopyImageToImageInfoEXT *); + VkResult (*p_vkCopyImageToMemoryEXT)(VkDevice, const VkCopyImageToMemoryInfoEXT *); VkResult (*p_vkCopyMemoryToAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToAccelerationStructureInfoKHR *); + VkResult (*p_vkCopyMemoryToImageEXT)(VkDevice, const VkCopyMemoryToImageInfoEXT *); VkResult (*p_vkCopyMemoryToMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToMicromapInfoEXT *); VkResult (*p_vkCopyMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapInfoEXT *); VkResult (*p_vkCopyMicromapToMemoryEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapToMemoryInfoEXT *); @@ -528,6 +531,7 @@ struct vulkan_device_funcs VkResult (*p_vkSetPrivateDataEXT)(VkDevice, VkObjectType, uint64_t, VkPrivateDataSlot, uint64_t); VkResult (*p_vkSignalSemaphore)(VkDevice, const VkSemaphoreSignalInfo *); VkResult (*p_vkSignalSemaphoreKHR)(VkDevice, const VkSemaphoreSignalInfo *); + VkResult (*p_vkTransitionImageLayoutEXT)(VkDevice, uint32_t, const VkHostImageLayoutTransitionInfoEXT *); void (*p_vkTrimCommandPool)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); void (*p_vkTrimCommandPoolKHR)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); void (*p_vkUninitializePerformanceApiINTEL)(VkDevice); @@ -563,6 +567,7 @@ struct vulkan_instance_funcs VkResult (*p_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice, uint32_t *, VkLayerProperties *); VkResult (*p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice, uint32_t, uint32_t *, VkPerformanceCounterKHR *, VkPerformanceCounterDescriptionKHR *); VkResult (*p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *); + VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *); VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *); void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *); void (*p_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); @@ -856,7 +861,10 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCompileDeferredNV) \ USE_VK_FUNC(vkCopyAccelerationStructureKHR) \ USE_VK_FUNC(vkCopyAccelerationStructureToMemoryKHR) \ + USE_VK_FUNC(vkCopyImageToImageEXT) \ + USE_VK_FUNC(vkCopyImageToMemoryEXT) \ USE_VK_FUNC(vkCopyMemoryToAccelerationStructureKHR) \ + USE_VK_FUNC(vkCopyMemoryToImageEXT) \ USE_VK_FUNC(vkCopyMemoryToMicromapEXT) \ USE_VK_FUNC(vkCopyMicromapEXT) \ USE_VK_FUNC(vkCopyMicromapToMemoryEXT) \ @@ -1067,6 +1075,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkSetPrivateDataEXT) \ USE_VK_FUNC(vkSignalSemaphore) \ USE_VK_FUNC(vkSignalSemaphoreKHR) \ + USE_VK_FUNC(vkTransitionImageLayoutEXT) \ USE_VK_FUNC(vkTrimCommandPool) \ USE_VK_FUNC(vkTrimCommandPoolKHR) \ USE_VK_FUNC(vkUninitializePerformanceApiINTEL) \ @@ -1099,6 +1108,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkEnumerateDeviceLayerProperties) \ USE_VK_FUNC(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) \ + USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures2) \ diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index c80806a002a..37c95b4faf8 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.254" + "api_version": "1.3.258" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 59f8b7275be..d295dffb1fb 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -403,6 +403,8 @@ #define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations" #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties" +#define VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION 1 +#define VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME "VK_EXT_host_image_copy" #define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1 #define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2" #define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1 @@ -503,7 +505,7 @@ #define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart" #define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2 #define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2" -#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2 +#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 3 #define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading" #define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1 #define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask" @@ -599,6 +601,8 @@ #define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME "VK_EXT_pipeline_library_group_handles" #define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION 1 #define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME "VK_EXT_dynamic_rendering_unused_attachments" +#define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2 +#define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix" #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" #define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION 1 @@ -629,7 +633,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 254 +#define VK_HEADER_VERSION 258 #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 @@ -798,6 +802,7 @@ typedef VkFlags VkGeometryInstanceFlagsKHR; typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV; typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; +typedef VkFlags VkHostImageCopyFlagsEXT; typedef VkFlags VkIOSSurfaceCreateFlagsMVK; typedef VkFlags VkImageAspectFlags; typedef VkFlags VkImageCompressionFixedRateFlagsEXT; @@ -1414,21 +1419,33 @@ typedef enum VkComponentSwizzle VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7fffffff, } VkComponentSwizzle;

-typedef enum VkComponentTypeNV -{ - VK_COMPONENT_TYPE_FLOAT16_NV = 0, - VK_COMPONENT_TYPE_FLOAT32_NV = 1, - VK_COMPONENT_TYPE_FLOAT64_NV = 2, - VK_COMPONENT_TYPE_SINT8_NV = 3, - VK_COMPONENT_TYPE_SINT16_NV = 4, - VK_COMPONENT_TYPE_SINT32_NV = 5, - VK_COMPONENT_TYPE_SINT64_NV = 6, - VK_COMPONENT_TYPE_UINT8_NV = 7, - VK_COMPONENT_TYPE_UINT16_NV = 8, - VK_COMPONENT_TYPE_UINT32_NV = 9, - VK_COMPONENT_TYPE_UINT64_NV = 10, - VK_COMPONENT_TYPE_NV_MAX_ENUM = 0x7fffffff, -} VkComponentTypeNV; +typedef enum VkComponentTypeKHR +{ + VK_COMPONENT_TYPE_FLOAT16_KHR = 0, + VK_COMPONENT_TYPE_FLOAT32_KHR = 1, + VK_COMPONENT_TYPE_FLOAT64_KHR = 2, + VK_COMPONENT_TYPE_SINT8_KHR = 3, + VK_COMPONENT_TYPE_SINT16_KHR = 4, + VK_COMPONENT_TYPE_SINT32_KHR = 5, + VK_COMPONENT_TYPE_SINT64_KHR = 6, + VK_COMPONENT_TYPE_UINT8_KHR = 7, + VK_COMPONENT_TYPE_UINT16_KHR = 8, + VK_COMPONENT_TYPE_UINT32_KHR = 9, + VK_COMPONENT_TYPE_UINT64_KHR = 10, + VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, + VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, + VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, + VK_COMPONENT_TYPE_SINT8_NV = VK_COMPONENT_TYPE_SINT8_KHR, + VK_COMPONENT_TYPE_SINT16_NV = VK_COMPONENT_TYPE_SINT16_KHR, + VK_COMPONENT_TYPE_SINT32_NV = VK_COMPONENT_TYPE_SINT32_KHR, + VK_COMPONENT_TYPE_SINT64_NV = VK_COMPONENT_TYPE_SINT64_KHR, + VK_COMPONENT_TYPE_UINT8_NV = VK_COMPONENT_TYPE_UINT8_KHR, + VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, + VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, + VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, + VK_COMPONENT_TYPE_KHR_MAX_ENUM = 0x7fffffff, +} VkComponentTypeKHR; +typedef VkComponentTypeKHR VkComponentTypeNV;

typedef enum VkCompositeAlphaFlagBitsKHR { @@ -2391,6 +2408,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMEN static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ull; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ull; typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;

typedef enum VkFragmentShadingRateCombinerOpKHR @@ -2488,6 +2506,12 @@ typedef enum VkGraphicsPipelineLibraryFlagBitsEXT VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, } VkGraphicsPipelineLibraryFlagBitsEXT;

+typedef enum VkHostImageCopyFlagBitsEXT +{ + VK_HOST_IMAGE_COPY_MEMCPY_EXT = 0x00000001, + VK_HOST_IMAGE_COPY_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} VkHostImageCopyFlagBitsEXT; + typedef enum VkImageAspectFlagBits { VK_IMAGE_ASPECT_NONE = 0, @@ -2640,6 +2664,7 @@ typedef enum VkImageUsageFlagBits VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, + VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = 0x00400000, VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkImageUsageFlagBits; @@ -3279,6 +3304,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ull; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI = 0x8000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ull; @@ -3625,14 +3651,19 @@ typedef enum VkSamplerYcbcrRange } VkSamplerYcbcrRange; typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;

-typedef enum VkScopeNV +typedef enum VkScopeKHR { - VK_SCOPE_DEVICE_NV = 1, - VK_SCOPE_WORKGROUP_NV = 2, - VK_SCOPE_SUBGROUP_NV = 3, - VK_SCOPE_QUEUE_FAMILY_NV = 5, - VK_SCOPE_NV_MAX_ENUM = 0x7fffffff, -} VkScopeNV; + VK_SCOPE_DEVICE_KHR = 1, + VK_SCOPE_WORKGROUP_KHR = 2, + VK_SCOPE_SUBGROUP_KHR = 3, + VK_SCOPE_QUEUE_FAMILY_KHR = 5, + VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR, + VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR, + VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR, + VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR, + VK_SCOPE_KHR_MAX_ENUM = 0x7fffffff, +} VkScopeKHR; +typedef VkScopeKHR VkScopeNV;

typedef enum VkSemaphoreImportFlagBits { @@ -4180,6 +4211,16 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = 1000270000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = 1000270001, + VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = 1000270002, + VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = 1000270003, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = 1000270004, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = 1000270005, + VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = 1000270006, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = 1000270007, + VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = 1000270008, + VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009, VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000, VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, @@ -4406,6 +4447,9 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, @@ -5373,6 +5417,21 @@ typedef struct VkConformanceVersion } VkConformanceVersion; typedef VkConformanceVersion VkConformanceVersionKHR;

+typedef struct VkCooperativeMatrixPropertiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; +} VkCooperativeMatrixPropertiesKHR; + typedef struct VkCooperativeMatrixPropertiesNV { VkStructureType sType; @@ -6214,6 +6273,14 @@ typedef struct VkGraphicsPipelineLibraryCreateInfoEXT VkGraphicsPipelineLibraryFlagsEXT flags; } VkGraphicsPipelineLibraryCreateInfoEXT;

+typedef struct VkHostImageCopyDevicePerformanceQueryEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; +} VkHostImageCopyDevicePerformanceQueryEXT; + typedef struct VkImageCaptureDescriptorDataInfoEXT { VkStructureType sType; @@ -7066,6 +7133,14 @@ typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT VkBool32 conservativeRasterizationPostDepthCoverage; } VkPhysicalDeviceConservativeRasterizationPropertiesEXT;

+typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesKHR; + typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { VkStructureType sType; @@ -7074,6 +7149,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV VkBool32 cooperativeMatrixRobustBufferAccess; } VkPhysicalDeviceCooperativeMatrixFeaturesNV;

+typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesKHR; + typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { VkStructureType sType; @@ -7724,6 +7806,25 @@ typedef struct VkPhysicalDeviceGroupProperties } VkPhysicalDeviceGroupProperties; typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;

+typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 hostImageCopy; +} VkPhysicalDeviceHostImageCopyFeaturesEXT; + +typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t copySrcLayoutCount; + VkImageLayout *pCopySrcLayouts; + uint32_t copyDstLayoutCount; + VkImageLayout *pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceHostImageCopyPropertiesEXT; + typedef struct VkPhysicalDeviceHostQueryResetFeatures { VkStructureType sType; @@ -10508,6 +10609,13 @@ typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI uint32_t subpass; } VkSubpassShadingPipelineCreateInfoHUAWEI;

+typedef struct VkSubresourceHostMemcpySizeEXT +{ + VkStructureType sType; + void *pNext; + VkDeviceSize WINE_VK_ALIGN(8) size; +} VkSubresourceHostMemcpySizeEXT; + typedef struct VkSubresourceLayout { VkDeviceSize WINE_VK_ALIGN(8) offset; @@ -11245,6 +11353,16 @@ typedef struct VkHdrMetadataEXT float maxFrameAverageLightLevel; } VkHdrMetadataEXT;

+typedef struct VkHostImageLayoutTransitionInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkImage WINE_VK_ALIGN(8) image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; +} VkHostImageLayoutTransitionInfoEXT; + typedef struct VkImageBlit { VkImageSubresourceLayers srcSubresource; @@ -11337,6 +11455,18 @@ typedef struct VkImageResolve2 } VkImageResolve2; typedef VkImageResolve2 VkImageResolve2KHR;

+typedef struct VkImageToMemoryCopyEXT +{ + VkStructureType sType; + const void *pNext; + void *pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkImageToMemoryCopyEXT; + typedef struct VkImageViewSampleWeightCreateInfoQCOM { VkStructureType sType; @@ -11358,6 +11488,18 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV const uint32_t *pStreamStrides; } VkIndirectCommandsLayoutCreateInfoNV;

+typedef struct VkMemoryToImageCopyEXT +{ + VkStructureType sType; + const void *pNext; + const void *pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkMemoryToImageCopyEXT; + typedef struct VkMicromapBuildInfoEXT { VkStructureType sType; @@ -11742,6 +11884,41 @@ typedef struct VkCopyImageInfo2 } VkCopyImageInfo2; typedef VkCopyImageInfo2 VkCopyImageInfo2KHR;

+typedef struct VkCopyImageToImageInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkHostImageCopyFlagsEXT flags; + VkImage WINE_VK_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + VkImage WINE_VK_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2 *pRegions; +} VkCopyImageToImageInfoEXT; + +typedef struct VkCopyImageToMemoryInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkHostImageCopyFlagsEXT flags; + VkImage WINE_VK_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + uint32_t regionCount; + const VkImageToMemoryCopyEXT *pRegions; +} VkCopyImageToMemoryInfoEXT; + +typedef struct VkCopyMemoryToImageInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkHostImageCopyFlagsEXT flags; + VkImage WINE_VK_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkMemoryToImageCopyEXT *pRegions; +} VkCopyMemoryToImageInfoEXT; + typedef struct VkDependencyInfo { VkStructureType sType; @@ -12148,7 +12325,10 @@ typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer, VkPipelin typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice, VkPipeline, uint32_t); typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyAccelerationStructureToMemoryInfoKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImageEXT)(VkDevice, const VkCopyImageToImageInfoEXT *); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemoryEXT)(VkDevice, const VkCopyImageToMemoryInfoEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToAccelerationStructureInfoKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImageEXT)(VkDevice, const VkCopyMemoryToImageInfoEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMemoryToMicromapInfoEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapInfoEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice, VkDeferredOperationKHR, const VkCopyMicromapToMemoryInfoEXT *); @@ -12324,6 +12504,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *); typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice, const VkPhysicalDeviceExternalBufferInfo *, VkExternalBufferProperties *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice, const VkPhysicalDeviceExternalBufferInfo *, VkExternalBufferProperties *); @@ -12427,6 +12608,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice, VkObjectType, ui typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice, const VkSemaphoreSignalInfo *); typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice, const VkSemaphoreSignalInfo *); typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance, VkDebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT, const VkDebugUtilsMessengerCallbackDataEXT *); +typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayoutEXT)(VkDevice, uint32_t, const VkHostImageLayoutTransitionInfoEXT *); typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice, VkCommandPool, VkCommandPoolTrimFlags); typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice); @@ -12696,7 +12878,10 @@ void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelin VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader); VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo); VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo); +VkResult VKAPI_CALL vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo); +VkResult VKAPI_CALL vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo); VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo); +VkResult VKAPI_CALL vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo); VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo); VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo); VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo); @@ -12872,6 +13057,7 @@ VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExter void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo); VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue); VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains); +VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties); void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties); void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties); @@ -12975,6 +13161,7 @@ VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo); VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo); void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData); +VkResult VKAPI_CALL vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT *pTransitions); void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device);

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/3371

566

Age (days ago)

566

Last active (days ago)

wine-gitlab@winehq.org

1 comments

2 participants

tags (0)

participants (2)

Georg Lehmann
Georg Lehmann (＠DadSchoorse)