[PATCH v2 0/1] MR6420: winevulkan: Update to VK spec version 1.3.295.
I have been putting this off for too long because handling VK_KHR_maintenance7 is not trivial. But by now a lot of other extensions have been released, so we should at least support those. -- v2: winevulkan: Update to VK spec version 1.3.295. https://gitlab.winehq.org/wine/wine/-/merge_requests/6420
From: Georg Lehmann <dadschoorse(a)gmail.com> I have been putting this off for too long because handling VK_KHR_maintenance7 is not trivial. But by now a lot of other extensions have been released, so we should at least support those. --- dlls/winevulkan/loader_thunks.c | 82 ++- dlls/winevulkan/loader_thunks.h | 56 +- dlls/winevulkan/make_vulkan | 3 +- dlls/winevulkan/vulkan_thunks.c | 981 +++++++++++++++++++++++++++++++- dlls/winevulkan/vulkan_thunks.h | 12 + dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 242 +++++++- 7 files changed, 1326 insertions(+), 52 deletions(-) diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 88007a7a2e5..5b6e3d9339c 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -94,6 +94,16 @@ VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pA return params.result; } +void WINAPI vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD *pData) +{ + struct vkAntiLagUpdateAMD_params params; + NTSTATUS status; + params.device = device; + params.pData = pData; + status = UNIX_CALL(vkAntiLagUpdateAMD, ¶ms); + assert(!status && "vkAntiLagUpdateAMD"); +} + VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { struct vkBeginCommandBuffer_params params; @@ -2178,11 +2188,11 @@ void WINAPI vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffe UNIX_CALL(vkCmdSetRenderingAttachmentLocationsKHR, ¶ms); } -void WINAPI vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *pLocationInfo) +void WINAPI vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *pInputAttachmentIndexInfo) { struct vkCmdSetRenderingInputAttachmentIndicesKHR_params params; params.commandBuffer = commandBuffer; - params.pLocationInfo = pLocationInfo; + params.pInputAttachmentIndexInfo = pInputAttachmentIndexInfo; UNIX_CALL(vkCmdSetRenderingInputAttachmentIndicesKHR, ¶ms); } @@ -3059,6 +3069,19 @@ VkResult WINAPI vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlo return params.result; } +VkResult WINAPI vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineBinaryHandlesInfoKHR *pBinaries) +{ + struct vkCreatePipelineBinariesKHR_params params; + NTSTATUS status; + params.device = device; + params.pCreateInfo = pCreateInfo; + params.pAllocator = pAllocator; + params.pBinaries = pBinaries; + status = UNIX_CALL(vkCreatePipelineBinariesKHR, ¶ms); + assert(!status && "vkCreatePipelineBinariesKHR"); + return params.result; +} + VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) { struct vkCreatePipelineCache_params params; @@ -3651,6 +3674,17 @@ void WINAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllo assert(!status && "vkDestroyPipeline"); } +void WINAPI vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks *pAllocator) +{ + struct vkDestroyPipelineBinaryKHR_params params; + NTSTATUS status; + params.device = device; + params.pipelineBinary = pipelineBinary; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkDestroyPipelineBinaryKHR, ¶ms); + assert(!status && "vkDestroyPipelineBinaryKHR"); +} + void WINAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) { struct vkDestroyPipelineCache_params params; @@ -5321,6 +5355,20 @@ VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice return params.result; } +VkResult WINAPI vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR *pInfo, VkPipelineBinaryKeyKHR *pPipelineBinaryKey, size_t *pPipelineBinaryDataSize, void *pPipelineBinaryData) +{ + struct vkGetPipelineBinaryDataKHR_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pPipelineBinaryKey = pPipelineBinaryKey; + params.pPipelineBinaryDataSize = pPipelineBinaryDataSize; + params.pPipelineBinaryData = pPipelineBinaryData; + status = UNIX_CALL(vkGetPipelineBinaryDataKHR, ¶ms); + assert(!status && "vkGetPipelineBinaryDataKHR"); + return params.result; +} + VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) { struct vkGetPipelineCacheData_params params; @@ -5395,6 +5443,18 @@ void WINAPI vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkC assert(!status && "vkGetPipelineIndirectMemoryRequirementsNV"); } +VkResult WINAPI vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR *pPipelineCreateInfo, VkPipelineBinaryKeyKHR *pPipelineKey) +{ + struct vkGetPipelineKeyKHR_params params; + NTSTATUS status; + params.device = device; + params.pPipelineCreateInfo = pPipelineCreateInfo; + params.pPipelineKey = pPipelineKey; + status = UNIX_CALL(vkGetPipelineKeyKHR, ¶ms); + assert(!status && "vkGetPipelineKeyKHR"); + return params.result; +} + VkResult WINAPI vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties) { struct vkGetPipelinePropertiesEXT_params params; @@ -5888,6 +5948,18 @@ VkResult WINAPI vkQueueWaitIdle(VkQueue queue) return params.result; } +VkResult WINAPI vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR *pInfo, const VkAllocationCallbacks *pAllocator) +{ + struct vkReleaseCapturedPipelineDataKHR_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkReleaseCapturedPipelineDataKHR, ¶ms); + assert(!status && "vkReleaseCapturedPipelineDataKHR"); + return params.result; +} + VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) { struct vkReleasePerformanceConfigurationINTEL_params params; @@ -6343,6 +6415,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkAllocateCommandBuffers", vkAllocateCommandBuffers}, {"vkAllocateDescriptorSets", vkAllocateDescriptorSets}, {"vkAllocateMemory", vkAllocateMemory}, + {"vkAntiLagUpdateAMD", vkAntiLagUpdateAMD}, {"vkBeginCommandBuffer", vkBeginCommandBuffer}, {"vkBindAccelerationStructureMemoryNV", vkBindAccelerationStructureMemoryNV}, {"vkBindBufferMemory", vkBindBufferMemory}, @@ -6638,6 +6711,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateIndirectCommandsLayoutNV", vkCreateIndirectCommandsLayoutNV}, {"vkCreateMicromapEXT", vkCreateMicromapEXT}, {"vkCreateOpticalFlowSessionNV", vkCreateOpticalFlowSessionNV}, + {"vkCreatePipelineBinariesKHR", vkCreatePipelineBinariesKHR}, {"vkCreatePipelineCache", vkCreatePipelineCache}, {"vkCreatePipelineLayout", vkCreatePipelineLayout}, {"vkCreatePrivateDataSlot", vkCreatePrivateDataSlot}, @@ -6685,6 +6759,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyMicromapEXT", vkDestroyMicromapEXT}, {"vkDestroyOpticalFlowSessionNV", vkDestroyOpticalFlowSessionNV}, {"vkDestroyPipeline", vkDestroyPipeline}, + {"vkDestroyPipelineBinaryKHR", vkDestroyPipelineBinaryKHR}, {"vkDestroyPipelineCache", vkDestroyPipelineCache}, {"vkDestroyPipelineLayout", vkDestroyPipelineLayout}, {"vkDestroyPrivateDataSlot", vkDestroyPrivateDataSlot}, @@ -6777,12 +6852,14 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetMemoryHostPointerPropertiesEXT", vkGetMemoryHostPointerPropertiesEXT}, {"vkGetMicromapBuildSizesEXT", vkGetMicromapBuildSizesEXT}, {"vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL}, + {"vkGetPipelineBinaryDataKHR", vkGetPipelineBinaryDataKHR}, {"vkGetPipelineCacheData", vkGetPipelineCacheData}, {"vkGetPipelineExecutableInternalRepresentationsKHR", vkGetPipelineExecutableInternalRepresentationsKHR}, {"vkGetPipelineExecutablePropertiesKHR", vkGetPipelineExecutablePropertiesKHR}, {"vkGetPipelineExecutableStatisticsKHR", vkGetPipelineExecutableStatisticsKHR}, {"vkGetPipelineIndirectDeviceAddressNV", vkGetPipelineIndirectDeviceAddressNV}, {"vkGetPipelineIndirectMemoryRequirementsNV", vkGetPipelineIndirectMemoryRequirementsNV}, + {"vkGetPipelineKeyKHR", vkGetPipelineKeyKHR}, {"vkGetPipelinePropertiesEXT", vkGetPipelinePropertiesEXT}, {"vkGetPrivateData", vkGetPrivateData}, {"vkGetPrivateDataEXT", vkGetPrivateDataEXT}, @@ -6823,6 +6900,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkQueueSubmit2", vkQueueSubmit2}, {"vkQueueSubmit2KHR", vkQueueSubmit2KHR}, {"vkQueueWaitIdle", vkQueueWaitIdle}, + {"vkReleaseCapturedPipelineDataKHR", vkReleaseCapturedPipelineDataKHR}, {"vkReleasePerformanceConfigurationINTEL", vkReleasePerformanceConfigurationINTEL}, {"vkReleaseProfilingLockKHR", vkReleaseProfilingLockKHR}, {"vkReleaseSwapchainImagesEXT", vkReleaseSwapchainImagesEXT}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index 7a981cadda9..bf175374b5d 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -30,6 +30,7 @@ enum unix_call unix_vkAllocateCommandBuffers, unix_vkAllocateDescriptorSets, unix_vkAllocateMemory, + unix_vkAntiLagUpdateAMD, unix_vkBeginCommandBuffer, unix_vkBindAccelerationStructureMemoryNV, unix_vkBindBufferMemory, @@ -329,6 +330,7 @@ enum unix_call unix_vkCreateInstance, unix_vkCreateMicromapEXT, unix_vkCreateOpticalFlowSessionNV, + unix_vkCreatePipelineBinariesKHR, unix_vkCreatePipelineCache, unix_vkCreatePipelineLayout, unix_vkCreatePrivateDataSlot, @@ -381,6 +383,7 @@ enum unix_call unix_vkDestroyMicromapEXT, unix_vkDestroyOpticalFlowSessionNV, unix_vkDestroyPipeline, + unix_vkDestroyPipelineBinaryKHR, unix_vkDestroyPipelineCache, unix_vkDestroyPipelineLayout, unix_vkDestroyPrivateDataSlot, @@ -530,12 +533,14 @@ enum unix_call unix_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, unix_vkGetPhysicalDeviceVideoFormatPropertiesKHR, unix_vkGetPhysicalDeviceWin32PresentationSupportKHR, + unix_vkGetPipelineBinaryDataKHR, unix_vkGetPipelineCacheData, unix_vkGetPipelineExecutableInternalRepresentationsKHR, unix_vkGetPipelineExecutablePropertiesKHR, unix_vkGetPipelineExecutableStatisticsKHR, unix_vkGetPipelineIndirectDeviceAddressNV, unix_vkGetPipelineIndirectMemoryRequirementsNV, + unix_vkGetPipelineKeyKHR, unix_vkGetPipelinePropertiesEXT, unix_vkGetPrivateData, unix_vkGetPrivateDataEXT, @@ -576,6 +581,7 @@ enum unix_call unix_vkQueueSubmit2, unix_vkQueueSubmit2KHR, unix_vkQueueWaitIdle, + unix_vkReleaseCapturedPipelineDataKHR, unix_vkReleasePerformanceConfigurationINTEL, unix_vkReleaseProfilingLockKHR, unix_vkReleaseSwapchainImagesEXT, @@ -676,6 +682,12 @@ struct vkAllocateMemory_params VkResult result; }; +struct vkAntiLagUpdateAMD_params +{ + VkDevice device; + const VkAntiLagDataAMD *pData; +}; + struct vkBeginCommandBuffer_params { VkCommandBuffer commandBuffer; @@ -2297,7 +2309,7 @@ struct vkCmdSetRenderingAttachmentLocationsKHR_params struct vkCmdSetRenderingInputAttachmentIndicesKHR_params { VkCommandBuffer commandBuffer; - const VkRenderingInputAttachmentIndexInfoKHR *pLocationInfo; + const VkRenderingInputAttachmentIndexInfoKHR *pInputAttachmentIndexInfo; }; struct vkCmdSetRepresentativeFragmentTestEnableNV_params @@ -2978,6 +2990,15 @@ struct vkCreateOpticalFlowSessionNV_params VkResult result; }; +struct vkCreatePipelineBinariesKHR_params +{ + VkDevice device; + const VkPipelineBinaryCreateInfoKHR *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkPipelineBinaryHandlesInfoKHR *pBinaries; + VkResult result; +}; + struct vkCreatePipelineCache_params { VkDevice device; @@ -3393,6 +3414,13 @@ struct vkDestroyPipeline_params const VkAllocationCallbacks *pAllocator; }; +struct vkDestroyPipelineBinaryKHR_params +{ + VkDevice device; + VkPipelineBinaryKHR DECLSPEC_ALIGN(8) pipelineBinary; + const VkAllocationCallbacks *pAllocator; +}; + struct vkDestroyPipelineCache_params { VkDevice device; @@ -4523,6 +4551,16 @@ struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params VkBool32 result; }; +struct vkGetPipelineBinaryDataKHR_params +{ + VkDevice device; + const VkPipelineBinaryDataInfoKHR *pInfo; + VkPipelineBinaryKeyKHR *pPipelineBinaryKey; + size_t *pPipelineBinaryDataSize; + void *pPipelineBinaryData; + VkResult result; +}; + struct vkGetPipelineCacheData_params { VkDevice device; @@ -4573,6 +4611,14 @@ struct vkGetPipelineIndirectMemoryRequirementsNV_params VkMemoryRequirements2 *pMemoryRequirements; }; +struct vkGetPipelineKeyKHR_params +{ + VkDevice device; + const VkPipelineCreateInfoKHR *pPipelineCreateInfo; + VkPipelineBinaryKeyKHR *pPipelineKey; + VkResult result; +}; + struct vkGetPipelinePropertiesEXT_params { VkDevice device; @@ -4906,6 +4952,14 @@ struct vkQueueWaitIdle_params VkResult result; }; +struct vkReleaseCapturedPipelineDataKHR_params +{ + VkDevice device; + const VkReleaseCapturedPipelineDataInfoKHR *pInfo; + const VkAllocationCallbacks *pAllocator; + VkResult result; +}; + struct vkReleasePerformanceConfigurationINTEL_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index babbcb2ef3f..7d0795f1f06 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -64,7 +64,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler()) -VK_XML_VERSION = "1.3.285" +VK_XML_VERSION = "1.3.295" WINE_VK_VERSION = (1, 3) # Filenames to create. @@ -100,6 +100,7 @@ UNSUPPORTED_EXTENSIONS = [ "VK_KHR_external_fence_win32", "VK_KHR_external_semaphore_win32", # Relates to external_semaphore and needs type conversions in bitflags. + "VK_KHR_maintenance7", # Causes infinity recursion in struct convert code "VK_KHR_shared_presentable_image", # Needs WSI work. "VK_KHR_win32_keyed_mutex", "VK_NV_external_memory_rdma", # Needs shared resources work. diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 5ffe97ef422..76bc26b53fd 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -163,6 +163,23 @@ typedef struct VkMemoryAllocateInfo32 uint32_t memoryTypeIndex; } VkMemoryAllocateInfo32; +typedef struct VkAntiLagPresentationInfoAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkAntiLagStageAMD stage; + uint64_t DECLSPEC_ALIGN(8) frameIndex; +} VkAntiLagPresentationInfoAMD32; + +typedef struct VkAntiLagDataAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkAntiLagModeAMD mode; + uint32_t maxFPS; + PTR32 pPresentationInfo; +} VkAntiLagDataAMD32; + typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32 { VkStructureType sType; @@ -2049,6 +2066,14 @@ typedef struct VkPipelineCreateFlags2CreateInfoKHR32 VkPipelineCreateFlags2KHR DECLSPEC_ALIGN(8) flags; } VkPipelineCreateFlags2CreateInfoKHR32; +typedef struct VkPipelineBinaryInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t binaryCount; + PTR32 pPipelineBinaries; +} VkPipelineBinaryInfoKHR32; + typedef struct VkPipelineCreationFeedbackCreateInfo32 { VkStructureType sType; @@ -2599,13 +2624,14 @@ typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32 VkBool32 cornerSampledImage; } VkPhysicalDeviceCornerSampledImageFeaturesNV32; -typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 { VkStructureType sType; PTR32 pNext; VkBool32 computeDerivativeGroupQuads; VkBool32 computeDerivativeGroupLinear; -} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32; +typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32; typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32 { @@ -3292,6 +3318,13 @@ typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 VkBool32 vertexInputDynamicState; } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32; +typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderRelaxedExtendedInstruction; +} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32; + typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32 { VkStructureType sType; @@ -3460,6 +3493,20 @@ typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 VkBool32 graphicsPipelineLibrary; } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32; +typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 pipelineBinaries; +} VkPhysicalDevicePipelineBinaryFeaturesKHR32; + +typedef struct VkDevicePipelineBinaryInternalCacheControlKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 disableInternalCache; +} VkDevicePipelineBinaryInternalCacheControlKHR32; + typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 { VkStructureType sType; @@ -3697,6 +3744,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 VkBool32 cooperativeMatrixRobustBufferAccess; } VkPhysicalDeviceCooperativeMatrixFeaturesKHR32; +typedef struct VkPhysicalDeviceAntiLagFeaturesAMD32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 antiLag; +} VkPhysicalDeviceAntiLagFeaturesAMD32; + typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM32 { VkStructureType sType; @@ -3834,6 +3888,13 @@ typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV32 VkBool32 shaderRawAccessChains; } VkPhysicalDeviceRawAccessChainsFeaturesNV32; +typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 commandBufferInheritance; +} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32; + typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 { VkStructureType sType; @@ -3841,6 +3902,13 @@ typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 VkBool32 imageAlignmentControl; } VkPhysicalDeviceImageAlignmentControlFeaturesMESA32; +typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderReplicatedComposites; +} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32; + typedef struct VkDeviceCreateInfo32 { VkStructureType sType; @@ -4559,6 +4627,50 @@ typedef struct VkOpticalFlowSessionCreateInfoNV32 VkOpticalFlowSessionCreateFlagsNV flags; } VkOpticalFlowSessionCreateInfoNV32; +typedef struct VkPipelineBinaryKeyKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t keySize; + uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]; +} VkPipelineBinaryKeyKHR32; + +typedef struct VkPipelineBinaryDataKHR32 +{ + PTR32 dataSize; + PTR32 pData; +} VkPipelineBinaryDataKHR32; + +typedef struct VkPipelineBinaryKeysAndDataKHR32 +{ + uint32_t binaryCount; + PTR32 pPipelineBinaryKeys; + PTR32 pPipelineBinaryData; +} VkPipelineBinaryKeysAndDataKHR32; + +typedef struct VkPipelineCreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; +} VkPipelineCreateInfoKHR32; + +typedef struct VkPipelineBinaryCreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pKeysAndDataInfo; + VkPipeline DECLSPEC_ALIGN(8) pipeline; + PTR32 pPipelineCreateInfo; +} VkPipelineBinaryCreateInfoKHR32; + +typedef struct VkPipelineBinaryHandlesInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t pipelineBinaryCount; + PTR32 pPipelineBinaries; +} VkPipelineBinaryHandlesInfoKHR32; + typedef struct VkPipelineCacheCreateInfo32 { VkStructureType sType; @@ -6687,6 +6799,13 @@ typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32 VkBool32 transformFeedbackDraw; } VkPhysicalDeviceTransformFeedbackPropertiesEXT32; +typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 meshAndTaskShaderDerivatives; +} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32; + typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 { VkStructureType sType; @@ -7200,6 +7319,17 @@ typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 VkBool32 triStripVertexOrderIndependentOfProvokingVertex; } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32; +typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 pipelineBinaryInternalCache; + VkBool32 pipelineBinaryInternalCacheControl; + VkBool32 pipelineBinaryPrefersInternalCache; + VkBool32 pipelineBinaryPrecompiledInternalCache; + VkBool32 pipelineBinaryCompressedData; +} VkPhysicalDevicePipelineBinaryPropertiesKHR32; + typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 { VkStructureType sType; @@ -7695,6 +7825,13 @@ typedef struct VkVideoFormatPropertiesKHR32 VkImageUsageFlags imageUsageFlags; } VkVideoFormatPropertiesKHR32; +typedef struct VkPipelineBinaryDataInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipelineBinaryKHR DECLSPEC_ALIGN(8) pipelineBinary; +} VkPipelineBinaryDataInfoKHR32; + typedef struct VkPipelineExecutableInfoKHR32 { VkStructureType sType; @@ -8087,6 +8224,13 @@ typedef struct VkSubmitInfo232 } VkSubmitInfo232; typedef VkSubmitInfo232 VkSubmitInfo2KHR32; +typedef struct VkReleaseCapturedPipelineDataInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipeline DECLSPEC_ALIGN(8) pipeline; +} VkReleaseCapturedPipelineDataInfoKHR32; + typedef struct VkReleaseSwapchainImagesInfoEXT32 { VkStructureType sType; @@ -8488,6 +8632,47 @@ static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_ } } +static inline void convert_VkAntiLagPresentationInfoAMD_win32_to_host(const VkAntiLagPresentationInfoAMD32 *in, VkAntiLagPresentationInfoAMD *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->stage = in->stage; + out->frameIndex = in->frameIndex; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkAntiLagPresentationInfoAMD *convert_VkAntiLagPresentationInfoAMD_array_win32_to_host(struct conversion_context *ctx, const VkAntiLagPresentationInfoAMD32 *in, uint32_t count) +{ + VkAntiLagPresentationInfoAMD *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkAntiLagPresentationInfoAMD_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkAntiLagDataAMD_win32_to_host(struct conversion_context *ctx, const VkAntiLagDataAMD32 *in, VkAntiLagDataAMD *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->mode = in->mode; + out->maxFPS = in->maxFPS; + out->pPresentationInfo = convert_VkAntiLagPresentationInfoAMD_array_win32_to_host(ctx, (const VkAntiLagPresentationInfoAMD32 *)UlongToPtr(in->pPresentationInfo), 1); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out) { const VkBaseInStructure32 *in_header; @@ -13114,6 +13299,18 @@ static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + { + VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineBinaryInfoKHR32 *in_ext = (const VkPipelineBinaryInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + out_ext->pNext = NULL; + out_ext->binaryCount = in_ext->binaryCount; + out_ext->pPipelineBinaries = UlongToPtr(in_ext->pPipelineBinaries); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: { VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14130,11 +14327,11 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; out_ext->pNext = NULL; out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; @@ -15107,6 +15304,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + { + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15358,6 +15566,28 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + { + VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + { + VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDevicePipelineBinaryInternalCacheControlKHR *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; + out_ext->pNext = NULL; + out_ext->disableInternalCache = in_ext->disableInternalCache; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15723,6 +15953,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + { + VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + out_ext->pNext = NULL; + out_ext->antiLag = in_ext->antiLag; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15947,6 +16188,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + { + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15958,6 +16210,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + { + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -16468,11 +16731,11 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; out_ext->pNext = NULL; out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; @@ -17445,6 +17708,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + { + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -17696,6 +17970,28 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + { + VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + { + VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDevicePipelineBinaryInternalCacheControlKHR32 *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; + out_ext->pNext = NULL; + out_ext->disableInternalCache = in_ext->disableInternalCache; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -18061,6 +18357,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + { + VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + out_ext->pNext = NULL; + out_ext->antiLag = in_ext->antiLag; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -18285,6 +18592,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + { + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -18296,6 +18614,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + { + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -19171,6 +19500,18 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + { + VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + out_ext->pNext = NULL; + out_ext->binaryCount = in_ext->binaryCount; + out_ext->pPipelineBinaries = in_ext->pPipelineBinaries; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: { VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -19412,6 +19753,18 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + { + VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineBinaryInfoKHR32 *in_ext = (const VkPipelineBinaryInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + out_ext->pNext = NULL; + out_ext->binaryCount = in_ext->binaryCount; + out_ext->pPipelineBinaries = UlongToPtr(in_ext->pPipelineBinaries); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: { VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20453,6 +20806,142 @@ static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct } } +static inline void convert_VkPipelineBinaryKeyKHR_win32_to_host(const VkPipelineBinaryKeyKHR32 *in, VkPipelineBinaryKeyKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->keySize = in->keySize; + memcpy(out->key, in->key, VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * sizeof(uint8_t)); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkPipelineBinaryKeyKHR *convert_VkPipelineBinaryKeyKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeyKHR32 *in, uint32_t count) +{ + VkPipelineBinaryKeyKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineBinaryKeyKHR_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkPipelineBinaryDataKHR_win32_to_host(const VkPipelineBinaryDataKHR32 *in, VkPipelineBinaryDataKHR *out) +{ + if (!in) return; + + out->dataSize = in->dataSize; + out->pData = UlongToPtr(in->pData); +} + +static inline const VkPipelineBinaryDataKHR *convert_VkPipelineBinaryDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryDataKHR32 *in, uint32_t count) +{ + VkPipelineBinaryDataKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineBinaryDataKHR_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, VkPipelineBinaryKeysAndDataKHR *out) +{ + if (!in) return; + + out->binaryCount = in->binaryCount; + out->pPipelineBinaryKeys = convert_VkPipelineBinaryKeyKHR_array_win32_to_host(ctx, (const VkPipelineBinaryKeyKHR32 *)UlongToPtr(in->pPipelineBinaryKeys), in->binaryCount); + out->pPipelineBinaryData = convert_VkPipelineBinaryDataKHR_array_win32_to_host(ctx, (const VkPipelineBinaryDataKHR32 *)UlongToPtr(in->pPipelineBinaryData), in->binaryCount); +} + +static inline const VkPipelineBinaryKeysAndDataKHR *convert_VkPipelineBinaryKeysAndDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, uint32_t count) +{ + VkPipelineBinaryKeysAndDataKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkPipelineCreateInfoKHR_win32_to_host(const VkPipelineCreateInfoKHR32 *in, VkPipelineCreateInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkPipelineCreateInfoKHR *convert_VkPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreateInfoKHR32 *in, uint32_t count) +{ + VkPipelineCreateInfoKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineCreateInfoKHR_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryCreateInfoKHR32 *in, VkPipelineBinaryCreateInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pKeysAndDataInfo = convert_VkPipelineBinaryKeysAndDataKHR_array_win32_to_host(ctx, (const VkPipelineBinaryKeysAndDataKHR32 *)UlongToPtr(in->pKeysAndDataInfo), 1); + out->pipeline = in->pipeline; + out->pPipelineCreateInfo = convert_VkPipelineCreateInfoKHR_array_win32_to_host(ctx, (const VkPipelineCreateInfoKHR32 *)UlongToPtr(in->pPipelineCreateInfo), 1); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host(const VkPipelineBinaryHandlesInfoKHR32 *in, VkPipelineBinaryHandlesInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pipelineBinaryCount = in->pipelineBinaryCount; + out->pPipelineBinaries = UlongToPtr(in->pPipelineBinaries); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(const VkPipelineBinaryHandlesInfoKHR *in, VkPipelineBinaryHandlesInfoKHR32 *out) +{ + if (!in) return; + + out->pipelineBinaryCount = in->pipelineBinaryCount; + out->pPipelineBinaries = PtrToUlong(in->pPipelineBinaries); +} + static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out) { if (!in) return; @@ -20794,6 +21283,18 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struc out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + { + VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineBinaryInfoKHR32 *in_ext = (const VkPipelineBinaryInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + out_ext->pNext = NULL; + out_ext->binaryCount = in_ext->binaryCount; + out_ext->pPipelineBinaries = UlongToPtr(in_ext->pPipelineBinaries); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: { VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -21748,6 +22249,20 @@ static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct convers { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + { + VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount; + out_ext->pEnabledValidationFeatures = UlongToPtr(in_ext->pEnabledValidationFeatures); + out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount; + out_ext->pDisabledValidationFeatures = UlongToPtr(in_ext->pDisabledValidationFeatures); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: { VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -21792,6 +22307,20 @@ static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + { + VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount; + out_ext->pEnabledValidationFeatures = UlongToPtr(in_ext->pEnabledValidationFeatures); + out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount; + out_ext->pDisabledValidationFeatures = UlongToPtr(in_ext->pDisabledValidationFeatures); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: { VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24929,11 +25458,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; out_ext->pNext = NULL; out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; @@ -25873,6 +26402,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + { + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26124,6 +26664,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + { + VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26489,6 +27040,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + { + VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + out_ext->pNext = NULL; + out_ext->antiLag = in_ext->antiLag; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26702,6 +27264,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + { + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26713,6 +27286,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + { + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -27107,11 +27691,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; out_header = (void *)out_ext; @@ -27907,6 +28491,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + { + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT); @@ -28114,6 +28707,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + { + VkPhysicalDevicePipelineBinaryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR); + const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE); @@ -28415,6 +29017,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + { + VkPhysicalDeviceAntiLagFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD); + const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + out_ext->antiLag = in_ext->antiLag; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { VkPhysicalDeviceCubicClampFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM); @@ -28590,6 +29201,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + { + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA); @@ -28599,6 +29219,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + { + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + out_header = (void *)out_ext; + break; + } default: break; } @@ -29571,6 +30200,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: + { + VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: { VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -29890,6 +30528,21 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + { + VkPhysicalDevicePipelineBinaryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineBinaryPropertiesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryPropertiesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_ext->pipelineBinaryInternalCache = in_ext->pipelineBinaryInternalCache; + out_ext->pipelineBinaryInternalCacheControl = in_ext->pipelineBinaryInternalCacheControl; + out_ext->pipelineBinaryPrefersInternalCache = in_ext->pipelineBinaryPrefersInternalCache; + out_ext->pipelineBinaryPrecompiledInternalCache = in_ext->pipelineBinaryPrecompiledInternalCache; + out_ext->pipelineBinaryCompressedData = in_ext->pipelineBinaryCompressedData; + 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)); @@ -30495,6 +31148,15 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: + { + VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR); + const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; + out_ext->meshAndTaskShaderDerivatives = in_ext->meshAndTaskShaderDerivatives; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: { VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV); @@ -31072,6 +31734,19 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + { + VkPhysicalDevicePipelineBinaryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR); + const VkPhysicalDevicePipelineBinaryPropertiesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; + out_ext->pipelineBinaryInternalCache = in_ext->pipelineBinaryInternalCache; + out_ext->pipelineBinaryInternalCacheControl = in_ext->pipelineBinaryInternalCacheControl; + out_ext->pipelineBinaryPrefersInternalCache = in_ext->pipelineBinaryPrefersInternalCache; + out_ext->pipelineBinaryPrecompiledInternalCache = in_ext->pipelineBinaryPrecompiledInternalCache; + out_ext->pipelineBinaryCompressedData = in_ext->pipelineBinaryCompressedData; + 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); @@ -31635,14 +32310,8 @@ static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conver case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: { VkSurfacePresentScalingCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSurfacePresentScalingCapabilitiesEXT32 *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT32 *)in_header; out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; out_ext->pNext = NULL; - out_ext->supportedPresentScaling = in_ext->supportedPresentScaling; - out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX; - out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY; - out_ext->minScaledImageExtent = in_ext->minScaledImageExtent; - out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -32271,6 +32940,25 @@ static inline void convert_VkVideoFormatPropertiesKHR_array_host_to_win32(const } } +static inline void convert_VkPipelineBinaryDataInfoKHR_win32_to_host(const VkPipelineBinaryDataInfoKHR32 *in, VkPipelineBinaryDataInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pipelineBinary = in->pipelineBinary; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkPipelineBinaryKeyKHR_host_to_win32(const VkPipelineBinaryKeyKHR *in, VkPipelineBinaryKeyKHR32 *out) +{ + if (!in) return; + + out->keySize = in->keySize; + memcpy(out->key, in->key, VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * sizeof(uint8_t)); +} + static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out) { if (!in) return; @@ -33661,6 +34349,17 @@ static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(str return out; } +static inline void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(const VkReleaseCapturedPipelineDataInfoKHR32 *in, VkReleaseCapturedPipelineDataInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pipeline = in->pipeline; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + #ifdef _WIN64 static inline void convert_VkReleaseSwapchainImagesInfoEXT_win64_to_host(const VkReleaseSwapchainImagesInfoEXT *in, VkReleaseSwapchainImagesInfoEXT *out) { @@ -34359,6 +35058,38 @@ static NTSTATUS thunk32_vkAllocateMemory(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkAntiLagUpdateAMD(void *args) +{ + struct vkAntiLagUpdateAMD_params *params = args; + + TRACE("%p, %p\n", params->device, params->pData); + + wine_device_from_handle(params->device)->funcs.p_vkAntiLagUpdateAMD(wine_device_from_handle(params->device)->host_device, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkAntiLagUpdateAMD(void *args) +{ + struct + { + PTR32 device; + PTR32 pData; + } *params = args; + VkAntiLagDataAMD pData_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x\n", params->device, params->pData); + + init_conversion_context(ctx); + convert_VkAntiLagDataAMD_win32_to_host(ctx, (const VkAntiLagDataAMD32 *)UlongToPtr(params->pData), &pData_host); + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAntiLagUpdateAMD(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pData_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkBeginCommandBuffer(void *args) { @@ -39591,7 +40322,7 @@ static void thunk64_vkCmdSetRenderingInputAttachmentIndicesKHR(void *args) { struct vkCmdSetRenderingInputAttachmentIndicesKHR_params *params = args; - wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRenderingInputAttachmentIndicesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pLocationInfo); + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRenderingInputAttachmentIndicesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pInputAttachmentIndexInfo); } #endif /* _WIN64 */ @@ -39600,12 +40331,12 @@ static void thunk32_vkCmdSetRenderingInputAttachmentIndicesKHR(void *args) struct { PTR32 commandBuffer; - PTR32 pLocationInfo; + PTR32 pInputAttachmentIndexInfo; } *params = args; - VkRenderingInputAttachmentIndexInfoKHR pLocationInfo_host; + VkRenderingInputAttachmentIndexInfoKHR pInputAttachmentIndexInfo_host; - convert_VkRenderingInputAttachmentIndexInfoKHR_win32_to_host((const VkRenderingInputAttachmentIndexInfoKHR32 *)UlongToPtr(params->pLocationInfo), &pLocationInfo_host); - wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRenderingInputAttachmentIndicesKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pLocationInfo_host); + convert_VkRenderingInputAttachmentIndexInfoKHR_win32_to_host((const VkRenderingInputAttachmentIndexInfoKHR32 *)UlongToPtr(params->pInputAttachmentIndexInfo), &pInputAttachmentIndexInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRenderingInputAttachmentIndicesKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pInputAttachmentIndexInfo_host); } #ifdef _WIN64 @@ -41882,6 +42613,44 @@ static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkCreatePipelineBinariesKHR(void *args) +{ + struct vkCreatePipelineBinariesKHR_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBinaries); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineBinariesKHR(wine_device_from_handle(params->device)->host_device, params->pCreateInfo, NULL, params->pBinaries); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreatePipelineBinariesKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pBinaries; + VkResult result; + } *params = args; + VkPipelineBinaryCreateInfoKHR pCreateInfo_host; + VkPipelineBinaryHandlesInfoKHR pBinaries_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pBinaries); + + init_conversion_context(ctx); + convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(ctx, (const VkPipelineBinaryCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host((VkPipelineBinaryHandlesInfoKHR32 *)UlongToPtr(params->pBinaries), &pBinaries_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePipelineBinariesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, &pBinaries_host); + convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(&pBinaries_host, (VkPipelineBinaryHandlesInfoKHR32 *)UlongToPtr(params->pBinaries)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCreatePipelineCache(void *args) { @@ -43481,6 +44250,33 @@ static NTSTATUS thunk32_vkDestroyPipeline(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyPipelineBinaryKHR(void *args) +{ + struct vkDestroyPipelineBinaryKHR_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineBinary), params->pAllocator); + + wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineBinaryKHR(wine_device_from_handle(params->device)->host_device, params->pipelineBinary, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyPipelineBinaryKHR(void *args) +{ + struct + { + PTR32 device; + VkPipelineBinaryKHR DECLSPEC_ALIGN(8) pipelineBinary; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineBinary), params->pAllocator); + + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineBinaryKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->pipelineBinary, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkDestroyPipelineCache(void *args) { @@ -48257,6 +49053,44 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *arg return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPipelineBinaryDataKHR(void *args) +{ + struct vkGetPipelineBinaryDataKHR_params *params = args; + + TRACE("%p, %p, %p, %p, %p\n", params->device, params->pInfo, params->pPipelineBinaryKey, params->pPipelineBinaryDataSize, params->pPipelineBinaryData); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineBinaryDataKHR(wine_device_from_handle(params->device)->host_device, params->pInfo, params->pPipelineBinaryKey, params->pPipelineBinaryDataSize, params->pPipelineBinaryData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPipelineBinaryDataKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pPipelineBinaryKey; + PTR32 pPipelineBinaryDataSize; + PTR32 pPipelineBinaryData; + VkResult result; + } *params = args; + VkPipelineBinaryDataInfoKHR pInfo_host; + VkPipelineBinaryKeyKHR pPipelineBinaryKey_host; + size_t pPipelineBinaryDataSize_host; + + TRACE("%#x, %#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pPipelineBinaryKey, params->pPipelineBinaryDataSize, params->pPipelineBinaryData); + + convert_VkPipelineBinaryDataInfoKHR_win32_to_host((const VkPipelineBinaryDataInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host); + convert_VkPipelineBinaryKeyKHR_win32_to_host((VkPipelineBinaryKeyKHR32 *)UlongToPtr(params->pPipelineBinaryKey), &pPipelineBinaryKey_host); + pPipelineBinaryDataSize_host = *(PTR32 *)UlongToPtr(params->pPipelineBinaryDataSize); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineBinaryDataKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pInfo_host, &pPipelineBinaryKey_host, &pPipelineBinaryDataSize_host, (void *)UlongToPtr(params->pPipelineBinaryData)); + convert_VkPipelineBinaryKeyKHR_host_to_win32(&pPipelineBinaryKey_host, (VkPipelineBinaryKeyKHR32 *)UlongToPtr(params->pPipelineBinaryKey)); + *(PTR32 *)UlongToPtr(params->pPipelineBinaryDataSize) = pPipelineBinaryDataSize_host; + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetPipelineCacheData(void *args) { @@ -48475,6 +49309,47 @@ static NTSTATUS thunk32_vkGetPipelineIndirectMemoryRequirementsNV(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPipelineKeyKHR(void *args) +{ + struct vkGetPipelineKeyKHR_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pPipelineCreateInfo, params->pPipelineKey); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineKeyKHR(wine_device_from_handle(params->device)->host_device, params->pPipelineCreateInfo, params->pPipelineKey); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPipelineKeyKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pPipelineCreateInfo; + PTR32 pPipelineKey; + VkResult result; + } *params = args; + VkPipelineCreateInfoKHR *pPipelineCreateInfo_host = NULL; + VkPipelineBinaryKeyKHR pPipelineKey_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->device, params->pPipelineCreateInfo, params->pPipelineKey); + + init_conversion_context(ctx); + if (params->pPipelineCreateInfo) + { + pPipelineCreateInfo_host = conversion_context_alloc(ctx, sizeof(*pPipelineCreateInfo_host)); + convert_VkPipelineCreateInfoKHR_win32_to_host((const VkPipelineCreateInfoKHR32 *)UlongToPtr(params->pPipelineCreateInfo), pPipelineCreateInfo_host); + } + convert_VkPipelineBinaryKeyKHR_win32_to_host((VkPipelineBinaryKeyKHR32 *)UlongToPtr(params->pPipelineKey), &pPipelineKey_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineKeyKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, pPipelineCreateInfo_host, &pPipelineKey_host); + convert_VkPipelineBinaryKeyKHR_host_to_win32(&pPipelineKey_host, (VkPipelineBinaryKeyKHR32 *)UlongToPtr(params->pPipelineKey)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetPipelinePropertiesEXT(void *args) { @@ -49744,6 +50619,36 @@ static NTSTATUS thunk32_vkQueueWaitIdle(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkReleaseCapturedPipelineDataKHR(void *args) +{ + struct vkReleaseCapturedPipelineDataKHR_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pAllocator); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkReleaseCapturedPipelineDataKHR(wine_device_from_handle(params->device)->host_device, params->pInfo, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkReleaseCapturedPipelineDataKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pAllocator; + VkResult result; + } *params = args; + VkReleaseCapturedPipelineDataInfoKHR pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pAllocator); + + convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host((const VkReleaseCapturedPipelineDataInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseCapturedPipelineDataKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pInfo_host, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkReleasePerformanceConfigurationINTEL(void *args) { @@ -50864,6 +51769,7 @@ static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args) static const char * const vk_device_extensions[] = { + "VK_AMD_anti_lag", "VK_AMD_buffer_marker", "VK_AMD_device_coherent_memory", "VK_AMD_draw_indirect_count", @@ -50978,6 +51884,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_shader_image_atomic_int64", "VK_EXT_shader_module_identifier", "VK_EXT_shader_object", + "VK_EXT_shader_replicated_composites", "VK_EXT_shader_stencil_export", "VK_EXT_shader_subgroup_ballot", "VK_EXT_shader_subgroup_vote", @@ -51012,6 +51919,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_bind_memory2", "VK_KHR_buffer_device_address", "VK_KHR_calibrated_timestamps", + "VK_KHR_compute_shader_derivatives", "VK_KHR_cooperative_matrix", "VK_KHR_copy_commands2", "VK_KHR_create_renderpass2", @@ -51047,6 +51955,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_map_memory2", "VK_KHR_multiview", "VK_KHR_performance_query", + "VK_KHR_pipeline_binary", "VK_KHR_pipeline_executable_properties", "VK_KHR_pipeline_library", "VK_KHR_present_id", @@ -51071,6 +51980,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_shader_maximal_reconvergence", "VK_KHR_shader_non_semantic_info", "VK_KHR_shader_quad_control", + "VK_KHR_shader_relaxed_extended_instruction", "VK_KHR_shader_subgroup_extended_types", "VK_KHR_shader_subgroup_rotate", "VK_KHR_shader_subgroup_uniform_control_flow", @@ -51101,6 +52011,7 @@ static const char * const vk_device_extensions[] = "VK_NVX_binary_import", "VK_NVX_image_view_handle", "VK_NV_clip_space_w_scaling", + "VK_NV_command_buffer_inheritance", "VK_NV_compute_shader_derivatives", "VK_NV_cooperative_matrix", "VK_NV_copy_memory_indirect", @@ -51264,6 +52175,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkAllocateCommandBuffers, thunk64_vkAllocateDescriptorSets, thunk64_vkAllocateMemory, + thunk64_vkAntiLagUpdateAMD, thunk64_vkBeginCommandBuffer, thunk64_vkBindAccelerationStructureMemoryNV, thunk64_vkBindBufferMemory, @@ -51563,6 +52475,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCreateInstance, thunk64_vkCreateMicromapEXT, thunk64_vkCreateOpticalFlowSessionNV, + thunk64_vkCreatePipelineBinariesKHR, thunk64_vkCreatePipelineCache, thunk64_vkCreatePipelineLayout, thunk64_vkCreatePrivateDataSlot, @@ -51615,6 +52528,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkDestroyMicromapEXT, thunk64_vkDestroyOpticalFlowSessionNV, thunk64_vkDestroyPipeline, + thunk64_vkDestroyPipelineBinaryKHR, thunk64_vkDestroyPipelineCache, thunk64_vkDestroyPipelineLayout, thunk64_vkDestroyPrivateDataSlot, @@ -51764,12 +52678,14 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, thunk64_vkGetPhysicalDeviceVideoFormatPropertiesKHR, thunk64_vkGetPhysicalDeviceWin32PresentationSupportKHR, + thunk64_vkGetPipelineBinaryDataKHR, thunk64_vkGetPipelineCacheData, thunk64_vkGetPipelineExecutableInternalRepresentationsKHR, thunk64_vkGetPipelineExecutablePropertiesKHR, thunk64_vkGetPipelineExecutableStatisticsKHR, thunk64_vkGetPipelineIndirectDeviceAddressNV, thunk64_vkGetPipelineIndirectMemoryRequirementsNV, + thunk64_vkGetPipelineKeyKHR, thunk64_vkGetPipelinePropertiesEXT, thunk64_vkGetPrivateData, thunk64_vkGetPrivateDataEXT, @@ -51810,6 +52726,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkQueueSubmit2, thunk64_vkQueueSubmit2KHR, thunk64_vkQueueWaitIdle, + thunk64_vkReleaseCapturedPipelineDataKHR, thunk64_vkReleasePerformanceConfigurationINTEL, thunk64_vkReleaseProfilingLockKHR, thunk64_vkReleaseSwapchainImagesEXT, @@ -51869,6 +52786,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkAllocateCommandBuffers, thunk32_vkAllocateDescriptorSets, thunk32_vkAllocateMemory, + thunk32_vkAntiLagUpdateAMD, thunk32_vkBeginCommandBuffer, thunk32_vkBindAccelerationStructureMemoryNV, thunk32_vkBindBufferMemory, @@ -52168,6 +53086,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCreateInstance, thunk32_vkCreateMicromapEXT, thunk32_vkCreateOpticalFlowSessionNV, + thunk32_vkCreatePipelineBinariesKHR, thunk32_vkCreatePipelineCache, thunk32_vkCreatePipelineLayout, thunk32_vkCreatePrivateDataSlot, @@ -52220,6 +53139,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkDestroyMicromapEXT, thunk32_vkDestroyOpticalFlowSessionNV, thunk32_vkDestroyPipeline, + thunk32_vkDestroyPipelineBinaryKHR, thunk32_vkDestroyPipelineCache, thunk32_vkDestroyPipelineLayout, thunk32_vkDestroyPrivateDataSlot, @@ -52369,12 +53289,14 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, thunk32_vkGetPhysicalDeviceVideoFormatPropertiesKHR, thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR, + thunk32_vkGetPipelineBinaryDataKHR, thunk32_vkGetPipelineCacheData, thunk32_vkGetPipelineExecutableInternalRepresentationsKHR, thunk32_vkGetPipelineExecutablePropertiesKHR, thunk32_vkGetPipelineExecutableStatisticsKHR, thunk32_vkGetPipelineIndirectDeviceAddressNV, thunk32_vkGetPipelineIndirectMemoryRequirementsNV, + thunk32_vkGetPipelineKeyKHR, thunk32_vkGetPipelinePropertiesEXT, thunk32_vkGetPrivateData, thunk32_vkGetPrivateDataEXT, @@ -52415,6 +53337,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkQueueSubmit2, thunk32_vkQueueSubmit2KHR, thunk32_vkQueueWaitIdle, + thunk32_vkReleaseCapturedPipelineDataKHR, thunk32_vkReleasePerformanceConfigurationINTEL, thunk32_vkReleaseProfilingLockKHR, thunk32_vkReleaseSwapchainImagesEXT, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index b1e1ca9f9ca..547da66da80 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -86,6 +86,7 @@ struct vulkan_device_funcs VkResult (*p_vkAllocateCommandBuffers)(VkDevice, const VkCommandBufferAllocateInfo *, VkCommandBuffer *); VkResult (*p_vkAllocateDescriptorSets)(VkDevice, const VkDescriptorSetAllocateInfo *, VkDescriptorSet *); VkResult (*p_vkAllocateMemory)(VkDevice, const VkMemoryAllocateInfo *, const VkAllocationCallbacks *, VkDeviceMemory *); + void (*p_vkAntiLagUpdateAMD)(VkDevice, const VkAntiLagDataAMD *); VkResult (*p_vkBeginCommandBuffer)(VkCommandBuffer, const VkCommandBufferBeginInfo *); VkResult (*p_vkBindAccelerationStructureMemoryNV)(VkDevice, uint32_t, const VkBindAccelerationStructureMemoryInfoNV *); VkResult (*p_vkBindBufferMemory)(VkDevice, VkBuffer, VkDeviceMemory, VkDeviceSize); @@ -381,6 +382,7 @@ struct vulkan_device_funcs VkResult (*p_vkCreateIndirectCommandsLayoutNV)(VkDevice, const VkIndirectCommandsLayoutCreateInfoNV *, const VkAllocationCallbacks *, VkIndirectCommandsLayoutNV *); VkResult (*p_vkCreateMicromapEXT)(VkDevice, const VkMicromapCreateInfoEXT *, const VkAllocationCallbacks *, VkMicromapEXT *); VkResult (*p_vkCreateOpticalFlowSessionNV)(VkDevice, const VkOpticalFlowSessionCreateInfoNV *, const VkAllocationCallbacks *, VkOpticalFlowSessionNV *); + VkResult (*p_vkCreatePipelineBinariesKHR)(VkDevice, const VkPipelineBinaryCreateInfoKHR *, const VkAllocationCallbacks *, VkPipelineBinaryHandlesInfoKHR *); VkResult (*p_vkCreatePipelineCache)(VkDevice, const VkPipelineCacheCreateInfo *, const VkAllocationCallbacks *, VkPipelineCache *); VkResult (*p_vkCreatePipelineLayout)(VkDevice, const VkPipelineLayoutCreateInfo *, const VkAllocationCallbacks *, VkPipelineLayout *); VkResult (*p_vkCreatePrivateDataSlot)(VkDevice, const VkPrivateDataSlotCreateInfo *, const VkAllocationCallbacks *, VkPrivateDataSlot *); @@ -428,6 +430,7 @@ struct vulkan_device_funcs void (*p_vkDestroyMicromapEXT)(VkDevice, VkMicromapEXT, const VkAllocationCallbacks *); void (*p_vkDestroyOpticalFlowSessionNV)(VkDevice, VkOpticalFlowSessionNV, const VkAllocationCallbacks *); void (*p_vkDestroyPipeline)(VkDevice, VkPipeline, const VkAllocationCallbacks *); + void (*p_vkDestroyPipelineBinaryKHR)(VkDevice, VkPipelineBinaryKHR, const VkAllocationCallbacks *); void (*p_vkDestroyPipelineCache)(VkDevice, VkPipelineCache, const VkAllocationCallbacks *); void (*p_vkDestroyPipelineLayout)(VkDevice, VkPipelineLayout, const VkAllocationCallbacks *); void (*p_vkDestroyPrivateDataSlot)(VkDevice, VkPrivateDataSlot, const VkAllocationCallbacks *); @@ -519,12 +522,14 @@ struct vulkan_device_funcs VkResult (*p_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *); void (*p_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *); VkResult (*p_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *); + VkResult (*p_vkGetPipelineBinaryDataKHR)(VkDevice, const VkPipelineBinaryDataInfoKHR *, VkPipelineBinaryKeyKHR *, size_t *, void *); VkResult (*p_vkGetPipelineCacheData)(VkDevice, VkPipelineCache, size_t *, void *); VkResult (*p_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice, const VkPipelineExecutableInfoKHR *, uint32_t *, VkPipelineExecutableInternalRepresentationKHR *); VkResult (*p_vkGetPipelineExecutablePropertiesKHR)(VkDevice, const VkPipelineInfoKHR *, uint32_t *, VkPipelineExecutablePropertiesKHR *); VkResult (*p_vkGetPipelineExecutableStatisticsKHR)(VkDevice, const VkPipelineExecutableInfoKHR *, uint32_t *, VkPipelineExecutableStatisticKHR *); VkDeviceAddress (*p_vkGetPipelineIndirectDeviceAddressNV)(VkDevice, const VkPipelineIndirectDeviceAddressInfoNV *); void (*p_vkGetPipelineIndirectMemoryRequirementsNV)(VkDevice, const VkComputePipelineCreateInfo *, VkMemoryRequirements2 *); + VkResult (*p_vkGetPipelineKeyKHR)(VkDevice, const VkPipelineCreateInfoKHR *, VkPipelineBinaryKeyKHR *); VkResult (*p_vkGetPipelinePropertiesEXT)(VkDevice, const VkPipelineInfoEXT *, VkBaseOutStructure *); void (*p_vkGetPrivateData)(VkDevice, VkObjectType, uint64_t, VkPrivateDataSlot, uint64_t *); void (*p_vkGetPrivateDataEXT)(VkDevice, VkObjectType, uint64_t, VkPrivateDataSlot, uint64_t *); @@ -565,6 +570,7 @@ struct vulkan_device_funcs VkResult (*p_vkQueueSubmit2)(VkQueue, uint32_t, const VkSubmitInfo2 *, VkFence); VkResult (*p_vkQueueSubmit2KHR)(VkQueue, uint32_t, const VkSubmitInfo2 *, VkFence); VkResult (*p_vkQueueWaitIdle)(VkQueue); + VkResult (*p_vkReleaseCapturedPipelineDataKHR)(VkDevice, const VkReleaseCapturedPipelineDataInfoKHR *, const VkAllocationCallbacks *); VkResult (*p_vkReleasePerformanceConfigurationINTEL)(VkDevice, VkPerformanceConfigurationINTEL); void (*p_vkReleaseProfilingLockKHR)(VkDevice); VkResult (*p_vkReleaseSwapchainImagesEXT)(VkDevice, const VkReleaseSwapchainImagesInfoEXT *); @@ -676,6 +682,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkAllocateCommandBuffers) \ USE_VK_FUNC(vkAllocateDescriptorSets) \ USE_VK_FUNC(vkAllocateMemory) \ + USE_VK_FUNC(vkAntiLagUpdateAMD) \ USE_VK_FUNC(vkBeginCommandBuffer) \ USE_VK_FUNC(vkBindAccelerationStructureMemoryNV) \ USE_VK_FUNC(vkBindBufferMemory) \ @@ -971,6 +978,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCreateIndirectCommandsLayoutNV) \ USE_VK_FUNC(vkCreateMicromapEXT) \ USE_VK_FUNC(vkCreateOpticalFlowSessionNV) \ + USE_VK_FUNC(vkCreatePipelineBinariesKHR) \ USE_VK_FUNC(vkCreatePipelineCache) \ USE_VK_FUNC(vkCreatePipelineLayout) \ USE_VK_FUNC(vkCreatePrivateDataSlot) \ @@ -1018,6 +1026,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkDestroyMicromapEXT) \ USE_VK_FUNC(vkDestroyOpticalFlowSessionNV) \ USE_VK_FUNC(vkDestroyPipeline) \ + USE_VK_FUNC(vkDestroyPipelineBinaryKHR) \ USE_VK_FUNC(vkDestroyPipelineCache) \ USE_VK_FUNC(vkDestroyPipelineLayout) \ USE_VK_FUNC(vkDestroyPrivateDataSlot) \ @@ -1109,12 +1118,14 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetMemoryHostPointerPropertiesEXT) \ USE_VK_FUNC(vkGetMicromapBuildSizesEXT) \ USE_VK_FUNC(vkGetPerformanceParameterINTEL) \ + USE_VK_FUNC(vkGetPipelineBinaryDataKHR) \ USE_VK_FUNC(vkGetPipelineCacheData) \ USE_VK_FUNC(vkGetPipelineExecutableInternalRepresentationsKHR) \ USE_VK_FUNC(vkGetPipelineExecutablePropertiesKHR) \ USE_VK_FUNC(vkGetPipelineExecutableStatisticsKHR) \ USE_VK_FUNC(vkGetPipelineIndirectDeviceAddressNV) \ USE_VK_FUNC(vkGetPipelineIndirectMemoryRequirementsNV) \ + USE_VK_FUNC(vkGetPipelineKeyKHR) \ USE_VK_FUNC(vkGetPipelinePropertiesEXT) \ USE_VK_FUNC(vkGetPrivateData) \ USE_VK_FUNC(vkGetPrivateDataEXT) \ @@ -1155,6 +1166,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkQueueSubmit2) \ USE_VK_FUNC(vkQueueSubmit2KHR) \ USE_VK_FUNC(vkQueueWaitIdle) \ + USE_VK_FUNC(vkReleaseCapturedPipelineDataKHR) \ USE_VK_FUNC(vkReleasePerformanceConfigurationINTEL) \ USE_VK_FUNC(vkReleaseProfilingLockKHR) \ USE_VK_FUNC(vkReleaseSwapchainImagesEXT) \ diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index d002b912ee5..67cee901fd9 100644 --- a/dlls/winevulkan/winevulkan.json +++ b/dlls/winevulkan/winevulkan.json @@ -2,6 +2,6 @@ "file_format_version": "1.0.0", "ICD": { "library_path": ".\\winevulkan.dll", - "api_version": "1.3.285" + "api_version": "1.3.295" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 9a00c0287ab..0842407e39b 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -71,6 +71,7 @@ #define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR 16 #define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE_KHR #define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT 32 +#define VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR 32 #define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7 #define VK_SHADER_INDEX_UNUSED_AMDX (~0U) #define VK_KHR_SURFACE_SPEC_VERSION 25 @@ -203,9 +204,9 @@ #define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" #define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 #define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 5 #define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" -#define VK_EXT_HDR_METADATA_SPEC_VERSION 2 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 3 #define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" #define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1 #define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer" @@ -595,7 +596,7 @@ #define VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME "VK_EXT_non_seamless_cube_map" #define VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION 1 #define VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME "VK_ARM_render_pass_striped" -#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 +#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 2 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" #define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 #define VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_NV_copy_memory_indirect" @@ -631,10 +632,14 @@ #define VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME "VK_EXT_pipeline_protected_access" #define VK_KHR_MAINTENANCE_5_SPEC_VERSION 1 #define VK_KHR_MAINTENANCE_5_EXTENSION_NAME "VK_KHR_maintenance5" +#define VK_AMD_ANTI_LAG_SPEC_VERSION 1 +#define VK_AMD_ANTI_LAG_EXTENSION_NAME "VK_AMD_anti_lag" #define VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION 1 #define VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME "VK_KHR_ray_tracing_position_fetch" #define VK_EXT_SHADER_OBJECT_SPEC_VERSION 1 #define VK_EXT_SHADER_OBJECT_EXTENSION_NAME "VK_EXT_shader_object" +#define VK_KHR_PIPELINE_BINARY_SPEC_VERSION 1 +#define VK_KHR_PIPELINE_BINARY_EXTENSION_NAME "VK_KHR_pipeline_binary" #define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1 #define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" #define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION 1 @@ -661,6 +666,8 @@ #define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix" #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" +#define VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 +#define VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_KHR_compute_shader_derivatives" #define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1 #define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" #define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 @@ -699,8 +706,14 @@ #define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation" #define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1 #define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains" +#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION 1 +#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME "VK_KHR_shader_relaxed_extended_instruction" +#define VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION 1 +#define VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME "VK_NV_command_buffer_inheritance" #define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1 #define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME "VK_NV_shader_atomic_float16_vector" +#define VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION 1 +#define VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME "VK_EXT_shader_replicated_composites" #define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1 #define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation" #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1 @@ -795,7 +808,7 @@ #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0) #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0) #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0) -#define VK_HEADER_VERSION 285 +#define VK_HEADER_VERSION 295 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; #define VK_USE_64_BIT_PTR_DEFINES 0 @@ -861,6 +874,7 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL) VK_DEFINE_HANDLE(VkPhysicalDevice) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineBinaryKHR) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) @@ -1666,6 +1680,21 @@ typedef enum VkAcquireProfilingLockFlagBitsKHR VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkAcquireProfilingLockFlagBitsKHR; +typedef enum VkAntiLagModeAMD +{ + VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD = 0, + VK_ANTI_LAG_MODE_ON_AMD = 1, + VK_ANTI_LAG_MODE_OFF_AMD = 2, + VK_ANTI_LAG_MODE_AMD_MAX_ENUM = 0x7fffffff, +} VkAntiLagModeAMD; + +typedef enum VkAntiLagStageAMD +{ + VK_ANTI_LAG_STAGE_INPUT_AMD = 0, + VK_ANTI_LAG_STAGE_PRESENT_AMD = 1, + VK_ANTI_LAG_STAGE_AMD_MAX_ENUM = 0x7fffffff, +} VkAntiLagStageAMD; + typedef enum VkAttachmentDescriptionFlagBits { VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, @@ -2393,7 +2422,8 @@ typedef enum VkDriverId VK_DRIVER_ID_MESA_DOZEN = 23, VK_DRIVER_ID_MESA_NVK = 24, VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, - VK_DRIVER_ID_MESA_AGXV = 26, + VK_DRIVER_ID_MESA_HONEYKRISP = 26, + VK_DRIVER_ID_RESERVED_27 = 27, VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, @@ -3591,6 +3621,7 @@ typedef enum VkObjectType VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, + VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, @@ -3895,6 +3926,7 @@ static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCE static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ull; static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ull; static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ull; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ull; static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ull; typedef enum VkPipelineCreationFeedbackFlagBits @@ -4281,10 +4313,11 @@ typedef enum VkRenderingFlagBits VK_RENDERING_SUSPENDING_BIT = 0x00000002, VK_RENDERING_RESUMING_BIT = 0x00000004, VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, - VK_RENDERING_CONTENTS_INLINE_BIT_EXT = 0x00000010, + VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 0x00000010, VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, + VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkRenderingFlagBits; typedef VkRenderingFlagBits VkRenderingFlagBitsKHR; @@ -4307,6 +4340,7 @@ typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR; typedef enum VkResult { + VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000, VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, @@ -4351,6 +4385,7 @@ typedef enum VkResult VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, VK_PIPELINE_COMPILE_REQUIRED = 1000297000, VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, + VK_PIPELINE_BINARY_MISSING_KHR = 1000483000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, @@ -4980,7 +5015,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR = 1000201000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, @@ -5333,10 +5368,23 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR = 1000470004, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR = 1000470005, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR = 1000470006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD = 1000476000, + VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD = 1000476001, + VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD = 1000476002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR = 1000483000, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR = 1000483001, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR = 1000483002, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR = 1000483003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR = 1000483004, + VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR = 1000483005, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR = 1000483006, + VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR = 1000483007, + VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR = 1000483008, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR = 1000483009, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, @@ -5365,6 +5413,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR = 1000511000, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, @@ -5398,7 +5447,10 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV = 1000559000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001, @@ -5510,6 +5562,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, @@ -5616,7 +5669,8 @@ typedef enum VkSubpassContents { VK_SUBPASS_CONTENTS_INLINE = 0, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, - VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = 1000451000, + VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR = 1000451000, + VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR, VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7fffffff, } VkSubpassContents; @@ -5766,6 +5820,7 @@ typedef enum VkValidationFeatureEnableEXT typedef enum VkVendorId { + VK_VENDOR_ID_KHRONOS = 0x00010000, VK_VENDOR_ID_VIV = 0x00010001, VK_VENDOR_ID_VSI = 0x00010002, VK_VENDOR_ID_KAZAN = 0x00010003, @@ -5876,11 +5931,6 @@ typedef enum VkVideoEncodeFeedbackFlagBitsKHR VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeFeedbackFlagBitsKHR; -typedef enum VkVideoEncodeFlagBitsKHR -{ - VK_VIDEO_ENCODE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, -} VkVideoEncodeFlagBitsKHR; - typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR { VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, @@ -6717,6 +6767,14 @@ typedef struct VkAllocationCallbacks PFN_vkInternalFreeNotification pfnInternalFree; } VkAllocationCallbacks; +typedef struct VkAntiLagPresentationInfoAMD +{ + VkStructureType sType; + void *pNext; + VkAntiLagStageAMD stage; + uint64_t WINE_VK_ALIGN(8) frameIndex; +} VkAntiLagPresentationInfoAMD; + typedef struct VkApplicationInfo { VkStructureType sType; @@ -7513,7 +7571,7 @@ typedef struct VkDescriptorAddressInfoEXT typedef struct VkDescriptorBufferBindingInfoEXT { VkStructureType sType; - void *pNext; + const void *pNext; VkDeviceAddress WINE_VK_ALIGN(8) address; VkBufferUsageFlags usage; } VkDescriptorBufferBindingInfoEXT; @@ -7521,7 +7579,7 @@ typedef struct VkDescriptorBufferBindingInfoEXT typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { VkStructureType sType; - void *pNext; + const void *pNext; VkBuffer WINE_VK_ALIGN(8) buffer; } VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; @@ -7794,6 +7852,13 @@ typedef union VkDeviceOrHostAddressKHR void *hostAddress; } VkDeviceOrHostAddressKHR; +typedef struct VkDevicePipelineBinaryInternalCacheControlKHR +{ + VkStructureType sType; + const void *pNext; + VkBool32 disableInternalCache; +} VkDevicePipelineBinaryInternalCacheControlKHR; + typedef struct VkDevicePrivateDataCreateInfo { VkStructureType sType; @@ -8963,6 +9028,13 @@ typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT VkBool32 reportAddressBinding; } VkPhysicalDeviceAddressBindingReportFeaturesEXT; +typedef struct VkPhysicalDeviceAntiLagFeaturesAMD +{ + VkStructureType sType; + void *pNext; + VkBool32 antiLag; +} VkPhysicalDeviceAntiLagFeaturesAMD; + typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { VkStructureType sType; @@ -9063,13 +9135,28 @@ typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT VkBool32 colorWriteEnable; } VkPhysicalDeviceColorWriteEnableFeaturesEXT; -typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV +typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV +{ + VkStructureType sType; + void *pNext; + VkBool32 commandBufferInheritance; +} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV; + +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR { VkStructureType sType; void *pNext; VkBool32 computeDerivativeGroupQuads; VkBool32 computeDerivativeGroupLinear; -} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR; +typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; + +typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 meshAndTaskShaderDerivatives; +} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR; typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { @@ -10568,6 +10655,24 @@ typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR VkBool32 allowCommandBufferQueryCopies; } VkPhysicalDevicePerformanceQueryPropertiesKHR; +typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 pipelineBinaries; +} VkPhysicalDevicePipelineBinaryFeaturesKHR; + +typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 pipelineBinaryInternalCache; + VkBool32 pipelineBinaryInternalCacheControl; + VkBool32 pipelineBinaryPrefersInternalCache; + VkBool32 pipelineBinaryPrecompiledInternalCache; + VkBool32 pipelineBinaryCompressedData; +} VkPhysicalDevicePipelineBinaryPropertiesKHR; + typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { VkStructureType sType; @@ -11201,6 +11306,20 @@ typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR VkBool32 shaderQuadControl; } VkPhysicalDeviceShaderQuadControlFeaturesKHR; +typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderRelaxedExtendedInstruction; +} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + +typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderReplicatedComposites; +} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { VkStructureType sType; @@ -11797,6 +11916,50 @@ typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; +typedef struct VkPipelineBinaryDataInfoKHR +{ + VkStructureType sType; + void *pNext; + VkPipelineBinaryKHR WINE_VK_ALIGN(8) pipelineBinary; +} VkPipelineBinaryDataInfoKHR; + +typedef struct VkPipelineBinaryDataKHR +{ + size_t dataSize; + void *pData; +} VkPipelineBinaryDataKHR; + +typedef struct VkPipelineBinaryHandlesInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t pipelineBinaryCount; + VkPipelineBinaryKHR *pPipelineBinaries; +} VkPipelineBinaryHandlesInfoKHR; + +typedef struct VkPipelineBinaryInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t binaryCount; + const VkPipelineBinaryKHR *pPipelineBinaries; +} VkPipelineBinaryInfoKHR; + +typedef struct VkPipelineBinaryKeyKHR +{ + VkStructureType sType; + void *pNext; + uint32_t keySize; + uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]; +} VkPipelineBinaryKeyKHR; + +typedef struct VkPipelineBinaryKeysAndDataKHR +{ + uint32_t binaryCount; + const VkPipelineBinaryKeyKHR *pPipelineBinaryKeys; + const VkPipelineBinaryDataKHR *pPipelineBinaryData; +} VkPipelineBinaryKeysAndDataKHR; + typedef struct VkPipelineCacheCreateInfo { VkStructureType sType; @@ -11898,6 +12061,12 @@ typedef struct VkPipelineCreateFlags2CreateInfoKHR VkPipelineCreateFlags2KHR WINE_VK_ALIGN(8) flags; } VkPipelineCreateFlags2CreateInfoKHR; +typedef struct VkPipelineCreateInfoKHR +{ + VkStructureType sType; + void *pNext; +} VkPipelineCreateInfoKHR; + typedef struct VkPipelineCreationFeedback { VkPipelineCreationFeedbackFlags flags; @@ -12378,6 +12547,13 @@ typedef struct VkRectLayerKHR uint32_t layer; } VkRectLayerKHR; +typedef struct VkReleaseCapturedPipelineDataInfoKHR +{ + VkStructureType sType; + void *pNext; + VkPipeline WINE_VK_ALIGN(8) pipeline; +} VkReleaseCapturedPipelineDataInfoKHR; + typedef struct VkReleaseSwapchainImagesInfoEXT { VkStructureType sType; @@ -14352,6 +14528,15 @@ typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT VkMicromapEXT WINE_VK_ALIGN(8) micromap; } VkAccelerationStructureTrianglesOpacityMicromapEXT; +typedef struct VkAntiLagDataAMD +{ + VkStructureType sType; + const void *pNext; + VkAntiLagModeAMD mode; + uint32_t maxFPS; + const VkAntiLagPresentationInfoAMD *pPresentationInfo; +} VkAntiLagDataAMD; + typedef struct VkAttachmentSampleLocationsEXT { uint32_t attachmentIndex; @@ -14906,6 +15091,15 @@ typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR uint32_t qualityLevel; } VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; +typedef struct VkPipelineBinaryCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + const VkPipelineBinaryKeysAndDataKHR *pKeysAndDataInfo; + VkPipeline WINE_VK_ALIGN(8) pipeline; + const VkPipelineCreateInfoKHR *pPipelineCreateInfo; +} VkPipelineBinaryCreateInfoKHR; + typedef struct VkPipelineDepthStencilStateCreateInfo { VkStructureType sType; @@ -15843,6 +16037,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice, const VkAc typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice, const VkCommandBufferAllocateInfo *, VkCommandBuffer *); typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice, const VkDescriptorSetAllocateInfo *, VkDescriptorSet *); typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice, const VkMemoryAllocateInfo *, const VkAllocationCallbacks *, VkDeviceMemory *); +typedef void (VKAPI_PTR *PFN_vkAntiLagUpdateAMD)(VkDevice, const VkAntiLagDataAMD *); typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer, const VkCommandBufferBeginInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice, uint32_t, const VkBindAccelerationStructureMemoryInfoNV *); typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice, VkBuffer, VkDeviceMemory, VkDeviceSize); @@ -16142,6 +16337,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice, con typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo *, const VkAllocationCallbacks *, VkInstance *); typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice, const VkMicromapCreateInfoEXT *, const VkAllocationCallbacks *, VkMicromapEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice, const VkOpticalFlowSessionCreateInfoNV *, const VkAllocationCallbacks *, VkOpticalFlowSessionNV *); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineBinariesKHR)(VkDevice, const VkPipelineBinaryCreateInfoKHR *, const VkAllocationCallbacks *, VkPipelineBinaryHandlesInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice, const VkPipelineCacheCreateInfo *, const VkAllocationCallbacks *, VkPipelineCache *); typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice, const VkPipelineLayoutCreateInfo *, const VkAllocationCallbacks *, VkPipelineLayout *); typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice, const VkPrivateDataSlotCreateInfo *, const VkAllocationCallbacks *, VkPrivateDataSlot *); @@ -16194,6 +16390,7 @@ typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance, const VkAllocationCa typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice, VkMicromapEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice, VkOpticalFlowSessionNV, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice, VkPipeline, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineBinaryKHR)(VkDevice, VkPipelineBinaryKHR, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice, VkPipelineCache, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice, VkPipelineLayout, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlot)(VkDevice, VkPrivateDataSlot, const VkAllocationCallbacks *); @@ -16348,12 +16545,14 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhys typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *, VkVideoEncodeQualityLevelPropertiesKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *, uint32_t *, VkVideoFormatPropertiesKHR *); typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice, uint32_t); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineBinaryDataKHR)(VkDevice, const VkPipelineBinaryDataInfoKHR *, VkPipelineBinaryKeyKHR *, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice, VkPipelineCache, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice, const VkPipelineExecutableInfoKHR *, uint32_t *, VkPipelineExecutableInternalRepresentationKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice, const VkPipelineInfoKHR *, uint32_t *, VkPipelineExecutablePropertiesKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice, const VkPipelineExecutableInfoKHR *, uint32_t *, VkPipelineExecutableStatisticKHR *); typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetPipelineIndirectDeviceAddressNV)(VkDevice, const VkPipelineIndirectDeviceAddressInfoNV *); typedef void (VKAPI_PTR *PFN_vkGetPipelineIndirectMemoryRequirementsNV)(VkDevice, const VkComputePipelineCreateInfo *, VkMemoryRequirements2 *); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineKeyKHR)(VkDevice, const VkPipelineCreateInfoKHR *, VkPipelineBinaryKeyKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice, const VkPipelineInfoEXT *, VkBaseOutStructure *); typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice, VkObjectType, uint64_t, VkPrivateDataSlot, uint64_t *); typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice, VkObjectType, uint64_t, VkPrivateDataSlot, uint64_t *); @@ -16394,6 +16593,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue, uint32_t, const VkSubmi typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue, uint32_t, const VkSubmitInfo2 *, VkFence); typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue, uint32_t, const VkSubmitInfo2 *, VkFence); typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue); +typedef VkResult (VKAPI_PTR *PFN_vkReleaseCapturedPipelineDataKHR)(VkDevice, const VkReleaseCapturedPipelineDataInfoKHR *, const VkAllocationCallbacks *); typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice, VkPerformanceConfigurationINTEL); typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice); typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice, const VkReleaseSwapchainImagesInfoEXT *); @@ -16441,6 +16641,7 @@ VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquirePr VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers); VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets); VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory); +void VKAPI_CALL vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD *pData); VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo); VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos); VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); @@ -16659,7 +16860,7 @@ void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, V void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR *pLocationInfo); -void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *pLocationInfo); +void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *pInputAttachmentIndexInfo); void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo); void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); @@ -16740,6 +16941,7 @@ VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIn VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance); VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap); VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession); +VkResult VKAPI_CALL vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineBinaryHandlesInfoKHR *pBinaries); VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache); VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout); VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot); @@ -16792,6 +16994,7 @@ void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbac void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator); @@ -16946,12 +17149,14 @@ VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice phy VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR *pQualityLevelProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties); VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); +VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR *pInfo, VkPipelineBinaryKeyKHR *pPipelineBinaryKey, size_t *pPipelineBinaryDataSize, void *pPipelineBinaryData); VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations); VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties); VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics); VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV *pInfo); void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo *pCreateInfo, VkMemoryRequirements2 *pMemoryRequirements); +VkResult VKAPI_CALL vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR *pPipelineCreateInfo, VkPipelineBinaryKeyKHR *pPipelineKey); VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties); void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData); void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData); @@ -16992,6 +17197,7 @@ VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkS VkResult VKAPI_CALL vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence); VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence); VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue); +VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR *pInfo, const VkAllocationCallbacks *pAllocator); VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration); void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device); VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/6420
participants (2)
-
Georg Lehmann -
Georg Lehmann (＠DadSchoorse)