[PATCH 0/1] MR11100: winevulkan: Update to VK spec version 1.4.353.
From: Georg Lehmann <dadschoorse@gmail.com> --- dlls/vulkan-1/vulkan-1.spec | 1 - dlls/winevulkan/loader_thunks.c | 147 ++- dlls/winevulkan/loader_thunks.h | 103 +- dlls/winevulkan/make_vulkan | 2 +- dlls/winevulkan/vulkan_thunks.c | 1759 ++++++++++++++++++++++++++++++- dlls/winevulkan/vulkan_thunks.h | 1 - dlls/winevulkan/winevulkan.json | 2 +- dlls/winevulkan/winevulkan.spec | 1 - include/wine/vulkan.h | 619 ++++++++++- 9 files changed, 2597 insertions(+), 38 deletions(-) diff --git a/dlls/vulkan-1/vulkan-1.spec b/dlls/vulkan-1/vulkan-1.spec index 7a49ad30a7a..14dfa1e8e92 100644 --- a/dlls/vulkan-1/vulkan-1.spec +++ b/dlls/vulkan-1/vulkan-1.spec @@ -4,7 +4,6 @@ # by the following copyright and permission notice: # # Copyright 2015-2026 The Khronos Group Inc. -# # SPDX-License-Identifier: Apache-2.0 OR MIT # # and from Vulkan video.xml file covered diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 2438a7ef2e9..d8d2365a0e3 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -4,7 +4,6 @@ * by the following copyright and permission notice: * * Copyright 2015-2026 The Khronos Group Inc. - * * SPDX-License-Identifier: Apache-2.0 OR MIT * * and from Vulkan video.xml file covered @@ -321,6 +320,30 @@ void WINAPI vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const Vk UNIX_CALL(vkCmdBeginDebugUtilsLabelEXT, ¶ms); } +VkResult WINAPI vkCmdBeginGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD *pGpaSampleBeginInfo, uint32_t *pSampleID) +{ + struct vkCmdBeginGpaSampleAMD_params params; + NTSTATUS status; + params.commandBuffer = commandBuffer; + params.gpaSession = gpaSession; + params.pGpaSampleBeginInfo = pGpaSampleBeginInfo; + params.pSampleID = pSampleID; + status = UNIX_CALL(vkCmdBeginGpaSampleAMD, ¶ms); + assert(!status && "vkCmdBeginGpaSampleAMD"); + return params.result; +} + +VkResult WINAPI vkCmdBeginGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) +{ + struct vkCmdBeginGpaSessionAMD_params params; + NTSTATUS status; + params.commandBuffer = commandBuffer; + params.gpaSession = gpaSession; + status = UNIX_CALL(vkCmdBeginGpaSessionAMD, ¶ms); + assert(!status && "vkCmdBeginGpaSessionAMD"); + return params.result; +} + void WINAPI vkCmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM *pPerTileBeginInfo) { struct vkCmdBeginPerTileExecutionQCOM_params params; @@ -892,6 +915,14 @@ void WINAPI vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCo UNIX_CALL(vkCmdCopyBufferToImage2KHR, ¶ms); } +void WINAPI vkCmdCopyGpaSessionResultsAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) +{ + struct vkCmdCopyGpaSessionResultsAMD_params params; + params.commandBuffer = commandBuffer; + params.gpaSession = gpaSession; + UNIX_CALL(vkCmdCopyGpaSessionResultsAMD, ¶ms); +} + void WINAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) { struct vkCmdCopyImage_params params; @@ -1556,6 +1587,26 @@ void WINAPI vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) UNIX_CALL(vkCmdEndDebugUtilsLabelEXT, ¶ms); } +void WINAPI vkCmdEndGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID) +{ + struct vkCmdEndGpaSampleAMD_params params; + params.commandBuffer = commandBuffer; + params.gpaSession = gpaSession; + params.sampleID = sampleID; + UNIX_CALL(vkCmdEndGpaSampleAMD, ¶ms); +} + +VkResult WINAPI vkCmdEndGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession) +{ + struct vkCmdEndGpaSessionAMD_params params; + NTSTATUS status; + params.commandBuffer = commandBuffer; + params.gpaSession = gpaSession; + status = UNIX_CALL(vkCmdEndGpaSessionAMD, ¶ms); + assert(!status && "vkCmdEndGpaSessionAMD"); + return params.result; +} + void WINAPI vkCmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM *pPerTileEndInfo) { struct vkCmdEndPerTileExecutionQCOM_params params; @@ -3580,6 +3631,19 @@ VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateIn return params.result; } +VkResult WINAPI vkCreateGpaSessionAMD(VkDevice device, const VkGpaSessionCreateInfoAMD *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkGpaSessionAMD *pGpaSession) +{ + struct vkCreateGpaSessionAMD_params params; + NTSTATUS status; + params.device = device; + params.pCreateInfo = pCreateInfo; + params.pAllocator = pAllocator; + params.pGpaSession = pGpaSession; + status = UNIX_CALL(vkCreateGpaSessionAMD, ¶ms); + assert(!status && "vkCreateGpaSessionAMD"); + return params.result; +} + VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { struct vkCreateGraphicsPipelines_params params; @@ -4253,6 +4317,17 @@ void WINAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, con assert(!status && "vkDestroyFramebuffer"); } +void WINAPI vkDestroyGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks *pAllocator) +{ + struct vkDestroyGpaSessionAMD_params params; + NTSTATUS status; + params.device = device; + params.gpaSession = gpaSession; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkDestroyGpaSessionAMD, ¶ms); + assert(!status && "vkDestroyGpaSessionAMD"); +} + void WINAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { struct vkDestroyImage_params params; @@ -5447,6 +5522,42 @@ void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const Vk assert(!status && "vkGetGeneratedCommandsMemoryRequirementsNV"); } +VkResult WINAPI vkGetGpaDeviceClockInfoAMD(VkDevice device, VkGpaDeviceGetClockInfoAMD *pInfo) +{ + struct vkGetGpaDeviceClockInfoAMD_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + status = UNIX_CALL(vkGetGpaDeviceClockInfoAMD, ¶ms); + assert(!status && "vkGetGpaDeviceClockInfoAMD"); + return params.result; +} + +VkResult WINAPI vkGetGpaSessionResultsAMD(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t *pSizeInBytes, void *pData) +{ + struct vkGetGpaSessionResultsAMD_params params; + NTSTATUS status; + params.device = device; + params.gpaSession = gpaSession; + params.sampleID = sampleID; + params.pSizeInBytes = pSizeInBytes; + params.pData = pData; + status = UNIX_CALL(vkGetGpaSessionResultsAMD, ¶ms); + assert(!status && "vkGetGpaSessionResultsAMD"); + return params.result; +} + +VkResult WINAPI vkGetGpaSessionStatusAMD(VkDevice device, VkGpaSessionAMD gpaSession) +{ + struct vkGetGpaSessionStatusAMD_params params; + NTSTATUS status; + params.device = device; + params.gpaSession = gpaSession; + status = UNIX_CALL(vkGetGpaSessionStatusAMD, ¶ms); + assert(!status && "vkGetGpaSessionStatusAMD"); + return params.result; +} + void WINAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) { struct vkGetImageMemoryRequirements_params params; @@ -7273,6 +7384,17 @@ VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFenc return params.result; } +VkResult WINAPI vkResetGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession) +{ + struct vkResetGpaSessionAMD_params params; + NTSTATUS status; + params.device = device; + params.gpaSession = gpaSession; + status = UNIX_CALL(vkResetGpaSessionAMD, ¶ms); + assert(!status && "vkResetGpaSessionAMD"); + return params.result; +} + void WINAPI vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { struct vkResetQueryPool_params params; @@ -7341,6 +7463,17 @@ VkResult WINAPI vkSetEvent(VkDevice device, VkEvent event) return params.result; } +VkResult WINAPI vkSetGpaDeviceClockModeAMD(VkDevice device, VkGpaDeviceClockModeInfoAMD *pInfo) +{ + struct vkSetGpaDeviceClockModeAMD_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + status = UNIX_CALL(vkSetGpaDeviceClockModeAMD, ¶ms); + assert(!status && "vkSetGpaDeviceClockModeAMD"); + return params.result; +} + void WINAPI vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata) { struct vkSetHdrMetadataEXT_params params; @@ -7762,6 +7895,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdBeginConditionalRenderingEXT", vkCmdBeginConditionalRenderingEXT}, {"vkCmdBeginCustomResolveEXT", vkCmdBeginCustomResolveEXT}, {"vkCmdBeginDebugUtilsLabelEXT", vkCmdBeginDebugUtilsLabelEXT}, + {"vkCmdBeginGpaSampleAMD", vkCmdBeginGpaSampleAMD}, + {"vkCmdBeginGpaSessionAMD", vkCmdBeginGpaSessionAMD}, {"vkCmdBeginPerTileExecutionQCOM", vkCmdBeginPerTileExecutionQCOM}, {"vkCmdBeginQuery", vkCmdBeginQuery}, {"vkCmdBeginQueryIndexedEXT", vkCmdBeginQueryIndexedEXT}, @@ -7821,6 +7956,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdCopyBufferToImage", vkCmdCopyBufferToImage}, {"vkCmdCopyBufferToImage2", vkCmdCopyBufferToImage2}, {"vkCmdCopyBufferToImage2KHR", vkCmdCopyBufferToImage2KHR}, + {"vkCmdCopyGpaSessionResultsAMD", vkCmdCopyGpaSessionResultsAMD}, {"vkCmdCopyImage", vkCmdCopyImage}, {"vkCmdCopyImage2", vkCmdCopyImage2}, {"vkCmdCopyImage2KHR", vkCmdCopyImage2KHR}, @@ -7888,6 +8024,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdEncodeVideoKHR", vkCmdEncodeVideoKHR}, {"vkCmdEndConditionalRenderingEXT", vkCmdEndConditionalRenderingEXT}, {"vkCmdEndDebugUtilsLabelEXT", vkCmdEndDebugUtilsLabelEXT}, + {"vkCmdEndGpaSampleAMD", vkCmdEndGpaSampleAMD}, + {"vkCmdEndGpaSessionAMD", vkCmdEndGpaSessionAMD}, {"vkCmdEndPerTileExecutionQCOM", vkCmdEndPerTileExecutionQCOM}, {"vkCmdEndQuery", vkCmdEndQuery}, {"vkCmdEndQueryIndexedEXT", vkCmdEndQueryIndexedEXT}, @@ -8097,6 +8235,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateEvent", vkCreateEvent}, {"vkCreateFence", vkCreateFence}, {"vkCreateFramebuffer", vkCreateFramebuffer}, + {"vkCreateGpaSessionAMD", vkCreateGpaSessionAMD}, {"vkCreateGraphicsPipelines", vkCreateGraphicsPipelines}, {"vkCreateImage", vkCreateImage}, {"vkCreateImageView", vkCreateImageView}, @@ -8149,6 +8288,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyEvent", vkDestroyEvent}, {"vkDestroyFence", vkDestroyFence}, {"vkDestroyFramebuffer", vkDestroyFramebuffer}, + {"vkDestroyGpaSessionAMD", vkDestroyGpaSessionAMD}, {"vkDestroyImage", vkDestroyImage}, {"vkDestroyImageView", vkDestroyImageView}, {"vkDestroyIndirectCommandsLayoutEXT", vkDestroyIndirectCommandsLayoutEXT}, @@ -8247,6 +8387,9 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetFramebufferTilePropertiesQCOM", vkGetFramebufferTilePropertiesQCOM}, {"vkGetGeneratedCommandsMemoryRequirementsEXT", vkGetGeneratedCommandsMemoryRequirementsEXT}, {"vkGetGeneratedCommandsMemoryRequirementsNV", vkGetGeneratedCommandsMemoryRequirementsNV}, + {"vkGetGpaDeviceClockInfoAMD", vkGetGpaDeviceClockInfoAMD}, + {"vkGetGpaSessionResultsAMD", vkGetGpaSessionResultsAMD}, + {"vkGetGpaSessionStatusAMD", vkGetGpaSessionStatusAMD}, {"vkGetImageMemoryRequirements", vkGetImageMemoryRequirements}, {"vkGetImageMemoryRequirements2", vkGetImageMemoryRequirements2}, {"vkGetImageMemoryRequirements2KHR", vkGetImageMemoryRequirements2KHR}, @@ -8343,12 +8486,14 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkResetDescriptorPool", vkResetDescriptorPool}, {"vkResetEvent", vkResetEvent}, {"vkResetFences", vkResetFences}, + {"vkResetGpaSessionAMD", vkResetGpaSessionAMD}, {"vkResetQueryPool", vkResetQueryPool}, {"vkResetQueryPoolEXT", vkResetQueryPoolEXT}, {"vkSetDebugUtilsObjectNameEXT", vkSetDebugUtilsObjectNameEXT}, {"vkSetDebugUtilsObjectTagEXT", vkSetDebugUtilsObjectTagEXT}, {"vkSetDeviceMemoryPriorityEXT", vkSetDeviceMemoryPriorityEXT}, {"vkSetEvent", vkSetEvent}, + {"vkSetGpaDeviceClockModeAMD", vkSetGpaDeviceClockModeAMD}, {"vkSetHdrMetadataEXT", vkSetHdrMetadataEXT}, {"vkSetLatencyMarkerNV", vkSetLatencyMarkerNV}, {"vkSetLatencySleepModeNV", vkSetLatencySleepModeNV}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index eee26cf2aeb..069ce5ba4df 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -4,7 +4,6 @@ * by the following copyright and permission notice: * * Copyright 2015-2026 The Khronos Group Inc. - * * SPDX-License-Identifier: Apache-2.0 OR MIT * * and from Vulkan video.xml file covered @@ -50,6 +49,8 @@ enum unix_call unix_vkCmdBeginConditionalRenderingEXT, unix_vkCmdBeginCustomResolveEXT, unix_vkCmdBeginDebugUtilsLabelEXT, + unix_vkCmdBeginGpaSampleAMD, + unix_vkCmdBeginGpaSessionAMD, unix_vkCmdBeginPerTileExecutionQCOM, unix_vkCmdBeginQuery, unix_vkCmdBeginQueryIndexedEXT, @@ -109,6 +110,7 @@ enum unix_call unix_vkCmdCopyBufferToImage, unix_vkCmdCopyBufferToImage2, unix_vkCmdCopyBufferToImage2KHR, + unix_vkCmdCopyGpaSessionResultsAMD, unix_vkCmdCopyImage, unix_vkCmdCopyImage2, unix_vkCmdCopyImage2KHR, @@ -176,6 +178,8 @@ enum unix_call unix_vkCmdEncodeVideoKHR, unix_vkCmdEndConditionalRenderingEXT, unix_vkCmdEndDebugUtilsLabelEXT, + unix_vkCmdEndGpaSampleAMD, + unix_vkCmdEndGpaSessionAMD, unix_vkCmdEndPerTileExecutionQCOM, unix_vkCmdEndQuery, unix_vkCmdEndQueryIndexedEXT, @@ -388,6 +392,7 @@ enum unix_call unix_vkCreateEvent, unix_vkCreateFence, unix_vkCreateFramebuffer, + unix_vkCreateGpaSessionAMD, unix_vkCreateGraphicsPipelines, unix_vkCreateImage, unix_vkCreateImageView, @@ -445,6 +450,7 @@ enum unix_call unix_vkDestroyEvent, unix_vkDestroyFence, unix_vkDestroyFramebuffer, + unix_vkDestroyGpaSessionAMD, unix_vkDestroyImage, unix_vkDestroyImageView, unix_vkDestroyIndirectCommandsLayoutEXT, @@ -554,6 +560,9 @@ enum unix_call unix_vkGetFramebufferTilePropertiesQCOM, unix_vkGetGeneratedCommandsMemoryRequirementsEXT, unix_vkGetGeneratedCommandsMemoryRequirementsNV, + unix_vkGetGpaDeviceClockInfoAMD, + unix_vkGetGpaSessionResultsAMD, + unix_vkGetGpaSessionStatusAMD, unix_vkGetImageMemoryRequirements, unix_vkGetImageMemoryRequirements2, unix_vkGetImageMemoryRequirements2KHR, @@ -707,12 +716,14 @@ enum unix_call unix_vkResetDescriptorPool, unix_vkResetEvent, unix_vkResetFences, + unix_vkResetGpaSessionAMD, unix_vkResetQueryPool, unix_vkResetQueryPoolEXT, unix_vkSetDebugUtilsObjectNameEXT, unix_vkSetDebugUtilsObjectTagEXT, unix_vkSetDeviceMemoryPriorityEXT, unix_vkSetEvent, + unix_vkSetGpaDeviceClockModeAMD, unix_vkSetHdrMetadataEXT, unix_vkSetLatencyMarkerNV, unix_vkSetLatencySleepModeNV, @@ -963,6 +974,22 @@ struct vkCmdBeginDebugUtilsLabelEXT_params const VkDebugUtilsLabelEXT *pLabelInfo; }; +struct vkCmdBeginGpaSampleAMD_params +{ + VkCommandBuffer commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + const VkGpaSampleBeginInfoAMD *pGpaSampleBeginInfo; + uint32_t *pSampleID; + VkResult result; +}; + +struct vkCmdBeginGpaSessionAMD_params +{ + VkCommandBuffer commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; +}; + struct vkCmdBeginPerTileExecutionQCOM_params { VkCommandBuffer commandBuffer; @@ -1416,6 +1443,12 @@ struct vkCmdCopyBufferToImage2KHR_params const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo; }; +struct vkCmdCopyGpaSessionResultsAMD_params +{ + VkCommandBuffer commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; +}; + struct vkCmdCopyImage_params { VkCommandBuffer commandBuffer; @@ -1946,6 +1979,20 @@ struct vkCmdEndDebugUtilsLabelEXT_params VkCommandBuffer commandBuffer; }; +struct vkCmdEndGpaSampleAMD_params +{ + VkCommandBuffer commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + uint32_t sampleID; +}; + +struct vkCmdEndGpaSessionAMD_params +{ + VkCommandBuffer commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; +}; + struct vkCmdEndPerTileExecutionQCOM_params { VkCommandBuffer commandBuffer; @@ -3494,6 +3541,15 @@ struct vkCreateFramebuffer_params VkResult result; }; +struct vkCreateGpaSessionAMD_params +{ + VkDevice device; + const VkGpaSessionCreateInfoAMD *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkGpaSessionAMD *pGpaSession; + VkResult result; +}; + struct vkCreateGraphicsPipelines_params { VkDevice device; @@ -3972,6 +4028,13 @@ struct vkDestroyFramebuffer_params const VkAllocationCallbacks *pAllocator; }; +struct vkDestroyGpaSessionAMD_params +{ + VkDevice device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + const VkAllocationCallbacks *pAllocator; +}; + struct vkDestroyImage_params { VkDevice device; @@ -4789,6 +4852,30 @@ struct vkGetGeneratedCommandsMemoryRequirementsNV_params VkMemoryRequirements2 *pMemoryRequirements; }; +struct vkGetGpaDeviceClockInfoAMD_params +{ + VkDevice device; + VkGpaDeviceGetClockInfoAMD *pInfo; + VkResult result; +}; + +struct vkGetGpaSessionResultsAMD_params +{ + VkDevice device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + uint32_t sampleID; + size_t *pSizeInBytes; + void *pData; + VkResult result; +}; + +struct vkGetGpaSessionStatusAMD_params +{ + VkDevice device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; +}; + struct vkGetImageMemoryRequirements_params { VkDevice device; @@ -6003,6 +6090,13 @@ struct vkResetFences_params VkResult result; }; +struct vkResetGpaSessionAMD_params +{ + VkDevice device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; +}; + struct vkResetQueryPool_params { VkDevice device; @@ -6047,6 +6141,13 @@ struct vkSetEvent_params VkResult result; }; +struct vkSetGpaDeviceClockModeAMD_params +{ + VkDevice device; + VkGpaDeviceClockModeInfoAMD *pInfo; + VkResult result; +}; + struct vkSetHdrMetadataEXT_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 90fb8d834bd..70273a19223 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -62,7 +62,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler()) -VK_XML_VERSION = "1.4.350" +VK_XML_VERSION = "1.4.353" # Filenames to create. WINE_VULKAN_H = "../../include/wine/vulkan.h" diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index d081d7c23d5..7ed99c4ff3c 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -4,7 +4,6 @@ * by the following copyright and permission notice: * * Copyright 2015-2026 The Khronos Group Inc. - * * SPDX-License-Identifier: Apache-2.0 OR MIT * * and from Vulkan video.xml file covered @@ -2001,6 +2000,18 @@ typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV32 VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode; } VkAccelerationStructureGeometryLinearSweptSpheresDataNV32; +typedef struct VkAccelerationStructureGeometryMicromapDataKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t usageCountsCount; + PTR32 pUsageCounts; + PTR32 ppUsageCounts; + VkDeviceAddress DECLSPEC_ALIGN(8) data; + VkDeviceAddress DECLSPEC_ALIGN(8) triangleArray; + VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride; +} VkAccelerationStructureGeometryMicromapDataKHR32; + typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32 { VkStructureType sType; @@ -2053,6 +2064,17 @@ typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32 VkMicromapEXT DECLSPEC_ALIGN(8) micromap; } VkAccelerationStructureTrianglesOpacityMicromapEXT32; +typedef struct VkAccelerationStructureTrianglesOpacityMicromapKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkIndexType indexType; + VkDeviceAddress DECLSPEC_ALIGN(8) indexBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) indexStride; + uint32_t baseTriangle; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) micromap; +} VkAccelerationStructureTrianglesOpacityMicromapKHR32; + typedef struct VkAccelerationStructureVersionInfoKHR32 { VkStructureType sType; @@ -3817,6 +3839,15 @@ typedef struct VkFormatProperties332 } VkFormatProperties332; typedef VkFormatProperties332 VkFormatProperties3KHR32; +typedef struct VkFormatProperties4KHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkFormatFeatureFlags4KHR DECLSPEC_ALIGN(8) linearTilingFeatures; + VkFormatFeatureFlags4KHR DECLSPEC_ALIGN(8) optimalTilingFeatures; + VkFormatFeatureFlags4KHR DECLSPEC_ALIGN(8) bufferFeatures; +} VkFormatProperties4KHR32; + typedef struct VkFragmentShadingRateAttachmentInfoKHR32 { VkStructureType sType; @@ -3958,6 +3989,52 @@ typedef struct VkGetLatencyMarkerInfoNV32 PTR32 pTimings; } VkGetLatencyMarkerInfoNV32; +typedef struct VkGpaDeviceClockModeInfoAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkGpaDeviceClockModeAMD clockMode; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; +} VkGpaDeviceClockModeInfoAMD32; + +typedef struct VkGpaDeviceGetClockInfoAMD32 +{ + VkStructureType sType; + PTR32 pNext; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; + uint32_t memoryClockFrequency; + uint32_t engineClockFrequency; +} VkGpaDeviceGetClockInfoAMD32; + +typedef struct VkGpaSampleBeginInfoAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkGpaSampleTypeAMD sampleType; + VkBool32 sampleInternalOperations; + VkBool32 cacheFlushOnCounterCollection; + VkBool32 sqShaderMaskEnable; + VkGpaSqShaderStageFlagsAMD sqShaderMask; + uint32_t perfCounterCount; + PTR32 pPerfCounters; + uint32_t streamingPerfTraceSampleInterval; + VkDeviceSize DECLSPEC_ALIGN(8) perfCounterDeviceMemoryLimit; + VkBool32 sqThreadTraceEnable; + VkBool32 sqThreadTraceSuppressInstructionTokens; + VkDeviceSize DECLSPEC_ALIGN(8) sqThreadTraceDeviceMemoryLimit; + VkPipelineStageFlags timingPreSample; + VkPipelineStageFlags timingPostSample; +} VkGpaSampleBeginInfoAMD32; + +typedef struct VkGpaSessionCreateInfoAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkGpaSessionAMD DECLSPEC_ALIGN(8) secondaryCopySource; +} VkGpaSessionCreateInfoAMD32; + typedef struct VkGraphicsPipelineCreateInfo32 { VkStructureType sType; @@ -4077,6 +4154,13 @@ typedef struct VkImageCompressionPropertiesEXT32 VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; } VkImageCompressionPropertiesEXT32; +typedef struct VkImageCreateFlags2CreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageCreateFlags2KHR DECLSPEC_ALIGN(8) flags; +} VkImageCreateFlags2CreateInfoKHR32; + typedef struct VkImageFormatListCreateInfo32 { VkStructureType sType; @@ -4132,6 +4216,13 @@ typedef struct VkImageSparseMemoryRequirementsInfo232 } VkImageSparseMemoryRequirementsInfo232; typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32; +typedef struct VkImageStencilUsage2CreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageUsageFlags2KHR DECLSPEC_ALIGN(8) stencilUsage; +} VkImageStencilUsage2CreateInfoKHR32; + typedef struct VkImageStencilUsageCreateInfo32 { VkStructureType sType; @@ -4147,6 +4238,13 @@ typedef struct VkImageSwapchainCreateInfoKHR32 VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; } VkImageSwapchainCreateInfoKHR32; +typedef struct VkImageUsageFlags2CreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageUsageFlags2KHR DECLSPEC_ALIGN(8) usage; +} VkImageUsageFlags2CreateInfoKHR32; + typedef struct VkImageViewASTCDecodeModeEXT32 { VkStructureType sType; @@ -4202,6 +4300,13 @@ typedef struct VkImageViewSlicedCreateInfoEXT32 uint32_t sliceCount; } VkImageViewSlicedCreateInfoEXT32; +typedef struct VkImageViewUsage2CreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageUsageFlags2KHR DECLSPEC_ALIGN(8) usage; +} VkImageViewUsage2CreateInfoKHR32; + typedef struct VkImageViewUsageCreateInfo32 { VkStructureType sType; @@ -5044,6 +5149,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM32 VkBool32 cooperativeMatrixConversion; } VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM32; +typedef struct VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 cooperativeMatrixDecodeVector; +} VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV32; + typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 { VkStructureType sType; @@ -5551,6 +5663,13 @@ typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 VkBool32 dynamicRenderingUnusedAttachments; } VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32; +typedef struct VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 elapsedTimerQuery; +} VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM32; + typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32 { VkStructureType sType; @@ -5618,6 +5737,13 @@ typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 VkBool32 extendedDynamicState; } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32; +typedef struct VkPhysicalDeviceExtendedFlagsFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 extendedFlags; +} VkPhysicalDeviceExtendedFlagsFeaturesKHR32; + typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 { VkStructureType sType; @@ -5908,6 +6034,34 @@ typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures32 } VkPhysicalDeviceGlobalPriorityQueryFeatures32; typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32; +typedef struct VkPhysicalDeviceGpaFeaturesAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 perfCounters; + VkBool32 streamingPerfCounters; + VkBool32 sqThreadTracing; + VkBool32 clockModes; +} VkPhysicalDeviceGpaFeaturesAMD32; + +typedef struct VkPhysicalDeviceGpaProperties2AMD32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t revisionId; +} VkPhysicalDeviceGpaProperties2AMD32; + +typedef struct VkPhysicalDeviceGpaPropertiesAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkPhysicalDeviceGpaPropertiesFlagsAMD flags; + VkDeviceSize DECLSPEC_ALIGN(8) maxSqttSeBufferSize; + uint32_t shaderEngineCount; + uint32_t perfBlockCount; + PTR32 pPerfBlocks; +} VkPhysicalDeviceGpaPropertiesAMD32; + typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 { VkStructureType sType; @@ -6043,6 +6197,15 @@ typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM32 VkExtent2D maxBlockMatchWindow; } VkPhysicalDeviceImageProcessing2PropertiesQCOM32; +typedef struct VkPhysicalDeviceImageProcessing3FeaturesQCOM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 imageGatherLinear; + VkBool32 imageGatherExtendedModes; + VkBool32 blockMatchExtendedClampToEdge; +} VkPhysicalDeviceImageProcessing3FeaturesQCOM32; + typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32 { VkStructureType sType; @@ -6483,6 +6646,13 @@ typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 VkBool32 multisampledRenderToSingleSampled; } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32; +typedef struct VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 multisampledRenderToSwapchain; +} VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT32; + typedef struct VkPhysicalDeviceMultiviewFeatures32 { VkStructureType sType; @@ -6556,6 +6726,13 @@ typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32 VkBool32 micromapHostCommands; } VkPhysicalDeviceOpacityMicromapFeaturesEXT32; +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 micromap; +} VkPhysicalDeviceOpacityMicromapFeaturesKHR32; + typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32 { VkStructureType sType; @@ -6564,6 +6741,16 @@ typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32 uint32_t maxOpacity4StateSubdivisionLevel; } VkPhysicalDeviceOpacityMicromapPropertiesEXT32; +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; + uint32_t maxOpacityLossy4StateSubdivisionLevel; + uint64_t DECLSPEC_ALIGN(8) maxMicromapTriangles; +} VkPhysicalDeviceOpacityMicromapPropertiesKHR32; + typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32 { VkStructureType sType; @@ -7518,6 +7705,20 @@ typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32; +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderMultipleWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM32; + +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxShaderWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM32; + typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32 { VkStructureType sType; @@ -7569,6 +7770,20 @@ typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 uint32_t shaderWarpsPerSM; } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32; +typedef struct VkPhysicalDeviceShaderSplitBarrierFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderSplitBarrier; +} VkPhysicalDeviceShaderSplitBarrierFeaturesEXT32; + +typedef struct VkPhysicalDeviceShaderSplitBarrierPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t splitBarrierReservedSharedMemory; +} VkPhysicalDeviceShaderSplitBarrierPropertiesEXT32; + typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 { VkStructureType sType; @@ -7996,6 +8211,13 @@ typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 VkBool32 videoEncodeAV1; } VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32; +typedef struct VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 videoEncodeFeedback2; +} VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR32; + typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 { VkStructureType sType; @@ -8925,6 +9147,14 @@ typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; } VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32; +typedef struct VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxPerPartitionFeedbackEntries; + VkVideoEncodePerPartitionFeedbackFlagsKHR perPartitionEncodeFeedbackFlags; +} VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR32; + typedef struct VkQueueFamilyCheckpointProperties2NV32 { VkStructureType sType; @@ -9553,6 +9783,13 @@ typedef struct VkShaderModuleValidationCacheCreateInfoEXT32 VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache; } VkShaderModuleValidationCacheCreateInfoEXT32; +typedef struct VkSharedPresentSurfaceCapabilities2KHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageUsageFlags2KHR DECLSPEC_ALIGN(8) sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilities2KHR32; + typedef struct VkSparseImageFormatProperties232 { VkStructureType sType; @@ -9754,6 +9991,13 @@ typedef struct VkSwapchainCreateInfoKHR32 VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain; } VkSwapchainCreateInfoKHR32; +typedef struct VkSwapchainFlagsSurfaceCapabilitiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkSwapchainCreateFlagsKHR swapchainSupportedFlags; +} VkSwapchainFlagsSurfaceCapabilitiesEXT32; + typedef struct VkSwapchainLatencyCreateInfoNV32 { VkStructureType sType; @@ -10280,6 +10524,14 @@ typedef struct VkVideoEncodeCapabilitiesKHR32 VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; } VkVideoEncodeCapabilitiesKHR32; +typedef struct VkVideoEncodeFeedback2CapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxPerPartitionFeedbackEntries; + VkVideoEncodePerPartitionFeedbackFlagsKHR supportedPerPartitionEncodeFeedbackFlags; +} VkVideoEncodeFeedback2CapabilitiesKHR32; + typedef struct VkVideoEncodeH264CapabilitiesKHR32 { VkStructureType sType; @@ -12285,6 +12537,21 @@ static void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_hos out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR: + { + VkAccelerationStructureTrianglesOpacityMicromapKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAccelerationStructureTrianglesOpacityMicromapKHR32 *in_ext = (const VkAccelerationStructureTrianglesOpacityMicromapKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR; + out_ext->pNext = NULL; + out_ext->indexType = in_ext->indexType; + out_ext->indexBuffer = in_ext->indexBuffer; + out_ext->indexStride = in_ext->indexStride; + out_ext->baseTriangle = in_ext->baseTriangle; + out_ext->micromap = in_ext->micromap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -12328,6 +12595,22 @@ static void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances); } +static const VkMicromapUsageKHR * const*convert_VkMicromapUsageKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +{ + VkMicromapUsageKHR **out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + out[i] = UlongToPtr(in[i]); + } + + return (void *)out; +} + static void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out) { const VkBaseInStructure32 *in_header; @@ -12366,6 +12649,22 @@ static void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR: + { + VkAccelerationStructureGeometryMicromapDataKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAccelerationStructureGeometryMicromapDataKHR32 *in_ext = (const VkAccelerationStructureGeometryMicromapDataKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR; + out_ext->pNext = NULL; + out_ext->usageCountsCount = in_ext->usageCountsCount; + out_ext->pUsageCounts = UlongToPtr(in_ext->pUsageCounts); + out_ext->ppUsageCounts = convert_VkMicromapUsageKHR_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->ppUsageCounts), in_ext->usageCountsCount); + out_ext->data = in_ext->data; + out_ext->triangleArray = in_ext->triangleArray; + out_ext->triangleArrayStride = in_ext->triangleArrayStride; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: { VkAccelerationStructureGeometrySpheresDataNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -12566,6 +12865,30 @@ static void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEX FIXME("Unexpected pNext\n"); } +static void convert_VkGpaSampleBeginInfoAMD_win32_to_host(const VkGpaSampleBeginInfoAMD32 *in, VkGpaSampleBeginInfoAMD *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->sampleType = in->sampleType; + out->sampleInternalOperations = in->sampleInternalOperations; + out->cacheFlushOnCounterCollection = in->cacheFlushOnCounterCollection; + out->sqShaderMaskEnable = in->sqShaderMaskEnable; + out->sqShaderMask = in->sqShaderMask; + out->perfCounterCount = in->perfCounterCount; + out->pPerfCounters = UlongToPtr(in->pPerfCounters); + out->streamingPerfTraceSampleInterval = in->streamingPerfTraceSampleInterval; + out->perfCounterDeviceMemoryLimit = in->perfCounterDeviceMemoryLimit; + out->sqThreadTraceEnable = in->sqThreadTraceEnable; + out->sqThreadTraceSuppressInstructionTokens = in->sqThreadTraceSuppressInstructionTokens; + out->sqThreadTraceDeviceMemoryLimit = in->sqThreadTraceDeviceMemoryLimit; + out->timingPreSample = in->timingPreSample; + out->timingPostSample = in->timingPostSample; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static void convert_VkPerTileBeginInfoQCOM_win32_to_host(const VkPerTileBeginInfoQCOM32 *in, VkPerTileBeginInfoQCOM *out) { if (!in) return; @@ -19078,6 +19401,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cooperativeMatrixDecodeVector = in_ext->cooperativeMatrixDecodeVector; + out_header->pNext = (void *)out_ext; + 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)); @@ -19501,6 +19835,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + { + VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *in_ext = (const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->elapsedTimerQuery = in_ext->elapsedTimerQuery; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -19577,6 +19922,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR: + { + VkPhysicalDeviceExtendedFlagsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedFlagsFeaturesKHR *in_ext = (const VkPhysicalDeviceExtendedFlagsFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->extendedFlags = in_ext->extendedFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -19754,6 +20110,20 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + { + VkPhysicalDeviceGpaFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGpaFeaturesAMD *in_ext = (const VkPhysicalDeviceGpaFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD; + out_ext->pNext = NULL; + out_ext->perfCounters = in_ext->perfCounters; + out_ext->streamingPerfCounters = in_ext->streamingPerfCounters; + out_ext->sqThreadTracing = in_ext->sqThreadTracing; + out_ext->clockModes = in_ext->clockModes; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -19854,6 +20224,19 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + { + VkPhysicalDeviceImageProcessing3FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessing3FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing3FeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->imageGatherLinear = in_ext->imageGatherLinear; + out_ext->imageGatherExtendedModes = in_ext->imageGatherExtendedModes; + out_ext->blockMatchExtendedClampToEdge = in_ext->blockMatchExtendedClampToEdge; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20175,6 +20558,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT: + { + VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->multisampledRenderToSwapchain = in_ext->multisampledRenderToSwapchain; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20258,6 +20652,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + { + VkPhysicalDeviceOpacityMicromapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpacityMicromapFeaturesKHR *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->micromap = in_ext->micromap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -21169,6 +21574,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *in_ext = (const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->shaderMultipleWaitQueues = in_ext->shaderMultipleWaitQueues; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -21224,6 +21640,17 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderSplitBarrier = in_ext->shaderSplitBarrier; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -21603,6 +22030,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_FEEDBACK_2_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeFeedback2 = in_ext->videoEncodeFeedback2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22346,6 +22784,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cooperativeMatrixDecodeVector = in_ext->cooperativeMatrixDecodeVector; + out_header->pNext = (void *)out_ext; + 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)); @@ -22769,6 +23218,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + { + VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->elapsedTimerQuery = in_ext->elapsedTimerQuery; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22845,6 +23305,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR: + { + VkPhysicalDeviceExtendedFlagsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedFlagsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceExtendedFlagsFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->extendedFlags = in_ext->extendedFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23022,6 +23493,20 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + { + VkPhysicalDeviceGpaFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGpaFeaturesAMD32 *in_ext = (const VkPhysicalDeviceGpaFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD; + out_ext->pNext = NULL; + out_ext->perfCounters = in_ext->perfCounters; + out_ext->streamingPerfCounters = in_ext->streamingPerfCounters; + out_ext->sqThreadTracing = in_ext->sqThreadTracing; + out_ext->clockModes = in_ext->clockModes; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23122,6 +23607,19 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + { + VkPhysicalDeviceImageProcessing3FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessing3FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing3FeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->imageGatherLinear = in_ext->imageGatherLinear; + out_ext->imageGatherExtendedModes = in_ext->imageGatherExtendedModes; + out_ext->blockMatchExtendedClampToEdge = in_ext->blockMatchExtendedClampToEdge; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23443,6 +23941,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT: + { + VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->multisampledRenderToSwapchain = in_ext->multisampledRenderToSwapchain; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23526,6 +24035,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + { + VkPhysicalDeviceOpacityMicromapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpacityMicromapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->micromap = in_ext->micromap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24437,6 +24957,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->shaderMultipleWaitQueues = in_ext->shaderMultipleWaitQueues; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24492,6 +25023,17 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderSplitBarrier = in_ext->shaderSplitBarrier; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24871,6 +25413,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_FEEDBACK_2_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeFeedback2 = in_ext->videoEncodeFeedback2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -25244,8 +25797,11 @@ static void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *c } } -static void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out) +static void convert_VkFramebufferAttachmentImageInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return; out->sType = in->sType; @@ -25257,8 +25813,38 @@ static void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFrame out->layerCount = in->layerCount; out->viewFormatCount = in->viewFormatCount; out->pViewFormats = UlongToPtr(in->pViewFormats); - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCreateFlags2CreateInfoKHR32 *in_ext = (const VkImageCreateFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } } static const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count) @@ -25271,7 +25857,7 @@ static const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentIm out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkFramebufferAttachmentImageInfo_win32_to_host(&in[i], &out[i]); + convert_VkFramebufferAttachmentImageInfo_win32_to_host(ctx, &in[i], &out[i]); } return out; @@ -25317,6 +25903,17 @@ static void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_cont } } +static void convert_VkGpaSessionCreateInfoAMD_win32_to_host(const VkGpaSessionCreateInfoAMD32 *in, VkGpaSessionCreateInfoAMD *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->secondaryCopySource = in->secondaryCopySource; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count) { VkPipelineShaderStageCreateInfo *out; @@ -26394,6 +26991,17 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCreateFlags2CreateInfoKHR *in_ext = (const VkImageCreateFlags2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: { VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26406,6 +27014,17 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR: + { + VkImageStencilUsage2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageStencilUsage2CreateInfoKHR *in_ext = (const VkImageStencilUsage2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stencilUsage = in_ext->stencilUsage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: { VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26428,6 +27047,17 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR *in_ext = (const VkImageUsageFlags2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: { VkOpaqueCaptureDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26581,6 +27211,17 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCreateFlags2CreateInfoKHR32 *in_ext = (const VkImageCreateFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: { VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26593,6 +27234,17 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR: + { + VkImageStencilUsage2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageStencilUsage2CreateInfoKHR32 *in_ext = (const VkImageStencilUsage2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stencilUsage = in_ext->stencilUsage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: { VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26615,6 +27267,17 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: { VkOpaqueCaptureDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26734,6 +27397,17 @@ static void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR: + { + VkImageViewUsage2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageViewUsage2CreateInfoKHR32 *in_ext = (const VkImageViewUsage2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: { VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -27606,6 +28280,18 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR: + { + VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR32 *in_ext = (const VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->maxPerPartitionFeedbackEntries = in_ext->maxPerPartitionFeedbackEntries; + out_ext->perPartitionEncodeFeedbackFlags = in_ext->perPartitionEncodeFeedbackFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: { VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -28989,6 +29675,17 @@ static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: { VkSwapchainLatencyCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -31437,6 +32134,30 @@ static void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(co FIXME("Unexpected pNext\n"); } +static void convert_VkGpaDeviceGetClockInfoAMD_win32_to_host(const VkGpaDeviceGetClockInfoAMD32 *in, VkGpaDeviceGetClockInfoAMD *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->memoryClockRatioToPeak = in->memoryClockRatioToPeak; + out->engineClockRatioToPeak = in->engineClockRatioToPeak; + out->memoryClockFrequency = in->memoryClockFrequency; + out->engineClockFrequency = in->engineClockFrequency; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkGpaDeviceGetClockInfoAMD_host_to_win32(const VkGpaDeviceGetClockInfoAMD *in, VkGpaDeviceGetClockInfoAMD32 *out) +{ + if (!in) return; + + out->memoryClockRatioToPeak = in->memoryClockRatioToPeak; + out->engineClockRatioToPeak = in->engineClockRatioToPeak; + out->memoryClockFrequency = in->memoryClockFrequency; + out->engineClockFrequency = in->engineClockFrequency; +} + static void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out) { const VkBaseInStructure32 *in_header; @@ -32610,6 +33331,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cooperativeMatrixDecodeVector = in_ext->cooperativeMatrixDecodeVector; + out_header->pNext = (void *)out_ext; + 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)); @@ -33033,6 +33765,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + { + VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->elapsedTimerQuery = in_ext->elapsedTimerQuery; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -33109,6 +33852,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR: + { + VkPhysicalDeviceExtendedFlagsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedFlagsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceExtendedFlagsFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->extendedFlags = in_ext->extendedFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -33275,6 +34029,20 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + { + VkPhysicalDeviceGpaFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGpaFeaturesAMD32 *in_ext = (const VkPhysicalDeviceGpaFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD; + out_ext->pNext = NULL; + out_ext->perfCounters = in_ext->perfCounters; + out_ext->streamingPerfCounters = in_ext->streamingPerfCounters; + out_ext->sqThreadTracing = in_ext->sqThreadTracing; + out_ext->clockModes = in_ext->clockModes; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -33375,6 +34143,19 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + { + VkPhysicalDeviceImageProcessing3FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessing3FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing3FeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->imageGatherLinear = in_ext->imageGatherLinear; + out_ext->imageGatherExtendedModes = in_ext->imageGatherExtendedModes; + out_ext->blockMatchExtendedClampToEdge = in_ext->blockMatchExtendedClampToEdge; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -33696,6 +34477,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT: + { + VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->multisampledRenderToSwapchain = in_ext->multisampledRenderToSwapchain; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -33779,6 +34571,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + { + VkPhysicalDeviceOpacityMicromapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpacityMicromapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->micromap = in_ext->micromap; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -34690,6 +35493,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->shaderMultipleWaitQueues = in_ext->shaderMultipleWaitQueues; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -34745,6 +35559,17 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderSplitBarrier = in_ext->shaderSplitBarrier; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -35124,6 +35949,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_FEEDBACK_2_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeFeedback2 = in_ext->videoEncodeFeedback2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -35636,6 +36472,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV: + { + VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV); + const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV; + out_ext->cooperativeMatrixDecodeVector = in_ext->cooperativeMatrixDecodeVector; + 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); @@ -35989,6 +36834,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM: + { + VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM); + const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *in_ext = (const VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM; + out_ext->elapsedTimerQuery = in_ext->elapsedTimerQuery; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV); @@ -36057,6 +36911,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR: + { + VkPhysicalDeviceExtendedFlagsFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR); + const VkPhysicalDeviceExtendedFlagsFeaturesKHR *in_ext = (const VkPhysicalDeviceExtendedFlagsFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR; + out_ext->extendedFlags = in_ext->extendedFlags; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV); @@ -36195,6 +37058,18 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD: + { + VkPhysicalDeviceGpaFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD); + const VkPhysicalDeviceGpaFeaturesAMD *in_ext = (const VkPhysicalDeviceGpaFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD; + out_ext->perfCounters = in_ext->perfCounters; + out_ext->streamingPerfCounters = in_ext->streamingPerfCounters; + out_ext->sqThreadTracing = in_ext->sqThreadTracing; + out_ext->clockModes = in_ext->clockModes; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT); @@ -36277,6 +37152,17 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM: + { + VkPhysicalDeviceImageProcessing3FeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM); + const VkPhysicalDeviceImageProcessing3FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing3FeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM; + out_ext->imageGatherLinear = in_ext->imageGatherLinear; + out_ext->imageGatherExtendedModes = in_ext->imageGatherExtendedModes; + out_ext->blockMatchExtendedClampToEdge = in_ext->blockMatchExtendedClampToEdge; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM); @@ -36542,6 +37428,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT: + { + VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT); + const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT; + out_ext->multisampledRenderToSwapchain = in_ext->multisampledRenderToSwapchain; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES); @@ -36611,6 +37506,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR: + { + VkPhysicalDeviceOpacityMicromapFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR); + const VkPhysicalDeviceOpacityMicromapFeaturesKHR *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR; + out_ext->micromap = in_ext->micromap; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV); @@ -37366,6 +38270,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM); + const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *in_ext = (const VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM; + out_ext->shaderMultipleWaitQueues = in_ext->shaderMultipleWaitQueues; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT); @@ -37411,6 +38324,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT); + const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderSplitBarrierFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT; + out_ext->shaderSplitBarrier = in_ext->shaderSplitBarrier; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES); @@ -37726,6 +38648,15 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR); + const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR; + out_ext->videoEncodeFeedback2 = in_ext->videoEncodeFeedback2; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR); @@ -37986,6 +38917,15 @@ static void convert_VkFormatProperties2_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR: + { + VkFormatProperties4KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: { VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -38035,6 +38975,17 @@ static void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR: + { + VkFormatProperties4KHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR); + const VkFormatProperties4KHR *in_ext = (const VkFormatProperties4KHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR; + out_ext->linearTilingFeatures = in_ext->linearTilingFeatures; + out_ext->optimalTilingFeatures = in_ext->optimalTilingFeatures; + out_ext->bufferFeatures = in_ext->bufferFeatures; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: { VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT); @@ -38161,6 +39112,17 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win64_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCreateFlags2CreateInfoKHR *in_ext = (const VkImageCreateFlags2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: { VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -38173,6 +39135,17 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win64_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR: + { + VkImageStencilUsage2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageStencilUsage2CreateInfoKHR *in_ext = (const VkImageStencilUsage2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stencilUsage = in_ext->stencilUsage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: { VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -38184,6 +39157,17 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win64_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR *in_ext = (const VkImageUsageFlags2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: { VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -38280,6 +39264,17 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCreateFlags2CreateInfoKHR32 *in_ext = (const VkImageCreateFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: { VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -38292,6 +39287,17 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR: + { + VkImageStencilUsage2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageStencilUsage2CreateInfoKHR32 *in_ext = (const VkImageStencilUsage2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stencilUsage = in_ext->stencilUsage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: { VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -38303,6 +39309,17 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: { VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39199,6 +40216,24 @@ static void convert_VkPhysicalDeviceProperties2_win64_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + { + VkPhysicalDeviceGpaProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + { + VkPhysicalDeviceGpaPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39434,6 +40469,15 @@ static void convert_VkPhysicalDeviceProperties2_win64_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + { + VkPhysicalDeviceOpacityMicromapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: { VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39724,6 +40768,15 @@ static void convert_VkPhysicalDeviceProperties2_win64_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: { VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39742,6 +40795,15 @@ static void convert_VkPhysicalDeviceProperties2_win64_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: { VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -40483,6 +41545,28 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win64(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + { + VkPhysicalDeviceGpaProperties2AMD *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD); + const VkPhysicalDeviceGpaProperties2AMD *in_ext = (const VkPhysicalDeviceGpaProperties2AMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD; + out_ext->revisionId = in_ext->revisionId; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + { + VkPhysicalDeviceGpaPropertiesAMD *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD); + const VkPhysicalDeviceGpaPropertiesAMD *in_ext = (const VkPhysicalDeviceGpaPropertiesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD; + out_ext->flags = in_ext->flags; + out_ext->maxSqttSeBufferSize = in_ext->maxSqttSeBufferSize; + out_ext->shaderEngineCount = in_ext->shaderEngineCount; + out_ext->perfBlockCount = in_ext->perfBlockCount; + out_ext->pPerfBlocks = in_ext->pPerfBlocks; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT); @@ -40786,6 +41870,18 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win64(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + { + VkPhysicalDeviceOpacityMicromapPropertiesKHR *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR); + const VkPhysicalDeviceOpacityMicromapPropertiesKHR *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR; + out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel; + out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel; + out_ext->maxOpacityLossy4StateSubdivisionLevel = in_ext->maxOpacityLossy4StateSubdivisionLevel; + out_ext->maxMicromapTriangles = in_ext->maxMicromapTriangles; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: { VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV); @@ -41174,6 +42270,15 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win64(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM); + const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *in_ext = (const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM; + out_ext->maxShaderWaitQueues = in_ext->maxShaderWaitQueues; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: { VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT); @@ -41194,6 +42299,15 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win64(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT); + const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT; + out_ext->splitBarrierReservedSharedMemory = in_ext->splitBarrierReservedSharedMemory; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: { VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = find_next_struct(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT); @@ -41905,6 +43019,24 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + { + VkPhysicalDeviceGpaProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + { + VkPhysicalDeviceGpaPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -42140,6 +43272,15 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + { + VkPhysicalDeviceOpacityMicromapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: { VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -42430,6 +43571,15 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: { VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -42448,6 +43598,15 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: { VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -43183,6 +44342,28 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD: + { + VkPhysicalDeviceGpaProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD); + const VkPhysicalDeviceGpaProperties2AMD *in_ext = (const VkPhysicalDeviceGpaProperties2AMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD; + out_ext->revisionId = in_ext->revisionId; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: + { + VkPhysicalDeviceGpaPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD); + const VkPhysicalDeviceGpaPropertiesAMD *in_ext = (const VkPhysicalDeviceGpaPropertiesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD; + out_ext->flags = in_ext->flags; + out_ext->maxSqttSeBufferSize = in_ext->maxSqttSeBufferSize; + out_ext->shaderEngineCount = in_ext->shaderEngineCount; + out_ext->perfBlockCount = in_ext->perfBlockCount; + out_ext->pPerfBlocks = PtrToUlong(in_ext->pPerfBlocks); + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT); @@ -43486,6 +44667,18 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR: + { + VkPhysicalDeviceOpacityMicromapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR); + const VkPhysicalDeviceOpacityMicromapPropertiesKHR *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR; + out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel; + out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel; + out_ext->maxOpacityLossy4StateSubdivisionLevel = in_ext->maxOpacityLossy4StateSubdivisionLevel; + out_ext->maxMicromapTriangles = in_ext->maxMicromapTriangles; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: { VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV); @@ -43874,6 +45067,15 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM: + { + VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM); + const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *in_ext = (const VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM; + out_ext->maxShaderWaitQueues = in_ext->maxShaderWaitQueues; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: { VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT); @@ -43894,6 +45096,15 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT: + { + VkPhysicalDeviceShaderSplitBarrierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT); + const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderSplitBarrierPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT; + out_ext->splitBarrierReservedSharedMemory = in_ext->splitBarrierReservedSharedMemory; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: { VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT); @@ -44565,8 +45776,11 @@ static void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFa } } -static void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out) +static void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return; out->sType = in->sType; @@ -44576,8 +45790,27 @@ static void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const V out->samples = in->samples; out->usage = in->usage; out->tiling = in->tiling; - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } } static void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out) @@ -44720,6 +45953,17 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: { VkLatencySurfaceCapabilitiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -44741,6 +45985,15 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR: + { + VkSharedPresentSurfaceCapabilities2KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: { VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -44799,6 +46052,15 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT: + { + VkSwapchainFlagsSurfaceCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT; + 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; @@ -44819,6 +46081,15 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR); + const VkImageUsageFlags2CreateInfoKHR *in_ext = (const VkImageUsageFlags2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->usage = in_ext->usage; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: { VkLatencySurfaceCapabilitiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV); @@ -44841,6 +46112,15 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR: + { + VkSharedPresentSurfaceCapabilities2KHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR); + const VkSharedPresentSurfaceCapabilities2KHR *in_ext = (const VkSharedPresentSurfaceCapabilities2KHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR; + out_ext->sharedPresentSupportedUsageFlags = in_ext->sharedPresentSupportedUsageFlags; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: { VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV); @@ -44891,6 +46171,15 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT: + { + VkSwapchainFlagsSurfaceCapabilitiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT); + const VkSwapchainFlagsSurfaceCapabilitiesEXT *in_ext = (const VkSwapchainFlagsSurfaceCapabilitiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT; + out_ext->swapchainSupportedFlags = in_ext->swapchainSupportedFlags; + out_header = (void *)out_ext; + break; + } default: break; } @@ -45110,6 +46399,18 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR: + { + VkVideoEncodeFeedback2CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeFeedback2CapabilitiesKHR32 *in_ext = (const VkVideoEncodeFeedback2CapabilitiesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_ext->maxPerPartitionFeedbackEntries = in_ext->maxPerPartitionFeedbackEntries; + out_ext->supportedPerPartitionEncodeFeedbackFlags = in_ext->supportedPerPartitionEncodeFeedbackFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: { VkVideoEncodeH264CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -45286,6 +46587,16 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR: + { + VkVideoEncodeFeedback2CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR); + const VkVideoEncodeFeedback2CapabilitiesKHR *in_ext = (const VkVideoEncodeFeedback2CapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR; + out_ext->maxPerPartitionFeedbackEntries = in_ext->maxPerPartitionFeedbackEntries; + out_ext->supportedPerPartitionEncodeFeedbackFlags = in_ext->supportedPerPartitionEncodeFeedbackFlags; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: { VkVideoEncodeH264CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR); @@ -45493,6 +46804,17 @@ static void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(struct conv { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: { VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -45526,6 +46848,28 @@ static void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_c { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageCreateFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCreateFlags2CreateInfoKHR32 *in_ext = (const VkImageCreateFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageUsageFlags2CreateInfoKHR32 *in_ext = (const VkImageUsageFlags2CreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: { VkVideoFormatAV1QuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -45594,6 +46938,24 @@ static void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormat { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageCreateFlags2CreateInfoKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR); + const VkImageCreateFlags2CreateInfoKHR *in_ext = (const VkImageCreateFlags2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR; + out_ext->flags = in_ext->flags; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + VkImageUsageFlags2CreateInfoKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR); + const VkImageUsageFlags2CreateInfoKHR *in_ext = (const VkImageUsageFlags2CreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR; + out_ext->usage = in_ext->usage; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: { VkVideoFormatAV1QuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR); @@ -48154,6 +49516,28 @@ static void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtil FIXME("Unexpected pNext\n"); } +static void convert_VkGpaDeviceClockModeInfoAMD_win32_to_host(const VkGpaDeviceClockModeInfoAMD32 *in, VkGpaDeviceClockModeInfoAMD *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->clockMode = in->clockMode; + out->memoryClockRatioToPeak = in->memoryClockRatioToPeak; + out->engineClockRatioToPeak = in->engineClockRatioToPeak; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkGpaDeviceClockModeInfoAMD_host_to_win32(const VkGpaDeviceClockModeInfoAMD *in, VkGpaDeviceClockModeInfoAMD32 *out) +{ + if (!in) return; + + out->clockMode = in->clockMode; + out->memoryClockRatioToPeak = in->memoryClockRatioToPeak; + out->engineClockRatioToPeak = in->engineClockRatioToPeak; +} + #ifdef _WIN64 static const VkSwapchainKHR *convert_VkSwapchainKHR_array_win64_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count) { @@ -49738,6 +51122,64 @@ static void thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args) vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdBeginDebugUtilsLabelEXT(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, &pLabelInfo_host); } +#ifdef _WIN64 +static NTSTATUS thunk64_vkCmdBeginGpaSampleAMD(void *args) +{ + struct vkCmdBeginGpaSampleAMD_params *params = args; + + TRACE("%p, 0x%s, %p, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->gpaSession), params->pGpaSampleBeginInfo, params->pSampleID); + + params->result = vulkan_command_buffer_from_handle(params->commandBuffer)->device->p_vkCmdBeginGpaSampleAMD(vulkan_command_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->gpaSession, params->pGpaSampleBeginInfo, params->pSampleID); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCmdBeginGpaSampleAMD(void *args) +{ + struct + { + PTR32 commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + PTR32 pGpaSampleBeginInfo; + PTR32 pSampleID; + VkResult result; + } *params = args; + VkGpaSampleBeginInfoAMD pGpaSampleBeginInfo_host; + + TRACE("%#x, 0x%s, %#x, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->gpaSession), params->pGpaSampleBeginInfo, params->pSampleID); + + convert_VkGpaSampleBeginInfoAMD_win32_to_host((const VkGpaSampleBeginInfoAMD32 *)UlongToPtr(params->pGpaSampleBeginInfo), &pGpaSampleBeginInfo_host); + params->result = vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdBeginGpaSampleAMD(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->gpaSession, &pGpaSampleBeginInfo_host, (uint32_t *)UlongToPtr(params->pSampleID)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkCmdBeginGpaSessionAMD(void *args) +{ + struct vkCmdBeginGpaSessionAMD_params *params = args; + + TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_command_buffer_from_handle(params->commandBuffer)->device->p_vkCmdBeginGpaSessionAMD(vulkan_command_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->gpaSession); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCmdBeginGpaSessionAMD(void *args) +{ + struct + { + PTR32 commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; + } *params = args; + + TRACE("%#x, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdBeginGpaSessionAMD(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->gpaSession); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static void thunk64_vkCmdBeginPerTileExecutionQCOM(void *args) { @@ -51232,6 +52674,26 @@ static void thunk32_vkCmdCopyBufferToImage2KHR(void *args) free_conversion_context(ctx); } +#ifdef _WIN64 +static void thunk64_vkCmdCopyGpaSessionResultsAMD(void *args) +{ + struct vkCmdCopyGpaSessionResultsAMD_params *params = args; + + vulkan_command_buffer_from_handle(params->commandBuffer)->device->p_vkCmdCopyGpaSessionResultsAMD(vulkan_command_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->gpaSession); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdCopyGpaSessionResultsAMD(void *args) +{ + struct + { + PTR32 commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + } *params = args; + + vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdCopyGpaSessionResultsAMD(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->gpaSession); +} + #ifdef _WIN64 static void thunk64_vkCmdCopyImage(void *args) { @@ -52839,6 +54301,54 @@ static void thunk32_vkCmdEndDebugUtilsLabelEXT(void *args) vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdEndDebugUtilsLabelEXT(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer); } +#ifdef _WIN64 +static void thunk64_vkCmdEndGpaSampleAMD(void *args) +{ + struct vkCmdEndGpaSampleAMD_params *params = args; + + vulkan_command_buffer_from_handle(params->commandBuffer)->device->p_vkCmdEndGpaSampleAMD(vulkan_command_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->gpaSession, params->sampleID); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdEndGpaSampleAMD(void *args) +{ + struct + { + PTR32 commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + uint32_t sampleID; + } *params = args; + + vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdEndGpaSampleAMD(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->gpaSession, params->sampleID); +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkCmdEndGpaSessionAMD(void *args) +{ + struct vkCmdEndGpaSessionAMD_params *params = args; + + TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_command_buffer_from_handle(params->commandBuffer)->device->p_vkCmdEndGpaSessionAMD(vulkan_command_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->gpaSession); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCmdEndGpaSessionAMD(void *args) +{ + struct + { + PTR32 commandBuffer; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; + } *params = args; + + TRACE("%#x, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdEndGpaSessionAMD(vulkan_command_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->gpaSession); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static void thunk64_vkCmdEndPerTileExecutionQCOM(void *args) { @@ -58070,6 +59580,37 @@ static NTSTATUS thunk32_vkCreateFramebuffer(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateGpaSessionAMD(void *args) +{ + struct vkCreateGpaSessionAMD_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pGpaSession); + + params->result = vulkan_device_from_handle(params->device)->p_vkCreateGpaSessionAMD(vulkan_device_from_handle(params->device)->host.device, params->pCreateInfo, NULL, params->pGpaSession); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateGpaSessionAMD(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pGpaSession; + VkResult result; + } *params = args; + VkGpaSessionCreateInfoAMD pCreateInfo_host; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pGpaSession); + + convert_VkGpaSessionCreateInfoAMD_win32_to_host((const VkGpaSessionCreateInfoAMD32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkCreateGpaSessionAMD(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pCreateInfo_host, NULL, (VkGpaSessionAMD *)UlongToPtr(params->pGpaSession)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCreateGraphicsPipelines(void *args) { @@ -59905,6 +61446,33 @@ static NTSTATUS thunk32_vkDestroyFramebuffer(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyGpaSessionAMD(void *args) +{ + struct vkDestroyGpaSessionAMD_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->gpaSession), params->pAllocator); + + vulkan_device_from_handle(params->device)->p_vkDestroyGpaSessionAMD(vulkan_device_from_handle(params->device)->host.device, params->gpaSession, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyGpaSessionAMD(void *args) +{ + struct + { + PTR32 device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->gpaSession), params->pAllocator); + + vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkDestroyGpaSessionAMD(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->gpaSession, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkDestroyImage(void *args) { @@ -63351,6 +64919,96 @@ static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetGpaDeviceClockInfoAMD(void *args) +{ + struct vkGetGpaDeviceClockInfoAMD_params *params = args; + + TRACE("%p, %p\n", params->device, params->pInfo); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetGpaDeviceClockInfoAMD(vulkan_device_from_handle(params->device)->host.device, params->pInfo); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetGpaDeviceClockInfoAMD(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + VkResult result; + } *params = args; + VkGpaDeviceGetClockInfoAMD pInfo_host; + + TRACE("%#x, %#x\n", params->device, params->pInfo); + + convert_VkGpaDeviceGetClockInfoAMD_win32_to_host((VkGpaDeviceGetClockInfoAMD32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetGpaDeviceClockInfoAMD(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host); + convert_VkGpaDeviceGetClockInfoAMD_host_to_win32(&pInfo_host, (VkGpaDeviceGetClockInfoAMD32 *)UlongToPtr(params->pInfo)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetGpaSessionResultsAMD(void *args) +{ + struct vkGetGpaSessionResultsAMD_params *params = args; + + TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->gpaSession), params->sampleID, params->pSizeInBytes, params->pData); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetGpaSessionResultsAMD(vulkan_device_from_handle(params->device)->host.device, params->gpaSession, params->sampleID, params->pSizeInBytes, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetGpaSessionResultsAMD(void *args) +{ + struct + { + PTR32 device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + uint32_t sampleID; + PTR32 pSizeInBytes; + PTR32 pData; + VkResult result; + } *params = args; + size_t pSizeInBytes_host; + + TRACE("%#x, 0x%s, %u, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->gpaSession), params->sampleID, params->pSizeInBytes, params->pData); + + pSizeInBytes_host = *(PTR32 *)UlongToPtr(params->pSizeInBytes); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetGpaSessionResultsAMD(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->gpaSession, params->sampleID, &pSizeInBytes_host, (void *)UlongToPtr(params->pData)); + *(PTR32 *)UlongToPtr(params->pSizeInBytes) = pSizeInBytes_host; + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetGpaSessionStatusAMD(void *args) +{ + struct vkGetGpaSessionStatusAMD_params *params = args; + + TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetGpaSessionStatusAMD(vulkan_device_from_handle(params->device)->host.device, params->gpaSession); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetGpaSessionStatusAMD(void *args) +{ + struct + { + PTR32 device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; + } *params = args; + + TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetGpaSessionStatusAMD(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->gpaSession); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetImageMemoryRequirements(void *args) { @@ -65608,7 +67266,7 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *ar TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties); init_conversion_context(ctx); - convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host); + convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host); pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->p_vkGetPhysicalDeviceSparseImageFormatProperties2(vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->host.physical_device, &pFormatInfo_host, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host); convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); @@ -65645,7 +67303,7 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties); init_conversion_context(ctx); - convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host); + convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host); pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->host.physical_device, &pFormatInfo_host, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host); convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount)); @@ -68386,6 +70044,33 @@ static NTSTATUS thunk32_vkResetFences(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkResetGpaSessionAMD(void *args) +{ + struct vkResetGpaSessionAMD_params *params = args; + + TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_device_from_handle(params->device)->p_vkResetGpaSessionAMD(vulkan_device_from_handle(params->device)->host.device, params->gpaSession); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkResetGpaSessionAMD(void *args) +{ + struct + { + PTR32 device; + VkGpaSessionAMD DECLSPEC_ALIGN(8) gpaSession; + VkResult result; + } *params = args; + + TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->gpaSession)); + + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkResetGpaSessionAMD(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->gpaSession); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkResetQueryPool(void *args) { @@ -68558,6 +70243,36 @@ static NTSTATUS thunk32_vkSetEvent(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkSetGpaDeviceClockModeAMD(void *args) +{ + struct vkSetGpaDeviceClockModeAMD_params *params = args; + + TRACE("%p, %p\n", params->device, params->pInfo); + + params->result = vulkan_device_from_handle(params->device)->p_vkSetGpaDeviceClockModeAMD(vulkan_device_from_handle(params->device)->host.device, params->pInfo); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkSetGpaDeviceClockModeAMD(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + VkResult result; + } *params = args; + VkGpaDeviceClockModeInfoAMD pInfo_host; + + TRACE("%#x, %#x\n", params->device, params->pInfo); + + convert_VkGpaDeviceClockModeInfoAMD_win32_to_host((VkGpaDeviceClockModeInfoAMD32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkSetGpaDeviceClockModeAMD(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host); + convert_VkGpaDeviceClockModeInfoAMD_host_to_win32(&pInfo_host, (VkGpaDeviceClockModeInfoAMD32 *)UlongToPtr(params->pInfo)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkSetHdrMetadataEXT(void *args) { @@ -69651,6 +71366,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdBeginConditionalRenderingEXT, (void *)thunk64_vkCmdBeginCustomResolveEXT, (void *)thunk64_vkCmdBeginDebugUtilsLabelEXT, + thunk64_vkCmdBeginGpaSampleAMD, + thunk64_vkCmdBeginGpaSessionAMD, (void *)thunk64_vkCmdBeginPerTileExecutionQCOM, (void *)thunk64_vkCmdBeginQuery, (void *)thunk64_vkCmdBeginQueryIndexedEXT, @@ -69710,6 +71427,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdCopyBufferToImage, (void *)thunk64_vkCmdCopyBufferToImage2, (void *)thunk64_vkCmdCopyBufferToImage2KHR, + (void *)thunk64_vkCmdCopyGpaSessionResultsAMD, (void *)thunk64_vkCmdCopyImage, (void *)thunk64_vkCmdCopyImage2, (void *)thunk64_vkCmdCopyImage2KHR, @@ -69777,6 +71495,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdEncodeVideoKHR, (void *)thunk64_vkCmdEndConditionalRenderingEXT, (void *)thunk64_vkCmdEndDebugUtilsLabelEXT, + (void *)thunk64_vkCmdEndGpaSampleAMD, + thunk64_vkCmdEndGpaSessionAMD, (void *)thunk64_vkCmdEndPerTileExecutionQCOM, (void *)thunk64_vkCmdEndQuery, (void *)thunk64_vkCmdEndQueryIndexedEXT, @@ -69989,6 +71709,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCreateEvent, thunk64_vkCreateFence, thunk64_vkCreateFramebuffer, + thunk64_vkCreateGpaSessionAMD, thunk64_vkCreateGraphicsPipelines, thunk64_vkCreateImage, thunk64_vkCreateImageView, @@ -70046,6 +71767,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkDestroyEvent, thunk64_vkDestroyFence, thunk64_vkDestroyFramebuffer, + thunk64_vkDestroyGpaSessionAMD, thunk64_vkDestroyImage, thunk64_vkDestroyImageView, thunk64_vkDestroyIndirectCommandsLayoutEXT, @@ -70155,6 +71877,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetFramebufferTilePropertiesQCOM, thunk64_vkGetGeneratedCommandsMemoryRequirementsEXT, thunk64_vkGetGeneratedCommandsMemoryRequirementsNV, + thunk64_vkGetGpaDeviceClockInfoAMD, + thunk64_vkGetGpaSessionResultsAMD, + thunk64_vkGetGpaSessionStatusAMD, thunk64_vkGetImageMemoryRequirements, thunk64_vkGetImageMemoryRequirements2, thunk64_vkGetImageMemoryRequirements2KHR, @@ -70308,12 +72033,14 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkResetDescriptorPool, thunk64_vkResetEvent, thunk64_vkResetFences, + thunk64_vkResetGpaSessionAMD, thunk64_vkResetQueryPool, thunk64_vkResetQueryPoolEXT, thunk64_vkSetDebugUtilsObjectNameEXT, thunk64_vkSetDebugUtilsObjectTagEXT, thunk64_vkSetDeviceMemoryPriorityEXT, thunk64_vkSetEvent, + thunk64_vkSetGpaDeviceClockModeAMD, thunk64_vkSetHdrMetadataEXT, thunk64_vkSetLatencyMarkerNV, thunk64_vkSetLatencySleepModeNV, @@ -70388,6 +72115,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdBeginConditionalRenderingEXT, (void *)thunk32_vkCmdBeginCustomResolveEXT, (void *)thunk32_vkCmdBeginDebugUtilsLabelEXT, + thunk32_vkCmdBeginGpaSampleAMD, + thunk32_vkCmdBeginGpaSessionAMD, (void *)thunk32_vkCmdBeginPerTileExecutionQCOM, (void *)thunk32_vkCmdBeginQuery, (void *)thunk32_vkCmdBeginQueryIndexedEXT, @@ -70447,6 +72176,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdCopyBufferToImage, (void *)thunk32_vkCmdCopyBufferToImage2, (void *)thunk32_vkCmdCopyBufferToImage2KHR, + (void *)thunk32_vkCmdCopyGpaSessionResultsAMD, (void *)thunk32_vkCmdCopyImage, (void *)thunk32_vkCmdCopyImage2, (void *)thunk32_vkCmdCopyImage2KHR, @@ -70514,6 +72244,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdEncodeVideoKHR, (void *)thunk32_vkCmdEndConditionalRenderingEXT, (void *)thunk32_vkCmdEndDebugUtilsLabelEXT, + (void *)thunk32_vkCmdEndGpaSampleAMD, + thunk32_vkCmdEndGpaSessionAMD, (void *)thunk32_vkCmdEndPerTileExecutionQCOM, (void *)thunk32_vkCmdEndQuery, (void *)thunk32_vkCmdEndQueryIndexedEXT, @@ -70726,6 +72458,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCreateEvent, thunk32_vkCreateFence, thunk32_vkCreateFramebuffer, + thunk32_vkCreateGpaSessionAMD, thunk32_vkCreateGraphicsPipelines, thunk32_vkCreateImage, thunk32_vkCreateImageView, @@ -70783,6 +72516,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkDestroyEvent, thunk32_vkDestroyFence, thunk32_vkDestroyFramebuffer, + thunk32_vkDestroyGpaSessionAMD, thunk32_vkDestroyImage, thunk32_vkDestroyImageView, thunk32_vkDestroyIndirectCommandsLayoutEXT, @@ -70892,6 +72626,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetFramebufferTilePropertiesQCOM, thunk32_vkGetGeneratedCommandsMemoryRequirementsEXT, thunk32_vkGetGeneratedCommandsMemoryRequirementsNV, + thunk32_vkGetGpaDeviceClockInfoAMD, + thunk32_vkGetGpaSessionResultsAMD, + thunk32_vkGetGpaSessionStatusAMD, thunk32_vkGetImageMemoryRequirements, thunk32_vkGetImageMemoryRequirements2, thunk32_vkGetImageMemoryRequirements2KHR, @@ -71045,12 +72782,14 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkResetDescriptorPool, thunk32_vkResetEvent, thunk32_vkResetFences, + thunk32_vkResetGpaSessionAMD, thunk32_vkResetQueryPool, thunk32_vkResetQueryPoolEXT, thunk32_vkSetDebugUtilsObjectNameEXT, thunk32_vkSetDebugUtilsObjectTagEXT, thunk32_vkSetDeviceMemoryPriorityEXT, thunk32_vkSetEvent, + thunk32_vkSetGpaDeviceClockModeAMD, thunk32_vkSetHdrMetadataEXT, thunk32_vkSetLatencyMarkerNV, thunk32_vkSetLatencySleepModeNV, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index f2d54c40d16..6e81be28d0d 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -4,7 +4,6 @@ * by the following copyright and permission notice: * * Copyright 2015-2026 The Khronos Group Inc. - * * SPDX-License-Identifier: Apache-2.0 OR MIT * * and from Vulkan video.xml file covered diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index e33bf00caf6..4a2c53b7e1c 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.350" + "api_version": "1.4.353" } } diff --git a/dlls/winevulkan/winevulkan.spec b/dlls/winevulkan/winevulkan.spec index a565652509e..aa02fd2358c 100644 --- a/dlls/winevulkan/winevulkan.spec +++ b/dlls/winevulkan/winevulkan.spec @@ -4,7 +4,6 @@ # by the following copyright and permission notice: # # Copyright 2015-2026 The Khronos Group Inc. -# # SPDX-License-Identifier: Apache-2.0 OR MIT # # and from Vulkan video.xml file covered diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 499be2d771f..5ab758f0338 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -4,7 +4,6 @@ * by the following copyright and permission notice: * * Copyright 2015-2026 The Khronos Group Inc. - * * SPDX-License-Identifier: Apache-2.0 OR MIT * * and from Vulkan video.xml file covered @@ -121,7 +120,7 @@ struct OH_NativeBuffer; #endif #endif #define VK_FALSE 0 -#define VK_HEADER_VERSION 350 +#define VK_HEADER_VERSION 353 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) #define VK_LOD_CLAMP_NONE 1000.0F #define VK_LUID_SIZE 8 @@ -255,6 +254,8 @@ typedef void* VkRemoteAddressNV; #define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2 #define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" #define VK_AMD_GCN_SHADER_SPEC_VERSION 1 +#define VK_AMD_GPA_INTERFACE_EXTENSION_NAME "VK_AMD_gpa_interface" +#define VK_AMD_GPA_INTERFACE_SPEC_VERSION 1 #define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" #define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2 #define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" @@ -459,6 +460,8 @@ typedef void* VkRemoteAddressNV; #define VK_EXT_METAL_SURFACE_SPEC_VERSION 1 #define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME "VK_EXT_multisampled_render_to_single_sampled" #define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SWAPCHAIN_EXTENSION_NAME "VK_EXT_multisampled_render_to_swapchain" +#define VK_EXT_MULTISAMPLED_RENDER_TO_SWAPCHAIN_SPEC_VERSION 1 #define VK_EXT_MULTI_DRAW_EXTENSION_NAME "VK_EXT_multi_draw" #define VK_EXT_MULTI_DRAW_SPEC_VERSION 1 #define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type" @@ -539,6 +542,8 @@ typedef void* VkRemoteAddressNV; #define VK_EXT_SHADER_OBJECT_SPEC_VERSION 1 #define VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME "VK_EXT_shader_replicated_composites" #define VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION 1 +#define VK_EXT_SHADER_SPLIT_BARRIER_EXTENSION_NAME "VK_EXT_shader_split_barrier" +#define VK_EXT_SHADER_SPLIT_BARRIER_SPEC_VERSION 1 #define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" #define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 #define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" @@ -665,6 +670,8 @@ typedef void* VkRemoteAddressNV; #define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read" #define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1 #define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1 +#define VK_KHR_EXTENDED_FLAGS_EXTENSION_NAME "VK_KHR_extended_flags" +#define VK_KHR_EXTENDED_FLAGS_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" @@ -749,6 +756,8 @@ typedef void* VkRemoteAddressNV; #define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1 #define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" #define VK_KHR_MULTIVIEW_SPEC_VERSION 1 +#define VK_KHR_OPACITY_MICROMAP_EXTENSION_NAME "VK_KHR_opacity_micromap" +#define VK_KHR_OPACITY_MICROMAP_SPEC_VERSION 1 #define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 #define VK_KHR_PIPELINE_BINARY_EXTENSION_NAME "VK_KHR_pipeline_binary" @@ -867,6 +876,8 @@ typedef void* VkRemoteAddressNV; #define VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION 1 #define VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME "VK_KHR_video_encode_av1" #define VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_FEEDBACK_2_EXTENSION_NAME "VK_KHR_video_encode_feedback2" +#define VK_KHR_VIDEO_ENCODE_FEEDBACK_2_SPEC_VERSION 1 #define VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_KHR_video_encode_h264" #define VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION 14 #define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME "VK_KHR_video_encode_intra_refresh" @@ -921,6 +932,8 @@ typedef void* VkRemoteAddressNV; #define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 #define VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME "VK_NV_cooperative_matrix2" #define VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION 1 +#define VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_EXTENSION_NAME "VK_NV_cooperative_matrix_decode_vector" +#define VK_NV_COOPERATIVE_MATRIX_DECODE_VECTOR_SPEC_VERSION 1 #define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix" #define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1 #define VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME "VK_NV_cooperative_vector" @@ -1023,6 +1036,8 @@ typedef void* VkRemoteAddressNV; #define VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION 1 #define VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME "VK_QCOM_data_graph_model" #define VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION 1 +#define VK_QCOM_ELAPSED_TIMER_QUERY_EXTENSION_NAME "VK_QCOM_elapsed_timer_query" +#define VK_QCOM_ELAPSED_TIMER_QUERY_SPEC_VERSION 1 #define VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME "VK_QCOM_filter_cubic_clamp" #define VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION 1 #define VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME "VK_QCOM_filter_cubic_weights" @@ -1031,6 +1046,8 @@ typedef void* VkRemoteAddressNV; #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 3 #define VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME "VK_QCOM_image_processing2" #define VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION 1 +#define VK_QCOM_IMAGE_PROCESSING_3_EXTENSION_NAME "VK_QCOM_image_processing3" +#define VK_QCOM_IMAGE_PROCESSING_3_SPEC_VERSION 1 #define VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME "VK_QCOM_image_processing" #define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1 #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" @@ -1047,6 +1064,8 @@ typedef void* VkRemoteAddressNV; #define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 5 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands" #define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 2 +#define VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_EXTENSION_NAME "VK_QCOM_shader_multiple_wait_queues" +#define VK_QCOM_SHADER_MULTIPLE_WAIT_QUEUES_SPEC_VERSION 1 #define VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME "VK_QCOM_tile_memory_heap" #define VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION 1 #define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" @@ -1108,6 +1127,7 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkGpaSessionAMD) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutEXT) @@ -1188,6 +1208,7 @@ typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; typedef VkFlags VkFormatFeatureFlags; typedef VkFlags64 VkFormatFeatureFlags2; typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR; +typedef VkFlags VkGpaPerfBlockPropertiesFlagsAMD; typedef VkFlags VkIndirectStateFlagsNV; typedef VkFlags VkPipelineCacheCreateFlags; typedef VkFlags VkPipelineColorBlendStateCreateFlags; @@ -1258,14 +1279,18 @@ typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR typedef VkFlags VkFenceCreateFlags; typedef VkFlags VkFenceImportFlags; typedef VkFenceImportFlags VkFenceImportFlagsKHR; +typedef VkFlags64 VkFormatFeatureFlags4KHR; typedef VkFlags VkFrameBoundaryFlagsEXT; typedef VkFlags VkFramebufferCreateFlags; +typedef VkFlags VkGpaSqShaderStageFlagsAMD; typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; typedef VkFlags VkHostImageCopyFlags; typedef VkHostImageCopyFlags VkHostImageCopyFlagsEXT; typedef VkFlags VkImageCompressionFixedRateFlagsEXT; typedef VkFlags VkImageCompressionFlagsEXT; +typedef VkFlags64 VkImageCreateFlags2KHR; +typedef VkFlags64 VkImageUsageFlags2KHR; typedef VkFlags VkIndirectCommandsInputModeFlagsEXT; typedef VkFlags VkIndirectCommandsLayoutUsageFlagsEXT; typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; @@ -1288,6 +1313,7 @@ typedef VkFlags VkPartitionedAccelerationStructureInstanceFlagsNV; typedef VkFlags VkPastPresentationTimingFlagsEXT; typedef VkFlags VkPerformanceCounterDescriptionFlagsARM; typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; +typedef VkFlags VkPhysicalDeviceGpaPropertiesFlagsAMD; typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; typedef VkFlags VkPipelineCompilerControlFlagsAMD; typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; @@ -1352,6 +1378,7 @@ typedef VkFlags VkVideoEncodeH264RateControlFlagsKHR; typedef VkFlags VkVideoEncodeH264StdFlagsKHR; typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR; typedef VkFlags VkVideoEncodeIntraRefreshModeFlagsKHR; +typedef VkFlags VkVideoEncodePerPartitionFeedbackFlagsKHR; typedef VkFlags VkVideoEncodeRateControlFlagsKHR; typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; typedef VkFlags VkVideoEncodeRgbChromaOffsetFlagsVALVE; @@ -1872,11 +1899,18 @@ typedef enum VkAccelerationStructureMotionInstanceTypeNV VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_NV_MAX_ENUM = 0x7fffffff, } VkAccelerationStructureMotionInstanceTypeNV; +typedef enum VkAccelerationStructureSerializedBlockTypeKHR +{ + VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAP_KHR = 0, + VK_ACCELERATION_STRUCTURE_SERIALIZED_BLOCK_TYPE_KHR_MAX_ENUM = 0x7fffffff, +} VkAccelerationStructureSerializedBlockTypeKHR; + typedef enum VkAccelerationStructureTypeKHR { VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + VK_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_KHR = 1000623000, VK_ACCELERATION_STRUCTURE_TYPE_KHR_MAX_ENUM = 0x7fffffff, VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, @@ -2287,9 +2321,10 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = 0x00000040, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR = 0x00000080, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 0x00000100, + VK_BUILD_ACCELERATION_STRUCTURE_MICROMAP_LOSSY_BIT_KHR = 0x00000400, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000, VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, @@ -2298,7 +2333,9 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, @@ -3052,6 +3089,7 @@ typedef enum VkDriverId VK_DRIVER_ID_MESA_HONEYKRISP = 26, VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27, VK_DRIVER_ID_MESA_KOSMICKRISP = 28, + VK_DRIVER_ID_MESA_GFXSTREAM = 29, VK_DRIVER_ID_MAX_ENUM = 0x7fffffff, VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, @@ -3762,6 +3800,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT 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_TENSOR_IMAGE_ALIASING_BIT_ARM = 0x80000000000ull; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_SXD_BIT_QCOM = 0x100000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT = 0x400000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM = 0x1000000000000ull; @@ -3778,6 +3817,9 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DATA_GRAPH_OPTICAL_FLO static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 0x800000000000000ull; typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR; +typedef VkFlags64 VkFormatFeatureFlagBits4KHR; + + typedef enum VkFragmentShadingRateCombinerOpKHR { VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, @@ -3848,15 +3890,17 @@ typedef enum VkGeometryInstanceFlagBitsKHR VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, - VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 0x00000010, - VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000020, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR = 0x00000020, VK_GEOMETRY_INSTANCE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_KHR, VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, } VkGeometryInstanceFlagBitsKHR; typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; @@ -3868,12 +3912,108 @@ typedef enum VkGeometryTypeKHR VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004, VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005, + VK_GEOMETRY_TYPE_MICROMAP_KHR = 1000623000, VK_GEOMETRY_TYPE_KHR_MAX_ENUM = 0x7fffffff, VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, } VkGeometryTypeKHR; typedef VkGeometryTypeKHR VkGeometryTypeNV; +typedef enum VkGpaDeviceClockModeAMD +{ + VK_GPA_DEVICE_CLOCK_MODE_DEFAULT_AMD = 0, + VK_GPA_DEVICE_CLOCK_MODE_QUERY_AMD = 1, + VK_GPA_DEVICE_CLOCK_MODE_PROFILING_AMD = 2, + VK_GPA_DEVICE_CLOCK_MODE_MIN_MEMORY_AMD = 3, + VK_GPA_DEVICE_CLOCK_MODE_MIN_ENGINE_AMD = 4, + VK_GPA_DEVICE_CLOCK_MODE_PEAK_AMD = 5, + VK_GPA_DEVICE_CLOCK_MODE_AMD_MAX_ENUM = 0x7fffffff, +} VkGpaDeviceClockModeAMD; + +typedef enum VkGpaPerfBlockAMD +{ + VK_GPA_PERF_BLOCK_CPF_AMD = 0, + VK_GPA_PERF_BLOCK_IA_AMD = 1, + VK_GPA_PERF_BLOCK_VGT_AMD = 2, + VK_GPA_PERF_BLOCK_PA_AMD = 3, + VK_GPA_PERF_BLOCK_SC_AMD = 4, + VK_GPA_PERF_BLOCK_SPI_AMD = 5, + VK_GPA_PERF_BLOCK_SQ_AMD = 6, + VK_GPA_PERF_BLOCK_SX_AMD = 7, + VK_GPA_PERF_BLOCK_TA_AMD = 8, + VK_GPA_PERF_BLOCK_TD_AMD = 9, + VK_GPA_PERF_BLOCK_TCP_AMD = 10, + VK_GPA_PERF_BLOCK_TCC_AMD = 11, + VK_GPA_PERF_BLOCK_TCA_AMD = 12, + VK_GPA_PERF_BLOCK_DB_AMD = 13, + VK_GPA_PERF_BLOCK_CB_AMD = 14, + VK_GPA_PERF_BLOCK_GDS_AMD = 15, + VK_GPA_PERF_BLOCK_SRBM_AMD = 16, + VK_GPA_PERF_BLOCK_GRBM_AMD = 17, + VK_GPA_PERF_BLOCK_GRBM_SE_AMD = 18, + VK_GPA_PERF_BLOCK_RLC_AMD = 19, + VK_GPA_PERF_BLOCK_DMA_AMD = 20, + VK_GPA_PERF_BLOCK_MC_AMD = 21, + VK_GPA_PERF_BLOCK_CPG_AMD = 22, + VK_GPA_PERF_BLOCK_CPC_AMD = 23, + VK_GPA_PERF_BLOCK_WD_AMD = 24, + VK_GPA_PERF_BLOCK_TCS_AMD = 25, + VK_GPA_PERF_BLOCK_ATC_AMD = 26, + VK_GPA_PERF_BLOCK_ATC_L2_AMD = 27, + VK_GPA_PERF_BLOCK_MC_VM_L2_AMD = 28, + VK_GPA_PERF_BLOCK_EA_AMD = 29, + VK_GPA_PERF_BLOCK_RPB_AMD = 30, + VK_GPA_PERF_BLOCK_RMI_AMD = 31, + VK_GPA_PERF_BLOCK_UMCCH_AMD = 32, + VK_GPA_PERF_BLOCK_GE_AMD = 33, + VK_GPA_PERF_BLOCK_GL1A_AMD = 34, + VK_GPA_PERF_BLOCK_GL1C_AMD = 35, + VK_GPA_PERF_BLOCK_GL1CG_AMD = 36, + VK_GPA_PERF_BLOCK_GL2A_AMD = 37, + VK_GPA_PERF_BLOCK_GL2C_AMD = 38, + VK_GPA_PERF_BLOCK_CHA_AMD = 39, + VK_GPA_PERF_BLOCK_CHC_AMD = 40, + VK_GPA_PERF_BLOCK_CHCG_AMD = 41, + VK_GPA_PERF_BLOCK_GUS_AMD = 42, + VK_GPA_PERF_BLOCK_GCR_AMD = 43, + VK_GPA_PERF_BLOCK_PH_AMD = 44, + VK_GPA_PERF_BLOCK_UTCL1_AMD = 45, + VK_GPA_PERF_BLOCK_GE_DIST_AMD = 46, + VK_GPA_PERF_BLOCK_GE_SE_AMD = 47, + VK_GPA_PERF_BLOCK_DF_MALL_AMD = 48, + VK_GPA_PERF_BLOCK_SQ_WGP_AMD = 49, + VK_GPA_PERF_BLOCK_PC_AMD = 50, + VK_GPA_PERF_BLOCK_GL1XA_AMD = 51, + VK_GPA_PERF_BLOCK_GL1XC_AMD = 52, + VK_GPA_PERF_BLOCK_WGS_AMD = 53, + VK_GPA_PERF_BLOCK_EACPWD_AMD = 54, + VK_GPA_PERF_BLOCK_EASE_AMD = 55, + VK_GPA_PERF_BLOCK_RLCUSER_AMD = 56, + VK_GPA_PERF_BLOCK_AMD_MAX_ENUM = 0x7fffffff, + VK_GPA_PERF_BLOCK_GE1_AMD = VK_GPA_PERF_BLOCK_GE_AMD, + VK_GPA_PERF_BLOCK_RLCLOCAL_AMD = VK_GPA_PERF_BLOCK_RLCUSER_AMD, +} VkGpaPerfBlockAMD; + +typedef enum VkGpaSampleTypeAMD +{ + VK_GPA_SAMPLE_TYPE_CUMULATIVE_AMD = 0, + VK_GPA_SAMPLE_TYPE_TRACE_AMD = 1, + VK_GPA_SAMPLE_TYPE_TIMING_AMD = 2, + VK_GPA_SAMPLE_TYPE_AMD_MAX_ENUM = 0x7fffffff, +} VkGpaSampleTypeAMD; + +typedef enum VkGpaSqShaderStageFlagBitsAMD +{ + VK_GPA_SQ_SHADER_STAGE_PS_BIT_AMD = 0x00000001, + VK_GPA_SQ_SHADER_STAGE_VS_BIT_AMD = 0x00000002, + VK_GPA_SQ_SHADER_STAGE_GS_BIT_AMD = 0x00000004, + VK_GPA_SQ_SHADER_STAGE_ES_BIT_AMD = 0x00000008, + VK_GPA_SQ_SHADER_STAGE_HS_BIT_AMD = 0x00000010, + VK_GPA_SQ_SHADER_STAGE_LS_BIT_AMD = 0x00000020, + VK_GPA_SQ_SHADER_STAGE_CS_BIT_AMD = 0x00000040, + VK_GPA_SQ_SHADER_STAGE_FLAG_BITS_AMD_MAX_ENUM = 0x7fffffff, +} VkGpaSqShaderStageFlagBitsAMD; + typedef enum VkGraphicsPipelineLibraryFlagBitsEXT { VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001, @@ -3987,6 +4127,30 @@ typedef enum VkImageCreateFlagBits VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, } VkImageCreateFlagBits; +typedef VkFlags64 VkImageCreateFlagBits2KHR; + +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPARSE_BINDING_BIT_KHR = 0x00000001ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPARSE_RESIDENCY_BIT_KHR = 0x00000002ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPARSE_ALIASED_BIT_KHR = 0x00000004ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_MUTABLE_FORMAT_BIT_KHR = 0x00000008ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_CUBE_COMPATIBLE_BIT_KHR = 0x00000010ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000040ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_EXTENDED_USAGE_BIT_KHR = 0x00000100ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_DISJOINT_BIT_KHR = 0x00000200ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_ALIAS_BIT_KHR = 0x00000400ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_PROTECTED_BIT_KHR = 0x00000800ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_CORNER_SAMPLED_BIT_NV = 0x00002000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_SUBSAMPLED_BIT_EXT = 0x00004000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000ull; +static const VkImageCreateFlagBits2KHR VK_IMAGE_CREATE_2_ALIAS_SINGLE_LAYER_DESCRIPTOR_BIT_KHR = 0x00400000ull; + typedef enum VkImageLayout { VK_IMAGE_LAYOUT_UNDEFINED = 0, @@ -4081,6 +4245,34 @@ typedef enum VkImageUsageFlagBits VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = VK_IMAGE_USAGE_HOST_TRANSFER_BIT, } VkImageUsageFlagBits; +typedef VkFlags64 VkImageUsageFlagBits2KHR; + +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_SAMPLED_BIT_KHR = 0x00000004ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_STORAGE_BIT_KHR = 0x00000008ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000010ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000020ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TRANSIENT_ATTACHMENT_BIT_KHR = 0x00000040ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_INPUT_ATTACHMENT_BIT_KHR = 0x00000080ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00000400ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x00040000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_HOST_TRANSFER_BIT_KHR = 0x00400000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TENSOR_ALIASING_BIT_ARM = 0x00800000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000ull; +static const VkImageUsageFlagBits2KHR VK_IMAGE_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ull; + typedef enum VkImageViewCreateFlagBits { VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, @@ -4394,6 +4586,7 @@ typedef enum VkObjectType VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_GPA_SESSION_AMD = 1000133000, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, @@ -4418,22 +4611,30 @@ typedef enum VkObjectType VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, } VkObjectType; -typedef enum VkOpacityMicromapFormatEXT +typedef enum VkOpacityMicromapFormatKHR { - VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, - VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, - VK_OPACITY_MICROMAP_FORMAT_EXT_MAX_ENUM = 0x7fffffff, -} VkOpacityMicromapFormatEXT; + VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR = 1, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR = 2, + VK_OPACITY_MICROMAP_FORMAT_KHR_MAX_ENUM = 0x7fffffff, + VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = VK_OPACITY_MICROMAP_FORMAT_2_STATE_KHR, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = VK_OPACITY_MICROMAP_FORMAT_4_STATE_KHR, +} VkOpacityMicromapFormatKHR; +typedef VkOpacityMicromapFormatKHR VkOpacityMicromapFormatEXT; -typedef enum VkOpacityMicromapSpecialIndexEXT +typedef enum VkOpacityMicromapSpecialIndexKHR { VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_EXT_MAX_ENUM = 0x7fffffff, -} VkOpacityMicromapSpecialIndexEXT; + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR = -4, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR = -3, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR = -2, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR = -1, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_KHR_MAX_ENUM = 0x7fffffff, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_KHR, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_KHR, +} VkOpacityMicromapSpecialIndexKHR; +typedef VkOpacityMicromapSpecialIndexKHR VkOpacityMicromapSpecialIndexEXT; typedef enum VkOpticalFlowExecuteFlagBitsNV { @@ -4733,7 +4934,7 @@ typedef enum VkPipelineCreateFlagBits VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000, VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000, VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000, - VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR = 0x01000000, VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT = 0x08000000, @@ -4748,6 +4949,7 @@ typedef enum VkPipelineCreateFlagBits VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, } VkPipelineCreateFlagBits; @@ -4787,6 +4989,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_S static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ull; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_KHR = 0x01000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT = 0x08000000ull; @@ -4803,6 +5006,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MIC static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INSTRUMENT_SHADERS_BIT_ARM = 0x8000000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ull; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_KHR = 0x20000000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT = 0x80000000000ull; typedef VkPipelineCreateFlagBits2 VkPipelineCreateFlagBits2KHR; @@ -5163,6 +5367,7 @@ typedef enum VkQueryType VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + VK_QUERY_TYPE_TIME_ELAPSED_QCOM = 1000173000, VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, @@ -5514,6 +5719,7 @@ typedef enum VkShaderCreateFlagBitsEXT VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT = 0x00000400, VK_SHADER_CREATE_INSTRUMENT_SHADER_BIT_ARM = 0x00000800, + VK_SHADER_CREATE_OPACITY_MICROMAP_DISALLOW_MIXED_SPECIAL_INDEX_BIT_EXT = 0x00001000, VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT = 0x00008000, VK_SHADER_CREATE_INDEPENDENT_SETS_BIT_KHR = 0x00040000, VK_SHADER_CREATE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, @@ -5908,6 +6114,13 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_FEATURES_AMD = 1000133000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_AMD = 1000133001, + VK_STRUCTURE_TYPE_GPA_SAMPLE_BEGIN_INFO_AMD = 1000133002, + VK_STRUCTURE_TYPE_GPA_SESSION_CREATE_INFO_AMD = 1000133003, + VK_STRUCTURE_TYPE_GPA_DEVICE_CLOCK_MODE_INFO_AMD = 1000133004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GPA_PROPERTIES_2_AMD = 1000133005, + VK_STRUCTURE_TYPE_GPA_DEVICE_GET_CLOCK_INFO_AMD = 1000133006, VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT = 1000135000, VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT = 1000135001, VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT = 1000135002, @@ -6011,6 +6224,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM = 1000172000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ELAPSED_TIMER_QUERY_FEATURES_QCOM = 1000173000, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO = 1000174000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, @@ -6211,6 +6425,11 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PERF_HINT_INFO_QCOM = 1000302000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM = 1000302001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM = 1000302002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_3_FEATURES_QCOM = 1000303000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_FEATURES_QCOM = 1000304000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MULTIPLE_WAIT_QUEUES_PROPERTIES_QCOM = 1000304001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_FEATURES_EXT = 1000305000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SPLIT_BARRIER_PROPERTIES_EXT = 1000305001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM = 1000309000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM = 1000309001, VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM = 1000309002, @@ -6673,6 +6892,9 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_FEEDBACK_2_FEATURES_KHR = 1000598000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_FEEDBACK_2_CAPABILITIES_KHR = 1000598001, + VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_CREATE_INFO_KHR = 1000598002, VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000, VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001, VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, @@ -6692,8 +6914,14 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002, VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SWAPCHAIN_FEATURES_EXT = 1000616000, + VK_STRUCTURE_TYPE_SWAPCHAIN_FLAGS_SURFACE_CAPABILITIES_EXT = 1000616001, VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_KHR = 1000623000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_KHR = 1000623001, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MICROMAP_DATA_KHR = 1000623002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_KHR = 1000623003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT = 1000628000, VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT = 1000628001, @@ -6722,6 +6950,13 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR = 1000657000, VK_STRUCTURE_TYPE_QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR = 1000657001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_4_KHR = 1000668000, + VK_STRUCTURE_TYPE_IMAGE_CREATE_FLAGS_2_CREATE_INFO_KHR = 1000668001, + VK_STRUCTURE_TYPE_IMAGE_USAGE_FLAGS_2_CREATE_INFO_KHR = 1000668002, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_2_CREATE_INFO_KHR = 1000668003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_FLAGS_FEATURES_KHR = 1000668004, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_2_CREATE_INFO_KHR = 1000668005, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_2_KHR = 1000668006, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE = 1000673000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC = 1000674000, VK_STRUCTURE_TYPE_THROTTLE_HINT_SUBMIT_INFO_SEC = 1000674001, @@ -6729,6 +6964,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM = 1000676001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM = 1000676002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT = 1000678000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_DECODE_VECTOR_FEATURES_NV = 1000689000, VK_STRUCTURE_TYPE_MAX_ENUM = 0x7fffffff, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, @@ -7077,6 +7313,7 @@ typedef enum VkSwapchainCreateFlagBitsKHR VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, + VK_SWAPCHAIN_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00000100, VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT = 0x00000200, VK_SWAPCHAIN_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, @@ -7378,6 +7615,13 @@ typedef enum VkVideoEncodeFeedbackFlagBitsKHR VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_FEEDBACK_AVERAGE_QUANTIZATION_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_FEEDBACK_MIN_QUANTIZATION_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_FEEDBACK_MAX_QUANTIZATION_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_FEEDBACK_INTRA_PIXELS_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_FEEDBACK_INTER_PIXELS_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_FEEDBACK_SKIPPED_PIXELS_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_FEEDBACK_PICTURE_PARTITION_COUNT_BIT_KHR = 0x00000200, VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeFeedbackFlagBitsKHR; @@ -7458,6 +7702,14 @@ typedef enum VkVideoEncodeIntraRefreshModeFlagBitsKHR VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeIntraRefreshModeFlagBitsKHR; +typedef enum VkVideoEncodePerPartitionFeedbackFlagBitsKHR +{ + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_STATUS_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_PER_PARTITION_FEEDBACK_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodePerPartitionFeedbackFlagBitsKHR; + typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, @@ -10154,6 +10406,24 @@ typedef struct VkFramebufferAttachmentImageInfo } VkFramebufferAttachmentImageInfo; typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR; +typedef struct VkGpaPerfBlockPropertiesAMD +{ + VkGpaPerfBlockAMD blockType; + VkGpaPerfBlockPropertiesFlagsAMD flags; + uint32_t instanceCount; + uint32_t maxEventID; + uint32_t maxGlobalOnlyCounters; + uint32_t maxGlobalSharedCounters; + uint32_t maxStreamingCounters; +} VkGpaPerfBlockPropertiesAMD; + +typedef struct VkGpaPerfCounterAMD +{ + VkGpaPerfBlockAMD blockType; + uint32_t blockInstance; + uint32_t eventID; +} VkGpaPerfCounterAMD; + typedef struct VkGraphicsShaderGroupCreateInfoNV { VkStructureType sType; @@ -10381,6 +10651,13 @@ typedef struct VkMicromapUsageEXT uint32_t format; } VkMicromapUsageEXT; +typedef struct VkMicromapUsageKHR +{ + uint32_t count; + uint32_t subdivisionLevel; + VkOpacityMicromapFormatKHR format; +} VkMicromapUsageKHR; + typedef struct VkMutableDescriptorTypeListEXT { uint32_t descriptorTypeCount; @@ -11191,6 +11468,18 @@ typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode; } VkAccelerationStructureGeometryLinearSweptSpheresDataNV; +typedef struct VkAccelerationStructureGeometryMicromapDataKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t usageCountsCount; + const VkMicromapUsageKHR *pUsageCounts; + const VkMicromapUsageKHR * const*ppUsageCounts; + VkDeviceAddress WINE_VK_ALIGN(8) data; + VkDeviceAddress WINE_VK_ALIGN(8) triangleArray; + VkDeviceSize WINE_VK_ALIGN(8) triangleArrayStride; +} VkAccelerationStructureGeometryMicromapDataKHR; + typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV { VkStructureType sType; @@ -11250,6 +11539,17 @@ typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT VkMicromapEXT WINE_VK_ALIGN(8) micromap; } VkAccelerationStructureTrianglesOpacityMicromapEXT; +typedef struct VkAccelerationStructureTrianglesOpacityMicromapKHR +{ + VkStructureType sType; + void *pNext; + VkIndexType indexType; + VkDeviceAddress WINE_VK_ALIGN(8) indexBuffer; + VkDeviceSize WINE_VK_ALIGN(8) indexStride; + uint32_t baseTriangle; + VkAccelerationStructureKHR WINE_VK_ALIGN(8) micromap; +} VkAccelerationStructureTrianglesOpacityMicromapKHR; + typedef struct VkAccelerationStructureVersionInfoKHR { VkStructureType sType; @@ -13286,6 +13586,15 @@ typedef struct VkFormatProperties3 } VkFormatProperties3; typedef VkFormatProperties3 VkFormatProperties3KHR; +typedef struct VkFormatProperties4KHR +{ + VkStructureType sType; + void *pNext; + VkFormatFeatureFlags4KHR WINE_VK_ALIGN(8) linearTilingFeatures; + VkFormatFeatureFlags4KHR WINE_VK_ALIGN(8) optimalTilingFeatures; + VkFormatFeatureFlags4KHR WINE_VK_ALIGN(8) bufferFeatures; +} VkFormatProperties4KHR; + typedef struct VkFragmentShadingRateAttachmentInfoKHR { VkStructureType sType; @@ -13427,6 +13736,52 @@ typedef struct VkGetLatencyMarkerInfoNV VkLatencyTimingsFrameReportNV *pTimings; } VkGetLatencyMarkerInfoNV; +typedef struct VkGpaDeviceClockModeInfoAMD +{ + VkStructureType sType; + const void *pNext; + VkGpaDeviceClockModeAMD clockMode; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; +} VkGpaDeviceClockModeInfoAMD; + +typedef struct VkGpaDeviceGetClockInfoAMD +{ + VkStructureType sType; + void *pNext; + float memoryClockRatioToPeak; + float engineClockRatioToPeak; + uint32_t memoryClockFrequency; + uint32_t engineClockFrequency; +} VkGpaDeviceGetClockInfoAMD; + +typedef struct VkGpaSampleBeginInfoAMD +{ + VkStructureType sType; + const void *pNext; + VkGpaSampleTypeAMD sampleType; + VkBool32 sampleInternalOperations; + VkBool32 cacheFlushOnCounterCollection; + VkBool32 sqShaderMaskEnable; + VkGpaSqShaderStageFlagsAMD sqShaderMask; + uint32_t perfCounterCount; + const VkGpaPerfCounterAMD *pPerfCounters; + uint32_t streamingPerfTraceSampleInterval; + VkDeviceSize WINE_VK_ALIGN(8) perfCounterDeviceMemoryLimit; + VkBool32 sqThreadTraceEnable; + VkBool32 sqThreadTraceSuppressInstructionTokens; + VkDeviceSize WINE_VK_ALIGN(8) sqThreadTraceDeviceMemoryLimit; + VkPipelineStageFlags timingPreSample; + VkPipelineStageFlags timingPostSample; +} VkGpaSampleBeginInfoAMD; + +typedef struct VkGpaSessionCreateInfoAMD +{ + VkStructureType sType; + const void *pNext; + VkGpaSessionAMD WINE_VK_ALIGN(8) secondaryCopySource; +} VkGpaSessionCreateInfoAMD; + typedef struct VkGraphicsPipelineCreateInfo { VkStructureType sType; @@ -13570,6 +13925,13 @@ typedef struct VkImageCopy VkExtent3D extent; } VkImageCopy; +typedef struct VkImageCreateFlags2CreateInfoKHR +{ + VkStructureType sType; + void *pNext; + VkImageCreateFlags2KHR WINE_VK_ALIGN(8) flags; +} VkImageCreateFlags2CreateInfoKHR; + typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { VkStructureType sType; @@ -13658,6 +14020,13 @@ typedef struct VkImageSparseMemoryRequirementsInfo2 } VkImageSparseMemoryRequirementsInfo2; typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; +typedef struct VkImageStencilUsage2CreateInfoKHR +{ + VkStructureType sType; + void *pNext; + VkImageUsageFlags2KHR WINE_VK_ALIGN(8) stencilUsage; +} VkImageStencilUsage2CreateInfoKHR; + typedef struct VkImageStencilUsageCreateInfo { VkStructureType sType; @@ -13673,6 +14042,13 @@ typedef struct VkImageSwapchainCreateInfoKHR VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; } VkImageSwapchainCreateInfoKHR; +typedef struct VkImageUsageFlags2CreateInfoKHR +{ + VkStructureType sType; + void *pNext; + VkImageUsageFlags2KHR WINE_VK_ALIGN(8) usage; +} VkImageUsageFlags2CreateInfoKHR; + typedef struct VkImageViewASTCDecodeModeEXT { VkStructureType sType; @@ -13728,6 +14104,13 @@ typedef struct VkImageViewSlicedCreateInfoEXT uint32_t sliceCount; } VkImageViewSlicedCreateInfoEXT; +typedef struct VkImageViewUsage2CreateInfoKHR +{ + VkStructureType sType; + void *pNext; + VkImageUsageFlags2KHR WINE_VK_ALIGN(8) usage; +} VkImageViewUsage2CreateInfoKHR; + typedef struct VkImageViewUsageCreateInfo { VkStructureType sType; @@ -14159,12 +14542,13 @@ typedef struct VkMicromapCreateInfoEXT VkDeviceAddress WINE_VK_ALIGN(8) deviceAddress; } VkMicromapCreateInfoEXT; -typedef struct VkMicromapTriangleEXT +typedef struct VkMicromapTriangleKHR { uint32_t dataOffset; uint16_t subdivisionLevel; uint16_t format; -} VkMicromapTriangleEXT; +} VkMicromapTriangleKHR; +typedef VkMicromapTriangleKHR VkMicromapTriangleEXT; typedef struct VkMicromapVersionInfoEXT { @@ -14730,6 +15114,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM VkBool32 cooperativeMatrixConversion; } VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM; +typedef struct VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV +{ + VkStructureType sType; + void *pNext; + VkBool32 cooperativeMatrixDecodeVector; +} VkPhysicalDeviceCooperativeMatrixDecodeVectorFeaturesNV; + typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR { VkStructureType sType; @@ -15237,6 +15628,13 @@ typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT VkBool32 dynamicRenderingUnusedAttachments; } VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; +typedef struct VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM +{ + VkStructureType sType; + void *pNext; + VkBool32 elapsedTimerQuery; +} VkPhysicalDeviceElapsedTimerQueryFeaturesQCOM; + typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { VkStructureType sType; @@ -15304,6 +15702,13 @@ typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT VkBool32 extendedDynamicState; } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; +typedef struct VkPhysicalDeviceExtendedFlagsFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 extendedFlags; +} VkPhysicalDeviceExtendedFlagsFeaturesKHR; + typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV { VkStructureType sType; @@ -15594,6 +15999,34 @@ typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures } VkPhysicalDeviceGlobalPriorityQueryFeatures; typedef VkPhysicalDeviceGlobalPriorityQueryFeatures VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; +typedef struct VkPhysicalDeviceGpaFeaturesAMD +{ + VkStructureType sType; + void *pNext; + VkBool32 perfCounters; + VkBool32 streamingPerfCounters; + VkBool32 sqThreadTracing; + VkBool32 clockModes; +} VkPhysicalDeviceGpaFeaturesAMD; + +typedef struct VkPhysicalDeviceGpaProperties2AMD +{ + VkStructureType sType; + void *pNext; + uint32_t revisionId; +} VkPhysicalDeviceGpaProperties2AMD; + +typedef struct VkPhysicalDeviceGpaPropertiesAMD +{ + VkStructureType sType; + void *pNext; + VkPhysicalDeviceGpaPropertiesFlagsAMD flags; + VkDeviceSize WINE_VK_ALIGN(8) maxSqttSeBufferSize; + uint32_t shaderEngineCount; + uint32_t perfBlockCount; + VkGpaPerfBlockPropertiesAMD *pPerfBlocks; +} VkPhysicalDeviceGpaPropertiesAMD; + typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { VkStructureType sType; @@ -15739,6 +16172,15 @@ typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM VkExtent2D maxBlockMatchWindow; } VkPhysicalDeviceImageProcessing2PropertiesQCOM; +typedef struct VkPhysicalDeviceImageProcessing3FeaturesQCOM +{ + VkStructureType sType; + void *pNext; + VkBool32 imageGatherLinear; + VkBool32 imageGatherExtendedModes; + VkBool32 blockMatchExtendedClampToEdge; +} VkPhysicalDeviceImageProcessing3FeaturesQCOM; + typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM { VkStructureType sType; @@ -16195,6 +16637,13 @@ typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT VkBool32 multisampledRenderToSingleSampled; } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; +typedef struct VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 multisampledRenderToSwapchain; +} VkPhysicalDeviceMultisampledRenderToSwapchainFeaturesEXT; + typedef struct VkPhysicalDeviceMultiviewFeatures { VkStructureType sType; @@ -16268,6 +16717,13 @@ typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT VkBool32 micromapHostCommands; } VkPhysicalDeviceOpacityMicromapFeaturesEXT; +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 micromap; +} VkPhysicalDeviceOpacityMicromapFeaturesKHR; + typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT { VkStructureType sType; @@ -16276,6 +16732,16 @@ typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT uint32_t maxOpacity4StateSubdivisionLevel; } VkPhysicalDeviceOpacityMicromapPropertiesEXT; +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; + uint32_t maxOpacityLossy4StateSubdivisionLevel; + uint64_t WINE_VK_ALIGN(8) maxMicromapTriangles; +} VkPhysicalDeviceOpacityMicromapPropertiesKHR; + typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV { VkStructureType sType; @@ -17230,6 +17696,20 @@ typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderMultipleWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesFeaturesQCOM; + +typedef struct VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM +{ + VkStructureType sType; + void *pNext; + uint32_t maxShaderWaitQueues; +} VkPhysicalDeviceShaderMultipleWaitQueuesPropertiesQCOM; + typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { VkStructureType sType; @@ -17281,6 +17761,20 @@ typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV uint32_t shaderWarpsPerSM; } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; +typedef struct VkPhysicalDeviceShaderSplitBarrierFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderSplitBarrier; +} VkPhysicalDeviceShaderSplitBarrierFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderSplitBarrierPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t splitBarrierReservedSharedMemory; +} VkPhysicalDeviceShaderSplitBarrierPropertiesEXT; + typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { VkStructureType sType; @@ -17708,6 +18202,13 @@ typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR VkBool32 videoEncodeAV1; } VkPhysicalDeviceVideoEncodeAV1FeaturesKHR; +typedef struct VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 videoEncodeFeedback2; +} VkPhysicalDeviceVideoEncodeFeedback2FeaturesKHR; + typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR { VkStructureType sType; @@ -18653,6 +19154,14 @@ typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; } VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; +typedef struct VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t maxPerPartitionFeedbackEntries; + VkVideoEncodePerPartitionFeedbackFlagsKHR perPartitionEncodeFeedbackFlags; +} VkQueryPoolVideoEncodePerPartitionFeedbackCreateInfoKHR; + typedef struct VkQueueFamilyCheckpointProperties2NV { VkStructureType sType; @@ -19338,6 +19847,13 @@ typedef struct VkShaderStatisticsInfoAMD uint32_t computeWorkGroupSize[3]; } VkShaderStatisticsInfoAMD; +typedef struct VkSharedPresentSurfaceCapabilities2KHR +{ + VkStructureType sType; + void *pNext; + VkImageUsageFlags2KHR WINE_VK_ALIGN(8) sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilities2KHR; + typedef struct VkSparseImageFormatProperties2 { VkStructureType sType; @@ -19539,6 +20055,13 @@ typedef struct VkSwapchainCreateInfoKHR VkSwapchainKHR WINE_VK_ALIGN(8) oldSwapchain; } VkSwapchainCreateInfoKHR; +typedef struct VkSwapchainFlagsSurfaceCapabilitiesEXT +{ + VkStructureType sType; + void *pNext; + VkSwapchainCreateFlagsKHR swapchainSupportedFlags; +} VkSwapchainFlagsSurfaceCapabilitiesEXT; + typedef struct VkSwapchainLatencyCreateInfoNV { VkStructureType sType; @@ -20090,6 +20613,14 @@ typedef struct VkVideoEncodeCapabilitiesKHR VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; } VkVideoEncodeCapabilitiesKHR; +typedef struct VkVideoEncodeFeedback2CapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t maxPerPartitionFeedbackEntries; + VkVideoEncodePerPartitionFeedbackFlagsKHR supportedPerPartitionEncodeFeedbackFlags; +} VkVideoEncodeFeedback2CapabilitiesKHR; + typedef struct VkVideoEncodeH264CapabilitiesKHR { VkStructureType sType; @@ -20599,6 +21130,8 @@ typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRendering2EXT)(VkCommandBuffer typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin); typedef void (VKAPI_PTR *PFN_vkCmdBeginCustomResolveEXT)(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT *pBeginCustomResolveInfo); typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCmdBeginGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD *pGpaSampleBeginInfo, uint32_t *pSampleID); +typedef VkResult (VKAPI_PTR *PFN_vkCmdBeginGpaSessionAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM *pPerTileBeginInfo); typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); @@ -20658,6 +21191,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions); typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo); typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyGpaSessionResultsAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions); typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo); typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo); @@ -20725,6 +21259,8 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBu typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo); typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdEndGpaSampleAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID); +typedef VkResult (VKAPI_PTR *PFN_vkCmdEndGpaSessionAMD)(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM *pPerTileEndInfo); typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); @@ -20937,6 +21473,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent); typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence); typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGpaSessionAMD)(VkDevice device, const VkGpaSessionCreateInfoAMD *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkGpaSessionAMD *pGpaSession); typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines); typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage); @@ -20999,6 +21536,7 @@ typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocatio typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator); typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator); typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator); +typedef void (VKAPI_PTR *PFN_vkDestroyGpaSessionAMD)(VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks *pAllocator); typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator); typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator); typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutEXT)(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks *pAllocator); @@ -21111,6 +21649,9 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, cons typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties); typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements); typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaDeviceClockInfoAMD)(VkDevice device, VkGpaDeviceGetClockInfoAMD *pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionResultsAMD)(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t *pSizeInBytes, void *pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetGpaSessionStatusAMD)(VkDevice device, VkGpaSessionAMD gpaSession); typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); @@ -21275,12 +21816,14 @@ typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandP typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences); +typedef VkResult (VKAPI_PTR *PFN_vkResetGpaSessionAMD)(VkDevice device, VkGpaSessionAMD gpaSession); typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo); typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo); typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetGpaDeviceClockModeAMD)(VkDevice device, VkGpaDeviceClockModeInfoAMD *pInfo); typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata); typedef void (VKAPI_PTR *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV *pLatencyMarkerInfo); typedef VkResult (VKAPI_PTR *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo); @@ -21343,6 +21886,8 @@ void VKAPI_CALL vkCmdBeginConditionalRendering2EXT(VkCommandBuffer commandBuffer void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin); void VKAPI_CALL vkCmdBeginCustomResolveEXT(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT *pBeginCustomResolveInfo); void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo); +VkResult VKAPI_CALL vkCmdBeginGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD *pGpaSampleBeginInfo, uint32_t *pSampleID); +VkResult VKAPI_CALL vkCmdBeginGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM *pPerTileBeginInfo); void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); @@ -21402,6 +21947,7 @@ void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyB void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions); void VKAPI_CALL vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo); void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo); +void VKAPI_CALL vkCmdCopyGpaSessionResultsAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions); void VKAPI_CALL vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo); void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo); @@ -21469,6 +22015,8 @@ void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t void VKAPI_CALL vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo); void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer); void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer); +void VKAPI_CALL vkCmdEndGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, uint32_t sampleID); +VkResult VKAPI_CALL vkCmdEndGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession); void VKAPI_CALL vkCmdEndPerTileExecutionQCOM(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM *pPerTileEndInfo); void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); @@ -21681,6 +22229,7 @@ VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDevi VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent); VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence); VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer); +VkResult VKAPI_CALL vkCreateGpaSessionAMD(VkDevice device, const VkGpaSessionCreateInfoAMD *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkGpaSessionAMD *pGpaSession); VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines); VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage); @@ -21743,6 +22292,7 @@ void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pA void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks *pAllocator); @@ -21855,6 +22405,9 @@ VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWi VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties); void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements); +VkResult VKAPI_CALL vkGetGpaDeviceClockInfoAMD(VkDevice device, VkGpaDeviceGetClockInfoAMD *pInfo); +VkResult VKAPI_CALL vkGetGpaSessionResultsAMD(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t *pSizeInBytes, void *pData); +VkResult VKAPI_CALL vkGetGpaSessionStatusAMD(VkDevice device, VkGpaSessionAMD gpaSession); VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties); void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements); void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); @@ -22019,12 +22572,14 @@ VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPoo VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event); VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences); +VkResult VKAPI_CALL vkResetGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession); void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo); VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo); void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority); VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event); +VkResult VKAPI_CALL vkSetGpaDeviceClockModeAMD(VkDevice device, VkGpaDeviceClockModeInfoAMD *pInfo); void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata); void VKAPI_CALL vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV *pLatencyMarkerInfo); VkResult VKAPI_CALL vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo); @@ -22088,6 +22643,8 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkCmdBeginConditionalRenderingEXT) \ USE_VK_FUNC(vkCmdBeginCustomResolveEXT) \ USE_VK_FUNC(vkCmdBeginDebugUtilsLabelEXT) \ + USE_VK_FUNC(vkCmdBeginGpaSampleAMD) \ + USE_VK_FUNC(vkCmdBeginGpaSessionAMD) \ USE_VK_FUNC(vkCmdBeginPerTileExecutionQCOM) \ USE_VK_FUNC(vkCmdBeginQuery) \ USE_VK_FUNC(vkCmdBeginQueryIndexedEXT) \ @@ -22147,6 +22704,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkCmdCopyBufferToImage) \ USE_VK_FUNC(vkCmdCopyBufferToImage2) \ USE_VK_FUNC(vkCmdCopyBufferToImage2KHR) \ + USE_VK_FUNC(vkCmdCopyGpaSessionResultsAMD) \ USE_VK_FUNC(vkCmdCopyImage) \ USE_VK_FUNC(vkCmdCopyImage2) \ USE_VK_FUNC(vkCmdCopyImage2KHR) \ @@ -22214,6 +22772,8 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkCmdEncodeVideoKHR) \ USE_VK_FUNC(vkCmdEndConditionalRenderingEXT) \ USE_VK_FUNC(vkCmdEndDebugUtilsLabelEXT) \ + USE_VK_FUNC(vkCmdEndGpaSampleAMD) \ + USE_VK_FUNC(vkCmdEndGpaSessionAMD) \ USE_VK_FUNC(vkCmdEndPerTileExecutionQCOM) \ USE_VK_FUNC(vkCmdEndQuery) \ USE_VK_FUNC(vkCmdEndQueryIndexedEXT) \ @@ -22423,6 +22983,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkCreateEvent) \ USE_VK_FUNC(vkCreateFence) \ USE_VK_FUNC(vkCreateFramebuffer) \ + USE_VK_FUNC(vkCreateGpaSessionAMD) \ USE_VK_FUNC(vkCreateGraphicsPipelines) \ USE_VK_FUNC(vkCreateImage) \ USE_VK_FUNC(vkCreateImageView) \ @@ -22475,6 +23036,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkDestroyEvent) \ USE_VK_FUNC(vkDestroyFence) \ USE_VK_FUNC(vkDestroyFramebuffer) \ + USE_VK_FUNC(vkDestroyGpaSessionAMD) \ USE_VK_FUNC(vkDestroyImage) \ USE_VK_FUNC(vkDestroyImageView) \ USE_VK_FUNC(vkDestroyIndirectCommandsLayoutEXT) \ @@ -22573,6 +23135,9 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkGetFramebufferTilePropertiesQCOM) \ USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsEXT) \ USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsNV) \ + USE_VK_FUNC(vkGetGpaDeviceClockInfoAMD) \ + USE_VK_FUNC(vkGetGpaSessionResultsAMD) \ + USE_VK_FUNC(vkGetGpaSessionStatusAMD) \ USE_VK_FUNC(vkGetImageDrmFormatModifierPropertiesEXT) \ USE_VK_FUNC(vkGetImageMemoryRequirements) \ USE_VK_FUNC(vkGetImageMemoryRequirements2) \ @@ -22677,12 +23242,14 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkResetDescriptorPool) \ USE_VK_FUNC(vkResetEvent) \ USE_VK_FUNC(vkResetFences) \ + USE_VK_FUNC(vkResetGpaSessionAMD) \ USE_VK_FUNC(vkResetQueryPool) \ USE_VK_FUNC(vkResetQueryPoolEXT) \ USE_VK_FUNC(vkSetDebugUtilsObjectNameEXT) \ USE_VK_FUNC(vkSetDebugUtilsObjectTagEXT) \ USE_VK_FUNC(vkSetDeviceMemoryPriorityEXT) \ USE_VK_FUNC(vkSetEvent) \ + USE_VK_FUNC(vkSetGpaDeviceClockModeAMD) \ USE_VK_FUNC(vkSetHdrMetadataEXT) \ USE_VK_FUNC(vkSetLatencyMarkerNV) \ USE_VK_FUNC(vkSetLatencySleepModeNV) \ @@ -22722,6 +23289,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_AMD_device_coherent_memory) \ USE_VK_EXT(VK_AMD_draw_indirect_count) \ USE_VK_EXT(VK_AMD_gcn_shader) \ + USE_VK_EXT(VK_AMD_gpa_interface) \ USE_VK_EXT(VK_AMD_gpu_shader_half_float) \ USE_VK_EXT(VK_AMD_gpu_shader_int16) \ USE_VK_EXT(VK_AMD_memory_overallocation_behavior) \ @@ -22816,6 +23384,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_EXT_mesh_shader) \ USE_VK_EXT(VK_EXT_multi_draw) \ USE_VK_EXT(VK_EXT_multisampled_render_to_single_sampled) \ + USE_VK_EXT(VK_EXT_multisampled_render_to_swapchain) \ USE_VK_EXT(VK_EXT_mutable_descriptor_type) \ USE_VK_EXT(VK_EXT_nested_command_buffer) \ USE_VK_EXT(VK_EXT_non_seamless_cube_map) \ @@ -22855,6 +23424,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_EXT_shader_module_identifier) \ USE_VK_EXT(VK_EXT_shader_object) \ USE_VK_EXT(VK_EXT_shader_replicated_composites) \ + USE_VK_EXT(VK_EXT_shader_split_barrier) \ USE_VK_EXT(VK_EXT_shader_stencil_export) \ USE_VK_EXT(VK_EXT_shader_subgroup_ballot) \ USE_VK_EXT(VK_EXT_shader_subgroup_partitioned) \ @@ -22912,6 +23482,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_KHR_driver_properties) \ USE_VK_EXT(VK_KHR_dynamic_rendering) \ USE_VK_EXT(VK_KHR_dynamic_rendering_local_read) \ + USE_VK_EXT(VK_KHR_extended_flags) \ USE_VK_EXT(VK_KHR_external_fence) \ USE_VK_EXT(VK_KHR_external_fence_win32) \ USE_VK_EXT(VK_KHR_external_memory) \ @@ -22943,6 +23514,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_KHR_maintenance9) \ USE_VK_EXT(VK_KHR_map_memory2) \ USE_VK_EXT(VK_KHR_multiview) \ + USE_VK_EXT(VK_KHR_opacity_micromap) \ USE_VK_EXT(VK_KHR_performance_query) \ USE_VK_EXT(VK_KHR_pipeline_binary) \ USE_VK_EXT(VK_KHR_pipeline_executable_properties) \ @@ -22999,6 +23571,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_KHR_video_decode_queue) \ USE_VK_EXT(VK_KHR_video_decode_vp9) \ USE_VK_EXT(VK_KHR_video_encode_av1) \ + USE_VK_EXT(VK_KHR_video_encode_feedback2) \ USE_VK_EXT(VK_KHR_video_encode_h264) \ USE_VK_EXT(VK_KHR_video_encode_intra_refresh) \ USE_VK_EXT(VK_KHR_video_encode_quantization_map) \ @@ -23020,6 +23593,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_NV_compute_shader_derivatives) \ USE_VK_EXT(VK_NV_cooperative_matrix) \ USE_VK_EXT(VK_NV_cooperative_matrix2) \ + USE_VK_EXT(VK_NV_cooperative_matrix_decode_vector) \ USE_VK_EXT(VK_NV_cooperative_vector) \ USE_VK_EXT(VK_NV_copy_memory_indirect) \ USE_VK_EXT(VK_NV_corner_sampled_image) \ @@ -23069,11 +23643,13 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_NV_viewport_swizzle) \ USE_VK_EXT(VK_QCOM_cooperative_matrix_conversion) \ USE_VK_EXT(VK_QCOM_data_graph_model) \ + USE_VK_EXT(VK_QCOM_elapsed_timer_query) \ USE_VK_EXT(VK_QCOM_filter_cubic_clamp) \ USE_VK_EXT(VK_QCOM_filter_cubic_weights) \ USE_VK_EXT(VK_QCOM_fragment_density_map_offset) \ USE_VK_EXT(VK_QCOM_image_processing) \ USE_VK_EXT(VK_QCOM_image_processing2) \ + USE_VK_EXT(VK_QCOM_image_processing3) \ USE_VK_EXT(VK_QCOM_multiview_per_view_render_areas) \ USE_VK_EXT(VK_QCOM_multiview_per_view_viewports) \ USE_VK_EXT(VK_QCOM_queue_perf_hint) \ @@ -23081,6 +23657,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_QCOM_render_pass_store_ops) \ USE_VK_EXT(VK_QCOM_render_pass_transform) \ USE_VK_EXT(VK_QCOM_rotated_copy_commands) \ + USE_VK_EXT(VK_QCOM_shader_multiple_wait_queues) \ USE_VK_EXT(VK_QCOM_tile_memory_heap) \ USE_VK_EXT(VK_QCOM_tile_properties) \ USE_VK_EXT(VK_QCOM_tile_shading) \ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/11100
participants (2)
-
Georg Lehmann -
Georg Lehmann (＠DadSchoorse)