From: Georg Lehmann dadschoorse@gmail.com
--- dlls/winevulkan/loader_thunks.c | 160 ++- dlls/winevulkan/loader_thunks.h | 114 +- dlls/winevulkan/make_vulkan | 2 +- dlls/winevulkan/vulkan_thunks.c | 1780 +++++++++++++++++++++++++++++-- dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 545 ++++++++-- 6 files changed, 2423 insertions(+), 180 deletions(-)
diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 9f0d6d17ad5..e932ec46476 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -164,6 +164,18 @@ VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, return params.result; }
+VkResult WINAPI vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM *pBindInfos) +{ + struct vkBindDataGraphPipelineSessionMemoryARM_params params; + NTSTATUS status; + params.device = device; + params.bindInfoCount = bindInfoCount; + params.pBindInfos = pBindInfos; + status = UNIX_CALL(vkBindDataGraphPipelineSessionMemoryARM, ¶ms); + assert(!status && "vkBindDataGraphPipelineSessionMemoryARM"); + return params.result; +} + VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { struct vkBindImageMemory_params params; @@ -1020,6 +1032,15 @@ void WINAPI vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGro UNIX_CALL(vkCmdDispatchBaseKHR, ¶ms); }
+void WINAPI vkCmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM *pInfo) +{ + struct vkCmdDispatchDataGraphARM_params params; + params.commandBuffer = commandBuffer; + params.session = session; + params.pInfo = pInfo; + UNIX_CALL(vkCmdDispatchDataGraphARM, ¶ms); +} + void WINAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { struct vkCmdDispatchIndirect_params params; @@ -3073,6 +3094,35 @@ VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoN return params.result; }
+VkResult WINAPI vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDataGraphPipelineSessionARM *pSession) +{ + struct vkCreateDataGraphPipelineSessionARM_params params; + NTSTATUS status; + params.device = device; + params.pCreateInfo = pCreateInfo; + params.pAllocator = pAllocator; + params.pSession = pSession; + status = UNIX_CALL(vkCreateDataGraphPipelineSessionARM, ¶ms); + assert(!status && "vkCreateDataGraphPipelineSessionARM"); + return params.result; +} + +VkResult WINAPI vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) +{ + struct vkCreateDataGraphPipelinesARM_params params; + NTSTATUS status; + params.device = device; + params.deferredOperation = deferredOperation; + params.pipelineCache = pipelineCache; + params.createInfoCount = createInfoCount; + params.pCreateInfos = pCreateInfos; + params.pAllocator = pAllocator; + params.pPipelines = pPipelines; + status = UNIX_CALL(vkCreateDataGraphPipelinesARM, ¶ms); + assert(!status && "vkCreateDataGraphPipelinesARM"); + return params.result; +} + VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) { struct vkCreateDebugReportCallbackEXT_params params; @@ -3741,6 +3791,17 @@ void WINAPI vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const Vk assert(!status && "vkDestroyCuModuleNVX"); }
+void WINAPI vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks *pAllocator) +{ + struct vkDestroyDataGraphPipelineSessionARM_params params; + NTSTATUS status; + params.device = device; + params.session = session; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkDestroyDataGraphPipelineSessionARM, ¶ms); + assert(!status && "vkDestroyDataGraphPipelineSessionARM"); +} + void WINAPI vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDebugReportCallbackEXT_params params; @@ -4489,6 +4550,56 @@ void WINAPI vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const assert(!status && "vkGetClusterAccelerationStructureBuildSizesNV"); }
+VkResult WINAPI vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t *pPropertiesCount, VkDataGraphPipelinePropertyARM *pProperties) +{ + struct vkGetDataGraphPipelineAvailablePropertiesARM_params params; + NTSTATUS status; + params.device = device; + params.pPipelineInfo = pPipelineInfo; + params.pPropertiesCount = pPropertiesCount; + params.pProperties = pProperties; + status = UNIX_CALL(vkGetDataGraphPipelineAvailablePropertiesARM, ¶ms); + assert(!status && "vkGetDataGraphPipelineAvailablePropertiesARM"); + return params.result; +} + +VkResult WINAPI vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM *pProperties) +{ + struct vkGetDataGraphPipelinePropertiesARM_params params; + NTSTATUS status; + params.device = device; + params.pPipelineInfo = pPipelineInfo; + params.propertiesCount = propertiesCount; + params.pProperties = pProperties; + status = UNIX_CALL(vkGetDataGraphPipelinePropertiesARM, ¶ms); + assert(!status && "vkGetDataGraphPipelinePropertiesARM"); + return params.result; +} + +VkResult WINAPI vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *pInfo, uint32_t *pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM *pBindPointRequirements) +{ + struct vkGetDataGraphPipelineSessionBindPointRequirementsARM_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pBindPointRequirementCount = pBindPointRequirementCount; + params.pBindPointRequirements = pBindPointRequirements; + status = UNIX_CALL(vkGetDataGraphPipelineSessionBindPointRequirementsARM, ¶ms); + assert(!status && "vkGetDataGraphPipelineSessionBindPointRequirementsARM"); + return params.result; +} + +void WINAPI vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements) +{ + struct vkGetDataGraphPipelineSessionMemoryRequirementsARM_params params; + NTSTATUS status; + params.device = device; + params.pInfo = pInfo; + params.pMemoryRequirements = pMemoryRequirements; + status = UNIX_CALL(vkGetDataGraphPipelineSessionMemoryRequirementsARM, ¶ms); + assert(!status && "vkGetDataGraphPipelineSessionMemoryRequirementsARM"); +} + uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) { struct vkGetDeferredOperationMaxConcurrencyKHR_params params; @@ -5498,6 +5609,30 @@ void WINAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhy assert(!status && "vkGetPhysicalDeviceProperties"); }
+void WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *pQueueFamilyDataGraphProcessingEngineProperties) +{ + struct vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM_params params; + NTSTATUS status; + params.physicalDevice = physicalDevice; + params.pQueueFamilyDataGraphProcessingEngineInfo = pQueueFamilyDataGraphProcessingEngineInfo; + params.pQueueFamilyDataGraphProcessingEngineProperties = pQueueFamilyDataGraphProcessingEngineProperties; + status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, ¶ms); + assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM"); +} + +VkResult WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties) +{ + struct vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM_params params; + NTSTATUS status; + params.physicalDevice = physicalDevice; + params.queueFamilyIndex = queueFamilyIndex; + params.pQueueFamilyDataGraphPropertyCount = pQueueFamilyDataGraphPropertyCount; + params.pQueueFamilyDataGraphProperties = pQueueFamilyDataGraphProperties; + status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, ¶ms); + assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM"); + return params.result; +} + void WINAPI vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses) { struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params params; @@ -6425,7 +6560,7 @@ void WINAPI vkReleaseProfilingLockKHR(VkDevice device) assert(!status && "vkReleaseProfilingLockKHR"); }
-VkResult WINAPI vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo) +VkResult WINAPI vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo) { struct vkReleaseSwapchainImagesEXT_params params; NTSTATUS status; @@ -6436,6 +6571,17 @@ VkResult WINAPI vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwap return params.result; }
+VkResult WINAPI vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo) +{ + struct vkReleaseSwapchainImagesKHR_params params; + NTSTATUS status; + params.device = device; + params.pReleaseInfo = pReleaseInfo; + status = UNIX_CALL(vkReleaseSwapchainImagesKHR, ¶ms); + assert(!status && "vkReleaseSwapchainImagesKHR"); + return params.result; +} + VkResult WINAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { struct vkResetCommandBuffer_params params; @@ -6925,6 +7071,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkBindBufferMemory", vkBindBufferMemory}, {"vkBindBufferMemory2", vkBindBufferMemory2}, {"vkBindBufferMemory2KHR", vkBindBufferMemory2KHR}, + {"vkBindDataGraphPipelineSessionMemoryARM", vkBindDataGraphPipelineSessionMemoryARM}, {"vkBindImageMemory", vkBindImageMemory}, {"vkBindImageMemory2", vkBindImageMemory2}, {"vkBindImageMemory2KHR", vkBindImageMemory2KHR}, @@ -7011,6 +7158,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdDispatch", vkCmdDispatch}, {"vkCmdDispatchBase", vkCmdDispatchBase}, {"vkCmdDispatchBaseKHR", vkCmdDispatchBaseKHR}, + {"vkCmdDispatchDataGraphARM", vkCmdDispatchDataGraphARM}, {"vkCmdDispatchIndirect", vkCmdDispatchIndirect}, {"vkCmdDispatchTileQCOM", vkCmdDispatchTileQCOM}, {"vkCmdDraw", vkCmdDraw}, @@ -7225,6 +7373,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateComputePipelines", vkCreateComputePipelines}, {"vkCreateCuFunctionNVX", vkCreateCuFunctionNVX}, {"vkCreateCuModuleNVX", vkCreateCuModuleNVX}, + {"vkCreateDataGraphPipelineSessionARM", vkCreateDataGraphPipelineSessionARM}, + {"vkCreateDataGraphPipelinesARM", vkCreateDataGraphPipelinesARM}, {"vkCreateDeferredOperationKHR", vkCreateDeferredOperationKHR}, {"vkCreateDescriptorPool", vkCreateDescriptorPool}, {"vkCreateDescriptorSetLayout", vkCreateDescriptorSetLayout}, @@ -7274,6 +7424,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyCommandPool", vkDestroyCommandPool}, {"vkDestroyCuFunctionNVX", vkDestroyCuFunctionNVX}, {"vkDestroyCuModuleNVX", vkDestroyCuModuleNVX}, + {"vkDestroyDataGraphPipelineSessionARM", vkDestroyDataGraphPipelineSessionARM}, {"vkDestroyDeferredOperationKHR", vkDestroyDeferredOperationKHR}, {"vkDestroyDescriptorPool", vkDestroyDescriptorPool}, {"vkDestroyDescriptorSetLayout", vkDestroyDescriptorSetLayout}, @@ -7333,6 +7484,10 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetCalibratedTimestampsEXT", vkGetCalibratedTimestampsEXT}, {"vkGetCalibratedTimestampsKHR", vkGetCalibratedTimestampsKHR}, {"vkGetClusterAccelerationStructureBuildSizesNV", vkGetClusterAccelerationStructureBuildSizesNV}, + {"vkGetDataGraphPipelineAvailablePropertiesARM", vkGetDataGraphPipelineAvailablePropertiesARM}, + {"vkGetDataGraphPipelinePropertiesARM", vkGetDataGraphPipelinePropertiesARM}, + {"vkGetDataGraphPipelineSessionBindPointRequirementsARM", vkGetDataGraphPipelineSessionBindPointRequirementsARM}, + {"vkGetDataGraphPipelineSessionMemoryRequirementsARM", vkGetDataGraphPipelineSessionMemoryRequirementsARM}, {"vkGetDeferredOperationMaxConcurrencyKHR", vkGetDeferredOperationMaxConcurrencyKHR}, {"vkGetDeferredOperationResultKHR", vkGetDeferredOperationResultKHR}, {"vkGetDescriptorEXT", vkGetDescriptorEXT}, @@ -7449,6 +7604,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkReleasePerformanceConfigurationINTEL", vkReleasePerformanceConfigurationINTEL}, {"vkReleaseProfilingLockKHR", vkReleaseProfilingLockKHR}, {"vkReleaseSwapchainImagesEXT", vkReleaseSwapchainImagesEXT}, + {"vkReleaseSwapchainImagesKHR", vkReleaseSwapchainImagesKHR}, {"vkResetCommandBuffer", vkResetCommandBuffer}, {"vkResetCommandPool", vkResetCommandPool}, {"vkResetDescriptorPool", vkResetDescriptorPool}, @@ -7528,6 +7684,8 @@ static const struct vulkan_func vk_phys_dev_dispatch_table[] = {"vkGetPhysicalDeviceProperties", vkGetPhysicalDeviceProperties}, {"vkGetPhysicalDeviceProperties2", vkGetPhysicalDeviceProperties2}, {"vkGetPhysicalDeviceProperties2KHR", vkGetPhysicalDeviceProperties2KHR}, + {"vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM", vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM}, + {"vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM", vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM}, {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR}, {"vkGetPhysicalDeviceQueueFamilyProperties", vkGetPhysicalDeviceQueueFamilyProperties}, {"vkGetPhysicalDeviceQueueFamilyProperties2", vkGetPhysicalDeviceQueueFamilyProperties2}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index 91c222d3390..7bf58a83988 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -36,6 +36,7 @@ enum unix_call unix_vkBindBufferMemory, unix_vkBindBufferMemory2, unix_vkBindBufferMemory2KHR, + unix_vkBindDataGraphPipelineSessionMemoryARM, unix_vkBindImageMemory, unix_vkBindImageMemory2, unix_vkBindImageMemory2KHR, @@ -122,6 +123,7 @@ enum unix_call unix_vkCmdDispatch, unix_vkCmdDispatchBase, unix_vkCmdDispatchBaseKHR, + unix_vkCmdDispatchDataGraphARM, unix_vkCmdDispatchIndirect, unix_vkCmdDispatchTileQCOM, unix_vkCmdDraw, @@ -336,6 +338,8 @@ enum unix_call unix_vkCreateComputePipelines, unix_vkCreateCuFunctionNVX, unix_vkCreateCuModuleNVX, + unix_vkCreateDataGraphPipelineSessionARM, + unix_vkCreateDataGraphPipelinesARM, unix_vkCreateDebugReportCallbackEXT, unix_vkCreateDebugUtilsMessengerEXT, unix_vkCreateDeferredOperationKHR, @@ -391,6 +395,7 @@ enum unix_call unix_vkDestroyCommandPool, unix_vkDestroyCuFunctionNVX, unix_vkDestroyCuModuleNVX, + unix_vkDestroyDataGraphPipelineSessionARM, unix_vkDestroyDebugReportCallbackEXT, unix_vkDestroyDebugUtilsMessengerEXT, unix_vkDestroyDeferredOperationKHR, @@ -462,6 +467,10 @@ enum unix_call unix_vkGetCalibratedTimestampsEXT, unix_vkGetCalibratedTimestampsKHR, unix_vkGetClusterAccelerationStructureBuildSizesNV, + unix_vkGetDataGraphPipelineAvailablePropertiesARM, + unix_vkGetDataGraphPipelinePropertiesARM, + unix_vkGetDataGraphPipelineSessionBindPointRequirementsARM, + unix_vkGetDataGraphPipelineSessionMemoryRequirementsARM, unix_vkGetDeferredOperationMaxConcurrencyKHR, unix_vkGetDeferredOperationResultKHR, unix_vkGetDescriptorEXT, @@ -552,6 +561,8 @@ enum unix_call unix_vkGetPhysicalDeviceProperties, unix_vkGetPhysicalDeviceProperties2, unix_vkGetPhysicalDeviceProperties2KHR, + unix_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, + unix_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, unix_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, unix_vkGetPhysicalDeviceQueueFamilyProperties, unix_vkGetPhysicalDeviceQueueFamilyProperties2, @@ -629,6 +640,7 @@ enum unix_call unix_vkReleasePerformanceConfigurationINTEL, unix_vkReleaseProfilingLockKHR, unix_vkReleaseSwapchainImagesEXT, + unix_vkReleaseSwapchainImagesKHR, unix_vkResetCommandBuffer, unix_vkResetCommandPool, unix_vkResetDescriptorPool, @@ -777,6 +789,14 @@ struct vkBindBufferMemory2KHR_params VkResult result; };
+struct vkBindDataGraphPipelineSessionMemoryARM_params +{ + VkDevice device; + uint32_t bindInfoCount; + const VkBindDataGraphPipelineSessionMemoryInfoARM *pBindInfos; + VkResult result; +}; + struct vkBindImageMemory_params { VkDevice device; @@ -1445,6 +1465,13 @@ struct vkCmdDispatchBaseKHR_params uint32_t groupCountZ; };
+struct vkCmdDispatchDataGraphARM_params +{ + VkCommandBuffer commandBuffer; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + const VkDataGraphPipelineDispatchInfoARM *pInfo; +}; + struct vkCmdDispatchIndirect_params { VkCommandBuffer commandBuffer; @@ -3034,6 +3061,27 @@ struct vkCreateCuModuleNVX_params VkResult result; };
+struct vkCreateDataGraphPipelineSessionARM_params +{ + VkDevice device; + const VkDataGraphPipelineSessionCreateInfoARM *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkDataGraphPipelineSessionARM *pSession; + VkResult result; +}; + +struct vkCreateDataGraphPipelinesARM_params +{ + VkDevice device; + VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation; + VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache; + uint32_t createInfoCount; + const VkDataGraphPipelineCreateInfoARM *pCreateInfos; + const VkAllocationCallbacks *pAllocator; + VkPipeline *pPipelines; + VkResult result; +}; + struct vkCreateDebugReportCallbackEXT_params { VkInstance instance; @@ -3520,6 +3568,13 @@ struct vkDestroyCuModuleNVX_params const VkAllocationCallbacks *pAllocator; };
+struct vkDestroyDataGraphPipelineSessionARM_params +{ + VkDevice device; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + const VkAllocationCallbacks *pAllocator; +}; + struct vkDestroyDebugReportCallbackEXT_params { VkInstance instance; @@ -4038,6 +4093,40 @@ struct vkGetClusterAccelerationStructureBuildSizesNV_params VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo; };
+struct vkGetDataGraphPipelineAvailablePropertiesARM_params +{ + VkDevice device; + const VkDataGraphPipelineInfoARM *pPipelineInfo; + uint32_t *pPropertiesCount; + VkDataGraphPipelinePropertyARM *pProperties; + VkResult result; +}; + +struct vkGetDataGraphPipelinePropertiesARM_params +{ + VkDevice device; + const VkDataGraphPipelineInfoARM *pPipelineInfo; + uint32_t propertiesCount; + VkDataGraphPipelinePropertyQueryResultARM *pProperties; + VkResult result; +}; + +struct vkGetDataGraphPipelineSessionBindPointRequirementsARM_params +{ + VkDevice device; + const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *pInfo; + uint32_t *pBindPointRequirementCount; + VkDataGraphPipelineSessionBindPointRequirementARM *pBindPointRequirements; + VkResult result; +}; + +struct vkGetDataGraphPipelineSessionMemoryRequirementsARM_params +{ + VkDevice device; + const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *pInfo; + VkMemoryRequirements2 *pMemoryRequirements; +}; + struct vkGetDeferredOperationMaxConcurrencyKHR_params { VkDevice device; @@ -4709,6 +4798,22 @@ struct vkGetPhysicalDeviceProperties2KHR_params VkPhysicalDeviceProperties2 *pProperties; };
+struct vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM_params +{ + VkPhysicalDevice physicalDevice; + const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *pQueueFamilyDataGraphProcessingEngineInfo; + VkQueueFamilyDataGraphProcessingEnginePropertiesARM *pQueueFamilyDataGraphProcessingEngineProperties; +}; + +struct vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM_params +{ + VkPhysicalDevice physicalDevice; + uint32_t queueFamilyIndex; + uint32_t *pQueueFamilyDataGraphPropertyCount; + VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties; + VkResult result; +}; + struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params { VkPhysicalDevice physicalDevice; @@ -5335,7 +5440,14 @@ struct vkReleaseProfilingLockKHR_params struct vkReleaseSwapchainImagesEXT_params { VkDevice device; - const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo; + const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo; + VkResult result; +}; + +struct vkReleaseSwapchainImagesKHR_params +{ + VkDevice device; + const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo; VkResult result; };
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 662ea876bb2..2a7b192685c 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.318" +VK_XML_VERSION = "1.4.325" WINE_VK_VERSION = (1, 4)
# Filenames to create. diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index c0bf1d5de80..c8045fa397e 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -336,6 +336,17 @@ typedef struct VkBindBufferMemoryInfo32 } VkBindBufferMemoryInfo32; typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;
+typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; +} VkBindDataGraphPipelineSessionMemoryInfoARM32; + typedef struct VkBindImageMemoryDeviceGroupInfo32 { VkStructureType sType; @@ -796,6 +807,13 @@ typedef struct VkVideoEncodeAV1DpbSlotInfoKHR32 PTR32 pStdReferenceInfo; } VkVideoEncodeAV1DpbSlotInfoKHR32;
+typedef struct VkVideoReferenceIntraRefreshInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t dirtyIntraRefreshRegions; +} VkVideoReferenceIntraRefreshInfoKHR32; + typedef struct VkVideoReferenceSlotInfoKHR32 { VkStructureType sType; @@ -1478,6 +1496,13 @@ typedef struct VkDecompressMemoryRegionNV32 VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod; } VkDecompressMemoryRegionNV32;
+typedef struct VkDataGraphPipelineDispatchInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelineDispatchFlagsARM DECLSPEC_ALIGN(8) flags; +} VkDataGraphPipelineDispatchInfoARM32; + typedef struct VkDispatchTileInfoQCOM32 { VkStructureType sType; @@ -1598,6 +1623,14 @@ typedef struct VkVideoEncodeAV1PictureInfoKHR32 VkBool32 generateObuExtensionHeader; } VkVideoEncodeAV1PictureInfoKHR32;
+typedef struct VkVideoEncodeIntraRefreshInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t intraRefreshCycleDuration; + uint32_t intraRefreshIndex; +} VkVideoEncodeIntraRefreshInfoKHR32; + typedef struct VkVideoEncodeInfoKHR32 { VkStructureType sType; @@ -2280,6 +2313,14 @@ typedef struct VkBufferViewCreateInfo32 VkDeviceSize DECLSPEC_ALIGN(8) range; } VkBufferViewCreateInfo32;
+typedef struct VkDataGraphProcessingEngineCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t processingEngineCount; + PTR32 pProcessingEngines; +} VkDataGraphProcessingEngineCreateInfoARM32; + typedef struct VkCommandPoolCreateInfo32 { VkStructureType sType; @@ -2458,6 +2499,88 @@ typedef struct VkCuModuleCreateInfoNVX32 PTR32 pData; } VkCuModuleCreateInfoNVX32;
+typedef struct VkDataGraphPipelineSessionCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelineSessionCreateFlagsARM DECLSPEC_ALIGN(8) flags; + VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline; +} VkDataGraphPipelineSessionCreateInfoARM32; + +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 VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t dimension; + uint32_t zeroCount; + uint32_t groupSize; +} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32; + +typedef struct VkDataGraphPipelineConstantARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t id; + PTR32 pConstantData; +} VkDataGraphPipelineConstantARM32; + +typedef struct VkDataGraphPipelineResourceInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t descriptorSet; + uint32_t binding; + uint32_t arrayElement; +} VkDataGraphPipelineResourceInfoARM32; + +typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pVendorOptions; +} VkDataGraphPipelineCompilerControlCreateInfoARM32; + +typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkShaderModule DECLSPEC_ALIGN(8) module; + PTR32 pName; + PTR32 pSpecializationInfo; + uint32_t constantCount; + PTR32 pConstants; +} VkDataGraphPipelineShaderModuleCreateInfoARM32; + +typedef struct VkDataGraphPipelineIdentifierCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t identifierSize; + PTR32 pIdentifier; +} VkDataGraphPipelineIdentifierCreateInfoARM32; + +typedef struct VkDataGraphPipelineCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipelineCreateFlags2KHR flags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t resourceInfoCount; + PTR32 pResourceInfos; +} VkDataGraphPipelineCreateInfoARM32; + typedef struct VkDebugReportCallbackCreateInfoEXT32 { VkStructureType sType; @@ -3853,6 +3976,13 @@ typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32 VkBool32 transformFeedbackPreservesProvokingVertex; } VkPhysicalDeviceProvokingVertexFeaturesEXT32;
+typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 videoEncodeIntraRefresh; +} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32; + typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32 { VkStructureType sType; @@ -4117,12 +4247,13 @@ typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 VkBool32 dynamicRenderingUnusedAttachments; } VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32;
-typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 { VkStructureType sType; PTR32 pNext; VkBool32 swapchainMaintenance1; -} VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32; +typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32;
typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT32 { @@ -4378,12 +4509,13 @@ typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 VkBool32 shaderReplicatedComposites; } VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32;
-typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 +typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 { VkStructureType sType; PTR32 pNext; VkBool32 presentModeFifoLatestReady; -} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32; +} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32; +typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32;
typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 { @@ -4489,6 +4621,31 @@ typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT32 VkBool32 shaderFloat8CooperativeMatrix; } VkPhysicalDeviceShaderFloat8FeaturesEXT32;
+typedef struct VkPhysicalDeviceDataGraphFeaturesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 dataGraph; + VkBool32 dataGraphUpdateAfterBind; + VkBool32 dataGraphSpecializationConstants; + VkBool32 dataGraphDescriptorBuffer; + VkBool32 dataGraphShaderModule; +} VkPhysicalDeviceDataGraphFeaturesARM32; + +typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 pipelineCacheIncrementalMode; +} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32; + +typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderUntypedPointers; +} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32; + typedef struct VkDeviceCreateInfo32 { VkStructureType sType; @@ -5795,22 +5952,24 @@ typedef struct VkSwapchainPresentBarrierCreateInfoNV32 VkBool32 presentBarrierEnable; } VkSwapchainPresentBarrierCreateInfoNV32;
-typedef struct VkSwapchainPresentModesCreateInfoEXT32 +typedef struct VkSwapchainPresentModesCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; uint32_t presentModeCount; PTR32 pPresentModes; -} VkSwapchainPresentModesCreateInfoEXT32; +} VkSwapchainPresentModesCreateInfoKHR32; +typedef VkSwapchainPresentModesCreateInfoKHR32 VkSwapchainPresentModesCreateInfoEXT32;
-typedef struct VkSwapchainPresentScalingCreateInfoEXT32 +typedef struct VkSwapchainPresentScalingCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPresentScalingFlagsEXT scalingBehavior; - VkPresentGravityFlagsEXT presentGravityX; - VkPresentGravityFlagsEXT presentGravityY; -} VkSwapchainPresentScalingCreateInfoEXT32; + VkPresentScalingFlagsKHR scalingBehavior; + VkPresentGravityFlagsKHR presentGravityX; + VkPresentGravityFlagsKHR presentGravityY; +} VkSwapchainPresentScalingCreateInfoKHR32; +typedef VkSwapchainPresentScalingCreateInfoKHR32 VkSwapchainPresentScalingCreateInfoEXT32;
typedef struct VkSwapchainLatencyCreateInfoNV32 { @@ -5841,18 +6000,6 @@ 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; @@ -5905,6 +6052,13 @@ typedef struct VkVideoEncodeAV1SessionCreateInfoKHR32 StdVideoAV1Level maxLevel; } VkVideoEncodeAV1SessionCreateInfoKHR32;
+typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode; +} VkVideoEncodeSessionIntraRefreshCreateInfoKHR32; + typedef struct VkVideoSessionCreateInfoKHR32 { VkStructureType sType; @@ -6238,6 +6392,48 @@ typedef struct VkCalibratedTimestampInfoKHR32 } VkCalibratedTimestampInfoKHR32; typedef VkCalibratedTimestampInfoKHR32 VkCalibratedTimestampInfoEXT32;
+typedef struct VkDataGraphPipelineInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline; +} VkDataGraphPipelineInfoARM32; + +typedef struct VkDataGraphPipelinePropertyQueryResultARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelinePropertyARM property; + VkBool32 isText; + PTR32 dataSize; + PTR32 pData; +} VkDataGraphPipelinePropertyQueryResultARM32; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; +} VkDataGraphPipelineSessionBindPointRequirementsInfoARM32; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelineSessionBindPointARM bindPoint; + VkDataGraphPipelineSessionBindPointTypeARM bindPointType; + uint32_t numObjects; +} VkDataGraphPipelineSessionBindPointRequirementARM32; + +typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; +} VkDataGraphPipelineSessionMemoryRequirementsInfoARM32; + typedef struct VkDescriptorAddressInfoEXT32 { VkStructureType sType; @@ -8272,6 +8468,30 @@ typedef struct VkPhysicalDeviceProperties232 } VkPhysicalDeviceProperties232; typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
+typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t queueFamilyIndex; + VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType; +} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32; + +typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes; + VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes; +} VkQueueFamilyDataGraphProcessingEnginePropertiesARM32; + +typedef struct VkQueueFamilyDataGraphPropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkPhysicalDeviceDataGraphProcessingEngineARM engine; + VkPhysicalDeviceDataGraphOperationSupportARM operation; +} VkQueueFamilyDataGraphPropertiesARM32; + typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR32 { VkStructureType sType; @@ -8355,12 +8575,13 @@ typedef struct VkFramebufferMixedSamplesCombinationNV32 VkSampleCountFlags colorSamples; } VkFramebufferMixedSamplesCombinationNV32;
-typedef struct VkSurfacePresentModeEXT32 +typedef struct VkSurfacePresentModeKHR32 { VkStructureType sType; PTR32 pNext; VkPresentModeKHR presentMode; -} VkSurfacePresentModeEXT32; +} VkSurfacePresentModeKHR32; +typedef VkSurfacePresentModeKHR32 VkSurfacePresentModeEXT32;
typedef struct VkPhysicalDeviceSurfaceInfo2KHR32 { @@ -8390,24 +8611,26 @@ typedef struct VkSurfaceCapabilitiesPresentWait2KHR32 VkBool32 presentWait2Supported; } VkSurfaceCapabilitiesPresentWait2KHR32;
-typedef struct VkSurfacePresentScalingCapabilitiesEXT32 +typedef struct VkSurfacePresentScalingCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - VkPresentScalingFlagsEXT supportedPresentScaling; - VkPresentGravityFlagsEXT supportedPresentGravityX; - VkPresentGravityFlagsEXT supportedPresentGravityY; + VkPresentScalingFlagsKHR supportedPresentScaling; + VkPresentGravityFlagsKHR supportedPresentGravityX; + VkPresentGravityFlagsKHR supportedPresentGravityY; VkExtent2D minScaledImageExtent; VkExtent2D maxScaledImageExtent; -} VkSurfacePresentScalingCapabilitiesEXT32; +} VkSurfacePresentScalingCapabilitiesKHR32; +typedef VkSurfacePresentScalingCapabilitiesKHR32 VkSurfacePresentScalingCapabilitiesEXT32;
-typedef struct VkSurfacePresentModeCompatibilityEXT32 +typedef struct VkSurfacePresentModeCompatibilityKHR32 { VkStructureType sType; PTR32 pNext; uint32_t presentModeCount; PTR32 pPresentModes; -} VkSurfacePresentModeCompatibilityEXT32; +} VkSurfacePresentModeCompatibilityKHR32; +typedef VkSurfacePresentModeCompatibilityKHR32 VkSurfacePresentModeCompatibilityEXT32;
typedef struct VkLatencySurfaceCapabilitiesNV32 { @@ -8565,6 +8788,17 @@ typedef struct VkVideoEncodeAV1CapabilitiesKHR32 VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags; } VkVideoEncodeAV1CapabilitiesKHR32;
+typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes; + uint32_t maxIntraRefreshCycleDuration; + uint32_t maxIntraRefreshActiveReferencePictures; + VkBool32 partitionIndependentIntraRefreshRegions; + VkBool32 nonRectangularIntraRefreshRegions; +} VkVideoEncodeIntraRefreshCapabilitiesKHR32; + typedef struct VkVideoCapabilitiesKHR32 { VkStructureType sType; @@ -8993,21 +9227,23 @@ typedef struct VkPresentId2KHR32 PTR32 pPresentIds; } VkPresentId2KHR32;
-typedef struct VkSwapchainPresentFenceInfoEXT32 +typedef struct VkSwapchainPresentFenceInfoKHR32 { VkStructureType sType; PTR32 pNext; uint32_t swapchainCount; PTR32 pFences; -} VkSwapchainPresentFenceInfoEXT32; +} VkSwapchainPresentFenceInfoKHR32; +typedef VkSwapchainPresentFenceInfoKHR32 VkSwapchainPresentFenceInfoEXT32;
-typedef struct VkSwapchainPresentModeInfoEXT32 +typedef struct VkSwapchainPresentModeInfoKHR32 { VkStructureType sType; PTR32 pNext; uint32_t swapchainCount; PTR32 pPresentModes; -} VkSwapchainPresentModeInfoEXT32; +} VkSwapchainPresentModeInfoKHR32; +typedef VkSwapchainPresentModeInfoKHR32 VkSwapchainPresentModeInfoEXT32;
typedef struct VkPresentInfoKHR32 { @@ -9117,14 +9353,15 @@ typedef struct VkReleaseCapturedPipelineDataInfoKHR32 VkPipeline DECLSPEC_ALIGN(8) pipeline; } VkReleaseCapturedPipelineDataInfoKHR32;
-typedef struct VkReleaseSwapchainImagesInfoEXT32 +typedef struct VkReleaseSwapchainImagesInfoKHR32 { VkStructureType sType; PTR32 pNext; VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; uint32_t imageIndexCount; PTR32 pImageIndices; -} VkReleaseSwapchainImagesInfoEXT32; +} VkReleaseSwapchainImagesInfoKHR32; +typedef VkReleaseSwapchainImagesInfoKHR32 VkReleaseSwapchainImagesInfoEXT32;
typedef struct VkDebugUtilsObjectTagInfoEXT32 { @@ -10128,6 +10365,70 @@ static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array return out; }
+#ifdef _WIN64 +static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->session = in->session; + out->bindPoint = in->bindPoint; + out->objectIndex = in->objectIndex; + out->memory = wine_device_memory_from_handle(in->memory)->host.device_memory; + out->memoryOffset = in->memoryOffset; +} +#endif /* _WIN64 */ + +static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win32_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->session = in->session; + out->bindPoint = in->bindPoint; + out->objectIndex = in->objectIndex; + 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 VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM *in, uint32_t count) +{ + VkBindDataGraphPipelineSessionMemoryInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_host(&in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, uint32_t count) +{ + VkBindDataGraphPipelineSessionMemoryInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + #ifdef _WIN64 static inline void convert_VkBindImageMemoryInfo_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out) { @@ -11337,6 +11638,17 @@ static inline void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: + { + VkVideoReferenceIntraRefreshInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoReferenceIntraRefreshInfoKHR32 *in_ext = (const VkVideoReferenceIntraRefreshInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR; + out_ext->pNext = NULL; + out_ext->dirtyIntraRefreshRegions = in_ext->dirtyIntraRefreshRegions; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -11928,7 +12240,7 @@ static inline void convert_VkClusterAccelerationStructureOpInputNV_win32_to_host
if (selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV) out->pClustersBottomLevel = convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_array_win32_to_host(ctx, (VkClusterAccelerationStructureClustersBottomLevelInputNV32 *)UlongToPtr(in->pClustersBottomLevel), 1); - if (selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV || selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV || selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV) + if (selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV || selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV || selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV || selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV) out->pTriangleClusters = convert_VkClusterAccelerationStructureTriangleClusterInputNV_array_win32_to_host(ctx, (VkClusterAccelerationStructureTriangleClusterInputNV32 *)UlongToPtr(in->pTriangleClusters), 1); if (selector == VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV) out->pMoveObjects = convert_VkClusterAccelerationStructureMoveObjectsInputNV_array_win32_to_host(ctx, (VkClusterAccelerationStructureMoveObjectsInputNV32 *)UlongToPtr(in->pMoveObjects), 1); @@ -12766,6 +13078,17 @@ static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegion return out; }
+static inline void convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host(const VkDataGraphPipelineDispatchInfoARM32 *in, VkDataGraphPipelineDispatchInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInfoQCOM32 *in, VkDispatchTileInfoQCOM *out) { if (!in) return; @@ -13030,6 +13353,18 @@ static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: + { + VkVideoEncodeIntraRefreshInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeIntraRefreshInfoKHR32 *in_ext = (const VkVideoEncodeIntraRefreshInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR; + out_ext->pNext = NULL; + out_ext->intraRefreshCycleDuration = in_ext->intraRefreshCycleDuration; + out_ext->intraRefreshIndex = in_ext->intraRefreshIndex; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -14746,16 +15081,39 @@ static inline void convert_VkBufferViewCreateInfo_win32_to_host(struct conversio } }
-static inline void convert_VkCommandPoolCreateInfo_win32_to_host(const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out) +static inline void convert_VkCommandPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *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->queueFamilyIndex = in->queueFamilyIndex; - 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_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + { + VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphProcessingEngineCreateInfoARM32 *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->processingEngineCount = in_ext->processingEngineCount; + out_ext->pProcessingEngines = UlongToPtr(in_ext->pProcessingEngines); + 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_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out) @@ -15288,6 +15646,295 @@ static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversi } }
+static inline void convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host(const VkDataGraphPipelineSessionCreateInfoARM32 *in, VkDataGraphPipelineSessionCreateInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->dataGraphPipeline = in->dataGraphPipeline; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, VkDataGraphPipelineConstantARM *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->id = in->id; + out->pConstantData = UlongToPtr(in->pConstantData); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: + { + VkTensorDescriptionARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTensorDescriptionARM32 *in_ext = (const VkTensorDescriptionARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; + out_ext->pNext = NULL; + out_ext->tiling = in_ext->tiling; + out_ext->format = in_ext->format; + out_ext->dimensionCount = in_ext->dimensionCount; + out_ext->pDimensions = UlongToPtr(in_ext->pDimensions); + out_ext->pStrides = UlongToPtr(in_ext->pStrides); + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: + { + VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; + out_ext->pNext = NULL; + out_ext->dimension = in_ext->dimension; + out_ext->zeroCount = in_ext->zeroCount; + out_ext->groupSize = in_ext->groupSize; + 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 VkDataGraphPipelineConstantARM *convert_VkDataGraphPipelineConstantARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, uint32_t count) +{ + VkDataGraphPipelineConstantARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelineConstantARM_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, VkDataGraphPipelineResourceInfoARM *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->descriptorSet = in->descriptorSet; + out->binding = in->binding; + out->arrayElement = in->arrayElement; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: + { + VkTensorDescriptionARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTensorDescriptionARM32 *in_ext = (const VkTensorDescriptionARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; + out_ext->pNext = NULL; + out_ext->tiling = in_ext->tiling; + out_ext->format = in_ext->format; + out_ext->dimensionCount = in_ext->dimensionCount; + out_ext->pDimensions = UlongToPtr(in_ext->pDimensions); + out_ext->pStrides = UlongToPtr(in_ext->pStrides); + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + +static inline const VkDataGraphPipelineResourceInfoARM *convert_VkDataGraphPipelineResourceInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, uint32_t count) +{ + VkDataGraphPipelineResourceInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, VkDataGraphPipelineCreateInfoARM *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->layout = in->layout; + out->resourceInfoCount = in->resourceInfoCount; + out->pResourceInfos = convert_VkDataGraphPipelineResourceInfoARM_array_win32_to_host(ctx, (const VkDataGraphPipelineResourceInfoARM32 *)UlongToPtr(in->pResourceInfos), in->resourceInfoCount); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + { + VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1); + out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount; + out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: + { + VkDataGraphPipelineCompilerControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphPipelineCompilerControlCreateInfoARM32 *in_ext = (const VkDataGraphPipelineCompilerControlCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->pVendorOptions = UlongToPtr(in_ext->pVendorOptions); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: + { + VkDataGraphPipelineShaderModuleCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphPipelineShaderModuleCreateInfoARM32 *in_ext = (const VkDataGraphPipelineShaderModuleCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->module = in_ext->module; + out_ext->pName = UlongToPtr(in_ext->pName); + out_ext->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in_ext->pSpecializationInfo), 1); + out_ext->constantCount = in_ext->constantCount; + out_ext->pConstants = convert_VkDataGraphPipelineConstantARM_array_win32_to_host(ctx, (const VkDataGraphPipelineConstantARM32 *)UlongToPtr(in_ext->pConstants), in_ext->constantCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: + { + VkDataGraphPipelineIdentifierCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphPipelineIdentifierCreateInfoARM32 *in_ext = (const VkDataGraphPipelineIdentifierCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->identifierSize = in_ext->identifierSize; + out_ext->pIdentifier = UlongToPtr(in_ext->pIdentifier); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + { + VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphProcessingEngineCreateInfoARM32 *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->processingEngineCount = in_ext->processingEngineCount; + out_ext->pProcessingEngines = UlongToPtr(in_ext->pProcessingEngines); + 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_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out) +{ + const VkBaseInStructure *in_header; + VkBaseOutStructure32 *out_header = (void *)out; + + if (!in) return; + + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + { + VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO); + const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1); + convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + { + VkDataGraphProcessingEngineCreateInfoARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM); + const VkDataGraphProcessingEngineCreateInfoARM *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + out_ext->pProcessingEngines = PtrToUlong(in_ext->pProcessingEngines); + out_header = (void *)out_ext; + break; + } + default: + break; + } + } +} + +static inline const VkDataGraphPipelineCreateInfoARM *convert_VkDataGraphPipelineCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, uint32_t count) +{ + VkDataGraphPipelineCreateInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(&in[i], &out[i]); + } +} + static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out) { if (!in) return; @@ -15381,6 +16028,18 @@ static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conve out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + { + VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphProcessingEngineCreateInfoARM32 *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->processingEngineCount = in_ext->processingEngineCount; + out_ext->pProcessingEngines = UlongToPtr(in_ext->pProcessingEngines); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -17413,6 +18072,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_ENCODE_INTRA_REFRESH_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -17812,11 +18482,11 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header->pNext = (void *)out_ext; @@ -18220,11 +18890,11 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; out_ext->pNext = NULL; out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header->pNext = (void *)out_ext; @@ -18376,6 +19046,43 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + { + VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + { + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + out_ext->pNext = NULL; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + { + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -20174,6 +20881,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_ENCODE_INTRA_REFRESH_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20573,11 +21291,11 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header->pNext = (void *)out_ext; @@ -20981,11 +21699,11 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; out_ext->pNext = NULL; out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header->pNext = (void *)out_ext; @@ -21137,6 +21855,43 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + { + VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + { + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + out_ext->pNext = NULL; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + { + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25218,11 +25973,11 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(stru out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: { - VkSwapchainPresentModesCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSwapchainPresentModesCreateInfoEXT32 *in_ext = (const VkSwapchainPresentModesCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT; + VkSwapchainPresentModesCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainPresentModesCreateInfoKHR32 *in_ext = (const VkSwapchainPresentModesCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR; out_ext->pNext = NULL; out_ext->presentModeCount = in_ext->presentModeCount; out_ext->pPresentModes = UlongToPtr(in_ext->pPresentModes); @@ -25230,11 +25985,11 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(stru out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: { - VkSwapchainPresentScalingCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSwapchainPresentScalingCreateInfoEXT32 *in_ext = (const VkSwapchainPresentScalingCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT; + VkSwapchainPresentScalingCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainPresentScalingCreateInfoKHR32 *in_ext = (const VkSwapchainPresentScalingCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR; out_ext->pNext = NULL; out_ext->scalingBehavior = in_ext->scalingBehavior; out_ext->presentGravityX = in_ext->presentGravityX; @@ -25436,6 +26191,17 @@ static inline void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: + { + VkVideoEncodeSessionIntraRefreshCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeSessionIntraRefreshCreateInfoKHR32 *in_ext = (const VkVideoEncodeSessionIntraRefreshCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->intraRefreshMode = in_ext->intraRefreshMode; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -26259,6 +27025,143 @@ static inline const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampI return out; }
+static inline void convert_VkDataGraphPipelineInfoARM_win32_to_host(const VkDataGraphPipelineInfoARM32 *in, VkDataGraphPipelineInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->dataGraphPipeline = in->dataGraphPipeline; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_host(const VkDataGraphPipelinePropertyQueryResultARM32 *in, VkDataGraphPipelinePropertyQueryResultARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->property = in->property; + out->isText = in->isText; + out->dataSize = in->dataSize; + out->pData = UlongToPtr(in->pData); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out) +{ + if (!in) return; + + out->property = in->property; + out->isText = in->isText; + out->dataSize = in->dataSize; + out->pData = PtrToUlong(in->pData); +} + +static inline VkDataGraphPipelinePropertyQueryResultARM *convert_VkDataGraphPipelinePropertyQueryResultARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelinePropertyQueryResultARM32 *in, uint32_t count) +{ + VkDataGraphPipelinePropertyQueryResultARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelinePropertyQueryResultARM_host_to_win32(&in[i], &out[i]); + } +} + +static inline void convert_VkDataGraphPipelineSessionBindPointRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 *in, VkDataGraphPipelineSessionBindPointRequirementsInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->session = in->session; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, VkDataGraphPipelineSessionBindPointRequirementARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->bindPoint = in->bindPoint; + out->bindPointType = in->bindPointType; + out->numObjects = in->numObjects; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out) +{ + if (!in) return; + + out->bindPoint = in->bindPoint; + out->bindPointType = in->bindPointType; + out->numObjects = in->numObjects; +} + +static inline VkDataGraphPipelineSessionBindPointRequirementARM *convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, uint32_t count) +{ + VkDataGraphPipelineSessionBindPointRequirementARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelineSessionBindPointRequirementARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelineSessionBindPointRequirementARM_host_to_win32(&in[i], &out[i]); + } +} + +static inline void convert_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 *in, VkDataGraphPipelineSessionMemoryRequirementsInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->session = in->session; + out->bindPoint = in->bindPoint; + out->objectIndex = in->objectIndex; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out) { if (!in) return; @@ -29517,6 +30420,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -29905,11 +30819,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header->pNext = (void *)out_ext; @@ -30302,11 +31216,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; out_ext->pNext = NULL; out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header->pNext = (void *)out_ext; @@ -30458,6 +31372,43 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + { + VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + { + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + out_ext->pNext = NULL; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + { + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -31911,6 +32862,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + { + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT); @@ -32231,11 +33191,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header = (void *)out_ext; break; @@ -32558,11 +33518,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header = (void *)out_ext; break; @@ -32692,6 +33652,37 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + { + VkPhysicalDeviceDataGraphFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM); + const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + { + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + { + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + out_header = (void *)out_ext; + break; + } default: break; } @@ -35703,6 +36694,86 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy } }
+static inline void convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM_win32_to_host(const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 *in, VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->queueFamilyIndex = in->queueFamilyIndex; + out->engineType = in->engineType; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_win32_to_host(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->foreignSemaphoreHandleTypes = in->foreignSemaphoreHandleTypes; + out->foreignMemoryHandleTypes = in->foreignMemoryHandleTypes; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_host_to_win32(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *out) +{ + if (!in) return; + + out->foreignSemaphoreHandleTypes = in->foreignSemaphoreHandleTypes; + out->foreignMemoryHandleTypes = in->foreignMemoryHandleTypes; +} + +static inline void convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(const VkQueueFamilyDataGraphPropertiesARM32 *in, VkQueueFamilyDataGraphPropertiesARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->engine = in->engine; + out->operation = in->operation; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkQueueFamilyDataGraphPropertiesARM_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out) +{ + if (!in) return; + + out->engine = in->engine; + out->operation = in->operation; +} + +static inline VkQueueFamilyDataGraphPropertiesARM *convert_VkQueueFamilyDataGraphPropertiesARM_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyDataGraphPropertiesARM32 *in, uint32_t count) +{ + VkQueueFamilyDataGraphPropertiesARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static inline void convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkQueueFamilyDataGraphPropertiesARM_host_to_win32(&in[i], &out[i]); + } +} + static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out) { if (!in) return; @@ -36016,11 +37087,11 @@ static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_ho { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: { - VkSurfacePresentModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSurfacePresentModeEXT32 *in_ext = (const VkSurfacePresentModeEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT; + VkSurfacePresentModeKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSurfacePresentModeKHR32 *in_ext = (const VkSurfacePresentModeKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR; out_ext->pNext = NULL; out_ext->presentMode = in_ext->presentMode; out_header->pNext = (void *)out_ext; @@ -36079,20 +37150,26 @@ static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: { - VkSurfacePresentScalingCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; + VkSurfacePresentScalingCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSurfacePresentScalingCapabilitiesKHR32 *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; out_ext->pNext = NULL; + out_ext->supportedPresentScaling = in_ext->supportedPresentScaling; + out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX; + out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY; + out_ext->minScaledImageExtent = in_ext->minScaledImageExtent; + out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: { - VkSurfacePresentModeCompatibilityEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSurfacePresentModeCompatibilityEXT32 *in_ext = (const VkSurfacePresentModeCompatibilityEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; + VkSurfacePresentModeCompatibilityKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSurfacePresentModeCompatibilityKHR32 *in_ext = (const VkSurfacePresentModeCompatibilityKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; out_ext->pNext = NULL; out_ext->presentModeCount = in_ext->presentModeCount; out_ext->pPresentModes = UlongToPtr(in_ext->pPresentModes); @@ -36159,11 +37236,11 @@ static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfa out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: { - VkSurfacePresentScalingCapabilitiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT); - const VkSurfacePresentScalingCapabilitiesEXT *in_ext = (const VkSurfacePresentScalingCapabilitiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; + VkSurfacePresentScalingCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR); + const VkSurfacePresentScalingCapabilitiesKHR *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; out_ext->supportedPresentScaling = in_ext->supportedPresentScaling; out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX; out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY; @@ -36172,11 +37249,11 @@ static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfa out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: { - VkSurfacePresentModeCompatibilityEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT); - const VkSurfacePresentModeCompatibilityEXT *in_ext = (const VkSurfacePresentModeCompatibilityEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; + VkSurfacePresentModeCompatibilityKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR); + const VkSurfacePresentModeCompatibilityKHR *in_ext = (const VkSurfacePresentModeCompatibilityKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; out_ext->presentModeCount = in_ext->presentModeCount; out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes); out_header = (void *)out_ext; @@ -36447,6 +37524,15 @@ static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversio out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: + { + VkVideoEncodeIntraRefreshCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -36619,6 +37705,19 @@ static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCap out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: + { + VkVideoEncodeIntraRefreshCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR); + const VkVideoEncodeIntraRefreshCapabilitiesKHR *in_ext = (const VkVideoEncodeIntraRefreshCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; + out_ext->intraRefreshModes = in_ext->intraRefreshModes; + out_ext->maxIntraRefreshCycleDuration = in_ext->maxIntraRefreshCycleDuration; + out_ext->maxIntraRefreshActiveReferencePictures = in_ext->maxIntraRefreshActiveReferencePictures; + out_ext->partitionIndependentIntraRefreshRegions = in_ext->partitionIndependentIntraRefreshRegions; + out_ext->nonRectangularIntraRefreshRegions = in_ext->nonRectangularIntraRefreshRegions; + out_header = (void *)out_ext; + break; + } default: break; } @@ -37990,11 +39089,11 @@ static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conve out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: { - VkSwapchainPresentFenceInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSwapchainPresentFenceInfoEXT32 *in_ext = (const VkSwapchainPresentFenceInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT; + VkSwapchainPresentFenceInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainPresentFenceInfoKHR32 *in_ext = (const VkSwapchainPresentFenceInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR; out_ext->pNext = NULL; out_ext->swapchainCount = in_ext->swapchainCount; out_ext->pFences = UlongToPtr(in_ext->pFences); @@ -38002,11 +39101,11 @@ static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conve out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: { - VkSwapchainPresentModeInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSwapchainPresentModeInfoEXT32 *in_ext = (const VkSwapchainPresentModeInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT; + VkSwapchainPresentModeInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainPresentModeInfoKHR32 *in_ext = (const VkSwapchainPresentModeInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR; out_ext->pNext = NULL; out_ext->swapchainCount = in_ext->swapchainCount; out_ext->pPresentModes = UlongToPtr(in_ext->pPresentModes); @@ -38461,7 +39560,7 @@ static inline void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(co }
#ifdef _WIN64 -static inline void convert_VkReleaseSwapchainImagesInfoEXT_win64_to_host(const VkReleaseSwapchainImagesInfoEXT *in, VkReleaseSwapchainImagesInfoEXT *out) +static inline void convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(const VkReleaseSwapchainImagesInfoKHR *in, VkReleaseSwapchainImagesInfoKHR *out) { if (!in) return;
@@ -38473,7 +39572,7 @@ static inline void convert_VkReleaseSwapchainImagesInfoEXT_win64_to_host(const V } #endif /* _WIN64 */
-static inline void convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host(const VkReleaseSwapchainImagesInfoEXT32 *in, VkReleaseSwapchainImagesInfoEXT *out) +static inline void convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host(const VkReleaseSwapchainImagesInfoKHR32 *in, VkReleaseSwapchainImagesInfoKHR *out) { if (!in) return;
@@ -39461,6 +40560,46 @@ static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args) return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkBindDataGraphPipelineSessionMemoryARM(void *args) +{ + struct vkBindDataGraphPipelineSessionMemoryARM_params *params = args; + const VkBindDataGraphPipelineSessionMemoryInfoARM *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_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win64_to_host(ctx, params->pBindInfos, params->bindInfoCount); + params->result = vulkan_device_from_handle(params->device)->p_vkBindDataGraphPipelineSessionMemoryARM(vulkan_device_from_handle(params->device)->host.device, params->bindInfoCount, pBindInfos_host); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkBindDataGraphPipelineSessionMemoryARM(void *args) +{ + struct + { + PTR32 device; + uint32_t bindInfoCount; + PTR32 pBindInfos; + VkResult result; + } *params = args; + const VkBindDataGraphPipelineSessionMemoryInfoARM *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_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win32_to_host(ctx, (const VkBindDataGraphPipelineSessionMemoryInfoARM32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkBindDataGraphPipelineSessionMemoryARM(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_vkBindImageMemory(void *args) { @@ -41708,6 +42847,37 @@ static void thunk32_vkCmdDispatchBaseKHR(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ); }
+#ifdef _WIN64 +static void thunk64_vkCmdDispatchDataGraphARM(void *args) +{ + struct vkCmdDispatchDataGraphARM_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->p_vkCmdDispatchDataGraphARM(wine_cmd_buffer_from_handle(params->commandBuffer)->host.command_buffer, params->session, params->pInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdDispatchDataGraphARM(void *args) +{ + struct + { + PTR32 commandBuffer; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + PTR32 pInfo; + } *params = args; + VkDataGraphPipelineDispatchInfoARM *pInfo_host = NULL; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + if (params->pInfo) + { + pInfo_host = conversion_context_alloc(ctx, sizeof(*pInfo_host)); + convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host((const VkDataGraphPipelineDispatchInfoARM32 *)UlongToPtr(params->pInfo), pInfo_host); + } + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->p_vkCmdDispatchDataGraphARM(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host.command_buffer, params->session, pInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdDispatchIndirect(void *args) { @@ -46692,11 +47862,15 @@ static NTSTATUS thunk32_vkCreateCommandPool(void *args) VkResult result; } *params = args; VkCommandPoolCreateInfo 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->pCommandPool);
- convert_VkCommandPoolCreateInfo_win32_to_host((const VkCommandPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + init_conversion_context(ctx); + convert_VkCommandPoolCreateInfo_win32_to_host(ctx, (const VkCommandPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); params->result = wine_vkCreateCommandPool((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkCommandPool *)UlongToPtr(params->pCommandPool), UlongToPtr(params->client_ptr)); + free_conversion_context(ctx); return STATUS_SUCCESS; }
@@ -46810,6 +47984,80 @@ static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args) return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateDataGraphPipelineSessionARM(void *args) +{ + struct vkCreateDataGraphPipelineSessionARM_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession); + + params->result = vulkan_device_from_handle(params->device)->p_vkCreateDataGraphPipelineSessionARM(vulkan_device_from_handle(params->device)->host.device, params->pCreateInfo, NULL, params->pSession); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateDataGraphPipelineSessionARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pSession; + VkResult result; + } *params = args; + VkDataGraphPipelineSessionCreateInfoARM pCreateInfo_host; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession); + + convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host((const VkDataGraphPipelineSessionCreateInfoARM32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkCreateDataGraphPipelineSessionARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pCreateInfo_host, NULL, (VkDataGraphPipelineSessionARM *)UlongToPtr(params->pSession)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateDataGraphPipelinesARM(void *args) +{ + struct vkCreateDataGraphPipelinesARM_params *params = args; + + TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines); + + params->result = vulkan_device_from_handle(params->device)->p_vkCreateDataGraphPipelinesARM(vulkan_device_from_handle(params->device)->host.device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->host.deferred_operation : 0, params->pipelineCache, params->createInfoCount, params->pCreateInfos, NULL, params->pPipelines); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateDataGraphPipelinesARM(void *args) +{ + struct + { + PTR32 device; + VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation; + VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache; + uint32_t createInfoCount; + PTR32 pCreateInfos; + PTR32 pAllocator; + PTR32 pPipelines; + VkResult result; + } *params = args; + const VkDataGraphPipelineCreateInfoARM *pCreateInfos_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, 0x%s, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines); + + if (params->deferredOperation == VK_NULL_HANDLE) + init_conversion_context(ctx); + else + ctx = &wine_deferred_operation_from_handle(params->deferredOperation)->ctx; + pCreateInfos_host = convert_VkDataGraphPipelineCreateInfoARM_array_win32_to_host(ctx, (const VkDataGraphPipelineCreateInfoARM32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkCreateDataGraphPipelinesARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->deferredOperation ? wine_deferred_operation_from_handle(params->deferredOperation)->host.deferred_operation : 0, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines)); + convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32(pCreateInfos_host, (VkDataGraphPipelineCreateInfoARM32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount); + if (params->deferredOperation == VK_NULL_HANDLE) + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args) { @@ -48678,6 +49926,33 @@ static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args) return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyDataGraphPipelineSessionARM(void *args) +{ + struct vkDestroyDataGraphPipelineSessionARM_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator); + + vulkan_device_from_handle(params->device)->p_vkDestroyDataGraphPipelineSessionARM(vulkan_device_from_handle(params->device)->host.device, params->session, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyDataGraphPipelineSessionARM(void *args) +{ + struct + { + PTR32 device; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator); + + vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkDestroyDataGraphPipelineSessionARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, params->session, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args) { @@ -50748,6 +52023,149 @@ static NTSTATUS thunk32_vkGetClusterAccelerationStructureBuildSizesNV(void *args return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDataGraphPipelineAvailablePropertiesARM(void *args) +{ + struct vkGetDataGraphPipelineAvailablePropertiesARM_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pPropertiesCount, params->pProperties); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetDataGraphPipelineAvailablePropertiesARM(vulkan_device_from_handle(params->device)->host.device, params->pPipelineInfo, params->pPropertiesCount, params->pProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDataGraphPipelineAvailablePropertiesARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pPipelineInfo; + PTR32 pPropertiesCount; + PTR32 pProperties; + VkResult result; + } *params = args; + VkDataGraphPipelineInfoARM pPipelineInfo_host; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pPropertiesCount, params->pProperties); + + convert_VkDataGraphPipelineInfoARM_win32_to_host((const VkDataGraphPipelineInfoARM32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetDataGraphPipelineAvailablePropertiesARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pPipelineInfo_host, (uint32_t *)UlongToPtr(params->pPropertiesCount), (VkDataGraphPipelinePropertyARM *)UlongToPtr(params->pProperties)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDataGraphPipelinePropertiesARM(void *args) +{ + struct vkGetDataGraphPipelinePropertiesARM_params *params = args; + + TRACE("%p, %p, %u, %p\n", params->device, params->pPipelineInfo, params->propertiesCount, params->pProperties); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetDataGraphPipelinePropertiesARM(vulkan_device_from_handle(params->device)->host.device, params->pPipelineInfo, params->propertiesCount, params->pProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDataGraphPipelinePropertiesARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pPipelineInfo; + uint32_t propertiesCount; + PTR32 pProperties; + VkResult result; + } *params = args; + VkDataGraphPipelineInfoARM pPipelineInfo_host; + VkDataGraphPipelinePropertyQueryResultARM *pProperties_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %u, %#x\n", params->device, params->pPipelineInfo, params->propertiesCount, params->pProperties); + + init_conversion_context(ctx); + convert_VkDataGraphPipelineInfoARM_win32_to_host((const VkDataGraphPipelineInfoARM32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host); + pProperties_host = convert_VkDataGraphPipelinePropertyQueryResultARM_array_win32_to_host(ctx, (VkDataGraphPipelinePropertyQueryResultARM32 *)UlongToPtr(params->pProperties), params->propertiesCount); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetDataGraphPipelinePropertiesARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pPipelineInfo_host, params->propertiesCount, pProperties_host); + convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_to_win32(pProperties_host, (VkDataGraphPipelinePropertyQueryResultARM32 *)UlongToPtr(params->pProperties), params->propertiesCount); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDataGraphPipelineSessionBindPointRequirementsARM(void *args) +{ + struct vkGetDataGraphPipelineSessionBindPointRequirementsARM_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pBindPointRequirementCount, params->pBindPointRequirements); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetDataGraphPipelineSessionBindPointRequirementsARM(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pBindPointRequirementCount, params->pBindPointRequirements); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDataGraphPipelineSessionBindPointRequirementsARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pBindPointRequirementCount; + PTR32 pBindPointRequirements; + VkResult result; + } *params = args; + VkDataGraphPipelineSessionBindPointRequirementsInfoARM pInfo_host; + VkDataGraphPipelineSessionBindPointRequirementARM *pBindPointRequirements_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pBindPointRequirementCount, params->pBindPointRequirements); + + init_conversion_context(ctx); + convert_VkDataGraphPipelineSessionBindPointRequirementsInfoARM_win32_to_host((const VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 *)UlongToPtr(params->pInfo), &pInfo_host); + pBindPointRequirements_host = convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_win32_to_host(ctx, (VkDataGraphPipelineSessionBindPointRequirementARM32 *)UlongToPtr(params->pBindPointRequirements), *(uint32_t *)UlongToPtr(params->pBindPointRequirementCount)); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetDataGraphPipelineSessionBindPointRequirementsARM(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, (uint32_t *)UlongToPtr(params->pBindPointRequirementCount), pBindPointRequirements_host); + convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_host_to_win32(pBindPointRequirements_host, (VkDataGraphPipelineSessionBindPointRequirementARM32 *)UlongToPtr(params->pBindPointRequirements), *(uint32_t *)UlongToPtr(params->pBindPointRequirementCount)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetDataGraphPipelineSessionMemoryRequirementsARM(void *args) +{ + struct vkGetDataGraphPipelineSessionMemoryRequirementsARM_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements); + + vulkan_device_from_handle(params->device)->p_vkGetDataGraphPipelineSessionMemoryRequirementsARM(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pMemoryRequirements); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetDataGraphPipelineSessionMemoryRequirementsARM(void *args) +{ + struct + { + PTR32 device; + PTR32 pInfo; + PTR32 pMemoryRequirements; + } *params = args; + VkDataGraphPipelineSessionMemoryRequirementsInfoARM 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_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_win32_to_host((const VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 *)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_vkGetDataGraphPipelineSessionMemoryRequirementsARM(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_vkGetDeferredOperationMaxConcurrencyKHR(void *args) { @@ -53748,6 +55166,74 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args) return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(void *args) +{ + struct vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM_params *params = args; + + TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyDataGraphProcessingEngineInfo, params->pQueueFamilyDataGraphProcessingEngineProperties); + + vulkan_physical_device_from_handle(params->physicalDevice)->instance->p_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(vulkan_physical_device_from_handle(params->physicalDevice)->host.physical_device, params->pQueueFamilyDataGraphProcessingEngineInfo, params->pQueueFamilyDataGraphProcessingEngineProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(void *args) +{ + struct + { + PTR32 physicalDevice; + PTR32 pQueueFamilyDataGraphProcessingEngineInfo; + PTR32 pQueueFamilyDataGraphProcessingEngineProperties; + } *params = args; + VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM pQueueFamilyDataGraphProcessingEngineInfo_host; + VkQueueFamilyDataGraphProcessingEnginePropertiesARM pQueueFamilyDataGraphProcessingEngineProperties_host; + + TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyDataGraphProcessingEngineInfo, params->pQueueFamilyDataGraphProcessingEngineProperties); + + convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM_win32_to_host((const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 *)UlongToPtr(params->pQueueFamilyDataGraphProcessingEngineInfo), &pQueueFamilyDataGraphProcessingEngineInfo_host); + convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_win32_to_host((VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *)UlongToPtr(params->pQueueFamilyDataGraphProcessingEngineProperties), &pQueueFamilyDataGraphProcessingEngineProperties_host); + vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->p_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->host.physical_device, &pQueueFamilyDataGraphProcessingEngineInfo_host, &pQueueFamilyDataGraphProcessingEngineProperties_host); + convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_host_to_win32(&pQueueFamilyDataGraphProcessingEngineProperties_host, (VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *)UlongToPtr(params->pQueueFamilyDataGraphProcessingEngineProperties)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(void *args) +{ + struct vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM_params *params = args; + + TRACE("%p, %u, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pQueueFamilyDataGraphPropertyCount, params->pQueueFamilyDataGraphProperties); + + params->result = vulkan_physical_device_from_handle(params->physicalDevice)->instance->p_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(vulkan_physical_device_from_handle(params->physicalDevice)->host.physical_device, params->queueFamilyIndex, params->pQueueFamilyDataGraphPropertyCount, params->pQueueFamilyDataGraphProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(void *args) +{ + struct + { + PTR32 physicalDevice; + uint32_t queueFamilyIndex; + PTR32 pQueueFamilyDataGraphPropertyCount; + PTR32 pQueueFamilyDataGraphProperties; + VkResult result; + } *params = args; + VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %u, %#x, %#x\n", params->physicalDevice, params->queueFamilyIndex, params->pQueueFamilyDataGraphPropertyCount, params->pQueueFamilyDataGraphProperties); + + init_conversion_context(ctx); + pQueueFamilyDataGraphProperties_host = convert_VkQueueFamilyDataGraphPropertiesARM_array_win32_to_host(ctx, (VkQueueFamilyDataGraphPropertiesARM32 *)UlongToPtr(params->pQueueFamilyDataGraphProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyDataGraphPropertyCount)); + params->result = vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->p_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(vulkan_physical_device_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->host.physical_device, params->queueFamilyIndex, (uint32_t *)UlongToPtr(params->pQueueFamilyDataGraphPropertyCount), pQueueFamilyDataGraphProperties_host); + convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win32(pQueueFamilyDataGraphProperties_host, (VkQueueFamilyDataGraphPropertiesARM32 *)UlongToPtr(params->pQueueFamilyDataGraphProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyDataGraphPropertyCount)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(void *args) { @@ -56228,11 +57714,11 @@ static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args) static NTSTATUS thunk64_vkReleaseSwapchainImagesEXT(void *args) { struct vkReleaseSwapchainImagesEXT_params *params = args; - VkReleaseSwapchainImagesInfoEXT pReleaseInfo_host; + VkReleaseSwapchainImagesInfoKHR pReleaseInfo_host;
TRACE("%p, %p\n", params->device, params->pReleaseInfo);
- convert_VkReleaseSwapchainImagesInfoEXT_win64_to_host(params->pReleaseInfo, &pReleaseInfo_host); + convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(params->pReleaseInfo, &pReleaseInfo_host); params->result = vulkan_device_from_handle(params->device)->p_vkReleaseSwapchainImagesEXT(vulkan_device_from_handle(params->device)->host.device, &pReleaseInfo_host); return STATUS_SUCCESS; } @@ -56246,15 +57732,46 @@ static NTSTATUS thunk32_vkReleaseSwapchainImagesEXT(void *args) PTR32 pReleaseInfo; VkResult result; } *params = args; - VkReleaseSwapchainImagesInfoEXT pReleaseInfo_host; + VkReleaseSwapchainImagesInfoKHR pReleaseInfo_host;
TRACE("%#x, %#x\n", params->device, params->pReleaseInfo);
- convert_VkReleaseSwapchainImagesInfoEXT_win32_to_host((const VkReleaseSwapchainImagesInfoEXT32 *)UlongToPtr(params->pReleaseInfo), &pReleaseInfo_host); + convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host((const VkReleaseSwapchainImagesInfoKHR32 *)UlongToPtr(params->pReleaseInfo), &pReleaseInfo_host); params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkReleaseSwapchainImagesEXT(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pReleaseInfo_host); return STATUS_SUCCESS; }
+#ifdef _WIN64 +static NTSTATUS thunk64_vkReleaseSwapchainImagesKHR(void *args) +{ + struct vkReleaseSwapchainImagesKHR_params *params = args; + VkReleaseSwapchainImagesInfoKHR pReleaseInfo_host; + + TRACE("%p, %p\n", params->device, params->pReleaseInfo); + + convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(params->pReleaseInfo, &pReleaseInfo_host); + params->result = vulkan_device_from_handle(params->device)->p_vkReleaseSwapchainImagesKHR(vulkan_device_from_handle(params->device)->host.device, &pReleaseInfo_host); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkReleaseSwapchainImagesKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pReleaseInfo; + VkResult result; + } *params = args; + VkReleaseSwapchainImagesInfoKHR pReleaseInfo_host; + + TRACE("%#x, %#x\n", params->device, params->pReleaseInfo); + + convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host((const VkReleaseSwapchainImagesInfoKHR32 *)UlongToPtr(params->pReleaseInfo), &pReleaseInfo_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkReleaseSwapchainImagesKHR(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pReleaseInfo_host); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkResetCommandBuffer(void *args) { @@ -57477,6 +58994,7 @@ static const char * const vk_device_extensions[] = "VK_AMD_shader_info", "VK_AMD_shader_trinary_minmax", "VK_AMD_texture_gather_bias_lod", + "VK_ARM_data_graph", "VK_ARM_format_pack", "VK_ARM_pipeline_opacity_micromap", "VK_ARM_rasterization_order_attachment_access", @@ -57660,6 +59178,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_pipeline_library", "VK_KHR_present_id", "VK_KHR_present_id2", + "VK_KHR_present_mode_fifo_latest_ready", "VK_KHR_present_wait", "VK_KHR_present_wait2", "VK_KHR_push_descriptor", @@ -57689,9 +59208,11 @@ static const char * const vk_device_extensions[] = "VK_KHR_shader_subgroup_rotate", "VK_KHR_shader_subgroup_uniform_control_flow", "VK_KHR_shader_terminate_invocation", + "VK_KHR_shader_untyped_pointers", "VK_KHR_spirv_1_4", "VK_KHR_storage_buffer_storage_class", "VK_KHR_swapchain", + "VK_KHR_swapchain_maintenance1", "VK_KHR_swapchain_mutable_format", "VK_KHR_synchronization2", "VK_KHR_timeline_semaphore", @@ -57705,6 +59226,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_video_decode_vp9", "VK_KHR_video_encode_av1", "VK_KHR_video_encode_h264", + "VK_KHR_video_encode_intra_refresh", "VK_KHR_video_encode_quantization_map", "VK_KHR_video_encode_queue", "VK_KHR_video_maintenance1", @@ -57782,6 +59304,7 @@ static const char * const vk_device_extensions[] = "VK_QCOM_tile_properties", "VK_QCOM_tile_shading", "VK_QCOM_ycbcr_degamma", + "VK_SEC_pipeline_cache_incremental_mode", "VK_VALVE_descriptor_set_host_mapping", "VK_VALVE_fragment_density_map_layered", "VK_VALVE_mutable_descriptor_type", @@ -57804,6 +59327,7 @@ static const char * const vk_instance_extensions[] = "VK_KHR_get_surface_capabilities2", "VK_KHR_portability_enumeration", "VK_KHR_surface", + "VK_KHR_surface_maintenance1", "VK_KHR_win32_surface", };
@@ -57895,6 +59419,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkBindBufferMemory, thunk64_vkBindBufferMemory2, thunk64_vkBindBufferMemory2KHR, + thunk64_vkBindDataGraphPipelineSessionMemoryARM, thunk64_vkBindImageMemory, thunk64_vkBindImageMemory2, thunk64_vkBindImageMemory2KHR, @@ -57981,6 +59506,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdDispatch, (void *)thunk64_vkCmdDispatchBase, (void *)thunk64_vkCmdDispatchBaseKHR, + (void *)thunk64_vkCmdDispatchDataGraphARM, (void *)thunk64_vkCmdDispatchIndirect, (void *)thunk64_vkCmdDispatchTileQCOM, (void *)thunk64_vkCmdDraw, @@ -58195,6 +59721,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCreateComputePipelines, thunk64_vkCreateCuFunctionNVX, thunk64_vkCreateCuModuleNVX, + thunk64_vkCreateDataGraphPipelineSessionARM, + thunk64_vkCreateDataGraphPipelinesARM, thunk64_vkCreateDebugReportCallbackEXT, thunk64_vkCreateDebugUtilsMessengerEXT, thunk64_vkCreateDeferredOperationKHR, @@ -58250,6 +59778,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkDestroyCommandPool, thunk64_vkDestroyCuFunctionNVX, thunk64_vkDestroyCuModuleNVX, + thunk64_vkDestroyDataGraphPipelineSessionARM, thunk64_vkDestroyDebugReportCallbackEXT, thunk64_vkDestroyDebugUtilsMessengerEXT, thunk64_vkDestroyDeferredOperationKHR, @@ -58321,6 +59850,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetCalibratedTimestampsEXT, thunk64_vkGetCalibratedTimestampsKHR, thunk64_vkGetClusterAccelerationStructureBuildSizesNV, + thunk64_vkGetDataGraphPipelineAvailablePropertiesARM, + thunk64_vkGetDataGraphPipelinePropertiesARM, + thunk64_vkGetDataGraphPipelineSessionBindPointRequirementsARM, + thunk64_vkGetDataGraphPipelineSessionMemoryRequirementsARM, thunk64_vkGetDeferredOperationMaxConcurrencyKHR, thunk64_vkGetDeferredOperationResultKHR, (void *)thunk64_vkGetDescriptorEXT, @@ -58411,6 +59944,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetPhysicalDeviceProperties, thunk64_vkGetPhysicalDeviceProperties2, thunk64_vkGetPhysicalDeviceProperties2KHR, + thunk64_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, + thunk64_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, thunk64_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, thunk64_vkGetPhysicalDeviceQueueFamilyProperties, thunk64_vkGetPhysicalDeviceQueueFamilyProperties2, @@ -58488,6 +60023,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkReleasePerformanceConfigurationINTEL, thunk64_vkReleaseProfilingLockKHR, thunk64_vkReleaseSwapchainImagesEXT, + thunk64_vkReleaseSwapchainImagesKHR, thunk64_vkResetCommandBuffer, thunk64_vkResetCommandPool, thunk64_vkResetDescriptorPool, @@ -58555,6 +60091,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkBindBufferMemory, thunk32_vkBindBufferMemory2, thunk32_vkBindBufferMemory2KHR, + thunk32_vkBindDataGraphPipelineSessionMemoryARM, thunk32_vkBindImageMemory, thunk32_vkBindImageMemory2, thunk32_vkBindImageMemory2KHR, @@ -58641,6 +60178,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdDispatch, (void *)thunk32_vkCmdDispatchBase, (void *)thunk32_vkCmdDispatchBaseKHR, + (void *)thunk32_vkCmdDispatchDataGraphARM, (void *)thunk32_vkCmdDispatchIndirect, (void *)thunk32_vkCmdDispatchTileQCOM, (void *)thunk32_vkCmdDraw, @@ -58855,6 +60393,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCreateComputePipelines, thunk32_vkCreateCuFunctionNVX, thunk32_vkCreateCuModuleNVX, + thunk32_vkCreateDataGraphPipelineSessionARM, + thunk32_vkCreateDataGraphPipelinesARM, thunk32_vkCreateDebugReportCallbackEXT, thunk32_vkCreateDebugUtilsMessengerEXT, thunk32_vkCreateDeferredOperationKHR, @@ -58910,6 +60450,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkDestroyCommandPool, thunk32_vkDestroyCuFunctionNVX, thunk32_vkDestroyCuModuleNVX, + thunk32_vkDestroyDataGraphPipelineSessionARM, thunk32_vkDestroyDebugReportCallbackEXT, thunk32_vkDestroyDebugUtilsMessengerEXT, thunk32_vkDestroyDeferredOperationKHR, @@ -58981,6 +60522,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetCalibratedTimestampsEXT, thunk32_vkGetCalibratedTimestampsKHR, thunk32_vkGetClusterAccelerationStructureBuildSizesNV, + thunk32_vkGetDataGraphPipelineAvailablePropertiesARM, + thunk32_vkGetDataGraphPipelinePropertiesARM, + thunk32_vkGetDataGraphPipelineSessionBindPointRequirementsARM, + thunk32_vkGetDataGraphPipelineSessionMemoryRequirementsARM, thunk32_vkGetDeferredOperationMaxConcurrencyKHR, thunk32_vkGetDeferredOperationResultKHR, (void *)thunk32_vkGetDescriptorEXT, @@ -59071,6 +60616,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetPhysicalDeviceProperties, thunk32_vkGetPhysicalDeviceProperties2, thunk32_vkGetPhysicalDeviceProperties2KHR, + thunk32_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, + thunk32_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, thunk32_vkGetPhysicalDeviceQueueFamilyProperties, thunk32_vkGetPhysicalDeviceQueueFamilyProperties2, @@ -59148,6 +60695,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkReleasePerformanceConfigurationINTEL, thunk32_vkReleaseProfilingLockKHR, thunk32_vkReleaseSwapchainImagesEXT, + thunk32_vkReleaseSwapchainImagesKHR, thunk32_vkResetCommandBuffer, thunk32_vkResetCommandPool, thunk32_vkResetDescriptorPool, diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index ab60ff58310..8a7269fa919 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.318" + "api_version": "1.4.325" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 2521baea60f..15c902a333e 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -69,6 +69,9 @@ #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_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX 128 +#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX 128 +#define VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM 128 #define VK_KHR_SURFACE_SPEC_VERSION 25 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" #define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 @@ -454,7 +457,7 @@ #define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product" #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 #define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" -#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 4 +#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 5 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" #define VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION 1 #define VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME "VK_EXT_depth_bias_control" @@ -560,6 +563,8 @@ #define VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME "VK_EXT_primitives_generated_query" #define VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION 1 #define VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_ray_tracing_maintenance1" +#define VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME "VK_KHR_shader_untyped_pointers" #define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE #define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1 #define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query" @@ -655,6 +660,10 @@ #define VK_KHR_PIPELINE_BINARY_EXTENSION_NAME "VK_KHR_pipeline_binary" #define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1 #define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" +#define VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_surface_maintenance1" +#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_swapchain_maintenance1" #define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION 1 #define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME "VK_QCOM_multiview_per_view_viewports" #define VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 @@ -679,6 +688,8 @@ #define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2" #define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2 #define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix" +#define VK_ARM_DATA_GRAPH_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_EXTENSION_NAME "VK_ARM_data_graph" #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" #define VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 @@ -727,6 +738,8 @@ #define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation" #define VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION 1 #define VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME "VK_QCOM_tile_memory_heap" +#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME "VK_KHR_video_encode_intra_refresh" #define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION 2 #define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME "VK_KHR_video_encode_quantization_map" #define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1 @@ -743,7 +756,7 @@ #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 +#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 4 #define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_cluster_acceleration_structure" #define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION 1 #define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_partitioned_acceleration_structure" @@ -777,6 +790,10 @@ #define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_EXT_fragment_density_map_offset" #define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION 1 #define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME "VK_EXT_zero_initialize_device_memory" +#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 +#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_KHR_present_mode_fifo_latest_ready" +#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION 1 +#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME "VK_SEC_pipeline_cache_incremental_mode" #define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 @@ -880,7 +897,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 318 +#define VK_HEADER_VERSION 325 #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 @@ -924,6 +941,7 @@ VK_DEFINE_HANDLE(VkCommandBuffer) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) @@ -1020,6 +1038,8 @@ typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; typedef VkFlags VkCompositeAlphaFlagsKHR; typedef VkFlags VkConditionalRenderingFlagsEXT; typedef VkFlags VkCullModeFlags; +typedef VkFlags64 VkDataGraphPipelineDispatchFlagsARM; +typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; typedef VkFlags VkDebugReportFlagsEXT; typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; @@ -1142,8 +1162,10 @@ typedef VkFlags VkPipelineTessellationStateCreateFlags; typedef VkFlags VkPipelineVertexInputStateCreateFlags; typedef VkFlags VkPipelineViewportStateCreateFlags; typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; -typedef VkFlags VkPresentGravityFlagsEXT; -typedef VkFlags VkPresentScalingFlagsEXT; +typedef VkFlags VkPresentGravityFlagsKHR; +typedef VkPresentGravityFlagsKHR VkPresentGravityFlagsEXT; +typedef VkFlags VkPresentScalingFlagsKHR; +typedef VkPresentScalingFlagsKHR VkPresentScalingFlagsEXT; typedef VkFlags VkPrivateDataSlotCreateFlags; typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT; typedef VkFlags VkQueryControlFlags; @@ -1216,6 +1238,7 @@ typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR; typedef VkFlags VkVideoEncodeH265RateControlFlagsKHR; typedef VkFlags VkVideoEncodeH265StdFlagsKHR; typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR; +typedef VkFlags VkVideoEncodeIntraRefreshModeFlagsKHR; typedef VkFlags VkVideoEncodeRateControlFlagsKHR; typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; typedef VkFlags VkVideoEncodeUsageFlagsKHR; @@ -1843,6 +1866,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000 static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ull; +static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM = 0x800000000000ull; +static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM = 0x1000000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM = 0x8000000000000ull; static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM = 0x10000000000000ull; typedef VkAccessFlagBits2 VkAccessFlagBits2KHR; @@ -2094,6 +2119,7 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ull; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ull; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ull; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM = 0x20000000ull; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ull; typedef VkBufferUsageFlagBits2 VkBufferUsageFlagBits2KHR;
@@ -2109,6 +2135,7 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR 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_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000, 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, @@ -2155,6 +2182,7 @@ typedef VkChromaLocation VkChromaLocationKHR;
typedef enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV = 0, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV = 0x00000001, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV = 0x00000002, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV = 0x00000004, @@ -2201,6 +2229,7 @@ typedef enum VkClusterAccelerationStructureOpTypeNV VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV = 2, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV = 3, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV = 4, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV = 5, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_NV_MAX_ENUM = 0x7fffffff, } VkClusterAccelerationStructureOpTypeNV;
@@ -2434,6 +2463,32 @@ typedef enum VkCullModeFlagBits VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkCullModeFlagBits;
+typedef VkFlags64 VkDataGraphPipelineDispatchFlagBitsARM; + + +typedef enum VkDataGraphPipelinePropertyARM +{ + VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0, + VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1, + VK_DATA_GRAPH_PIPELINE_PROPERTY_ARM_MAX_ENUM = 0x7fffffff, +} VkDataGraphPipelinePropertyARM; + +typedef enum VkDataGraphPipelineSessionBindPointARM +{ + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_ARM_MAX_ENUM = 0x7fffffff, +} VkDataGraphPipelineSessionBindPointARM; + +typedef enum VkDataGraphPipelineSessionBindPointTypeARM +{ + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_ARM_MAX_ENUM = 0x7fffffff, +} VkDataGraphPipelineSessionBindPointTypeARM; + +typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagBitsARM; + +static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 0x00000001ull; + typedef enum VkDebugReportFlagBitsEXT { VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, @@ -3387,6 +3442,7 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_ 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_TENSOR_DATA_GRAPH_BIT_ARM = 0x1000000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ull; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV = 0x8000000000000ull; @@ -4003,6 +4059,7 @@ typedef enum VkObjectType VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, + VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM = 1000507000, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, @@ -4204,6 +4261,18 @@ typedef enum VkPerformanceValueTypeINTEL VK_PERFORMANCE_VALUE_TYPE_INTEL_MAX_ENUM = 0x7fffffff, } VkPerformanceValueTypeINTEL;
+typedef enum VkPhysicalDeviceDataGraphOperationTypeARM +{ + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0, + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_ARM_MAX_ENUM = 0x7fffffff, +} VkPhysicalDeviceDataGraphOperationTypeARM; + +typedef enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM +{ + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0, + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_ARM_MAX_ENUM = 0x7fffffff, +} VkPhysicalDeviceDataGraphProcessingEngineTypeARM; + typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM;
static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001ull; @@ -4224,6 +4293,7 @@ typedef enum VkPipelineBindPoint VK_PIPELINE_BIND_POINT_COMPUTE = 1, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, + VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM = 1000507000, VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7fffffff, } VkPipelineBindPoint; @@ -4540,6 +4610,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUA static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ull; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM = 0x40000000000ull; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 0x100000000000ull; typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR;
@@ -4562,13 +4633,17 @@ typedef enum VkPolygonMode VK_POLYGON_MODE_MAX_ENUM = 0x7fffffff, } VkPolygonMode;
-typedef enum VkPresentGravityFlagBitsEXT +typedef enum VkPresentGravityFlagBitsKHR { - VK_PRESENT_GRAVITY_MIN_BIT_EXT = 0x00000001, - VK_PRESENT_GRAVITY_MAX_BIT_EXT = 0x00000002, - VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = 0x00000004, - VK_PRESENT_GRAVITY_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, -} VkPresentGravityFlagBitsEXT; + VK_PRESENT_GRAVITY_MIN_BIT_KHR = 0x00000001, + VK_PRESENT_GRAVITY_MAX_BIT_KHR = 0x00000002, + VK_PRESENT_GRAVITY_CENTERED_BIT_KHR = 0x00000004, + VK_PRESENT_GRAVITY_MIN_BIT_EXT = VK_PRESENT_GRAVITY_MIN_BIT_KHR, + VK_PRESENT_GRAVITY_MAX_BIT_EXT = VK_PRESENT_GRAVITY_MAX_BIT_KHR, + VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR, + VK_PRESENT_GRAVITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkPresentGravityFlagBitsKHR; +typedef VkPresentGravityFlagBitsKHR VkPresentGravityFlagBitsEXT;
typedef enum VkPresentModeKHR { @@ -4576,17 +4651,22 @@ typedef enum VkPresentModeKHR VK_PRESENT_MODE_MAILBOX_KHR = 1, VK_PRESENT_MODE_FIFO_KHR = 2, VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, - VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = 1000361000, + VK_PRESENT_MODE_FIFO_LATEST_READY_KHR = 1000361000, + VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR, VK_PRESENT_MODE_KHR_MAX_ENUM = 0x7fffffff, } VkPresentModeKHR;
-typedef enum VkPresentScalingFlagBitsEXT +typedef enum VkPresentScalingFlagBitsKHR { - VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = 0x00000001, - VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = 0x00000002, - VK_PRESENT_SCALING_STRETCH_BIT_EXT = 0x00000004, - VK_PRESENT_SCALING_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, -} VkPresentScalingFlagBitsEXT; + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR = 0x00000001, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR = 0x00000002, + VK_PRESENT_SCALING_STRETCH_BIT_KHR = 0x00000004, + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, + VK_PRESENT_SCALING_STRETCH_BIT_EXT = VK_PRESENT_SCALING_STRETCH_BIT_KHR, + VK_PRESENT_SCALING_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkPresentScalingFlagBitsKHR; +typedef VkPresentScalingFlagBitsKHR VkPresentScalingFlagBitsEXT;
typedef enum VkPrimitiveTopology { @@ -4699,6 +4779,7 @@ typedef enum VkQueueFlagBits VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, + VK_QUEUE_DATA_GRAPH_BIT_ARM = 0x00000400, VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkQueueFlagBits;
@@ -4817,7 +4898,7 @@ typedef enum VkResult VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, VK_ERROR_INVALID_SHADER_NV = -1000012000, - VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_VALIDATION_FAILED = -1000011001, VK_ERROR_OUT_OF_DATE_KHR = -1000001004, VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, VK_ERROR_SURFACE_LOST_KHR = -1000000000, @@ -4848,6 +4929,7 @@ typedef enum VkResult VK_PIPELINE_COMPILE_REQUIRED = 1000297000, VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, VK_PIPELINE_BINARY_MISSING_KHR = 1000483000, + VK_ERROR_VALIDATION_FAILED_EXT = VK_ERROR_VALIDATION_FAILED, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, @@ -5566,15 +5648,15 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001, VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004, - VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR = 1000274000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR = 1000274001, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR = 1000274002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR = 1000275000, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR = 1000275001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR = 1000275002, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR = 1000275003, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR = 1000275004, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR = 1000275005, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, @@ -5711,7 +5793,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = 1000361000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000, VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, @@ -5728,6 +5810,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES = 1000388000, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES = 1000388001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, @@ -5898,6 +5981,26 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM = 1000507000, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM = 1000507001, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM = 1000507002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM = 1000507003, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM = 1000507004, + VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM = 1000507005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM = 1000507006, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM = 1000507007, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM = 1000507008, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM = 1000507009, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM = 1000507010, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM = 1000507011, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM = 1000507012, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM = 1000507013, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM = 1000507014, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM = 1000507015, + VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM = 1000507016, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM = 1000507017, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM = 1000507018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM = 1000507019, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR = 1000511000, @@ -5955,6 +6058,11 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002, VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003, VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR = 1000552000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR = 1000552001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR = 1000552002, + VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR = 1000552003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR = 1000552004, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553001, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR = 1000553002, @@ -6023,6 +6131,7 @@ typedef enum VkStructureType 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_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -6185,6 +6294,15 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, @@ -6222,6 +6340,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, @@ -6351,9 +6470,10 @@ typedef enum VkSwapchainCreateFlagBitsKHR VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, 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_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, VK_SWAPCHAIN_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkSwapchainCreateFlagBitsKHR;
@@ -6386,6 +6506,7 @@ static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_SHADER_BIT_ARM = 0x0000000 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; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM = 0x00000020ull;
typedef VkFlags64 VkTensorViewCreateFlagBitsARM;
@@ -6572,6 +6693,7 @@ typedef enum VkVideoEncodeAV1CapabilityFlagBitsKHR VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR = 0x00000004, VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR = 0x00000008, VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR = 0x00000020, VK_VIDEO_ENCODE_AV1_CAPABILITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeAV1CapabilityFlagBitsKHR;
@@ -6647,6 +6769,7 @@ typedef enum VkVideoEncodeFlagBitsKHR { VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000001, VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR = 0x00000004, VK_VIDEO_ENCODE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeFlagBitsKHR;
@@ -6662,6 +6785,7 @@ typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 0x00000080, VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 0x00000100, VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 0x00000400, VK_VIDEO_ENCODE_H2_64_CAPABILITY_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeH264CapabilityFlagBitsKHR;
@@ -6700,6 +6824,16 @@ typedef enum VkVideoEncodeH264StdFlagBitsKHR VK_VIDEO_ENCODE_H2_64_STD_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, } VkVideoEncodeH264StdFlagBitsKHR;
+typedef enum VkVideoEncodeIntraRefreshModeFlagBitsKHR +{ + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR = 0, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, +} VkVideoEncodeIntraRefreshModeFlagBitsKHR; + typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, @@ -7666,6 +7800,17 @@ typedef struct VkBindBufferMemoryInfo } VkBindBufferMemoryInfo; typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
+typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM +{ + VkStructureType sType; + const void *pNext; + VkDataGraphPipelineSessionARM WINE_VK_ALIGN(8) session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; + VkDeviceMemory WINE_VK_ALIGN(8) memory; + VkDeviceSize WINE_VK_ALIGN(8) memoryOffset; +} VkBindDataGraphPipelineSessionMemoryInfoARM; + typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT { VkStructureType sType; @@ -7968,6 +8113,11 @@ typedef struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV uint32_t geometryFlags:3; } VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV;
+typedef struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV +{ + VkDeviceAddress WINE_VK_ALIGN(8) clusterTemplateAddress; +} VkClusterAccelerationStructureGetTemplateIndicesInfoNV; + typedef struct VkClusterAccelerationStructureMoveObjectsInfoNV { VkDeviceAddress WINE_VK_ALIGN(8) srcAccelerationStructure; @@ -8278,6 +8428,104 @@ typedef struct VkCuModuleTexturingModeCreateInfoNVX VkBool32 use64bitTexturing; } VkCuModuleTexturingModeCreateInfoNVX;
+typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + const char *pVendorOptions; +} VkDataGraphPipelineCompilerControlCreateInfoARM; + +typedef struct VkDataGraphPipelineConstantARM +{ + VkStructureType sType; + const void *pNext; + uint32_t id; + const void *pConstantData; +} VkDataGraphPipelineConstantARM; + +typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t dimension; + uint32_t zeroCount; + uint32_t groupSize; +} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + +typedef struct VkDataGraphPipelineDispatchInfoARM +{ + VkStructureType sType; + void *pNext; + VkDataGraphPipelineDispatchFlagsARM WINE_VK_ALIGN(8) flags; +} VkDataGraphPipelineDispatchInfoARM; + +typedef struct VkDataGraphPipelineIdentifierCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t identifierSize; + const uint8_t *pIdentifier; +} VkDataGraphPipelineIdentifierCreateInfoARM; + +typedef struct VkDataGraphPipelineInfoARM +{ + VkStructureType sType; + const void *pNext; + VkPipeline WINE_VK_ALIGN(8) dataGraphPipeline; +} VkDataGraphPipelineInfoARM; + +typedef struct VkDataGraphPipelinePropertyQueryResultARM +{ + VkStructureType sType; + const void *pNext; + VkDataGraphPipelinePropertyARM property; + VkBool32 isText; + size_t dataSize; + void *pData; +} VkDataGraphPipelinePropertyQueryResultARM; + +typedef struct VkDataGraphPipelineResourceInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t descriptorSet; + uint32_t binding; + uint32_t arrayElement; +} VkDataGraphPipelineResourceInfoARM; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementARM +{ + VkStructureType sType; + const void *pNext; + VkDataGraphPipelineSessionBindPointARM bindPoint; + VkDataGraphPipelineSessionBindPointTypeARM bindPointType; + uint32_t numObjects; +} VkDataGraphPipelineSessionBindPointRequirementARM; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM +{ + VkStructureType sType; + const void *pNext; + VkDataGraphPipelineSessionARM WINE_VK_ALIGN(8) session; +} VkDataGraphPipelineSessionBindPointRequirementsInfoARM; + +typedef struct VkDataGraphPipelineSessionCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + VkDataGraphPipelineSessionCreateFlagsARM WINE_VK_ALIGN(8) flags; + VkPipeline WINE_VK_ALIGN(8) dataGraphPipeline; +} VkDataGraphPipelineSessionCreateInfoARM; + +typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM +{ + VkStructureType sType; + const void *pNext; + VkDataGraphPipelineSessionARM WINE_VK_ALIGN(8) session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; +} VkDataGraphPipelineSessionMemoryRequirementsInfoARM; + typedef struct VkDebugMarkerMarkerInfoEXT { VkStructureType sType; @@ -10363,6 +10611,30 @@ typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT uint32_t maxCustomBorderColorSamplers; } VkPhysicalDeviceCustomBorderColorPropertiesEXT;
+typedef struct VkPhysicalDeviceDataGraphFeaturesARM +{ + VkStructureType sType; + void *pNext; + VkBool32 dataGraph; + VkBool32 dataGraphUpdateAfterBind; + VkBool32 dataGraphSpecializationConstants; + VkBool32 dataGraphDescriptorBuffer; + VkBool32 dataGraphShaderModule; +} VkPhysicalDeviceDataGraphFeaturesARM; + +typedef struct VkPhysicalDeviceDataGraphOperationSupportARM +{ + VkPhysicalDeviceDataGraphOperationTypeARM operationType; + char name[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM]; + uint32_t version; +} VkPhysicalDeviceDataGraphOperationSupportARM; + +typedef struct VkPhysicalDeviceDataGraphProcessingEngineARM +{ + VkPhysicalDeviceDataGraphProcessingEngineTypeARM type; + VkBool32 isForeign; +} VkPhysicalDeviceDataGraphProcessingEngineARM; + typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { VkStructureType sType; @@ -11880,6 +12152,13 @@ typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR VkBool32 pipelineBinaryCompressedData; } VkPhysicalDevicePipelineBinaryPropertiesKHR;
+typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC +{ + VkStructureType sType; + void *pNext; + VkBool32 pipelineCacheIncrementalMode; +} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { VkStructureType sType; @@ -11972,12 +12251,13 @@ typedef struct VkPhysicalDevicePresentIdFeaturesKHR VkBool32 presentId; } VkPhysicalDevicePresentIdFeaturesKHR;
-typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT +typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR { VkStructureType sType; void *pNext; VkBool32 presentModeFifoLatestReady; -} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; +} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; +typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT;
typedef struct VkPhysicalDevicePresentWait2FeaturesKHR { @@ -12056,6 +12336,14 @@ typedef struct VkPhysicalDevicePushDescriptorProperties } VkPhysicalDevicePushDescriptorProperties; typedef VkPhysicalDevicePushDescriptorProperties VkPhysicalDevicePushDescriptorPropertiesKHR;
+typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t queueFamilyIndex; + VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType; +} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { VkStructureType sType; @@ -12653,6 +12941,13 @@ typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT VkBool32 shaderTileImageReadFromHelperInvocation; } VkPhysicalDeviceShaderTileImagePropertiesEXT;
+typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderUntypedPointers; +} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR; + typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { VkStructureType sType; @@ -12749,12 +13044,13 @@ typedef struct VkPhysicalDeviceSurfaceInfo2KHR VkSurfaceKHR WINE_VK_ALIGN(8) surface; } VkPhysicalDeviceSurfaceInfo2KHR;
-typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR { VkStructureType sType; void *pNext; VkBool32 swapchainMaintenance1; -} VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR; +typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT;
typedef struct VkPhysicalDeviceSynchronization2Features { @@ -13007,6 +13303,13 @@ typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR VkBool32 videoEncodeAV1; } VkPhysicalDeviceVideoEncodeAV1FeaturesKHR;
+typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 videoEncodeIntraRefresh; +} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR { VkStructureType sType; @@ -13948,6 +14251,22 @@ typedef struct VkQueueFamilyCheckpointPropertiesNV VkPipelineStageFlags checkpointExecutionStageMask; } VkQueueFamilyCheckpointPropertiesNV;
+typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM +{ + VkStructureType sType; + const void *pNext; + VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes; + VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes; +} VkQueueFamilyDataGraphProcessingEnginePropertiesARM; + +typedef struct VkQueueFamilyDataGraphPropertiesARM +{ + VkStructureType sType; + const void *pNext; + VkPhysicalDeviceDataGraphProcessingEngineARM engine; + VkPhysicalDeviceDataGraphOperationSupportARM operation; +} VkQueueFamilyDataGraphPropertiesARM; + typedef struct VkQueueFamilyGlobalPriorityProperties { VkStructureType sType; @@ -14053,14 +14372,15 @@ typedef struct VkReleaseCapturedPipelineDataInfoKHR VkPipeline WINE_VK_ALIGN(8) pipeline; } VkReleaseCapturedPipelineDataInfoKHR;
-typedef struct VkReleaseSwapchainImagesInfoEXT +typedef struct VkReleaseSwapchainImagesInfoKHR { VkStructureType sType; const void *pNext; VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; uint32_t imageIndexCount; const uint32_t *pImageIndices; -} VkReleaseSwapchainImagesInfoEXT; +} VkReleaseSwapchainImagesInfoKHR; +typedef VkReleaseSwapchainImagesInfoKHR VkReleaseSwapchainImagesInfoEXT;
typedef struct VkRenderPassAttachmentBeginInfo { @@ -14157,7 +14477,7 @@ typedef struct VkRenderPassTileShadingCreateInfoQCOM typedef struct VkRenderPassTransformBeginInfoQCOM { VkStructureType sType; - void *pNext; + const void *pNext; VkSurfaceTransformFlagBitsKHR transform; } VkRenderPassTransformBeginInfoQCOM;
@@ -14798,31 +15118,34 @@ typedef struct VkSurfaceFormatKHR VkColorSpaceKHR colorSpace; } VkSurfaceFormatKHR;
-typedef struct VkSurfacePresentModeCompatibilityEXT +typedef struct VkSurfacePresentModeCompatibilityKHR { VkStructureType sType; void *pNext; uint32_t presentModeCount; VkPresentModeKHR *pPresentModes; -} VkSurfacePresentModeCompatibilityEXT; +} VkSurfacePresentModeCompatibilityKHR; +typedef VkSurfacePresentModeCompatibilityKHR VkSurfacePresentModeCompatibilityEXT;
-typedef struct VkSurfacePresentModeEXT +typedef struct VkSurfacePresentModeKHR { VkStructureType sType; void *pNext; VkPresentModeKHR presentMode; -} VkSurfacePresentModeEXT; +} VkSurfacePresentModeKHR; +typedef VkSurfacePresentModeKHR VkSurfacePresentModeEXT;
-typedef struct VkSurfacePresentScalingCapabilitiesEXT +typedef struct VkSurfacePresentScalingCapabilitiesKHR { VkStructureType sType; void *pNext; - VkPresentScalingFlagsEXT supportedPresentScaling; - VkPresentGravityFlagsEXT supportedPresentGravityX; - VkPresentGravityFlagsEXT supportedPresentGravityY; + VkPresentScalingFlagsKHR supportedPresentScaling; + VkPresentGravityFlagsKHR supportedPresentGravityX; + VkPresentGravityFlagsKHR supportedPresentGravityY; VkExtent2D minScaledImageExtent; VkExtent2D maxScaledImageExtent; -} VkSurfacePresentScalingCapabilitiesEXT; +} VkSurfacePresentScalingCapabilitiesKHR; +typedef VkSurfacePresentScalingCapabilitiesKHR VkSurfacePresentScalingCapabilitiesEXT;
typedef struct VkSwapchainCreateInfoKHR { @@ -14860,38 +15183,42 @@ typedef struct VkSwapchainPresentBarrierCreateInfoNV VkBool32 presentBarrierEnable; } VkSwapchainPresentBarrierCreateInfoNV;
-typedef struct VkSwapchainPresentFenceInfoEXT +typedef struct VkSwapchainPresentFenceInfoKHR { VkStructureType sType; const void *pNext; uint32_t swapchainCount; const VkFence *pFences; -} VkSwapchainPresentFenceInfoEXT; +} VkSwapchainPresentFenceInfoKHR; +typedef VkSwapchainPresentFenceInfoKHR VkSwapchainPresentFenceInfoEXT;
-typedef struct VkSwapchainPresentModeInfoEXT +typedef struct VkSwapchainPresentModeInfoKHR { VkStructureType sType; const void *pNext; uint32_t swapchainCount; const VkPresentModeKHR *pPresentModes; -} VkSwapchainPresentModeInfoEXT; +} VkSwapchainPresentModeInfoKHR; +typedef VkSwapchainPresentModeInfoKHR VkSwapchainPresentModeInfoEXT;
-typedef struct VkSwapchainPresentModesCreateInfoEXT +typedef struct VkSwapchainPresentModesCreateInfoKHR { VkStructureType sType; const void *pNext; uint32_t presentModeCount; const VkPresentModeKHR *pPresentModes; -} VkSwapchainPresentModesCreateInfoEXT; +} VkSwapchainPresentModesCreateInfoKHR; +typedef VkSwapchainPresentModesCreateInfoKHR VkSwapchainPresentModesCreateInfoEXT;
-typedef struct VkSwapchainPresentScalingCreateInfoEXT +typedef struct VkSwapchainPresentScalingCreateInfoKHR { VkStructureType sType; const void *pNext; - VkPresentScalingFlagsEXT scalingBehavior; - VkPresentGravityFlagsEXT presentGravityX; - VkPresentGravityFlagsEXT presentGravityY; -} VkSwapchainPresentScalingCreateInfoEXT; + VkPresentScalingFlagsKHR scalingBehavior; + VkPresentGravityFlagsKHR presentGravityX; + VkPresentGravityFlagsKHR presentGravityY; +} VkSwapchainPresentScalingCreateInfoKHR; +typedef VkSwapchainPresentScalingCreateInfoKHR VkSwapchainPresentScalingCreateInfoEXT;
typedef struct VkTensorCaptureDescriptorDataInfoARM { @@ -15461,6 +15788,25 @@ typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR int32_t maxQpDelta; } VkVideoEncodeH265QuantizationMapCapabilitiesKHR;
+typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR +{ + VkStructureType sType; + void *pNext; + VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes; + uint32_t maxIntraRefreshCycleDuration; + uint32_t maxIntraRefreshActiveReferencePictures; + VkBool32 partitionIndependentIntraRefreshRegions; + VkBool32 nonRectangularIntraRefreshRegions; +} VkVideoEncodeIntraRefreshCapabilitiesKHR; + +typedef struct VkVideoEncodeIntraRefreshInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t intraRefreshCycleDuration; + uint32_t intraRefreshIndex; +} VkVideoEncodeIntraRefreshInfoKHR; + typedef struct VkVideoEncodeQualityLevelInfoKHR { VkStructureType sType; @@ -15508,6 +15854,13 @@ typedef struct VkVideoEncodeRateControlLayerInfoKHR uint32_t frameRateDenominator; } VkVideoEncodeRateControlLayerInfoKHR;
+typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode; +} VkVideoEncodeSessionIntraRefreshCreateInfoKHR; + typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR { VkStructureType sType; @@ -15608,6 +15961,13 @@ typedef struct VkVideoProfileListInfoKHR const VkVideoProfileInfoKHR *pProfiles; } VkVideoProfileListInfoKHR;
+typedef struct VkVideoReferenceIntraRefreshInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t dirtyIntraRefreshRegions; +} VkVideoReferenceIntraRefreshInfoKHR; + typedef struct VkVideoReferenceSlotInfoKHR { VkStructureType sType; @@ -16522,7 +16882,7 @@ typedef struct VkCommandBufferBeginInfo typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { VkStructureType sType; - void *pNext; + const void *pNext; VkSurfaceTransformFlagBitsKHR transform; VkRect2D renderArea; } VkCommandBufferInheritanceRenderPassTransformInfoQCOM; @@ -16634,6 +16994,24 @@ typedef struct VkCopyTensorInfoARM const VkTensorCopyARM *pRegions; } VkCopyTensorInfoARM;
+typedef struct VkDataGraphPipelineCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + VkPipelineCreateFlags2KHR flags; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + uint32_t resourceInfoCount; + const VkDataGraphPipelineResourceInfoARM *pResourceInfos; +} VkDataGraphPipelineCreateInfoARM; + +typedef struct VkDataGraphProcessingEngineCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t processingEngineCount; + VkPhysicalDeviceDataGraphProcessingEngineARM *pProcessingEngines; +} VkDataGraphProcessingEngineCreateInfoARM; + typedef struct VkDebugUtilsMessengerCallbackDataEXT { VkStructureType sType; @@ -17806,6 +18184,17 @@ typedef struct VkCopyMemoryToImageInfo } VkCopyMemoryToImageInfo; typedef VkCopyMemoryToImageInfo VkCopyMemoryToImageInfoEXT;
+typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM +{ + VkStructureType sType; + const void *pNext; + VkShaderModule WINE_VK_ALIGN(8) module; + const char *pName; + const VkSpecializationInfo *pSpecializationInfo; + uint32_t constantCount; + const VkDataGraphPipelineConstantARM *pConstants; +} VkDataGraphPipelineShaderModuleCreateInfoARM; + typedef struct VkDependencyInfo { VkStructureType sType; @@ -18112,6 +18501,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice, typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice, VkBuffer, VkDeviceMemory, VkDeviceSize); typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice, uint32_t, const VkBindBufferMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice, uint32_t, const VkBindBufferMemoryInfo *); +typedef VkResult (VKAPI_PTR *PFN_vkBindDataGraphPipelineSessionMemoryARM)(VkDevice, uint32_t, const VkBindDataGraphPipelineSessionMemoryInfoARM *); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice, VkImage, VkDeviceMemory, VkDeviceSize); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice, uint32_t, const VkBindImageMemoryInfo *); @@ -18198,6 +18588,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer, uint32_t, typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer, uint32_t, 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_vkCmdDispatchDataGraphARM)(VkCommandBuffer, VkDataGraphPipelineSessionARM, const VkDataGraphPipelineDispatchInfoARM *); typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer, VkBuffer, VkDeviceSize); typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer, const VkDispatchTileInfoQCOM *); typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer, uint32_t, uint32_t, uint32_t, uint32_t); @@ -18412,6 +18803,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice, const VkCommandP typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice, VkPipelineCache, uint32_t, const VkComputePipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *); typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice, const VkCuFunctionCreateInfoNVX *, const VkAllocationCallbacks *, VkCuFunctionNVX *); typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice, const VkCuModuleCreateInfoNVX *, const VkAllocationCallbacks *, VkCuModuleNVX *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelineSessionARM)(VkDevice, const VkDataGraphPipelineSessionCreateInfoARM *, const VkAllocationCallbacks *, VkDataGraphPipelineSessionARM *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelinesARM)(VkDevice, VkDeferredOperationKHR, VkPipelineCache, uint32_t, const VkDataGraphPipelineCreateInfoARM *, const VkAllocationCallbacks *, VkPipeline *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance, const VkDebugReportCallbackCreateInfoEXT *, const VkAllocationCallbacks *, VkDebugReportCallbackEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance, const VkDebugUtilsMessengerCreateInfoEXT *, const VkAllocationCallbacks *, VkDebugUtilsMessengerEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice, const VkAllocationCallbacks *, VkDeferredOperationKHR *); @@ -18468,6 +18861,7 @@ typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice, VkBufferView, const typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice, VkCommandPool, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice, VkCuFunctionNVX, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice, VkCuModuleNVX, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyDataGraphPipelineSessionARM)(VkDevice, VkDataGraphPipelineSessionARM, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance, VkDebugReportCallbackEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance, VkDebugUtilsMessengerEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice, VkDeferredOperationKHR, const VkAllocationCallbacks *); @@ -18540,6 +18934,10 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDe typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice, uint32_t, const VkCalibratedTimestampInfoKHR *, uint64_t *, uint64_t *); typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsKHR)(VkDevice, uint32_t, const VkCalibratedTimestampInfoKHR *, uint64_t *, uint64_t *); typedef void (VKAPI_PTR *PFN_vkGetClusterAccelerationStructureBuildSizesNV)(VkDevice, const VkClusterAccelerationStructureInputInfoNV *, VkAccelerationStructureBuildSizesInfoKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineAvailablePropertiesARM)(VkDevice, const VkDataGraphPipelineInfoARM *, uint32_t *, VkDataGraphPipelinePropertyARM *); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelinePropertiesARM)(VkDevice, const VkDataGraphPipelineInfoARM *, uint32_t, VkDataGraphPipelinePropertyQueryResultARM *); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM)(VkDevice, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *, uint32_t *, VkDataGraphPipelineSessionBindPointRequirementARM *); +typedef void (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM)(VkDevice, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *, VkMemoryRequirements2 *); typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice, VkDeferredOperationKHR); typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice, VkDeferredOperationKHR); typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice, const VkDescriptorGetInfoEXT *, size_t, void *); @@ -18634,6 +19032,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhys typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice, VkPhysicalDeviceProperties *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice, VkPhysicalDeviceProperties2 *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice, VkPhysicalDeviceProperties2 *); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM)(VkPhysicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM)(VkPhysicalDevice, uint32_t, uint32_t *, VkQueueFamilyDataGraphPropertiesARM *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *, uint32_t *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties2 *); @@ -18710,7 +19110,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue); typedef VkResult (VKAPI_PTR *PFN_vkReleaseCapturedPipelineDataKHR)(VkDevice, const VkReleaseCapturedPipelineDataInfoKHR *, const VkAllocationCallbacks *); typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice, VkPerformanceConfigurationINTEL); typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice); -typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice, const VkReleaseSwapchainImagesInfoEXT *); +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice, const VkReleaseSwapchainImagesInfoKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesKHR)(VkDevice, const VkReleaseSwapchainImagesInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer, VkCommandBufferResetFlags); typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice, VkCommandPool, VkCommandPoolResetFlags); typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice, VkDescriptorPool, VkDescriptorPoolResetFlags); @@ -18766,6 +19167,7 @@ VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_ VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos); +VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM *pBindInfos); VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos); @@ -18852,6 +19254,7 @@ void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); 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 vkCmdDispatchDataGraphARM(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM *pInfo); void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 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); @@ -19066,6 +19469,8 @@ VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCrea VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines); VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction); VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule); +VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDataGraphPipelineSessionARM *pSession); +VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines); VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback); VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger); VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation); @@ -19122,6 +19527,7 @@ void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, co void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator); @@ -19194,6 +19600,10 @@ VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, c VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation); VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation); void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const VkClusterAccelerationStructureInputInfoNV *pInfo, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo); +VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t *pPropertiesCount, VkDataGraphPipelinePropertyARM *pProperties); +VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM *pProperties); +VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *pInfo, uint32_t *pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM *pBindPointRequirements); +void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements); uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation); VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation); void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor); @@ -19288,6 +19698,8 @@ VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice phy void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties); void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties); void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties); +void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *pQueueFamilyDataGraphProcessingEngineProperties); +VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties); void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses); void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties); void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties); @@ -19364,7 +19776,8 @@ VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue); VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR *pInfo, const VkAllocationCallbacks *pAllocator); VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration); void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device); -VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo); +VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo); +VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo); VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); @@ -19421,6 +19834,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkBindBufferMemory) \ USE_VK_FUNC(vkBindBufferMemory2) \ USE_VK_FUNC(vkBindBufferMemory2KHR) \ + USE_VK_FUNC(vkBindDataGraphPipelineSessionMemoryARM) \ USE_VK_FUNC(vkBindImageMemory) \ USE_VK_FUNC(vkBindImageMemory2) \ USE_VK_FUNC(vkBindImageMemory2KHR) \ @@ -19507,6 +19921,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkCmdDispatch) \ USE_VK_FUNC(vkCmdDispatchBase) \ USE_VK_FUNC(vkCmdDispatchBaseKHR) \ + USE_VK_FUNC(vkCmdDispatchDataGraphARM) \ USE_VK_FUNC(vkCmdDispatchIndirect) \ USE_VK_FUNC(vkCmdDispatchTileQCOM) \ USE_VK_FUNC(vkCmdDraw) \ @@ -19721,6 +20136,8 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkCreateComputePipelines) \ USE_VK_FUNC(vkCreateCuFunctionNVX) \ USE_VK_FUNC(vkCreateCuModuleNVX) \ + USE_VK_FUNC(vkCreateDataGraphPipelineSessionARM) \ + USE_VK_FUNC(vkCreateDataGraphPipelinesARM) \ USE_VK_FUNC(vkCreateDeferredOperationKHR) \ USE_VK_FUNC(vkCreateDescriptorPool) \ USE_VK_FUNC(vkCreateDescriptorSetLayout) \ @@ -19770,6 +20187,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkDestroyCommandPool) \ USE_VK_FUNC(vkDestroyCuFunctionNVX) \ USE_VK_FUNC(vkDestroyCuModuleNVX) \ + USE_VK_FUNC(vkDestroyDataGraphPipelineSessionARM) \ USE_VK_FUNC(vkDestroyDeferredOperationKHR) \ USE_VK_FUNC(vkDestroyDescriptorPool) \ USE_VK_FUNC(vkDestroyDescriptorSetLayout) \ @@ -19829,6 +20247,10 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetCalibratedTimestampsEXT) \ USE_VK_FUNC(vkGetCalibratedTimestampsKHR) \ USE_VK_FUNC(vkGetClusterAccelerationStructureBuildSizesNV) \ + USE_VK_FUNC(vkGetDataGraphPipelineAvailablePropertiesARM) \ + USE_VK_FUNC(vkGetDataGraphPipelinePropertiesARM) \ + USE_VK_FUNC(vkGetDataGraphPipelineSessionBindPointRequirementsARM) \ + USE_VK_FUNC(vkGetDataGraphPipelineSessionMemoryRequirementsARM) \ USE_VK_FUNC(vkGetDeferredOperationMaxConcurrencyKHR) \ USE_VK_FUNC(vkGetDeferredOperationResultKHR) \ USE_VK_FUNC(vkGetDescriptorEXT) \ @@ -19946,6 +20368,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkReleasePerformanceConfigurationINTEL) \ USE_VK_FUNC(vkReleaseProfilingLockKHR) \ USE_VK_FUNC(vkReleaseSwapchainImagesEXT) \ + USE_VK_FUNC(vkReleaseSwapchainImagesKHR) \ USE_VK_FUNC(vkResetCommandBuffer) \ USE_VK_FUNC(vkResetCommandPool) \ USE_VK_FUNC(vkResetDescriptorPool) \ @@ -20030,6 +20453,8 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetPhysicalDeviceProperties) \ USE_VK_FUNC(vkGetPhysicalDeviceProperties2) \ USE_VK_FUNC(vkGetPhysicalDeviceProperties2KHR) \ + USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM) \ + USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM) \ USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties) \ USE_VK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties2) \