[PATCH 0/1] MR8314: winevulkan: Update to VK spec version 1.4.318.
From: Georg Lehmann <dadschoorse(a)gmail.com> --- dlls/winevulkan/loader_thunks.c | 152 ++- dlls/winevulkan/loader_thunks.h | 104 ++ dlls/winevulkan/make_vulkan | 2 +- dlls/winevulkan/vulkan_thunks.c | 2099 ++++++++++++++++++++++++++++++- dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 743 ++++++++++- 6 files changed, 3075 insertions(+), 27 deletions(-) diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 1a10a8fdc0a..9f0d6d17ad5 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -215,6 +215,18 @@ VkResult WINAPI vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSe return params.result; } +VkResult WINAPI vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM *pBindInfos) +{ + struct vkBindTensorMemoryARM_params params; + NTSTATUS status; + params.device = device; + params.bindInfoCount = bindInfoCount; + params.pBindInfos = pBindInfos; + status = UNIX_CALL(vkBindTensorMemoryARM, ¶ms); + assert(!status && "vkBindTensorMemoryARM"); + return params.result; +} + VkResult WINAPI vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos) { struct vkBindVideoSessionMemoryKHR_params params; @@ -906,6 +918,14 @@ void WINAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool UNIX_CALL(vkCmdCopyQueryPoolResults, ¶ms); } +void WINAPI vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM *pCopyTensorInfo) +{ + struct vkCmdCopyTensorARM_params params; + params.commandBuffer = commandBuffer; + params.pCopyTensorInfo = pCopyTensorInfo; + UNIX_CALL(vkCmdCopyTensorARM, ¶ms); +} + void WINAPI vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo) { struct vkCmdCuLaunchKernelNVX_params params; @@ -1009,10 +1029,11 @@ void WINAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer UNIX_CALL(vkCmdDispatchIndirect, ¶ms); } -void WINAPI vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer) +void WINAPI vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM *pDispatchTileInfo) { struct vkCmdDispatchTileQCOM_params params; params.commandBuffer = commandBuffer; + params.pDispatchTileInfo = pDispatchTileInfo; UNIX_CALL(vkCmdDispatchTileQCOM, ¶ms); } @@ -3527,6 +3548,32 @@ VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInf return params.result; } +VkResult WINAPI vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorARM *pTensor) +{ + struct vkCreateTensorARM_params params; + NTSTATUS status; + params.device = device; + params.pCreateInfo = pCreateInfo; + params.pAllocator = pAllocator; + params.pTensor = pTensor; + status = UNIX_CALL(vkCreateTensorARM, ¶ms); + assert(!status && "vkCreateTensorARM"); + return params.result; +} + +VkResult WINAPI vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorViewARM *pView) +{ + struct vkCreateTensorViewARM_params params; + NTSTATUS status; + params.device = device; + params.pCreateInfo = pCreateInfo; + params.pAllocator = pAllocator; + params.pView = pView; + status = UNIX_CALL(vkCreateTensorViewARM, ¶ms); + assert(!status && "vkCreateTensorViewARM"); + return params.result; +} + VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache) { struct vkCreateValidationCacheEXT_params params; @@ -4057,6 +4104,28 @@ void WINAPI vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, con assert(!status && "vkDestroySwapchainKHR"); } +void WINAPI vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks *pAllocator) +{ + struct vkDestroyTensorARM_params params; + NTSTATUS status; + params.device = device; + params.tensor = tensor; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkDestroyTensorARM, ¶ms); + assert(!status && "vkDestroyTensorARM"); +} + +void WINAPI vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks *pAllocator) +{ + struct vkDestroyTensorViewARM_params params; + NTSTATUS status; + params.device = device; + params.tensorView = tensorView; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkDestroyTensorViewARM, ¶ms); + assert(!status && "vkDestroyTensorViewARM"); +} + void WINAPI vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator) { struct vkDestroyValidationCacheEXT_params params; @@ -4760,6 +4829,17 @@ VkResult WINAPI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, return params.result; } +void WINAPI vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements) +{ + struct vkGetDeviceTensorMemoryRequirementsARM_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pMemoryRequirements = pMemoryRequirements; + status = UNIX_CALL(vkGetDeviceTensorMemoryRequirementsARM, ¶ms); + assert(!status && "vkGetDeviceTensorMemoryRequirementsARM"); +} + VkResult WINAPI vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties) { struct vkGetDynamicRenderingTilePropertiesQCOM_params params; @@ -5215,6 +5295,17 @@ void WINAPI vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice p assert(!status && "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); } +void WINAPI vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM *pExternalTensorInfo, VkExternalTensorPropertiesARM *pExternalTensorProperties) +{ + struct vkGetPhysicalDeviceExternalTensorPropertiesARM_params params; + NTSTATUS status; + params.physicalDevice = physicalDevice; + params.pExternalTensorInfo = pExternalTensorInfo; + params.pExternalTensorProperties = pExternalTensorProperties; + status = UNIX_CALL(vkGetPhysicalDeviceExternalTensorPropertiesARM, ¶ms); + assert(!status && "vkGetPhysicalDeviceExternalTensorPropertiesARM"); +} + void WINAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) { struct vkGetPhysicalDeviceFeatures_params params; @@ -6018,6 +6109,41 @@ VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchai return params.result; } +void WINAPI vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements) +{ + struct vkGetTensorMemoryRequirementsARM_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pMemoryRequirements = pMemoryRequirements; + status = UNIX_CALL(vkGetTensorMemoryRequirementsARM, ¶ms); + assert(!status && "vkGetTensorMemoryRequirementsARM"); +} + +VkResult WINAPI vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM *pInfo, void *pData) +{ + struct vkGetTensorOpaqueCaptureDescriptorDataARM_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pData = pData; + status = UNIX_CALL(vkGetTensorOpaqueCaptureDescriptorDataARM, ¶ms); + assert(!status && "vkGetTensorOpaqueCaptureDescriptorDataARM"); + return params.result; +} + +VkResult WINAPI vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM *pInfo, void *pData) +{ + struct vkGetTensorViewOpaqueCaptureDescriptorDataARM_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pData = pData; + status = UNIX_CALL(vkGetTensorViewOpaqueCaptureDescriptorDataARM, ¶ms); + assert(!status && "vkGetTensorViewOpaqueCaptureDescriptorDataARM"); + return params.result; +} + VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData) { struct vkGetValidationCacheDataEXT_params params; @@ -6703,6 +6829,18 @@ VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFe return params.result; } +VkResult WINAPI vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR *pPresentWait2Info) +{ + struct vkWaitForPresent2KHR_params params; + NTSTATUS status; + params.device = device; + params.swapchain = swapchain; + params.pPresentWait2Info = pPresentWait2Info; + status = UNIX_CALL(vkWaitForPresent2KHR, ¶ms); + assert(!status && "vkWaitForPresent2KHR"); + return params.result; +} + VkResult WINAPI vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) { struct vkWaitForPresentKHR_params params; @@ -6791,6 +6929,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkBindImageMemory2", vkBindImageMemory2}, {"vkBindImageMemory2KHR", vkBindImageMemory2KHR}, {"vkBindOpticalFlowSessionImageNV", vkBindOpticalFlowSessionImageNV}, + {"vkBindTensorMemoryARM", vkBindTensorMemoryARM}, {"vkBindVideoSessionMemoryKHR", vkBindVideoSessionMemoryKHR}, {"vkBuildAccelerationStructuresKHR", vkBuildAccelerationStructuresKHR}, {"vkBuildMicromapsEXT", vkBuildMicromapsEXT}, @@ -6861,6 +7000,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdCopyMicromapEXT", vkCmdCopyMicromapEXT}, {"vkCmdCopyMicromapToMemoryEXT", vkCmdCopyMicromapToMemoryEXT}, {"vkCmdCopyQueryPoolResults", vkCmdCopyQueryPoolResults}, + {"vkCmdCopyTensorARM", vkCmdCopyTensorARM}, {"vkCmdCuLaunchKernelNVX", vkCmdCuLaunchKernelNVX}, {"vkCmdDebugMarkerBeginEXT", vkCmdDebugMarkerBeginEXT}, {"vkCmdDebugMarkerEndEXT", vkCmdDebugMarkerEndEXT}, @@ -7119,6 +7259,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateShaderModule", vkCreateShaderModule}, {"vkCreateShadersEXT", vkCreateShadersEXT}, {"vkCreateSwapchainKHR", vkCreateSwapchainKHR}, + {"vkCreateTensorARM", vkCreateTensorARM}, + {"vkCreateTensorViewARM", vkCreateTensorViewARM}, {"vkCreateValidationCacheEXT", vkCreateValidationCacheEXT}, {"vkCreateVideoSessionKHR", vkCreateVideoSessionKHR}, {"vkCreateVideoSessionParametersKHR", vkCreateVideoSessionParametersKHR}, @@ -7163,6 +7305,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyShaderEXT", vkDestroyShaderEXT}, {"vkDestroyShaderModule", vkDestroyShaderModule}, {"vkDestroySwapchainKHR", vkDestroySwapchainKHR}, + {"vkDestroyTensorARM", vkDestroyTensorARM}, + {"vkDestroyTensorViewARM", vkDestroyTensorViewARM}, {"vkDestroyValidationCacheEXT", vkDestroyValidationCacheEXT}, {"vkDestroyVideoSessionKHR", vkDestroyVideoSessionKHR}, {"vkDestroyVideoSessionParametersKHR", vkDestroyVideoSessionParametersKHR}, @@ -7220,6 +7364,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetDeviceQueue", vkGetDeviceQueue}, {"vkGetDeviceQueue2", vkGetDeviceQueue2}, {"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI}, + {"vkGetDeviceTensorMemoryRequirementsARM", vkGetDeviceTensorMemoryRequirementsARM}, {"vkGetDynamicRenderingTilePropertiesQCOM", vkGetDynamicRenderingTilePropertiesQCOM}, {"vkGetEncodedVideoSessionParametersKHR", vkGetEncodedVideoSessionParametersKHR}, {"vkGetEventStatus", vkGetEventStatus}, @@ -7276,6 +7421,9 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetShaderModuleCreateInfoIdentifierEXT", vkGetShaderModuleCreateInfoIdentifierEXT}, {"vkGetShaderModuleIdentifierEXT", vkGetShaderModuleIdentifierEXT}, {"vkGetSwapchainImagesKHR", vkGetSwapchainImagesKHR}, + {"vkGetTensorMemoryRequirementsARM", vkGetTensorMemoryRequirementsARM}, + {"vkGetTensorOpaqueCaptureDescriptorDataARM", vkGetTensorOpaqueCaptureDescriptorDataARM}, + {"vkGetTensorViewOpaqueCaptureDescriptorDataARM", vkGetTensorViewOpaqueCaptureDescriptorDataARM}, {"vkGetValidationCacheDataEXT", vkGetValidationCacheDataEXT}, {"vkGetVideoSessionMemoryRequirementsKHR", vkGetVideoSessionMemoryRequirementsKHR}, {"vkInitializePerformanceApiINTEL", vkInitializePerformanceApiINTEL}, @@ -7334,6 +7482,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkUpdateIndirectExecutionSetShaderEXT", vkUpdateIndirectExecutionSetShaderEXT}, {"vkUpdateVideoSessionParametersKHR", vkUpdateVideoSessionParametersKHR}, {"vkWaitForFences", vkWaitForFences}, + {"vkWaitForPresent2KHR", vkWaitForPresent2KHR}, {"vkWaitForPresentKHR", vkWaitForPresentKHR}, {"vkWaitSemaphores", vkWaitSemaphores}, {"vkWaitSemaphoresKHR", vkWaitSemaphoresKHR}, @@ -7359,6 +7508,7 @@ static const struct vulkan_func vk_phys_dev_dispatch_table[] = {"vkGetPhysicalDeviceExternalFencePropertiesKHR", vkGetPhysicalDeviceExternalFencePropertiesKHR}, {"vkGetPhysicalDeviceExternalSemaphoreProperties", vkGetPhysicalDeviceExternalSemaphoreProperties}, {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", vkGetPhysicalDeviceExternalSemaphorePropertiesKHR}, + {"vkGetPhysicalDeviceExternalTensorPropertiesARM", vkGetPhysicalDeviceExternalTensorPropertiesARM}, {"vkGetPhysicalDeviceFeatures", vkGetPhysicalDeviceFeatures}, {"vkGetPhysicalDeviceFeatures2", vkGetPhysicalDeviceFeatures2}, {"vkGetPhysicalDeviceFeatures2KHR", vkGetPhysicalDeviceFeatures2KHR}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index b0451321125..91c222d3390 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -40,6 +40,7 @@ enum unix_call unix_vkBindImageMemory2, unix_vkBindImageMemory2KHR, unix_vkBindOpticalFlowSessionImageNV, + unix_vkBindTensorMemoryARM, unix_vkBindVideoSessionMemoryKHR, unix_vkBuildAccelerationStructuresKHR, unix_vkBuildMicromapsEXT, @@ -110,6 +111,7 @@ enum unix_call unix_vkCmdCopyMicromapEXT, unix_vkCmdCopyMicromapToMemoryEXT, unix_vkCmdCopyQueryPoolResults, + unix_vkCmdCopyTensorARM, unix_vkCmdCuLaunchKernelNVX, unix_vkCmdDebugMarkerBeginEXT, unix_vkCmdDebugMarkerEndEXT, @@ -372,6 +374,8 @@ enum unix_call unix_vkCreateShaderModule, unix_vkCreateShadersEXT, unix_vkCreateSwapchainKHR, + unix_vkCreateTensorARM, + unix_vkCreateTensorViewARM, unix_vkCreateValidationCacheEXT, unix_vkCreateVideoSessionKHR, unix_vkCreateVideoSessionParametersKHR, @@ -422,6 +426,8 @@ enum unix_call unix_vkDestroyShaderModule, unix_vkDestroySurfaceKHR, unix_vkDestroySwapchainKHR, + unix_vkDestroyTensorARM, + unix_vkDestroyTensorViewARM, unix_vkDestroyValidationCacheEXT, unix_vkDestroyVideoSessionKHR, unix_vkDestroyVideoSessionParametersKHR, @@ -486,6 +492,7 @@ enum unix_call unix_vkGetDeviceQueue, unix_vkGetDeviceQueue2, unix_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, + unix_vkGetDeviceTensorMemoryRequirementsARM, unix_vkGetDynamicRenderingTilePropertiesQCOM, unix_vkGetEncodedVideoSessionParametersKHR, unix_vkGetEventStatus, @@ -525,6 +532,7 @@ enum unix_call unix_vkGetPhysicalDeviceExternalFencePropertiesKHR, unix_vkGetPhysicalDeviceExternalSemaphoreProperties, unix_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, + unix_vkGetPhysicalDeviceExternalTensorPropertiesARM, unix_vkGetPhysicalDeviceFeatures, unix_vkGetPhysicalDeviceFeatures2, unix_vkGetPhysicalDeviceFeatures2KHR, @@ -593,6 +601,9 @@ enum unix_call unix_vkGetShaderModuleCreateInfoIdentifierEXT, unix_vkGetShaderModuleIdentifierEXT, unix_vkGetSwapchainImagesKHR, + unix_vkGetTensorMemoryRequirementsARM, + unix_vkGetTensorOpaqueCaptureDescriptorDataARM, + unix_vkGetTensorViewOpaqueCaptureDescriptorDataARM, unix_vkGetValidationCacheDataEXT, unix_vkGetVideoSessionMemoryRequirementsKHR, unix_vkInitializePerformanceApiINTEL, @@ -652,6 +663,7 @@ enum unix_call unix_vkUpdateIndirectExecutionSetShaderEXT, unix_vkUpdateVideoSessionParametersKHR, unix_vkWaitForFences, + unix_vkWaitForPresent2KHR, unix_vkWaitForPresentKHR, unix_vkWaitSemaphores, unix_vkWaitSemaphoresKHR, @@ -800,6 +812,14 @@ struct vkBindOpticalFlowSessionImageNV_params VkResult result; }; +struct vkBindTensorMemoryARM_params +{ + VkDevice device; + uint32_t bindInfoCount; + const VkBindTensorMemoryInfoARM *pBindInfos; + VkResult result; +}; + struct vkBindVideoSessionMemoryKHR_params { VkDevice device; @@ -1345,6 +1365,12 @@ struct vkCmdCopyQueryPoolResults_params VkQueryResultFlags flags; }; +struct vkCmdCopyTensorARM_params +{ + VkCommandBuffer commandBuffer; + const VkCopyTensorInfoARM *pCopyTensorInfo; +}; + struct vkCmdCuLaunchKernelNVX_params { VkCommandBuffer commandBuffer; @@ -1429,6 +1455,7 @@ struct vkCmdDispatchIndirect_params struct vkCmdDispatchTileQCOM_params { VkCommandBuffer commandBuffer; + const VkDispatchTileInfoQCOM *pDispatchTileInfo; }; struct vkCmdDraw_params @@ -3357,6 +3384,24 @@ struct vkCreateSwapchainKHR_params VkResult result; }; +struct vkCreateTensorARM_params +{ + VkDevice device; + const VkTensorCreateInfoARM *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkTensorARM *pTensor; + VkResult result; +}; + +struct vkCreateTensorViewARM_params +{ + VkDevice device; + const VkTensorViewCreateInfoARM *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkTensorViewARM *pView; + VkResult result; +}; + struct vkCreateValidationCacheEXT_params { VkDevice device; @@ -3718,6 +3763,20 @@ struct vkDestroySwapchainKHR_params const VkAllocationCallbacks *pAllocator; }; +struct vkDestroyTensorARM_params +{ + VkDevice device; + VkTensorARM DECLSPEC_ALIGN(8) tensor; + const VkAllocationCallbacks *pAllocator; +}; + +struct vkDestroyTensorViewARM_params +{ + VkDevice device; + VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; + const VkAllocationCallbacks *pAllocator; +}; + struct vkDestroyValidationCacheEXT_params { VkDevice device; @@ -4201,6 +4260,13 @@ struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params VkResult result; }; +struct vkGetDeviceTensorMemoryRequirementsARM_params +{ + VkDevice device; + const VkDeviceTensorMemoryRequirementsARM *pInfo; + VkMemoryRequirements2 *pMemoryRequirements; +}; + struct vkGetDynamicRenderingTilePropertiesQCOM_params { VkDevice device; @@ -4500,6 +4566,13 @@ struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params VkExternalSemaphoreProperties *pExternalSemaphoreProperties; }; +struct vkGetPhysicalDeviceExternalTensorPropertiesARM_params +{ + VkPhysicalDevice physicalDevice; + const VkPhysicalDeviceExternalTensorInfoARM *pExternalTensorInfo; + VkExternalTensorPropertiesARM *pExternalTensorProperties; +}; + struct vkGetPhysicalDeviceFeatures_params { VkPhysicalDevice physicalDevice; @@ -5051,6 +5124,29 @@ struct vkGetSwapchainImagesKHR_params VkResult result; }; +struct vkGetTensorMemoryRequirementsARM_params +{ + VkDevice device; + const VkTensorMemoryRequirementsInfoARM *pInfo; + VkMemoryRequirements2 *pMemoryRequirements; +}; + +struct vkGetTensorOpaqueCaptureDescriptorDataARM_params +{ + VkDevice device; + const VkTensorCaptureDescriptorDataInfoARM *pInfo; + void *pData; + VkResult result; +}; + +struct vkGetTensorViewOpaqueCaptureDescriptorDataARM_params +{ + VkDevice device; + const VkTensorViewCaptureDescriptorDataInfoARM *pInfo; + void *pData; + VkResult result; +}; + struct vkGetValidationCacheDataEXT_params { VkDevice device; @@ -5504,6 +5600,14 @@ struct vkWaitForFences_params VkResult result; }; +struct vkWaitForPresent2KHR_params +{ + VkDevice device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + const VkPresentWait2InfoKHR *pPresentWait2Info; + VkResult result; +}; + struct vkWaitForPresentKHR_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 3ee113377a4..d7c1cb33198 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -64,7 +64,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler()) -VK_XML_VERSION = "1.4.315" +VK_XML_VERSION = "1.4.318" WINE_VK_VERSION = (1, 4) # Filenames to create. diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 38ece69ec30..c84703a82b6 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -155,6 +155,13 @@ typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32 } VkMemoryOpaqueCaptureAddressAllocateInfo32; typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32; +typedef struct VkMemoryDedicatedAllocateInfoTensorARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkMemoryDedicatedAllocateInfoTensorARM32; + typedef struct VkMemoryAllocateInfo32 { VkStructureType sType; @@ -366,6 +373,15 @@ typedef struct VkBindImageMemoryInfo32 } VkBindImageMemoryInfo32; typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32; +typedef struct VkBindTensorMemoryInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorARM DECLSPEC_ALIGN(8) tensor; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; +} VkBindTensorMemoryInfoARM32; + typedef struct VkBindVideoSessionMemoryInfoKHR32 { VkStructureType sType; @@ -629,6 +645,13 @@ typedef struct VkSubpassBeginInfo32 } VkSubpassBeginInfo32; typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32; +typedef struct VkAttachmentFeedbackLoopInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 feedbackLoopEnable; +} VkAttachmentFeedbackLoopInfoEXT32; + typedef struct VkRenderingAttachmentInfo32 { VkStructureType sType; @@ -1328,6 +1351,26 @@ typedef struct VkCopyMicromapToMemoryInfoEXT32 VkCopyMicromapModeEXT mode; } VkCopyMicromapToMemoryInfoEXT32; +typedef struct VkTensorCopyARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t dimensionCount; + PTR32 pSrcOffset; + PTR32 pDstOffset; + PTR32 pExtent; +} VkTensorCopyARM32; + +typedef struct VkCopyTensorInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorARM DECLSPEC_ALIGN(8) srcTensor; + VkTensorARM DECLSPEC_ALIGN(8) dstTensor; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyTensorInfoARM32; + typedef struct VkCuLaunchInfoNVX32 { VkStructureType sType; @@ -1566,6 +1609,28 @@ typedef struct StdVideoH265PictureParameterSet32 PTR32 pPredictorPaletteEntries; } StdVideoH265PictureParameterSet32; +typedef struct StdVideoDecodeVP9PictureInfo32 +{ + StdVideoDecodeVP9PictureInfoFlags flags; + StdVideoVP9Profile profile; + StdVideoVP9FrameType frame_type; + uint8_t frame_context_idx; + uint8_t reset_frame_context; + uint8_t refresh_frame_flags; + uint8_t ref_frame_sign_bias_mask; + StdVideoVP9InterpolationFilter interpolation_filter; + uint8_t base_q_idx; + int8_t delta_q_y_dc; + int8_t delta_q_uv_dc; + int8_t delta_q_uv_ac; + uint8_t tile_cols_log2; + uint8_t tile_rows_log2; + uint16_t reserved1[3]; + PTR32 pColorConfig; + PTR32 pLoopFilter; + PTR32 pSegmentation; +} StdVideoDecodeVP9PictureInfo32; + typedef struct StdVideoAV1SequenceHeader32 { StdVideoAV1SequenceHeaderFlags flags; @@ -1670,6 +1735,17 @@ typedef struct VkVideoDecodeH265PictureInfoKHR32 PTR32 pSliceSegmentOffsets; } VkVideoDecodeH265PictureInfoKHR32; +typedef struct VkVideoDecodeVP9PictureInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]; + uint32_t uncompressedHeaderOffset; + uint32_t compressedHeaderOffset; + uint32_t tilesOffset; +} VkVideoDecodeVP9PictureInfoKHR32; + typedef struct VkVideoDecodeAV1InlineSessionParametersInfoKHR32 { VkStructureType sType; @@ -1712,6 +1788,12 @@ typedef struct VkDecompressMemoryRegionNV32 VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod; } VkDecompressMemoryRegionNV32; +typedef struct VkDispatchTileInfoQCOM32 +{ + VkStructureType sType; + PTR32 pNext; +} VkDispatchTileInfoQCOM32; + typedef struct StdVideoEncodeH264SliceHeader32 { StdVideoEncodeH264SliceHeaderFlags flags; @@ -2035,6 +2117,19 @@ typedef struct VkImageMemoryBarrier32 VkImageSubresourceRange subresourceRange; } VkImageMemoryBarrier32; +typedef struct VkTensorMemoryBarrierARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkTensorMemoryBarrierARM32; + typedef struct VkMemoryBarrier232 { VkStructureType sType; @@ -2087,6 +2182,14 @@ typedef struct VkImageMemoryBarrier232 } VkImageMemoryBarrier232; typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32; +typedef struct VkTensorDependencyInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t tensorMemoryBarrierCount; + PTR32 pTensorMemoryBarriers; +} VkTensorDependencyInfoARM32; + typedef struct VkDependencyInfo32 { VkStructureType sType; @@ -2160,6 +2263,14 @@ typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV32 PTR32 pAccelerationStructures; } VkWriteDescriptorSetPartitionedAccelerationStructureNV32; +typedef struct VkWriteDescriptorSetTensorARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t tensorViewCount; + PTR32 pTensorViews; +} VkWriteDescriptorSetTensorARM32; + typedef struct VkWriteDescriptorSet32 { VkStructureType sType; @@ -2429,6 +2540,13 @@ typedef struct VkVideoDecodeH265ProfileInfoKHR32 StdVideoH265ProfileIdc stdProfileIdc; } VkVideoDecodeH265ProfileInfoKHR32; +typedef struct VkVideoDecodeVP9ProfileInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + StdVideoVP9Profile stdProfile; +} VkVideoDecodeVP9ProfileInfoKHR32; + typedef struct VkVideoDecodeAV1ProfileInfoKHR32 { VkStructureType sType; @@ -2933,6 +3051,13 @@ typedef struct VkPhysicalDevicePresentIdFeaturesKHR32 VkBool32 presentId; } VkPhysicalDevicePresentIdFeaturesKHR32; +typedef struct VkPhysicalDevicePresentId2FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 presentId2; +} VkPhysicalDevicePresentId2FeaturesKHR32; + typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32 { VkStructureType sType; @@ -2940,6 +3065,13 @@ typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32 VkBool32 presentWait; } VkPhysicalDevicePresentWaitFeaturesKHR32; +typedef struct VkPhysicalDevicePresentWait2FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 presentWait2; +} VkPhysicalDevicePresentWait2FeaturesKHR32; + typedef struct VkPhysicalDevice16BitStorageFeatures32 { VkStructureType sType; @@ -3028,6 +3160,13 @@ typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR32 VkBool32 maintenance8; } VkPhysicalDeviceMaintenance8FeaturesKHR32; +typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 maintenance9; +} VkPhysicalDeviceMaintenance9FeaturesKHR32; + typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32 { VkStructureType sType; @@ -3993,6 +4132,14 @@ typedef struct VkPhysicalDeviceSynchronization2Features32 } VkPhysicalDeviceSynchronization2Features32; typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32; +typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 unifiedImageLayouts; + VkBool32 unifiedImageLayoutsVideo; +} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32; + typedef struct VkPhysicalDeviceHostImageCopyFeatures32 { VkStructureType sType; @@ -4046,6 +4193,13 @@ typedef struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR32 VkBool32 videoMaintenance2; } VkPhysicalDeviceVideoMaintenance2FeaturesKHR32; +typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 videoDecodeVP9; +} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32; + typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 { VkStructureType sType; @@ -4677,6 +4831,47 @@ typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM32 VkBool32 tileShadingImageProcessing; } VkPhysicalDeviceTileShadingFeaturesQCOM32; +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 fragmentDensityMapLayered; +} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32; + +typedef struct VkPhysicalDeviceFormatPackFeaturesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 formatPack; +} VkPhysicalDeviceFormatPackFeaturesARM32; + +typedef struct VkPhysicalDeviceTensorFeaturesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 tensorNonPacked; + VkBool32 shaderTensorAccess; + VkBool32 shaderStorageTensorArrayDynamicIndexing; + VkBool32 shaderStorageTensorArrayNonUniformIndexing; + VkBool32 descriptorBindingStorageTensorUpdateAfterBind; + VkBool32 tensors; +} VkPhysicalDeviceTensorFeaturesARM32; + +typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 descriptorBufferTensorDescriptors; +} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32; + +typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderFloat8; + VkBool32 shaderFloat8CooperativeMatrix; +} VkPhysicalDeviceShaderFloat8FeaturesEXT32; + typedef struct VkDeviceCreateInfo32 { VkStructureType sType; @@ -5117,6 +5312,13 @@ typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32 VkGraphicsPipelineLibraryFlagsEXT flags; } VkGraphicsPipelineLibraryCreateInfoEXT32; +typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32; + typedef struct VkGraphicsPipelineCreateInfo32 { VkStructureType sType; @@ -6022,6 +6224,45 @@ typedef struct VkSwapchainCreateInfoKHR32 VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain; } VkSwapchainCreateInfoKHR32; +typedef struct VkTensorDescriptionARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorTilingARM tiling; + VkFormat format; + uint32_t dimensionCount; + PTR32 pDimensions; + PTR32 pStrides; + VkTensorUsageFlagsARM DECLSPEC_ALIGN(8) usage; +} VkTensorDescriptionARM32; + +typedef struct VkExternalMemoryTensorCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryTensorCreateInfoARM32; + +typedef struct VkTensorCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags; + PTR32 pDescription; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + PTR32 pQueueFamilyIndices; +} VkTensorCreateInfoARM32; + +typedef struct VkTensorViewCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorViewCreateFlagsARM DECLSPEC_ALIGN(8) flags; + VkTensorARM DECLSPEC_ALIGN(8) tensor; + VkFormat format; +} VkTensorViewCreateInfoARM32; + typedef struct VkValidationCacheCreateInfoEXT32 { VkStructureType sType; @@ -6373,6 +6614,13 @@ typedef union VkDescriptorDataEXT32 VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure; } VkDescriptorDataEXT32; +typedef struct VkDescriptorGetTensorInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; +} VkDescriptorGetTensorInfoARM32; + typedef struct VkDescriptorGetInfoEXT32 { VkStructureType sType; @@ -6571,6 +6819,13 @@ typedef struct VkDeviceQueueInfo232 uint32_t queueIndex; } VkDeviceQueueInfo232; +typedef struct VkDeviceTensorMemoryRequirementsARM32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pCreateInfo; +} VkDeviceTensorMemoryRequirementsARM32; + typedef struct VkTilePropertiesQCOM32 { VkStructureType sType; @@ -6878,6 +7133,22 @@ typedef struct VkExternalSemaphoreProperties32 } VkExternalSemaphoreProperties32; typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32; +typedef struct VkPhysicalDeviceExternalTensorInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags; + PTR32 pDescription; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalTensorInfoARM32; + +typedef struct VkExternalTensorPropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalTensorPropertiesARM32; + typedef struct VkSubpassResolvePerformanceQueryEXT32 { VkStructureType sType; @@ -6895,6 +7166,14 @@ typedef struct VkFormatProperties332 } VkFormatProperties332; typedef VkFormatProperties332 VkFormatProperties3KHR32; +typedef struct VkTensorFormatPropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingTensorFeatures; + VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingTensorFeatures; +} VkTensorFormatPropertiesARM32; + typedef struct VkFormatProperties232 { VkStructureType sType; @@ -7354,6 +7633,14 @@ typedef struct VkPhysicalDeviceMaintenance6Properties32 } VkPhysicalDeviceMaintenance6Properties32; typedef VkPhysicalDeviceMaintenance6Properties32 VkPhysicalDeviceMaintenance6PropertiesKHR32; +typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 image2DViewOf3DSparse; + VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue; +} VkPhysicalDeviceMaintenance9PropertiesKHR32; + typedef struct VkPhysicalDeviceFloatControlsProperties32 { VkStructureType sType; @@ -8316,6 +8603,41 @@ typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM32 VkExtent2D maxTileShadingRate; } VkPhysicalDeviceTileShadingPropertiesQCOM32; +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32; + +typedef struct VkPhysicalDeviceTensorPropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxTensorDimensionCount; + uint64_t DECLSPEC_ALIGN(8) maxTensorElements; + uint64_t DECLSPEC_ALIGN(8) maxPerDimensionTensorElements; + int64_t maxTensorStride; + uint64_t DECLSPEC_ALIGN(8) maxTensorSize; + uint32_t maxTensorShaderAccessArrayLength; + uint32_t maxTensorShaderAccessSize; + uint32_t maxDescriptorSetStorageTensors; + uint32_t maxPerStageDescriptorSetStorageTensors; + uint32_t maxDescriptorSetUpdateAfterBindStorageTensors; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors; + VkBool32 shaderStorageTensorArrayNonUniformIndexingNative; + VkShaderStageFlags shaderTensorSupportedStages; +} VkPhysicalDeviceTensorPropertiesARM32; + +typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 tensorCaptureReplayDescriptorDataSize; + PTR32 tensorViewCaptureReplayDescriptorDataSize; + PTR32 tensorDescriptorSize; +} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32; + typedef struct VkPhysicalDeviceProperties232 { VkStructureType sType; @@ -8324,6 +8646,13 @@ typedef struct VkPhysicalDeviceProperties232 } VkPhysicalDeviceProperties232; typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32; +typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t optimalImageTransferToQueueFamilies; +} VkQueueFamilyOwnershipTransferPropertiesKHR32; + typedef struct VkQueueFamilyGlobalPriorityProperties32 { VkStructureType sType; @@ -8421,6 +8750,20 @@ typedef struct VkSurfaceCapabilitiesPresentBarrierNV32 VkBool32 presentBarrierSupported; } VkSurfaceCapabilitiesPresentBarrierNV32; +typedef struct VkSurfaceCapabilitiesPresentId2KHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 presentId2Supported; +} VkSurfaceCapabilitiesPresentId2KHR32; + +typedef struct VkSurfaceCapabilitiesPresentWait2KHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 presentWait2Supported; +} VkSurfaceCapabilitiesPresentWait2KHR32; + typedef struct VkSurfacePresentScalingCapabilitiesEXT32 { VkStructureType sType; @@ -8527,6 +8870,13 @@ typedef struct VkVideoDecodeH265CapabilitiesKHR32 StdVideoH265LevelIdc maxLevelIdc; } VkVideoDecodeH265CapabilitiesKHR32; +typedef struct VkVideoDecodeVP9CapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + StdVideoVP9Level maxLevel; +} VkVideoDecodeVP9CapabilitiesKHR32; + typedef struct VkVideoDecodeAV1CapabilitiesKHR32 { VkStructureType sType; @@ -8853,6 +9203,27 @@ typedef struct VkShaderModuleIdentifierEXT32 uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; } VkShaderModuleIdentifierEXT32; +typedef struct VkTensorMemoryRequirementsInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkTensorMemoryRequirementsInfoARM32; + +typedef struct VkTensorCaptureDescriptorDataInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkTensorCaptureDescriptorDataInfoARM32; + +typedef struct VkTensorViewCaptureDescriptorDataInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; +} VkTensorViewCaptureDescriptorDataInfoARM32; + typedef struct VkVideoSessionMemoryRequirementsKHR32 { VkStructureType sType; @@ -8969,6 +9340,14 @@ typedef struct VkFrameBoundaryEXT32 PTR32 pTag; } VkFrameBoundaryEXT32; +typedef struct VkFrameBoundaryTensorsARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t tensorCount; + PTR32 pTensors; +} VkFrameBoundaryTensorsARM32; + typedef struct VkBindSparseInfo32 { VkStructureType sType; @@ -9023,6 +9402,14 @@ typedef struct VkPresentIdKHR32 PTR32 pPresentIds; } VkPresentIdKHR32; +typedef struct VkPresentId2KHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t swapchainCount; + PTR32 pPresentIds; +} VkPresentId2KHR32; + typedef struct VkSwapchainPresentFenceInfoEXT32 { VkStructureType sType; @@ -9297,6 +9684,14 @@ typedef struct VkVideoSessionParametersUpdateInfoKHR32 uint32_t updateSequenceCount; } VkVideoSessionParametersUpdateInfoKHR32; +typedef struct VkPresentWait2InfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint64_t DECLSPEC_ALIGN(8) presentId; + uint64_t DECLSPEC_ALIGN(8) timeout; +} VkPresentWait2InfoKHR32; + typedef struct VkSemaphoreWaitInfo32 { VkStructureType sType; @@ -9567,6 +9962,17 @@ static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + { + VkMemoryDedicatedAllocateInfoTensorARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryDedicatedAllocateInfoTensorARM32 *in_ext = (const VkMemoryDedicatedAllocateInfoTensorARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; + out_ext->pNext = NULL; + out_ext->tensor = in_ext->tensor; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -10319,6 +10725,66 @@ static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_w return out; } +#ifdef _WIN64 +static inline void convert_VkBindTensorMemoryInfoARM_win64_to_host(const VkBindTensorMemoryInfoARM *in, VkBindTensorMemoryInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->tensor = in->tensor; + out->memory = wine_device_memory_from_handle(in->memory)->host.device_memory; + out->memoryOffset = in->memoryOffset; +} +#endif /* _WIN64 */ + +static inline void convert_VkBindTensorMemoryInfoARM_win32_to_host(const VkBindTensorMemoryInfoARM32 *in, VkBindTensorMemoryInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->tensor = in->tensor; + out->memory = wine_device_memory_from_handle(in->memory)->host.device_memory; + out->memoryOffset = in->memoryOffset; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +#ifdef _WIN64 +static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM *in, uint32_t count) +{ + VkBindTensorMemoryInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkBindTensorMemoryInfoARM_win64_to_host(&in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM32 *in, uint32_t count) +{ + VkBindTensorMemoryInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkBindTensorMemoryInfoARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + #ifdef _WIN64 static inline void convert_VkBindVideoSessionMemoryInfoKHR_win64_to_host(const VkBindVideoSessionMemoryInfoKHR *in, VkBindVideoSessionMemoryInfoKHR *out) { @@ -10915,8 +11381,11 @@ static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBegin FIXME("Unexpected pNext\n"); } -static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out) +static inline void convert_VkRenderingAttachmentInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return; out->sType = in->sType; @@ -10929,8 +11398,27 @@ static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRende out->loadOp = in->loadOp; out->storeOp = in->storeOp; out->clearValue = in->clearValue; - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: + { + VkAttachmentFeedbackLoopInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAttachmentFeedbackLoopInfoEXT32 *in_ext = (const VkAttachmentFeedbackLoopInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; + out_ext->pNext = NULL; + out_ext->feedbackLoopEnable = in_ext->feedbackLoopEnable; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } } static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count) @@ -10943,7 +11431,7 @@ static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkRenderingAttachmentInfo_win32_to_host(&in[i], &out[i]); + convert_VkRenderingAttachmentInfo_win32_to_host(ctx, &in[i], &out[i]); } return out; @@ -12547,6 +13035,50 @@ static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkC FIXME("Unexpected pNext\n"); } +static inline void convert_VkTensorCopyARM_win32_to_host(const VkTensorCopyARM32 *in, VkTensorCopyARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->dimensionCount = in->dimensionCount; + out->pSrcOffset = UlongToPtr(in->pSrcOffset); + out->pDstOffset = UlongToPtr(in->pDstOffset); + out->pExtent = UlongToPtr(in->pExtent); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkTensorCopyARM *convert_VkTensorCopyARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCopyARM32 *in, uint32_t count) +{ + VkTensorCopyARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkTensorCopyARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkCopyTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkCopyTensorInfoARM32 *in, VkCopyTensorInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->srcTensor = in->srcTensor; + out->dstTensor = in->dstTensor; + out->regionCount = in->regionCount; + out->pRegions = convert_VkTensorCopyARM_array_win32_to_host(ctx, (const VkTensorCopyARM32 *)UlongToPtr(in->pRegions), in->regionCount); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out) { if (!in) return; @@ -12937,6 +13469,46 @@ static inline const StdVideoH265PictureParameterSet *convert_StdVideoH265Picture return out; } +static inline void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out) +{ + if (!in) return; + + out->flags = in->flags; + out->profile = in->profile; + out->frame_type = in->frame_type; + out->frame_context_idx = in->frame_context_idx; + out->reset_frame_context = in->reset_frame_context; + out->refresh_frame_flags = in->refresh_frame_flags; + out->ref_frame_sign_bias_mask = in->ref_frame_sign_bias_mask; + out->interpolation_filter = in->interpolation_filter; + out->base_q_idx = in->base_q_idx; + out->delta_q_y_dc = in->delta_q_y_dc; + out->delta_q_uv_dc = in->delta_q_uv_dc; + out->delta_q_uv_ac = in->delta_q_uv_ac; + out->tile_cols_log2 = in->tile_cols_log2; + out->tile_rows_log2 = in->tile_rows_log2; + memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint16_t)); + out->pColorConfig = UlongToPtr(in->pColorConfig); + out->pLoopFilter = UlongToPtr(in->pLoopFilter); + out->pSegmentation = UlongToPtr(in->pSegmentation); +} + +static inline const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count) +{ + StdVideoDecodeVP9PictureInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_StdVideoDecodeVP9PictureInfo_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static inline void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out) { if (!in) return; @@ -13137,6 +13709,21 @@ static inline void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: + { + VkVideoDecodeVP9PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeVP9PictureInfoKHR32 *in_ext = (const VkVideoDecodeVP9PictureInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pStdPictureInfo = convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(ctx, (const StdVideoDecodeVP9PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1); + memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR * sizeof(int32_t)); + out_ext->uncompressedHeaderOffset = in_ext->uncompressedHeaderOffset; + out_ext->compressedHeaderOffset = in_ext->compressedHeaderOffset; + out_ext->tilesOffset = in_ext->tilesOffset; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: { VkVideoDecodeAV1InlineSessionParametersInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -13198,6 +13785,16 @@ static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegion return out; } +static inline void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInfoQCOM32 *in, VkDispatchTileInfoQCOM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const StdVideoEncodeH264SliceHeader32 *in, StdVideoEncodeH264SliceHeader *out) { if (!in) return; @@ -13959,6 +14556,39 @@ static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win return out; } +static inline void convert_VkTensorMemoryBarrierARM_win32_to_host(const VkTensorMemoryBarrierARM32 *in, VkTensorMemoryBarrierARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->srcStageMask = in->srcStageMask; + out->srcAccessMask = in->srcAccessMask; + out->dstStageMask = in->dstStageMask; + out->dstAccessMask = in->dstAccessMask; + out->srcQueueFamilyIndex = in->srcQueueFamilyIndex; + out->dstQueueFamilyIndex = in->dstQueueFamilyIndex; + out->tensor = in->tensor; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkTensorMemoryBarrierARM *convert_VkTensorMemoryBarrierARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorMemoryBarrierARM32 *in, uint32_t count) +{ + VkTensorMemoryBarrierARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkTensorMemoryBarrierARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out) { if (!in) return; @@ -14144,6 +14774,9 @@ static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_w static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return; out->sType = in->sType; @@ -14155,8 +14788,45 @@ static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_cont out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, (const VkBufferMemoryBarrier232 *)UlongToPtr(in->pBufferMemoryBarriers), in->bufferMemoryBarrierCount); out->imageMemoryBarrierCount = in->imageMemoryBarrierCount; out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, (const VkImageMemoryBarrier232 *)UlongToPtr(in->pImageMemoryBarriers), in->imageMemoryBarrierCount); - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: + { + VkTensorMemoryBarrierARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTensorMemoryBarrierARM32 *in_ext = (const VkTensorMemoryBarrierARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; + out_ext->pNext = NULL; + out_ext->srcStageMask = in_ext->srcStageMask; + out_ext->srcAccessMask = in_ext->srcAccessMask; + out_ext->dstStageMask = in_ext->dstStageMask; + out_ext->dstAccessMask = in_ext->dstAccessMask; + out_ext->srcQueueFamilyIndex = in_ext->srcQueueFamilyIndex; + out_ext->dstQueueFamilyIndex = in_ext->dstQueueFamilyIndex; + out_ext->tensor = in_ext->tensor; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + { + VkTensorDependencyInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTensorDependencyInfoARM32 *in_ext = (const VkTensorDependencyInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; + out_ext->pNext = NULL; + out_ext->tensorMemoryBarrierCount = in_ext->tensorMemoryBarrierCount; + out_ext->pTensorMemoryBarriers = convert_VkTensorMemoryBarrierARM_array_win32_to_host(ctx, (const VkTensorMemoryBarrierARM32 *)UlongToPtr(in_ext->pTensorMemoryBarriers), 1); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } } static inline void convert_VkPushConstantsInfo_win32_to_host(struct conversion_context *ctx, const VkPushConstantsInfo32 *in, VkPushConstantsInfo *out) @@ -14320,6 +14990,18 @@ static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: + { + VkWriteDescriptorSetTensorARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkWriteDescriptorSetTensorARM32 *in_ext = (const VkWriteDescriptorSetTensorARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; + out_ext->pNext = NULL; + out_ext->tensorViewCount = in_ext->tensorViewCount; + out_ext->pTensorViews = UlongToPtr(in_ext->pTensorViews); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -14983,6 +15665,17 @@ static inline void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + { + VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeVP9ProfileInfoKHR32 *in_ext = (const VkVideoDecodeVP9ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stdProfile = in_ext->stdProfile; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: { VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -16223,6 +16916,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + { + VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->presentId2 = in_ext->presentId2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -16234,6 +16938,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + { + VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->presentWait2 = in_ext->presentWait2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -16359,6 +17074,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->maintenance9 = in_ext->maintenance9; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -17693,6 +18419,18 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + { + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -17772,6 +18510,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + { + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -18732,6 +19481,65 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + { + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + { + VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->formatPack = in_ext->formatPack; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + { + VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -18880,6 +19688,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + { + VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->presentId2 = in_ext->presentId2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -18891,6 +19710,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + { + VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->presentWait2 = in_ext->presentWait2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -19016,6 +19846,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->maintenance9 = in_ext->maintenance9; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20350,6 +21191,18 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + { + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20429,6 +21282,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + { + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -21389,6 +22253,65 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + { + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + { + VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->formatPack = in_ext->formatPack; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + { + VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -22467,6 +23390,17 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: + { + VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; + out_ext->pNext = NULL; + out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -22708,6 +23642,17 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: + { + VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; + out_ext->pNext = NULL; + out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -24018,6 +24963,17 @@ static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + { + VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeVP9ProfileInfoKHR32 *in_ext = (const VkVideoDecodeVP9ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stdProfile = in_ext->stdProfile; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: { VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -25502,6 +26458,121 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(stru } } +static inline void convert_VkTensorDescriptionARM_win32_to_host(const VkTensorDescriptionARM32 *in, VkTensorDescriptionARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->tiling = in->tiling; + out->format = in->format; + out->dimensionCount = in->dimensionCount; + out->pDimensions = UlongToPtr(in->pDimensions); + out->pStrides = UlongToPtr(in->pStrides); + out->usage = in->usage; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkTensorDescriptionARM *convert_VkTensorDescriptionARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorDescriptionARM32 *in, uint32_t count) +{ + VkTensorDescriptionARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkTensorDescriptionARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, VkTensorCreateInfoARM *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->pDescription = convert_VkTensorDescriptionARM_array_win32_to_host(ctx, (const VkTensorDescriptionARM32 *)UlongToPtr(in->pDescription), 1); + out->sharingMode = in->sharingMode; + out->queueFamilyIndexCount = in->queueFamilyIndexCount; + out->pQueueFamilyIndices = UlongToPtr(in->pQueueFamilyIndices); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + { + VkExternalMemoryTensorCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExternalMemoryTensorCreateInfoARM32 *in_ext = (const VkExternalMemoryTensorCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->handleTypes = in_ext->handleTypes; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + +static inline void convert_VkTensorViewCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorViewCreateInfoARM32 *in, VkTensorViewCreateInfoARM *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->tensor = in->tensor; + out->format = in->format; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out) { if (!in) return; @@ -26392,14 +27463,36 @@ static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_c static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return; out->sType = in->sType; out->pNext = NULL; out->type = in->type; convert_VkDescriptorDataEXT_win32_to_host(ctx, &in->data, &out->data, in->type); - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: + { + VkDescriptorGetTensorInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDescriptorGetTensorInfoARM32 *in_ext = (const VkDescriptorGetTensorInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; + out_ext->pNext = NULL; + out_ext->tensorView = in_ext->tensorView; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } } static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out) @@ -26994,6 +28087,33 @@ static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueI FIXME("Unexpected pNext\n"); } +static inline const VkTensorCreateInfoARM *convert_VkTensorCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, uint32_t count) +{ + VkTensorCreateInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkTensorCreateInfoARM_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(struct conversion_context *ctx, const VkDeviceTensorMemoryRequirementsARM32 *in, VkDeviceTensorMemoryRequirementsARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pCreateInfo = convert_VkTensorCreateInfoARM_array_win32_to_host(ctx, (const VkTensorCreateInfoARM32 *)UlongToPtr(in->pCreateInfo), 1); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out) { if (!in) return; @@ -27851,6 +28971,37 @@ static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkE out->externalSemaphoreFeatures = in->externalSemaphoreFeatures; } +static inline void convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalTensorInfoARM32 *in, VkPhysicalDeviceExternalTensorInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->pDescription = convert_VkTensorDescriptionARM_array_win32_to_host(ctx, (const VkTensorDescriptionARM32 *)UlongToPtr(in->pDescription), 1); + out->handleType = in->handleType; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkExternalTensorPropertiesARM_win32_to_host(const VkExternalTensorPropertiesARM32 *in, VkExternalTensorPropertiesARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->externalMemoryProperties = in->externalMemoryProperties; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkExternalTensorPropertiesARM_host_to_win32(const VkExternalTensorPropertiesARM *in, VkExternalTensorPropertiesARM32 *out) +{ + if (!in) return; + + out->externalMemoryProperties = in->externalMemoryProperties; +} + static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out) { const VkBaseInStructure32 *in_header; @@ -27948,6 +29099,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + { + VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->presentId2 = in_ext->presentId2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -27959,6 +29121,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + { + VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->presentWait2 = in_ext->presentWait2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -28084,6 +29257,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->maintenance9 = in_ext->maintenance9; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -29385,6 +30569,18 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + { + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -29464,6 +30660,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + { + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -30402,6 +31609,65 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + { + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + { + VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->formatPack = in_ext->formatPack; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + { + VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -30490,6 +31756,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + { + VkPhysicalDevicePresentId2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR); + const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + out_ext->presentId2 = in_ext->presentId2; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR); @@ -30499,6 +31774,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + { + VkPhysicalDevicePresentWait2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR); + const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + out_ext->presentWait2 = in_ext->presentWait2; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES); @@ -30602,6 +31886,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR); + const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + out_ext->maintenance9 = in_ext->maintenance9; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES); @@ -31707,6 +33000,16 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + { + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { VkPhysicalDeviceHostImageCopyFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES); @@ -31772,6 +33075,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + { + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR); @@ -32548,6 +33860,57 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + { + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE); + const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + out_ext->fragmentDensityMapLayered = in_ext->fragmentDensityMapLayered; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + { + VkPhysicalDeviceFormatPackFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM); + const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + out_ext->formatPack = in_ext->formatPack; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM); + const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + { + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + { + VkPhysicalDeviceShaderFloat8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT); + const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + out_header = (void *)out_ext; + break; + } default: break; } @@ -32586,6 +33949,15 @@ static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + { + VkTensorFormatPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -32626,6 +33998,16 @@ static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatPrope out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: + { + VkTensorFormatPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM); + const VkTensorFormatPropertiesARM *in_ext = (const VkTensorFormatPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; + out_ext->optimalTilingTensorFeatures = in_ext->optimalTilingTensorFeatures; + out_ext->linearTilingTensorFeatures = in_ext->linearTilingTensorFeatures; + out_header = (void *)out_ext; + break; + } default: break; } @@ -33421,6 +34803,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + { + VkPhysicalDeviceMaintenance9PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -34106,6 +35497,37 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: + { + VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + { + VkPhysicalDeviceTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + { + VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; + out_ext->pNext = NULL; + out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize; + out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize; + out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -34345,6 +35767,16 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + { + VkPhysicalDeviceMaintenance9PropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR); + const VkPhysicalDeviceMaintenance9PropertiesKHR *in_ext = (const VkPhysicalDeviceMaintenance9PropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; + out_ext->image2DViewOf3DSparse = in_ext->image2DViewOf3DSparse; + out_ext->defaultVertexAttributeValue = in_ext->defaultVertexAttributeValue; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { VkPhysicalDeviceFloatControlsProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES); @@ -35443,6 +36875,47 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: + { + VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE); + const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; + out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + { + VkPhysicalDeviceTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM); + const VkPhysicalDeviceTensorPropertiesARM *in_ext = (const VkPhysicalDeviceTensorPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; + out_ext->maxTensorDimensionCount = in_ext->maxTensorDimensionCount; + out_ext->maxTensorElements = in_ext->maxTensorElements; + out_ext->maxPerDimensionTensorElements = in_ext->maxPerDimensionTensorElements; + out_ext->maxTensorStride = in_ext->maxTensorStride; + out_ext->maxTensorSize = in_ext->maxTensorSize; + out_ext->maxTensorShaderAccessArrayLength = in_ext->maxTensorShaderAccessArrayLength; + out_ext->maxTensorShaderAccessSize = in_ext->maxTensorShaderAccessSize; + out_ext->maxDescriptorSetStorageTensors = in_ext->maxDescriptorSetStorageTensors; + out_ext->maxPerStageDescriptorSetStorageTensors = in_ext->maxPerStageDescriptorSetStorageTensors; + out_ext->maxDescriptorSetUpdateAfterBindStorageTensors = in_ext->maxDescriptorSetUpdateAfterBindStorageTensors; + out_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors = in_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors; + out_ext->shaderStorageTensorArrayNonUniformIndexingNative = in_ext->shaderStorageTensorArrayNonUniformIndexingNative; + out_ext->shaderTensorSupportedStages = in_ext->shaderTensorSupportedStages; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + { + VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM); + const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; + out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize; + out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize; + out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize; + out_header = (void *)out_ext; + break; + } default: break; } @@ -35476,6 +36949,15 @@ static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct convers { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + { + VkQueueFamilyOwnershipTransferPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: { VkQueueFamilyGlobalPriorityProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -35541,6 +37023,15 @@ static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueF { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + { + VkQueueFamilyOwnershipTransferPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR); + const VkQueueFamilyOwnershipTransferPropertiesKHR *in_ext = (const VkQueueFamilyOwnershipTransferPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; + out_ext->optimalImageTransferToQueueFamilies = in_ext->optimalImageTransferToQueueFamilies; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: { VkQueueFamilyGlobalPriorityProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES); @@ -35785,6 +37276,28 @@ static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + { + VkSurfaceCapabilitiesPresentId2KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSurfaceCapabilitiesPresentId2KHR32 *in_ext = (const VkSurfaceCapabilitiesPresentId2KHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; + out_ext->pNext = NULL; + out_ext->presentId2Supported = in_ext->presentId2Supported; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + { + VkSurfaceCapabilitiesPresentWait2KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSurfaceCapabilitiesPresentWait2KHR32 *in_ext = (const VkSurfaceCapabilitiesPresentWait2KHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; + out_ext->pNext = NULL; + out_ext->presentWait2Supported = in_ext->presentWait2Supported; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: { VkSurfacePresentScalingCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -35847,6 +37360,24 @@ static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfa out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: + { + VkSurfaceCapabilitiesPresentId2KHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR); + const VkSurfaceCapabilitiesPresentId2KHR *in_ext = (const VkSurfaceCapabilitiesPresentId2KHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; + out_ext->presentId2Supported = in_ext->presentId2Supported; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: + { + VkSurfaceCapabilitiesPresentWait2KHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR); + const VkSurfaceCapabilitiesPresentWait2KHR *in_ext = (const VkSurfaceCapabilitiesPresentWait2KHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; + out_ext->presentWait2Supported = in_ext->presentWait2Supported; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: { VkSurfacePresentScalingCapabilitiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT); @@ -36099,6 +37630,15 @@ static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversio out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + { + VkVideoDecodeVP9CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: { VkVideoDecodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -36239,6 +37779,15 @@ static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCap out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: + { + VkVideoDecodeVP9CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR); + const VkVideoDecodeVP9CapabilitiesKHR *in_ext = (const VkVideoDecodeVP9CapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; + out_ext->maxLevel = in_ext->maxLevel; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: { VkVideoDecodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR); @@ -37003,6 +38552,39 @@ static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkSha memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t)); } +static inline void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const VkTensorMemoryRequirementsInfoARM32 *in, VkTensorMemoryRequirementsInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->tensor = in->tensor; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorCaptureDescriptorDataInfoARM32 *in, VkTensorCaptureDescriptorDataInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->tensor = in->tensor; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorViewCaptureDescriptorDataInfoARM32 *in, VkTensorViewCaptureDescriptorDataInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->tensorView = in->tensorView; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkVideoSessionMemoryRequirementsKHR_win32_to_host(const VkVideoSessionMemoryRequirementsKHR32 *in, VkVideoSessionMemoryRequirementsKHR *out) { if (!in) return; @@ -37527,6 +39109,18 @@ static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_cont out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + { + VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + out_ext->pNext = NULL; + out_ext->tensorCount = in_ext->tensorCount; + out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -37660,6 +39254,18 @@ static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conve out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: + { + VkPresentId2KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPresentId2KHR32 *in_ext = (const VkPresentId2KHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; + out_ext->pNext = NULL; + out_ext->swapchainCount = in_ext->swapchainCount; + out_ext->pPresentIds = UlongToPtr(in_ext->pPresentIds); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: { VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -37703,6 +39309,18 @@ static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conve out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + { + VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + out_ext->pNext = NULL; + out_ext->tensorCount = in_ext->tensorCount; + out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -37830,6 +39448,18 @@ static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + { + VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + out_ext->pNext = NULL; + out_ext->tensorCount = in_ext->tensorCount; + out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -38061,6 +39691,18 @@ static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + { + VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + out_ext->pNext = NULL; + out_ext->tensorCount = in_ext->tensorCount; + out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -38675,6 +40317,18 @@ static inline void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(s } } +static inline void convert_VkPresentWait2InfoKHR_win32_to_host(const VkPresentWait2InfoKHR32 *in, VkPresentWait2InfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->presentId = in->presentId; + out->timeout = in->timeout; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out) { if (!in) return; @@ -39273,6 +40927,46 @@ static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkBindTensorMemoryARM(void *args) +{ + struct vkBindTensorMemoryARM_params *params = args; + const VkBindTensorMemoryInfoARM *pBindInfos_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos); + + init_conversion_context(ctx); + pBindInfos_host = convert_VkBindTensorMemoryInfoARM_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount); + params->result = vulkan_device_from_handle(params->device)->p_vkBindTensorMemoryARM(vulkan_device_from_handle(params->device)->host.device, params->bindInfoCount, pBindInfos_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkBindTensorMemoryARM(void *args) +{ + struct + { + PTR32 device; + uint32_t bindInfoCount; + PTR32 pBindInfos; + VkResult result; + } *params = args; + const VkBindTensorMemoryInfoARM *pBindInfos_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos); + + init_conversion_context(ctx); + pBindInfos_host = convert_VkBindTensorMemoryInfoARM_array_win32_to_host(ctx, (const VkBindTensorMemoryInfoARM32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkBindTensorMemoryARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->bindInfoCount, pBindInfos_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkBindVideoSessionMemoryKHR(void *args) { @@ -41083,6 +42777,32 @@ static void thunk32_vkCmdCopyQueryPoolResults(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags); } +#ifdef _WIN64 +static void thunk64_vkCmdCopyTensorARM(void *args) +{ + struct vkCmdCopyTensorARM_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->p_vkCmdCopyTensorARM(wine_cmd_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->pCopyTensorInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdCopyTensorARM(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pCopyTensorInfo; + } *params = args; + VkCopyTensorInfoARM pCopyTensorInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkCopyTensorInfoARM_win32_to_host(ctx, (const VkCopyTensorInfoARM32 *)UlongToPtr(params->pCopyTensorInfo), &pCopyTensorInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdCopyTensorARM(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, &pCopyTensorInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdCuLaunchKernelNVX(void *args) { @@ -41341,7 +43061,7 @@ static void thunk64_vkCmdDispatchTileQCOM(void *args) { struct vkCmdDispatchTileQCOM_params *params = args; - wine_cmd_buffer_from_handle(params->commandBuffer)->device->p_vkCmdDispatchTileQCOM(wine_cmd_buffer_from_handle(params->commandBuffer)->host.command_buffer); + wine_cmd_buffer_from_handle(params->commandBuffer)->device->p_vkCmdDispatchTileQCOM(wine_cmd_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->pDispatchTileInfo); } #endif /* _WIN64 */ @@ -41350,9 +43070,12 @@ static void thunk32_vkCmdDispatchTileQCOM(void *args) struct { PTR32 commandBuffer; + PTR32 pDispatchTileInfo; } *params = args; + VkDispatchTileInfoQCOM pDispatchTileInfo_host; - wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdDispatchTileQCOM(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer); + convert_VkDispatchTileInfoQCOM_win32_to_host((const VkDispatchTileInfoQCOM32 *)UlongToPtr(params->pDispatchTileInfo), &pDispatchTileInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdDispatchTileQCOM(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, &pDispatchTileInfo_host); } #ifdef _WIN64 @@ -47770,6 +49493,76 @@ static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateTensorARM(void *args) +{ + struct vkCreateTensorARM_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pTensor); + + params->result = vulkan_device_from_handle(params->device)->p_vkCreateTensorARM(vulkan_device_from_handle(params->device)->host.device, params->pCreateInfo, NULL, params->pTensor); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateTensorARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pTensor; + VkResult result; + } *params = args; + VkTensorCreateInfoARM pCreateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pTensor); + + init_conversion_context(ctx); + convert_VkTensorCreateInfoARM_win32_to_host(ctx, (const VkTensorCreateInfoARM32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkCreateTensorARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pCreateInfo_host, NULL, (VkTensorARM *)UlongToPtr(params->pTensor)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateTensorViewARM(void *args) +{ + struct vkCreateTensorViewARM_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView); + + params->result = vulkan_device_from_handle(params->device)->p_vkCreateTensorViewARM(vulkan_device_from_handle(params->device)->host.device, params->pCreateInfo, NULL, params->pView); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateTensorViewARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pView; + VkResult result; + } *params = args; + VkTensorViewCreateInfoARM pCreateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView); + + init_conversion_context(ctx); + convert_VkTensorViewCreateInfoARM_win32_to_host(ctx, (const VkTensorViewCreateInfoARM32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkCreateTensorViewARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pCreateInfo_host, NULL, (VkTensorViewARM *)UlongToPtr(params->pView)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCreateValidationCacheEXT(void *args) { @@ -49167,6 +50960,60 @@ static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyTensorARM(void *args) +{ + struct vkDestroyTensorARM_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->tensor), params->pAllocator); + + vulkan_device_from_handle(params->device)->p_vkDestroyTensorARM(vulkan_device_from_handle(params->device)->host.device, params->tensor, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyTensorARM(void *args) +{ + struct + { + PTR32 device; + VkTensorARM DECLSPEC_ALIGN(8) tensor; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->tensor), params->pAllocator); + + vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkDestroyTensorARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->tensor, NULL); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyTensorViewARM(void *args) +{ + struct vkDestroyTensorViewARM_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->tensorView), params->pAllocator); + + vulkan_device_from_handle(params->device)->p_vkDestroyTensorViewARM(vulkan_device_from_handle(params->device)->host.device, params->tensorView, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyTensorViewARM(void *args) +{ + struct + { + PTR32 device; + VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->tensorView), params->pAllocator); + + vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkDestroyTensorViewARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->tensorView, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkDestroyValidationCacheEXT(void *args) { @@ -51221,6 +53068,42 @@ static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *ar return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDeviceTensorMemoryRequirementsARM(void *args) +{ + struct vkGetDeviceTensorMemoryRequirementsARM_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements); + + vulkan_device_from_handle(params->device)->p_vkGetDeviceTensorMemoryRequirementsARM(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pMemoryRequirements); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDeviceTensorMemoryRequirementsARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pMemoryRequirements; + } *params = args; + VkDeviceTensorMemoryRequirementsARM pInfo_host; + VkMemoryRequirements2 pMemoryRequirements_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements); + + init_conversion_context(ctx); + convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(ctx, (const VkDeviceTensorMemoryRequirementsARM32 *)UlongToPtr(params->pInfo), &pInfo_host); + convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host); + vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetDeviceTensorMemoryRequirementsARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, &pMemoryRequirements_host); + convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetDynamicRenderingTilePropertiesQCOM(void *args) { @@ -52541,6 +54424,42 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void * return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPhysicalDeviceExternalTensorPropertiesARM(void *args) +{ + struct vkGetPhysicalDeviceExternalTensorPropertiesARM_params *params = args; + + TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalTensorInfo, params->pExternalTensorProperties); + + vulkan_physical_device_from_handle(params->physicalDevice)->instance->p_vkGetPhysicalDeviceExternalTensorPropertiesARM(vulkan_physical_device_from_handle(params->physicalDevice)->host.physical_device, params->pExternalTensorInfo, params->pExternalTensorProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPhysicalDeviceExternalTensorPropertiesARM(void *args) +{ + struct + { + PTR32 physicalDevice; + PTR32 pExternalTensorInfo; + PTR32 pExternalTensorProperties; + } *params = args; + VkPhysicalDeviceExternalTensorInfoARM pExternalTensorInfo_host; + VkExternalTensorPropertiesARM pExternalTensorProperties_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalTensorInfo, params->pExternalTensorProperties); + + init_conversion_context(ctx); + convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(ctx, (const VkPhysicalDeviceExternalTensorInfoARM32 *)UlongToPtr(params->pExternalTensorInfo), &pExternalTensorInfo_host); + convert_VkExternalTensorPropertiesARM_win32_to_host((VkExternalTensorPropertiesARM32 *)UlongToPtr(params->pExternalTensorProperties), &pExternalTensorProperties_host); + vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->p_vkGetPhysicalDeviceExternalTensorPropertiesARM(vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->host.physical_device, &pExternalTensorInfo_host, &pExternalTensorProperties_host); + convert_VkExternalTensorPropertiesARM_host_to_win32(&pExternalTensorProperties_host, (VkExternalTensorPropertiesARM32 *)UlongToPtr(params->pExternalTensorProperties)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetPhysicalDeviceFeatures(void *args) { @@ -54760,6 +56679,102 @@ static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetTensorMemoryRequirementsARM(void *args) +{ + struct vkGetTensorMemoryRequirementsARM_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements); + + vulkan_device_from_handle(params->device)->p_vkGetTensorMemoryRequirementsARM(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pMemoryRequirements); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetTensorMemoryRequirementsARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pMemoryRequirements; + } *params = args; + VkTensorMemoryRequirementsInfoARM pInfo_host; + VkMemoryRequirements2 pMemoryRequirements_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements); + + init_conversion_context(ctx); + convert_VkTensorMemoryRequirementsInfoARM_win32_to_host((const VkTensorMemoryRequirementsInfoARM32 *)UlongToPtr(params->pInfo), &pInfo_host); + convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host); + vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetTensorMemoryRequirementsARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, &pMemoryRequirements_host); + convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetTensorOpaqueCaptureDescriptorDataARM(void *args) +{ + struct vkGetTensorOpaqueCaptureDescriptorDataARM_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetTensorOpaqueCaptureDescriptorDataARM(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetTensorOpaqueCaptureDescriptorDataARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pData; + VkResult result; + } *params = args; + VkTensorCaptureDescriptorDataInfoARM pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData); + + convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host((const VkTensorCaptureDescriptorDataInfoARM32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetTensorOpaqueCaptureDescriptorDataARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, (void *)UlongToPtr(params->pData)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetTensorViewOpaqueCaptureDescriptorDataARM(void *args) +{ + struct vkGetTensorViewOpaqueCaptureDescriptorDataARM_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pData); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetTensorViewOpaqueCaptureDescriptorDataARM(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetTensorViewOpaqueCaptureDescriptorDataARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pData; + VkResult result; + } *params = args; + VkTensorViewCaptureDescriptorDataInfoARM pInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pData); + + convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_host((const VkTensorViewCaptureDescriptorDataInfoARM32 *)UlongToPtr(params->pInfo), &pInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetTensorViewOpaqueCaptureDescriptorDataARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, (void *)UlongToPtr(params->pData)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetValidationCacheDataEXT(void *args) { @@ -56582,6 +58597,36 @@ static NTSTATUS thunk32_vkWaitForFences(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkWaitForPresent2KHR(void *args) +{ + struct vkWaitForPresent2KHR_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pPresentWait2Info); + + params->result = vulkan_device_from_handle(params->device)->p_vkWaitForPresent2KHR(vulkan_device_from_handle(params->device)->host.device, vulkan_swapchain_from_handle(params->swapchain)->host.swapchain, params->pPresentWait2Info); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkWaitForPresent2KHR(void *args) +{ + struct + { + PTR32 device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + PTR32 pPresentWait2Info; + VkResult result; + } *params = args; + VkPresentWait2InfoKHR pPresentWait2Info_host; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pPresentWait2Info); + + convert_VkPresentWait2InfoKHR_win32_to_host((const VkPresentWait2InfoKHR32 *)UlongToPtr(params->pPresentWait2Info), &pPresentWait2Info_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkWaitForPresent2KHR(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, vulkan_swapchain_from_handle(params->swapchain)->host.swapchain, &pPresentWait2Info_host); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkWaitForPresentKHR(void *args) { @@ -56759,12 +58804,14 @@ static const char * const vk_device_extensions[] = "VK_AMD_shader_info", "VK_AMD_shader_trinary_minmax", "VK_AMD_texture_gather_bias_lod", + "VK_ARM_format_pack", "VK_ARM_pipeline_opacity_micromap", "VK_ARM_rasterization_order_attachment_access", "VK_ARM_render_pass_striped", "VK_ARM_scheduling_controls", "VK_ARM_shader_core_builtins", "VK_ARM_shader_core_properties", + "VK_ARM_tensors", "VK_EXT_4444_formats", "VK_EXT_astc_decode_mode", "VK_EXT_attachment_feedback_loop_dynamic_state", @@ -56854,6 +58901,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_shader_atomic_float", "VK_EXT_shader_atomic_float2", "VK_EXT_shader_demote_to_helper_invocation", + "VK_EXT_shader_float8", "VK_EXT_shader_image_atomic_int64", "VK_EXT_shader_module_identifier", "VK_EXT_shader_object", @@ -56930,6 +58978,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_maintenance5", "VK_KHR_maintenance6", "VK_KHR_maintenance8", + "VK_KHR_maintenance9", "VK_KHR_map_memory2", "VK_KHR_multiview", "VK_KHR_performance_query", @@ -56937,7 +58986,9 @@ static const char * const vk_device_extensions[] = "VK_KHR_pipeline_executable_properties", "VK_KHR_pipeline_library", "VK_KHR_present_id", + "VK_KHR_present_id2", "VK_KHR_present_wait", + "VK_KHR_present_wait2", "VK_KHR_push_descriptor", "VK_KHR_ray_query", "VK_KHR_ray_tracing_maintenance1", @@ -56971,6 +59022,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_swapchain_mutable_format", "VK_KHR_synchronization2", "VK_KHR_timeline_semaphore", + "VK_KHR_unified_image_layouts", "VK_KHR_uniform_buffer_standard_layout", "VK_KHR_variable_pointers", "VK_KHR_vertex_attribute_divisor", @@ -56978,6 +59030,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_video_decode_h264", "VK_KHR_video_decode_h265", "VK_KHR_video_decode_queue", + "VK_KHR_video_decode_vp9", "VK_KHR_video_encode_av1", "VK_KHR_video_encode_h264", "VK_KHR_video_encode_h265", @@ -57060,6 +59113,7 @@ static const char * const vk_device_extensions[] = "VK_QCOM_tile_shading", "VK_QCOM_ycbcr_degamma", "VK_VALVE_descriptor_set_host_mapping", + "VK_VALVE_fragment_density_map_layered", "VK_VALVE_mutable_descriptor_type", }; @@ -57098,6 +59152,7 @@ static const char * const vk_host_surface_extensions[] = "VK_EXT_metal_surface", "VK_EXT_directfb_surface", "VK_QNX_screen_surface", + "VK_OHOS_surface", }; BOOL wine_vk_device_extension_supported(const char *name) @@ -57174,6 +59229,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkBindImageMemory2, thunk64_vkBindImageMemory2KHR, thunk64_vkBindOpticalFlowSessionImageNV, + thunk64_vkBindTensorMemoryARM, thunk64_vkBindVideoSessionMemoryKHR, thunk64_vkBuildAccelerationStructuresKHR, thunk64_vkBuildMicromapsEXT, @@ -57244,6 +59300,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdCopyMicromapEXT, (void *)thunk64_vkCmdCopyMicromapToMemoryEXT, (void *)thunk64_vkCmdCopyQueryPoolResults, + (void *)thunk64_vkCmdCopyTensorARM, (void *)thunk64_vkCmdCuLaunchKernelNVX, (void *)thunk64_vkCmdDebugMarkerBeginEXT, (void *)thunk64_vkCmdDebugMarkerEndEXT, @@ -57506,6 +59563,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCreateShaderModule, thunk64_vkCreateShadersEXT, thunk64_vkCreateSwapchainKHR, + thunk64_vkCreateTensorARM, + thunk64_vkCreateTensorViewARM, thunk64_vkCreateValidationCacheEXT, thunk64_vkCreateVideoSessionKHR, thunk64_vkCreateVideoSessionParametersKHR, @@ -57556,6 +59615,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkDestroyShaderModule, thunk64_vkDestroySurfaceKHR, thunk64_vkDestroySwapchainKHR, + thunk64_vkDestroyTensorARM, + thunk64_vkDestroyTensorViewARM, thunk64_vkDestroyValidationCacheEXT, thunk64_vkDestroyVideoSessionKHR, thunk64_vkDestroyVideoSessionParametersKHR, @@ -57620,6 +59681,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetDeviceQueue, thunk64_vkGetDeviceQueue2, thunk64_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, + thunk64_vkGetDeviceTensorMemoryRequirementsARM, thunk64_vkGetDynamicRenderingTilePropertiesQCOM, thunk64_vkGetEncodedVideoSessionParametersKHR, thunk64_vkGetEventStatus, @@ -57659,6 +59721,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetPhysicalDeviceExternalFencePropertiesKHR, thunk64_vkGetPhysicalDeviceExternalSemaphoreProperties, thunk64_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, + thunk64_vkGetPhysicalDeviceExternalTensorPropertiesARM, thunk64_vkGetPhysicalDeviceFeatures, thunk64_vkGetPhysicalDeviceFeatures2, thunk64_vkGetPhysicalDeviceFeatures2KHR, @@ -57727,6 +59790,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetShaderModuleCreateInfoIdentifierEXT, thunk64_vkGetShaderModuleIdentifierEXT, thunk64_vkGetSwapchainImagesKHR, + thunk64_vkGetTensorMemoryRequirementsARM, + thunk64_vkGetTensorOpaqueCaptureDescriptorDataARM, + thunk64_vkGetTensorViewOpaqueCaptureDescriptorDataARM, thunk64_vkGetValidationCacheDataEXT, thunk64_vkGetVideoSessionMemoryRequirementsKHR, thunk64_vkInitializePerformanceApiINTEL, @@ -57786,6 +59852,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkUpdateIndirectExecutionSetShaderEXT, thunk64_vkUpdateVideoSessionParametersKHR, thunk64_vkWaitForFences, + thunk64_vkWaitForPresent2KHR, thunk64_vkWaitForPresentKHR, thunk64_vkWaitSemaphores, thunk64_vkWaitSemaphoresKHR, @@ -57822,6 +59889,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkBindImageMemory2, thunk32_vkBindImageMemory2KHR, thunk32_vkBindOpticalFlowSessionImageNV, + thunk32_vkBindTensorMemoryARM, thunk32_vkBindVideoSessionMemoryKHR, thunk32_vkBuildAccelerationStructuresKHR, thunk32_vkBuildMicromapsEXT, @@ -57892,6 +59960,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdCopyMicromapEXT, (void *)thunk32_vkCmdCopyMicromapToMemoryEXT, (void *)thunk32_vkCmdCopyQueryPoolResults, + (void *)thunk32_vkCmdCopyTensorARM, (void *)thunk32_vkCmdCuLaunchKernelNVX, (void *)thunk32_vkCmdDebugMarkerBeginEXT, (void *)thunk32_vkCmdDebugMarkerEndEXT, @@ -58154,6 +60223,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCreateShaderModule, thunk32_vkCreateShadersEXT, thunk32_vkCreateSwapchainKHR, + thunk32_vkCreateTensorARM, + thunk32_vkCreateTensorViewARM, thunk32_vkCreateValidationCacheEXT, thunk32_vkCreateVideoSessionKHR, thunk32_vkCreateVideoSessionParametersKHR, @@ -58204,6 +60275,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkDestroyShaderModule, thunk32_vkDestroySurfaceKHR, thunk32_vkDestroySwapchainKHR, + thunk32_vkDestroyTensorARM, + thunk32_vkDestroyTensorViewARM, thunk32_vkDestroyValidationCacheEXT, thunk32_vkDestroyVideoSessionKHR, thunk32_vkDestroyVideoSessionParametersKHR, @@ -58268,6 +60341,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetDeviceQueue, thunk32_vkGetDeviceQueue2, thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, + thunk32_vkGetDeviceTensorMemoryRequirementsARM, thunk32_vkGetDynamicRenderingTilePropertiesQCOM, thunk32_vkGetEncodedVideoSessionParametersKHR, thunk32_vkGetEventStatus, @@ -58307,6 +60381,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR, thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties, thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, + thunk32_vkGetPhysicalDeviceExternalTensorPropertiesARM, thunk32_vkGetPhysicalDeviceFeatures, thunk32_vkGetPhysicalDeviceFeatures2, thunk32_vkGetPhysicalDeviceFeatures2KHR, @@ -58375,6 +60450,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetShaderModuleCreateInfoIdentifierEXT, thunk32_vkGetShaderModuleIdentifierEXT, thunk32_vkGetSwapchainImagesKHR, + thunk32_vkGetTensorMemoryRequirementsARM, + thunk32_vkGetTensorOpaqueCaptureDescriptorDataARM, + thunk32_vkGetTensorViewOpaqueCaptureDescriptorDataARM, thunk32_vkGetValidationCacheDataEXT, thunk32_vkGetVideoSessionMemoryRequirementsKHR, thunk32_vkInitializePerformanceApiINTEL, @@ -58434,6 +60512,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkUpdateIndirectExecutionSetShaderEXT, thunk32_vkUpdateVideoSessionParametersKHR, thunk32_vkWaitForFences, + thunk32_vkWaitForPresent2KHR, thunk32_vkWaitForPresentKHR, thunk32_vkWaitSemaphores, thunk32_vkWaitSemaphoresKHR, diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index 41b1b69a594..ab60ff58310 100644 --- a/dlls/winevulkan/winevulkan.json +++ b/dlls/winevulkan/winevulkan.json @@ -2,6 +2,6 @@ "file_format_version": "1.0.0", "ICD": { "library_path": ".\\winevulkan.dll", - "api_version": "1.4.315" + "api_version": "1.4.318" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 8b4807d3ee7..8fa862b4449 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -66,6 +66,7 @@ #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_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR 3 #define VK_SHADER_INDEX_UNUSED_AMDX (~0U) #define VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV (~0U) #define VK_KHR_SURFACE_SPEC_VERSION 25 @@ -630,6 +631,8 @@ #define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3" #define VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION 2 #define VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME "VK_EXT_subpass_merge_feedback" +#define VK_ARM_TENSORS_SPEC_VERSION 1 +#define VK_ARM_TENSORS_EXTENSION_NAME "VK_ARM_tensors" #define VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION 1 #define VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME "VK_EXT_shader_module_identifier" #define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 @@ -644,6 +647,10 @@ #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_PRESENT_ID_2_SPEC_VERSION 1 +#define VK_KHR_PRESENT_ID_2_EXTENSION_NAME "VK_KHR_present_id2" +#define VK_KHR_PRESENT_WAIT_2_SPEC_VERSION 1 +#define VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME "VK_KHR_present_wait2" #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 @@ -684,6 +691,8 @@ #define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" #define VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION 1 #define VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME "VK_KHR_video_encode_av1" +#define VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME "VK_KHR_video_decode_vp9" #define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 #define VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_video_maintenance1" #define VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION 1 @@ -702,6 +711,8 @@ #define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_KHR_vertex_attribute_divisor" #define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1 #define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none" +#define VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION 1 +#define VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME "VK_KHR_unified_image_layouts" #define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1 #define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2" #define VK_MSFT_LAYERED_DRIVER_SPEC_VERSION 1 @@ -732,6 +743,8 @@ #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_EXT_SHADER_FLOAT8_SPEC_VERSION 1 +#define VK_EXT_SHADER_FLOAT8_EXTENSION_NAME "VK_EXT_shader_float8" #define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1 #define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation" #define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 2 @@ -746,6 +759,8 @@ #define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control" #define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1 #define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control" +#define VK_KHR_MAINTENANCE_9_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_9_EXTENSION_NAME "VK_KHR_maintenance9" #define VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION 1 #define VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_video_maintenance2" #define VK_HUAWEI_HDR_VIVID_SPEC_VERSION 1 @@ -758,6 +773,10 @@ #define VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_KHR_depth_clamp_zero_one" #define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1 #define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_vertex_attribute_robustness" +#define VK_ARM_FORMAT_PACK_SPEC_VERSION 1 +#define VK_ARM_FORMAT_PACK_EXTENSION_NAME "VK_ARM_format_pack" +#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION 1 +#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME "VK_VALVE_fragment_density_map_layered" #define VK_KHR_ROBUSTNESS_2_SPEC_VERSION 1 #define VK_KHR_ROBUSTNESS_2_EXTENSION_NAME "VK_KHR_robustness2" #define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 @@ -805,6 +824,16 @@ #define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8 #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode" +#define STD_VIDEO_VP9_NUM_REF_FRAMES 8 +#define STD_VIDEO_VP9_REFS_PER_FRAME 3 +#define STD_VIDEO_VP9_MAX_REF_FRAMES 4 +#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2 +#define STD_VIDEO_VP9_MAX_SEGMENTS 8 +#define STD_VIDEO_VP9_SEG_LVL_MAX 4 +#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7 +#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3 +#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_vp9_decode" #define STD_VIDEO_AV1_NUM_REF_FRAMES 8 #define STD_VIDEO_AV1_REFS_PER_FRAME 7 #define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8 @@ -857,7 +886,7 @@ #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0) #define VK_API_VERSION_1_4 VK_MAKE_API_VERSION(0, 1, 4, 0) #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0) -#define VK_HEADER_VERSION 315 +#define VK_HEADER_VERSION 318 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; #define VK_USE_64_BIT_PTR_DEFINES 0 @@ -890,6 +919,7 @@ #define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) #define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) +#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) #define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) #define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) @@ -940,6 +970,8 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorARM) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorViewARM) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) @@ -953,6 +985,7 @@ struct MTLCommandQueue_id; struct MTLDevice_id; struct MTLSharedEvent_id; struct MTLTexture_id; +struct OHNativeWindow; typedef uint32_t VkBool32; typedef uint64_t VkDeviceAddress; typedef uint64_t VkDeviceSize; @@ -1151,9 +1184,13 @@ typedef VkFlags VkSubmitFlags; typedef VkSubmitFlags VkSubmitFlagsKHR; typedef VkFlags VkSubpassDescriptionFlags; typedef VkFlags VkSurfaceCounterFlagsEXT; +typedef VkFlags VkSurfaceCreateFlagsOHOS; typedef VkFlags VkSurfaceTransformFlagsKHR; typedef VkFlags VkSwapchainCreateFlagsKHR; typedef VkFlags VkSwapchainImageUsageFlagsANDROID; +typedef VkFlags64 VkTensorCreateFlagsARM; +typedef VkFlags64 VkTensorUsageFlagsARM; +typedef VkFlags64 VkTensorViewCreateFlagsARM; typedef VkFlags VkTileShadingRenderPassFlagsQCOM; typedef VkFlags VkToolPurposeFlags; typedef VkToolPurposeFlags VkToolPurposeFlagsEXT; @@ -1584,6 +1621,73 @@ typedef enum StdVideoH265SliceType STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7fffffff, } StdVideoH265SliceType; +typedef enum StdVideoVP9ColorSpace +{ + STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN = 0, + STD_VIDEO_VP9_COLOR_SPACE_BT_601 = 1, + STD_VIDEO_VP9_COLOR_SPACE_BT_709 = 2, + STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170 = 3, + STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240 = 4, + STD_VIDEO_VP9_COLOR_SPACE_BT_2020 = 5, + STD_VIDEO_VP9_COLOR_SPACE_RESERVED = 6, + STD_VIDEO_VP9_COLOR_SPACE_RGB = 7, + STD_VIDEO_VP9_COLOR_SPACE_INVALID = 0x7fffffff, +} StdVideoVP9ColorSpace; + +typedef enum StdVideoVP9FrameType +{ + STD_VIDEO_VP9_FRAME_TYPE_KEY = 0, + STD_VIDEO_VP9_FRAME_TYPE_NON_KEY = 1, + STD_VIDEO_VP9_FRAME_TYPE_INVALID = 0x7fffffff, +} StdVideoVP9FrameType; + +typedef enum StdVideoVP9InterpolationFilter +{ + STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP = 0, + STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR = 3, + STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE = 4, + STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID = 0x7fffffff, +} StdVideoVP9InterpolationFilter; + +typedef enum StdVideoVP9Level +{ + STD_VIDEO_VP9_LEVEL_1_0 = 0, + STD_VIDEO_VP9_LEVEL_1_1 = 1, + STD_VIDEO_VP9_LEVEL_2_0 = 2, + STD_VIDEO_VP9_LEVEL_2_1 = 3, + STD_VIDEO_VP9_LEVEL_3_0 = 4, + STD_VIDEO_VP9_LEVEL_3_1 = 5, + STD_VIDEO_VP9_LEVEL_4_0 = 6, + STD_VIDEO_VP9_LEVEL_4_1 = 7, + STD_VIDEO_VP9_LEVEL_5_0 = 8, + STD_VIDEO_VP9_LEVEL_5_1 = 9, + STD_VIDEO_VP9_LEVEL_5_2 = 10, + STD_VIDEO_VP9_LEVEL_6_0 = 11, + STD_VIDEO_VP9_LEVEL_6_1 = 12, + STD_VIDEO_VP9_LEVEL_6_2 = 13, + STD_VIDEO_VP9_LEVEL_INVALID = 0x7fffffff, +} StdVideoVP9Level; + +typedef enum StdVideoVP9Profile +{ + STD_VIDEO_VP9_PROFILE_0 = 0, + STD_VIDEO_VP9_PROFILE_1 = 1, + STD_VIDEO_VP9_PROFILE_2 = 2, + STD_VIDEO_VP9_PROFILE_3 = 3, + STD_VIDEO_VP9_PROFILE_INVALID = 0x7fffffff, +} StdVideoVP9Profile; + +typedef enum StdVideoVP9ReferenceName +{ + STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME = 0, + STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME = 1, + STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME = 2, + STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME = 3, + STD_VIDEO_VP9_REFERENCE_NAME_INVALID = 0x7fffffff, +} StdVideoVP9ReferenceName; + typedef enum VkAccelerationStructureBuildTypeKHR { VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, @@ -2007,15 +2111,19 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0x00000040, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000080, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0x00000100, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = 0x00000800, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 0x00000100, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkBuildAccelerationStructureFlagBitsKHR; typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; @@ -2226,8 +2334,8 @@ typedef enum VkComponentTypeKHR VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000, VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000, VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001, - VK_COMPONENT_TYPE_FLOAT_E4M3_NV = 1000491002, - VK_COMPONENT_TYPE_FLOAT_E5M2_NV = 1000491003, + VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002, + VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003, VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, @@ -2239,6 +2347,8 @@ typedef enum VkComponentTypeKHR VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, + VK_COMPONENT_TYPE_FLOAT_E4M3_NV = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, + VK_COMPONENT_TYPE_FLOAT_E5M2_NV = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT, VK_COMPONENT_TYPE_KHR_MAX_ENUM = 0x7fffffff, } VkComponentTypeKHR; typedef VkComponentTypeKHR VkComponentTypeNV; @@ -2405,6 +2515,13 @@ typedef enum VkDebugUtilsMessageTypeFlagBitsEXT VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, } VkDebugUtilsMessageTypeFlagBitsEXT; +typedef enum VkDefaultVertexAttributeValueKHR +{ + VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR = 0, + VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR = 1, + VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_KHR_MAX_ENUM = 0x7fffffff, +} VkDefaultVertexAttributeValueKHR; + typedef enum VkDependencyFlagBits { VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, @@ -2412,6 +2529,7 @@ typedef enum VkDependencyFlagBits VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 0x00000020, + VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR = 0x00000040, VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7fffffff, @@ -2492,6 +2610,7 @@ typedef enum VkDescriptorType VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, + VK_DESCRIPTOR_TYPE_TENSOR_ARM = 1000460000, VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, @@ -3074,9 +3193,24 @@ typedef enum VkFormat VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, + VK_FORMAT_R8_BOOL_ARM = 1000460000, VK_FORMAT_R16G16_SFIXED5_NV = 1000464000, VK_FORMAT_A1B5G5R5_UNORM_PACK16 = 1000470000, VK_FORMAT_A8_UNORM = 1000470001, + VK_FORMAT_R10X6_UINT_PACK16_ARM = 1000609000, + VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM = 1000609001, + VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM = 1000609002, + VK_FORMAT_R12X4_UINT_PACK16_ARM = 1000609003, + VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM = 1000609004, + VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM = 1000609005, + VK_FORMAT_R14X2_UINT_PACK16_ARM = 1000609006, + VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM = 1000609007, + VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM = 1000609008, + VK_FORMAT_R14X2_UNORM_PACK16_ARM = 1000609009, + VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM = 1000609010, + VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM = 1000609011, + VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM = 1000609012, + VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM = 1000609013, VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, @@ -3252,9 +3386,11 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_B static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ull; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM = 0x8000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ull; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM = 0x80000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT = 0x400000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ull; @@ -3332,13 +3468,15 @@ typedef enum VkGeometryInstanceFlagBitsKHR VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, - VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0x00000010, - VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000020, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000020, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, VK_GEOMETRY_INSTANCE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkGeometryInstanceFlagBitsKHR; typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; @@ -3367,8 +3505,10 @@ typedef enum VkGraphicsPipelineLibraryFlagBitsEXT typedef enum VkHostImageCopyFlagBits { - VK_HOST_IMAGE_COPY_MEMCPY = 0x00000001, - VK_HOST_IMAGE_COPY_MEMCPY_EXT = VK_HOST_IMAGE_COPY_MEMCPY, + VK_HOST_IMAGE_COPY_MEMCPY_BIT = 0x00000001, + VK_HOST_IMAGE_COPY_MEMCPY = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + VK_HOST_IMAGE_COPY_MEMCPY_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkHostImageCopyFlagBits; typedef VkHostImageCopyFlagBits VkHostImageCopyFlagBitsEXT; @@ -3491,6 +3631,7 @@ typedef enum VkImageLayout VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, + VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM = 1000460000, VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR = 1000553000, VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT = 1000620000, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, @@ -3544,6 +3685,7 @@ typedef enum VkImageUsageFlagBits VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, VK_IMAGE_USAGE_HOST_TRANSFER_BIT = 0x00400000, + VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM = 0x00800000, VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000, VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000, VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000, @@ -3862,6 +4004,8 @@ typedef enum VkObjectType VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, + VK_OBJECT_TYPE_TENSOR_ARM = 1000460000, + VK_OBJECT_TYPE_TENSOR_VIEW_ARM = 1000460001, VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, @@ -4150,7 +4294,8 @@ typedef enum VkPipelineCreateFlagBits VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT = 0x40000000, VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, @@ -4208,6 +4353,7 @@ static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SP static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ull; static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ull; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ull; typedef VkPipelineCreateFlagBits2 VkPipelineCreateFlagBits2KHR; typedef enum VkPipelineCreationFeedbackFlagBits @@ -4496,6 +4642,12 @@ typedef enum VkQueryPipelineStatisticFlagBits VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkQueryPipelineStatisticFlagBits; +typedef enum VkQueryPoolCreateFlagBits +{ + VK_QUERY_POOL_CREATE_RESET_BIT_KHR = 0x00000001, + VK_QUERY_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, +} VkQueryPoolCreateFlagBits; + typedef enum VkQueryPoolSamplingModeINTEL { VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, @@ -4618,6 +4770,7 @@ typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV; typedef enum VkRenderPassCreateFlagBits { VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, + VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000004, VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkRenderPassCreateFlagBits; @@ -4628,6 +4781,7 @@ typedef enum VkRenderingFlagBits VK_RENDERING_RESUMING_BIT = 0x00000004, VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 0x00000010, + VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000020, 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, @@ -5674,6 +5828,30 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, + VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM = 1000460000, + VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM = 1000460001, + VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM = 1000460002, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM = 1000460003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM = 1000460004, + VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM = 1000460005, + VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM = 1000460006, + VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM = 1000460007, + VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM = 1000460008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM = 1000460009, + VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM = 1000460010, + VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM = 1000460011, + VK_STRUCTURE_TYPE_TENSOR_COPY_ARM = 1000460012, + VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM = 1000460013, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM = 1000460014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM = 1000460015, + VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM = 1000460016, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM = 1000460017, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM = 1000460018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM = 1000460019, + VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM = 1000460020, + VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460021, + VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460022, + VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM = 1000460023, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, @@ -5696,6 +5874,12 @@ typedef enum VkStructureType 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_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR = 1000479000, + VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR = 1000479001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR = 1000479002, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR = 1000480000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR = 1000480001, + VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR = 1000480002, 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, @@ -5759,6 +5943,10 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR = 1000513008, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR = 1000513009, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR = 1000513010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR = 1000514000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR = 1000514001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR = 1000514002, + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR = 1000514003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, @@ -5773,6 +5961,8 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES = 1000525000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR = 1000527000, + VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT = 1000527001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES = 1000528000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES = 1000544000, @@ -5806,6 +5996,7 @@ typedef enum VkStructureType 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_SHADER_FLOAT8_FEATURES_EXT = 1000567000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV = 1000569000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000569001, @@ -5842,6 +6033,9 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR = 1000584000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR = 1000584001, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR = 1000584002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR = 1000586000, VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002, @@ -5853,6 +6047,10 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE = 1000611001, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002, VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = 1000619003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, @@ -6184,6 +6382,8 @@ typedef enum VkSwapchainCreateFlagBitsKHR VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0x00000008, + VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, + VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, VK_SWAPCHAIN_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkSwapchainCreateFlagBitsKHR; @@ -6197,6 +6397,30 @@ typedef enum VkSystemAllocationScope VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7fffffff, } VkSystemAllocationScope; +typedef VkFlags64 VkTensorCreateFlagBitsARM; + +static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM = 0x00000001ull; +static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_PROTECTED_BIT_ARM = 0x00000002ull; +static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000004ull; + +typedef enum VkTensorTilingARM +{ + VK_TENSOR_TILING_OPTIMAL_ARM = 0, + VK_TENSOR_TILING_LINEAR_ARM = 1, + VK_TENSOR_TILING_ARM_MAX_ENUM = 0x7fffffff, +} VkTensorTilingARM; + +typedef VkFlags64 VkTensorUsageFlagBitsARM; + +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_SHADER_BIT_ARM = 0x00000002ull; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM = 0x00000004ull; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM = 0x00000008ull; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM = 0x00000010ull; + +typedef VkFlags64 VkTensorViewCreateFlagBitsARM; + +static const VkTensorViewCreateFlagBitsARM VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000001ull; + typedef enum VkTessellationDomainOrigin { VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, @@ -6325,6 +6549,7 @@ typedef enum VkVideoCodecOperationFlagBitsKHR VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004, + VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR = 0x00000008, VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR = 0x00010000, VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000, VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR = 0x00040000, @@ -6846,6 +7071,19 @@ typedef struct StdVideoDecodeH265ReferenceInfoFlags uint32_t unused_for_reference:1; } StdVideoDecodeH265ReferenceInfoFlags; +typedef struct StdVideoDecodeVP9PictureInfoFlags +{ + uint32_t error_resilient_mode:1; + uint32_t intra_only:1; + uint32_t allow_high_precision_mv:1; + uint32_t refresh_frame_context:1; + uint32_t frame_parallel_decoding_mode:1; + uint32_t segmentation_enabled:1; + uint32_t show_frame:1; + uint32_t UsePrevFrameMvs:1; + uint32_t reserved:24; +} StdVideoDecodeVP9PictureInfoFlags; + typedef struct StdVideoEncodeAV1DecoderModelInfo { uint8_t buffer_delay_length_minus_1; @@ -7261,6 +7499,28 @@ typedef struct StdVideoH265VpsFlags uint32_t vps_poc_proportional_to_timing_flag:1; } StdVideoH265VpsFlags; +typedef struct StdVideoVP9ColorConfigFlags +{ + uint32_t color_range:1; + uint32_t reserved:31; +} StdVideoVP9ColorConfigFlags; + +typedef struct StdVideoVP9LoopFilterFlags +{ + uint32_t loop_filter_delta_enabled:1; + uint32_t loop_filter_delta_update:1; + uint32_t reserved:30; +} StdVideoVP9LoopFilterFlags; + +typedef struct StdVideoVP9SegmentationFlags +{ + uint32_t segmentation_update_map:1; + uint32_t segmentation_temporal_update:1; + uint32_t segmentation_update_data:1; + uint32_t segmentation_abs_or_delta_update:1; + uint32_t reserved:28; +} StdVideoVP9SegmentationFlags; + typedef struct VkAabbPositionsKHR { float minX; @@ -7425,6 +7685,13 @@ typedef struct VkAttachmentDescriptionStencilLayout } VkAttachmentDescriptionStencilLayout; typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR; +typedef struct VkAttachmentFeedbackLoopInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkBool32 feedbackLoopEnable; +} VkAttachmentFeedbackLoopInfoEXT; + typedef struct VkAttachmentReference { uint32_t attachment; @@ -7582,6 +7849,15 @@ typedef struct VkBindShaderGroupIndirectCommandNV uint32_t groupIndex; } VkBindShaderGroupIndirectCommandNV; +typedef struct VkBindTensorMemoryInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorARM WINE_VK_ALIGN(8) tensor; + VkDeviceMemory WINE_VK_ALIGN(8) memory; + VkDeviceSize WINE_VK_ALIGN(8) memoryOffset; +} VkBindTensorMemoryInfoARM; + typedef struct VkBindVertexBufferIndirectCommandEXT { VkDeviceAddress WINE_VK_ALIGN(8) bufferAddress; @@ -8265,6 +8541,13 @@ typedef struct VkDescriptorBufferInfo VkDeviceSize WINE_VK_ALIGN(8) range; } VkDescriptorBufferInfo; +typedef struct VkDescriptorGetTensorInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorViewARM WINE_VK_ALIGN(8) tensorView; +} VkDescriptorGetTensorInfoARM; + typedef struct VkDescriptorImageInfo { VkSampler WINE_VK_ALIGN(8) sampler; @@ -8727,6 +9010,13 @@ typedef struct VkExternalMemoryProperties } VkExternalMemoryProperties; typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; +typedef struct VkExternalMemoryTensorCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryTensorCreateInfoARM; + typedef struct VkExternalSemaphoreProperties { VkStructureType sType; @@ -8737,6 +9027,13 @@ typedef struct VkExternalSemaphoreProperties } VkExternalSemaphoreProperties; typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; +typedef struct VkExternalTensorPropertiesARM +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalTensorPropertiesARM; + typedef struct VkFenceCreateInfo { VkStructureType sType; @@ -8800,6 +9097,14 @@ typedef struct VkFrameBoundaryEXT const void *pTag; } VkFrameBoundaryEXT; +typedef struct VkFrameBoundaryTensorsARM +{ + VkStructureType sType; + const void *pNext; + uint32_t tensorCount; + const VkTensorARM *pTensors; +} VkFrameBoundaryTensorsARM; + typedef struct VkFramebufferAttachmentImageInfo { VkStructureType sType; @@ -9409,6 +9714,13 @@ typedef struct VkMemoryDedicatedAllocateInfo } VkMemoryDedicatedAllocateInfo; typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; +typedef struct VkMemoryDedicatedAllocateInfoTensorARM +{ + VkStructureType sType; + const void *pNext; + VkTensorARM WINE_VK_ALIGN(8) tensor; +} VkMemoryDedicatedAllocateInfoTensorARM; + typedef struct VkMemoryDedicatedRequirements { VkStructureType sType; @@ -10266,6 +10578,22 @@ typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT VkDeviceSize WINE_VK_ALIGN(8) descriptorBufferAddressSpaceSize; } VkPhysicalDeviceDescriptorBufferPropertiesEXT; +typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM +{ + VkStructureType sType; + void *pNext; + VkBool32 descriptorBufferTensorDescriptors; +} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM; + +typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM +{ + VkStructureType sType; + void *pNext; + size_t tensorCaptureReplayDescriptorDataSize; + size_t tensorViewCaptureReplayDescriptorDataSize; + size_t tensorDescriptorSize; +} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM; + typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { VkStructureType sType; @@ -10665,6 +10993,13 @@ typedef struct VkPhysicalDeviceFloatControlsProperties } VkPhysicalDeviceFloatControlsProperties; typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR; +typedef struct VkPhysicalDeviceFormatPackFeaturesARM +{ + VkStructureType sType; + void *pNext; + VkBool32 formatPack; +} VkPhysicalDeviceFormatPackFeaturesARM; + typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { VkStructureType sType; @@ -10691,6 +11026,20 @@ typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT VkBool32 fragmentDensityMapNonSubsampledImages; } VkPhysicalDeviceFragmentDensityMapFeaturesEXT; +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE +{ + VkStructureType sType; + void *pNext; + VkBool32 fragmentDensityMapLayered; +} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE +{ + VkStructureType sType; + void *pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT { VkStructureType sType; @@ -11286,6 +11635,21 @@ typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR VkBool32 maintenance8; } VkPhysicalDeviceMaintenance8FeaturesKHR; +typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 maintenance9; +} VkPhysicalDeviceMaintenance9FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 image2DViewOf3DSparse; + VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue; +} VkPhysicalDeviceMaintenance9PropertiesKHR; + typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT { VkStructureType sType; @@ -11696,6 +12060,13 @@ typedef struct VkPhysicalDevicePresentBarrierFeaturesNV VkBool32 presentBarrier; } VkPhysicalDevicePresentBarrierFeaturesNV; +typedef struct VkPhysicalDevicePresentId2FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 presentId2; +} VkPhysicalDevicePresentId2FeaturesKHR; + typedef struct VkPhysicalDevicePresentIdFeaturesKHR { VkStructureType sType; @@ -11710,6 +12081,13 @@ typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT VkBool32 presentModeFifoLatestReady; } VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; +typedef struct VkPhysicalDevicePresentWait2FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 presentWait2; +} VkPhysicalDevicePresentWait2FeaturesKHR; + typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { VkStructureType sType; @@ -12172,6 +12550,14 @@ typedef struct VkPhysicalDeviceShaderFloat16Int8Features typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; +typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderFloat8; + VkBool32 shaderFloat8CooperativeMatrix; +} VkPhysicalDeviceShaderFloat8FeaturesEXT; + typedef struct VkPhysicalDeviceShaderFloatControls2Features { VkStructureType sType; @@ -12480,6 +12866,37 @@ typedef struct VkPhysicalDeviceSynchronization2Features } VkPhysicalDeviceSynchronization2Features; typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR; +typedef struct VkPhysicalDeviceTensorFeaturesARM +{ + VkStructureType sType; + void *pNext; + VkBool32 tensorNonPacked; + VkBool32 shaderTensorAccess; + VkBool32 shaderStorageTensorArrayDynamicIndexing; + VkBool32 shaderStorageTensorArrayNonUniformIndexing; + VkBool32 descriptorBindingStorageTensorUpdateAfterBind; + VkBool32 tensors; +} VkPhysicalDeviceTensorFeaturesARM; + +typedef struct VkPhysicalDeviceTensorPropertiesARM +{ + VkStructureType sType; + void *pNext; + uint32_t maxTensorDimensionCount; + uint64_t WINE_VK_ALIGN(8) maxTensorElements; + uint64_t WINE_VK_ALIGN(8) maxPerDimensionTensorElements; + int64_t maxTensorStride; + uint64_t WINE_VK_ALIGN(8) maxTensorSize; + uint32_t maxTensorShaderAccessArrayLength; + uint32_t maxTensorShaderAccessSize; + uint32_t maxDescriptorSetStorageTensors; + uint32_t maxPerStageDescriptorSetStorageTensors; + uint32_t maxDescriptorSetUpdateAfterBindStorageTensors; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors; + VkBool32 shaderStorageTensorArrayNonUniformIndexingNative; + VkShaderStageFlags shaderTensorSupportedStages; +} VkPhysicalDeviceTensorPropertiesARM; + typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { VkStructureType sType; @@ -12610,6 +13027,14 @@ typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT VkBool32 transformFeedbackDraw; } VkPhysicalDeviceTransformFeedbackPropertiesEXT; +typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 unifiedImageLayouts; + VkBool32 unifiedImageLayoutsVideo; +} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { VkStructureType sType; @@ -12670,6 +13095,13 @@ typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT VkBool32 vertexInputDynamicState; } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; +typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 videoDecodeVP9; +} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR; + typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR { VkStructureType sType; @@ -13256,6 +13688,13 @@ typedef union VkPipelineExecutableStatisticValueKHR double f64; } VkPipelineExecutableStatisticValueKHR; +typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE +{ + VkStructureType sType; + const void *pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE; + typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { VkStructureType sType; @@ -13482,6 +13921,14 @@ typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT VkBool32 negativeOneToOne; } VkPipelineViewportDepthClipControlCreateInfoEXT; +typedef struct VkPresentId2KHR +{ + VkStructureType sType; + const void *pNext; + uint32_t swapchainCount; + const uint64_t *pPresentIds; +} VkPresentId2KHR; + typedef struct VkPresentIdKHR { VkStructureType sType; @@ -13502,6 +13949,14 @@ typedef struct VkPresentInfoKHR VkResult *pResults; } VkPresentInfoKHR; +typedef struct VkPresentWait2InfoKHR +{ + VkStructureType sType; + const void *pNext; + uint64_t WINE_VK_ALIGN(8) presentId; + uint64_t WINE_VK_ALIGN(8) timeout; +} VkPresentWait2InfoKHR; + typedef struct VkPrivateDataSlotCreateInfo { VkStructureType sType; @@ -13612,6 +14067,13 @@ typedef struct VkQueueFamilyGlobalPriorityProperties typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropertiesKHR; typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropertiesEXT; +typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t optimalImageTransferToQueueFamilies; +} VkQueueFamilyOwnershipTransferPropertiesKHR; + typedef struct VkQueueFamilyProperties { VkQueueFlags queueFlags; @@ -14425,6 +14887,20 @@ typedef struct VkSurfaceCapabilitiesPresentBarrierNV VkBool32 presentBarrierSupported; } VkSurfaceCapabilitiesPresentBarrierNV; +typedef struct VkSurfaceCapabilitiesPresentId2KHR +{ + VkStructureType sType; + void *pNext; + VkBool32 presentId2Supported; +} VkSurfaceCapabilitiesPresentId2KHR; + +typedef struct VkSurfaceCapabilitiesPresentWait2KHR +{ + VkStructureType sType; + void *pNext; + VkBool32 presentWait2Supported; +} VkSurfaceCapabilitiesPresentWait2KHR; + typedef struct VkSurfaceFormatKHR { VkFormat format; @@ -14526,6 +15002,79 @@ typedef struct VkSwapchainPresentScalingCreateInfoEXT VkPresentGravityFlagsEXT presentGravityY; } VkSwapchainPresentScalingCreateInfoEXT; +typedef struct VkTensorCaptureDescriptorDataInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorARM WINE_VK_ALIGN(8) tensor; +} VkTensorCaptureDescriptorDataInfoARM; + +typedef struct VkTensorCopyARM +{ + VkStructureType sType; + const void *pNext; + uint32_t dimensionCount; + const uint64_t *pSrcOffset; + const uint64_t *pDstOffset; + const uint64_t *pExtent; +} VkTensorCopyARM; + +typedef struct VkTensorDescriptionARM +{ + VkStructureType sType; + const void *pNext; + VkTensorTilingARM tiling; + VkFormat format; + uint32_t dimensionCount; + const int64_t *pDimensions; + const int64_t *pStrides; + VkTensorUsageFlagsARM WINE_VK_ALIGN(8) usage; +} VkTensorDescriptionARM; + +typedef struct VkTensorFormatPropertiesARM +{ + VkStructureType sType; + const void *pNext; + VkFormatFeatureFlags2 WINE_VK_ALIGN(8) optimalTilingTensorFeatures; + VkFormatFeatureFlags2 WINE_VK_ALIGN(8) linearTilingTensorFeatures; +} VkTensorFormatPropertiesARM; + +typedef struct VkTensorMemoryBarrierARM +{ + VkStructureType sType; + const void *pNext; + VkPipelineStageFlags2 WINE_VK_ALIGN(8) srcStageMask; + VkAccessFlags2 WINE_VK_ALIGN(8) srcAccessMask; + VkPipelineStageFlags2 WINE_VK_ALIGN(8) dstStageMask; + VkAccessFlags2 WINE_VK_ALIGN(8) dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkTensorARM WINE_VK_ALIGN(8) tensor; +} VkTensorMemoryBarrierARM; + +typedef struct VkTensorMemoryRequirementsInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorARM WINE_VK_ALIGN(8) tensor; +} VkTensorMemoryRequirementsInfoARM; + +typedef struct VkTensorViewCaptureDescriptorDataInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorViewARM WINE_VK_ALIGN(8) tensorView; +} VkTensorViewCaptureDescriptorDataInfoARM; + +typedef struct VkTensorViewCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorViewCreateFlagsARM WINE_VK_ALIGN(8) flags; + VkTensorARM WINE_VK_ALIGN(8) tensor; + VkFormat format; +} VkTensorViewCreateInfoARM; + typedef struct VkTextureLODGatherFormatPropertiesAMD { VkStructureType sType; @@ -14757,6 +15306,20 @@ typedef struct VkVideoDecodeUsageInfoKHR VkVideoDecodeUsageFlagsKHR videoUsageHints; } VkVideoDecodeUsageInfoKHR; +typedef struct VkVideoDecodeVP9CapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + StdVideoVP9Level maxLevel; +} VkVideoDecodeVP9CapabilitiesKHR; + +typedef struct VkVideoDecodeVP9ProfileInfoKHR +{ + VkStructureType sType; + const void *pNext; + StdVideoVP9Profile stdProfile; +} VkVideoDecodeVP9ProfileInfoKHR; + typedef struct VkVideoEncodeAV1CapabilitiesKHR { VkStructureType sType; @@ -15414,6 +15977,14 @@ typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV const VkDeviceAddress *pAccelerationStructures; } VkWriteDescriptorSetPartitionedAccelerationStructureNV; +typedef struct VkWriteDescriptorSetTensorARM +{ + VkStructureType sType; + const void *pNext; + uint32_t tensorViewCount; + const VkTensorViewARM *pTensorViews; +} VkWriteDescriptorSetTensorARM; + typedef struct VkWriteIndirectExecutionSetPipelineEXT { VkStructureType sType; @@ -15896,6 +16467,36 @@ typedef struct StdVideoH265VideoParameterSet const StdVideoH265ProfileTierLevel *pProfileTierLevel; } StdVideoH265VideoParameterSet; +typedef struct StdVideoVP9ColorConfig +{ + StdVideoVP9ColorConfigFlags flags; + uint8_t BitDepth; + uint8_t subsampling_x; + uint8_t subsampling_y; + uint8_t reserved1; + StdVideoVP9ColorSpace color_space; +} StdVideoVP9ColorConfig; + +typedef struct StdVideoVP9LoopFilter +{ + StdVideoVP9LoopFilterFlags flags; + uint8_t loop_filter_level; + uint8_t loop_filter_sharpness; + uint8_t update_ref_delta; + int8_t loop_filter_ref_deltas[STD_VIDEO_VP9_MAX_REF_FRAMES]; + uint8_t update_mode_delta; + int8_t loop_filter_mode_deltas[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS]; +} StdVideoVP9LoopFilter; + +typedef struct StdVideoVP9Segmentation +{ + StdVideoVP9SegmentationFlags flags; + uint8_t segmentation_tree_probs[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS]; + uint8_t segmentation_pred_prob[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB]; + uint8_t FeatureEnabled[STD_VIDEO_VP9_MAX_SEGMENTS]; + int16_t FeatureData[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX]; +} StdVideoVP9Segmentation; + typedef struct VkAccelerationStructureGeometryAabbsDataKHR { VkStructureType sType; @@ -16265,6 +16866,16 @@ typedef struct VkCopyMicromapToMemoryInfoEXT VkCopyMicromapModeEXT mode; } VkCopyMicromapToMemoryInfoEXT; +typedef struct VkCopyTensorInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorARM WINE_VK_ALIGN(8) srcTensor; + VkTensorARM WINE_VK_ALIGN(8) dstTensor; + uint32_t regionCount; + const VkTensorCopyARM *pRegions; +} VkCopyTensorInfoARM; + typedef struct VkDebugUtilsMessengerCallbackDataEXT { VkStructureType sType; @@ -16683,6 +17294,15 @@ typedef struct VkPartitionedAccelerationStructureWriteInstanceDataNV VkDeviceAddress WINE_VK_ALIGN(8) accelerationStructure; } VkPartitionedAccelerationStructureWriteInstanceDataNV; +typedef struct VkPhysicalDeviceExternalTensorInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorCreateFlagsARM WINE_VK_ALIGN(8) flags; + const VkTensorDescriptionARM *pDescription; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalTensorInfoARM; + typedef struct VkPhysicalDeviceProperties { uint32_t apiVersion; @@ -16987,6 +17607,25 @@ typedef struct VkSurfaceFormat2KHR VkSurfaceFormatKHR surfaceFormat; } VkSurfaceFormat2KHR; +typedef struct VkTensorCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + VkTensorCreateFlagsARM WINE_VK_ALIGN(8) flags; + const VkTensorDescriptionARM *pDescription; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t *pQueueFamilyIndices; +} VkTensorCreateInfoARM; + +typedef struct VkTensorDependencyInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t tensorMemoryBarrierCount; + const VkTensorMemoryBarrierARM *pTensorMemoryBarriers; +} VkTensorDependencyInfoARM; + typedef struct VkVideoBeginCodingInfoKHR { VkStructureType sType; @@ -17142,6 +17781,28 @@ typedef struct StdVideoAV1SequenceHeader const StdVideoAV1TimingInfo *pTimingInfo; } StdVideoAV1SequenceHeader; +typedef struct StdVideoDecodeVP9PictureInfo +{ + StdVideoDecodeVP9PictureInfoFlags flags; + StdVideoVP9Profile profile; + StdVideoVP9FrameType frame_type; + uint8_t frame_context_idx; + uint8_t reset_frame_context; + uint8_t refresh_frame_flags; + uint8_t ref_frame_sign_bias_mask; + StdVideoVP9InterpolationFilter interpolation_filter; + uint8_t base_q_idx; + int8_t delta_q_y_dc; + int8_t delta_q_uv_dc; + int8_t delta_q_uv_ac; + uint8_t tile_cols_log2; + uint8_t tile_rows_log2; + uint16_t reserved1[3]; + const StdVideoVP9ColorConfig *pColorConfig; + const StdVideoVP9LoopFilter *pLoopFilter; + const StdVideoVP9Segmentation *pSegmentation; +} StdVideoDecodeVP9PictureInfo; + typedef struct StdVideoEncodeH264PictureInfo { StdVideoEncodeH264PictureInfoFlags flags; @@ -17424,6 +18085,13 @@ typedef struct VkDependencyInfo } VkDependencyInfo; typedef VkDependencyInfo VkDependencyInfoKHR; +typedef struct VkDeviceTensorMemoryRequirementsARM +{ + VkStructureType sType; + const void *pNext; + const VkTensorCreateInfoARM *pCreateInfo; +} VkDeviceTensorMemoryRequirementsARM; + typedef struct VkIndirectCommandsLayoutTokenEXT { VkStructureType sType; @@ -17573,6 +18241,17 @@ typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR const VkVideoDecodeH265SessionParametersAddInfoKHR *pParametersAddInfo; } VkVideoDecodeH265SessionParametersCreateInfoKHR; +typedef struct VkVideoDecodeVP9PictureInfoKHR +{ + VkStructureType sType; + const void *pNext; + const StdVideoDecodeVP9PictureInfo *pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]; + uint32_t uncompressedHeaderOffset; + uint32_t compressedHeaderOffset; + uint32_t tilesOffset; +} VkVideoDecodeVP9PictureInfoKHR; + typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR { VkStructureType sType; @@ -17787,6 +18466,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice, VkImage, VkDeviceM typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice, VkOpticalFlowSessionNV, VkOpticalFlowSessionBindingPointNV, VkImageView, VkImageLayout); +typedef VkResult (VKAPI_PTR *PFN_vkBindTensorMemoryARM)(VkDevice, uint32_t, const VkBindTensorMemoryInfoARM *); typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice, VkVideoSessionKHR, uint32_t, const VkBindVideoSessionMemoryInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice, VkDeferredOperationKHR, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR *, const VkAccelerationStructureBuildRangeInfoKHR * const*); typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice, VkDeferredOperationKHR, uint32_t, const VkMicromapBuildInfoEXT *); @@ -17857,6 +18537,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer, cons typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer, const VkCopyMicromapInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer, const VkCopyMicromapToMemoryInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer, VkQueryPool, uint32_t, uint32_t, VkBuffer, VkDeviceSize, VkDeviceSize, VkQueryResultFlags); +typedef void (VKAPI_PTR *PFN_vkCmdCopyTensorARM)(VkCommandBuffer, const VkCopyTensorInfoARM *); typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer, const VkCuLaunchInfoNVX *); typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer); @@ -17868,7 +18549,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer, uint32_t, uint32_t, typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer, VkBuffer, VkDeviceSize); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer, const VkDispatchTileInfoQCOM *); typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer, uint32_t, uint32_t, uint32_t, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer, uint32_t, uint32_t, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer, VkBuffer, VkDeviceSize); @@ -18120,6 +18801,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice, const VkSemaphoreC typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice, const VkShaderModuleCreateInfo *, const VkAllocationCallbacks *, VkShaderModule *); typedef VkResult (VKAPI_PTR *PFN_vkCreateShadersEXT)(VkDevice, uint32_t, const VkShaderCreateInfoEXT *, const VkAllocationCallbacks *, VkShaderEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice, const VkSwapchainCreateInfoKHR *, const VkAllocationCallbacks *, VkSwapchainKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateTensorARM)(VkDevice, const VkTensorCreateInfoARM *, const VkAllocationCallbacks *, VkTensorARM *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateTensorViewARM)(VkDevice, const VkTensorViewCreateInfoARM *, const VkAllocationCallbacks *, VkTensorViewARM *); typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice, const VkValidationCacheCreateInfoEXT *, const VkAllocationCallbacks *, VkValidationCacheEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice, const VkVideoSessionCreateInfoKHR *, const VkAllocationCallbacks *, VkVideoSessionKHR *); typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice, const VkVideoSessionParametersCreateInfoKHR *, const VkAllocationCallbacks *, VkVideoSessionParametersKHR *); @@ -18170,6 +18853,8 @@ typedef void (VKAPI_PTR *PFN_vkDestroyShaderEXT)(VkDevice, VkShaderEXT, const Vk typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice, VkShaderModule, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyTensorARM)(VkDevice, VkTensorARM, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyTensorViewARM)(VkDevice, VkTensorViewARM, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice, VkValidationCacheEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice, VkVideoSessionKHR, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice, VkVideoSessionParametersKHR, const VkAllocationCallbacks *); @@ -18236,6 +18921,7 @@ typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice, const typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice, uint32_t, uint32_t, VkQueue *); typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice, const VkDeviceQueueInfo2 *, VkQueue *); typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice, VkRenderPass, VkExtent2D *); +typedef void (VKAPI_PTR *PFN_vkGetDeviceTensorMemoryRequirementsARM)(VkDevice, const VkDeviceTensorMemoryRequirementsARM *, VkMemoryRequirements2 *); typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice, const VkRenderingInfo *, VkTilePropertiesQCOM *); typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice, const VkVideoEncodeSessionParametersGetInfoKHR *, VkVideoEncodeSessionParametersFeedbackInfoKHR *, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice, VkEvent); @@ -18278,6 +18964,7 @@ typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysi typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice, const VkPhysicalDeviceExternalFenceInfo *, VkExternalFenceProperties *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *, VkExternalSemaphoreProperties *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *, VkExternalSemaphoreProperties *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM)(VkPhysicalDevice, const VkPhysicalDeviceExternalTensorInfoARM *, VkExternalTensorPropertiesARM *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice, VkPhysicalDeviceFeatures2 *); @@ -18346,6 +19033,9 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice, VkPipeline, VkSha typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice, const VkShaderModuleCreateInfo *, VkShaderModuleIdentifierEXT *); typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice, VkShaderModule, VkShaderModuleIdentifierEXT *); typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice, VkSwapchainKHR, uint32_t *, VkImage *); +typedef void (VKAPI_PTR *PFN_vkGetTensorMemoryRequirementsARM)(VkDevice, const VkTensorMemoryRequirementsInfoARM *, VkMemoryRequirements2 *); +typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)(VkDevice, const VkTensorCaptureDescriptorDataInfoARM *, void *); +typedef VkResult (VKAPI_PTR *PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)(VkDevice, const VkTensorViewCaptureDescriptorDataInfoARM *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice, VkValidationCacheEXT, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice, VkVideoSessionKHR, uint32_t *, VkVideoSessionMemoryRequirementsKHR *); typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice, const VkInitializePerformanceApiInfoINTEL *); @@ -18405,6 +19095,7 @@ typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice, typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetShaderEXT *); typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice, VkVideoSessionParametersKHR, const VkVideoSessionParametersUpdateInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice, uint32_t, const VkFence *, VkBool32, uint64_t); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresent2KHR)(VkDevice, VkSwapchainKHR, const VkPresentWait2InfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice, VkSwapchainKHR, uint64_t, uint64_t); typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice, const VkSemaphoreWaitInfo *, uint64_t); typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice, const VkSemaphoreWaitInfo *, uint64_t); @@ -18429,6 +19120,7 @@ VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMe VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +VkResult VKAPI_CALL vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM *pBindInfos); VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos); VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos); VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos); @@ -18499,6 +19191,7 @@ void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, cons void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo); void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo); void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +void VKAPI_CALL vkCmdCopyTensorARM(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM *pCopyTensorInfo); void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo); void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo); void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer); @@ -18510,7 +19203,7 @@ void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCount void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -void VKAPI_CALL vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer); +void VKAPI_CALL vkCmdDispatchTileQCOM(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM *pDispatchTileInfo); void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); void VKAPI_CALL vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); @@ -18762,6 +19455,8 @@ VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateIn VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule); VkResult VKAPI_CALL vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders); VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain); +VkResult VKAPI_CALL vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorARM *pTensor); +VkResult VKAPI_CALL vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorViewARM *pView); VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache); VkResult VKAPI_CALL vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession); VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters); @@ -18812,6 +19507,8 @@ void VKAPI_CALL vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const Vk void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator); @@ -18878,6 +19575,7 @@ PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *p void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue); void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue); VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize); +void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements); VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties); VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event); @@ -18920,6 +19618,7 @@ void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice phys void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties); void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties); void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties); +void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM *pExternalTensorInfo, VkExternalTensorPropertiesARM *pExternalTensorProperties); void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures); void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures); void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures); @@ -18988,6 +19687,9 @@ VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkS void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier); void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier); VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages); +void VKAPI_CALL vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements); +VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM *pInfo, void *pData); +VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM *pInfo, void *pData); VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements); VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo); @@ -19047,6 +19749,7 @@ void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndir void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites); VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo); VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout); +VkResult VKAPI_CALL vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR *pPresentWait2Info); VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout); VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout); @@ -19072,6 +19775,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkBindImageMemory2) \ USE_VK_FUNC(vkBindImageMemory2KHR) \ USE_VK_FUNC(vkBindOpticalFlowSessionImageNV) \ + USE_VK_FUNC(vkBindTensorMemoryARM) \ USE_VK_FUNC(vkBindVideoSessionMemoryKHR) \ USE_VK_FUNC(vkBuildAccelerationStructuresKHR) \ USE_VK_FUNC(vkBuildMicromapsEXT) \ @@ -19142,6 +19846,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkCmdCopyMicromapEXT) \ USE_VK_FUNC(vkCmdCopyMicromapToMemoryEXT) \ USE_VK_FUNC(vkCmdCopyQueryPoolResults) \ + USE_VK_FUNC(vkCmdCopyTensorARM) \ USE_VK_FUNC(vkCmdCuLaunchKernelNVX) \ USE_VK_FUNC(vkCmdDebugMarkerBeginEXT) \ USE_VK_FUNC(vkCmdDebugMarkerEndEXT) \ @@ -19400,6 +20105,8 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkCreateShaderModule) \ USE_VK_FUNC(vkCreateShadersEXT) \ USE_VK_FUNC(vkCreateSwapchainKHR) \ + USE_VK_FUNC(vkCreateTensorARM) \ + USE_VK_FUNC(vkCreateTensorViewARM) \ USE_VK_FUNC(vkCreateValidationCacheEXT) \ USE_VK_FUNC(vkCreateVideoSessionKHR) \ USE_VK_FUNC(vkCreateVideoSessionParametersKHR) \ @@ -19444,6 +20151,8 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkDestroyShaderEXT) \ USE_VK_FUNC(vkDestroyShaderModule) \ USE_VK_FUNC(vkDestroySwapchainKHR) \ + USE_VK_FUNC(vkDestroyTensorARM) \ + USE_VK_FUNC(vkDestroyTensorViewARM) \ USE_VK_FUNC(vkDestroyValidationCacheEXT) \ USE_VK_FUNC(vkDestroyVideoSessionKHR) \ USE_VK_FUNC(vkDestroyVideoSessionParametersKHR) \ @@ -19500,6 +20209,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetDeviceQueue) \ USE_VK_FUNC(vkGetDeviceQueue2) \ USE_VK_FUNC(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI) \ + USE_VK_FUNC(vkGetDeviceTensorMemoryRequirementsARM) \ USE_VK_FUNC(vkGetDynamicRenderingTilePropertiesQCOM) \ USE_VK_FUNC(vkGetEncodedVideoSessionParametersKHR) \ USE_VK_FUNC(vkGetEventStatus) \ @@ -19558,6 +20268,9 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetShaderModuleCreateInfoIdentifierEXT) \ USE_VK_FUNC(vkGetShaderModuleIdentifierEXT) \ USE_VK_FUNC(vkGetSwapchainImagesKHR) \ + USE_VK_FUNC(vkGetTensorMemoryRequirementsARM) \ + USE_VK_FUNC(vkGetTensorOpaqueCaptureDescriptorDataARM) \ + USE_VK_FUNC(vkGetTensorViewOpaqueCaptureDescriptorDataARM) \ USE_VK_FUNC(vkGetValidationCacheDataEXT) \ USE_VK_FUNC(vkGetVideoSessionMemoryRequirementsKHR) \ USE_VK_FUNC(vkInitializePerformanceApiINTEL) \ @@ -19616,6 +20329,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkUpdateIndirectExecutionSetShaderEXT) \ USE_VK_FUNC(vkUpdateVideoSessionParametersKHR) \ USE_VK_FUNC(vkWaitForFences) \ + USE_VK_FUNC(vkWaitForPresent2KHR) \ USE_VK_FUNC(vkWaitForPresentKHR) \ USE_VK_FUNC(vkWaitSemaphores) \ USE_VK_FUNC(vkWaitSemaphoresKHR) \ @@ -19646,6 +20360,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeVectorPropertiesNV) \ + USE_VK_FUNC(vkGetPhysicalDeviceExternalTensorPropertiesARM) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures2) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures2KHR) \ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8314
participants (2)
-
Georg Lehmann -
Georg Lehmann (ï¼ DadSchoorse)