[PATCH v5 0/3] MR5016: winevulkan: Update to VK spec version 1.3.277.
-- v5: winevulkan: Enable VK_ARM_render_pass_striped. winevulkan: Update to VK spec version 1.3.277. winevulkan: Prepare for VK_KHR_calibrated_timestamps. https://gitlab.winehq.org/wine/wine/-/merge_requests/5016
From: Georg Lehmann <dadschoorse(a)gmail.com> --- dlls/winevulkan/vulkan.c | 65 +++++++++++++++++++++++++++------------- 1 file changed, 44 insertions(+), 21 deletions(-) diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c index 240ba3e8618..282c17f430e 100644 --- a/dlls/winevulkan/vulkan.c +++ b/dlls/winevulkan/vulkan.c @@ -1325,17 +1325,19 @@ static inline uint64_t convert_timestamp(VkTimeDomainEXT host_domain, VkTimeDoma return value; } -VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice handle, uint32_t timestamp_count, - const VkCalibratedTimestampInfoEXT *timestamp_infos, - uint64_t *timestamps, uint64_t *max_deviation) +static VkResult wine_vk_get_timestamps(struct wine_device *device, uint32_t timestamp_count, + const VkCalibratedTimestampInfoEXT *timestamp_infos, + uint64_t *timestamps, uint64_t *max_deviation, + VkResult (*get_timestamps)(VkDevice, uint32_t, const VkCalibratedTimestampInfoEXT *, uint64_t *, uint64_t *)) { - struct wine_device *device = wine_device_from_handle(handle); VkCalibratedTimestampInfoEXT* host_timestamp_infos; unsigned int i; VkResult res; - TRACE("%p, %u, %p, %p, %p\n", device, timestamp_count, timestamp_infos, timestamps, max_deviation); - if (!(host_timestamp_infos = malloc(sizeof(VkCalibratedTimestampInfoEXT) * timestamp_count))) + if (timestamp_count == 0) + return VK_SUCCESS; + + if (!(host_timestamp_infos = calloc(sizeof(VkCalibratedTimestampInfoEXT), timestamp_count))) return VK_ERROR_OUT_OF_HOST_MEMORY; for (i = 0; i < timestamp_count; i++) @@ -1345,24 +1347,23 @@ VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice handle, uint32_t timestamp_c host_timestamp_infos[i].timeDomain = map_to_host_time_domain(timestamp_infos[i].timeDomain); } - res = device->funcs.p_vkGetCalibratedTimestampsEXT(device->host_device, timestamp_count, host_timestamp_infos, - timestamps, max_deviation); - if (res != VK_SUCCESS) - return res; - - for (i = 0; i < timestamp_count; i++) - timestamps[i] = convert_timestamp(host_timestamp_infos[i].timeDomain, timestamp_infos[i].timeDomain, timestamps[i]); + res = get_timestamps(device->host_device, timestamp_count, host_timestamp_infos, timestamps, max_deviation); + if (res == VK_SUCCESS) + { + for (i = 0; i < timestamp_count; i++) + timestamps[i] = convert_timestamp(host_timestamp_infos[i].timeDomain, timestamp_infos[i].timeDomain, timestamps[i]); + } free(host_timestamp_infos); return res; } -VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice handle, - uint32_t *time_domain_count, - VkTimeDomainEXT *time_domains) +static VkResult wine_vk_get_time_domains(struct wine_phys_dev *phys_dev, + uint32_t *time_domain_count, + VkTimeDomainEXT *time_domains, + VkResult (*get_domains)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *)) { - struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle); BOOL supports_device = FALSE, supports_monotonic = FALSE, supports_monotonic_raw = FALSE; const VkTimeDomainEXT performance_counter_domain = get_performance_counter_time_domain(); VkTimeDomainEXT *host_time_domains; @@ -1373,16 +1374,14 @@ VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice ha VkResult res; /* Find out the time domains supported on the host */ - res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(phys_dev->host_physical_device, - &host_time_domain_count, NULL); + res = get_domains(phys_dev->host_physical_device, &host_time_domain_count, NULL); if (res != VK_SUCCESS) return res; if (!(host_time_domains = malloc(sizeof(VkTimeDomainEXT) * host_time_domain_count))) return VK_ERROR_OUT_OF_HOST_MEMORY; - res = phys_dev->instance->funcs.p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(phys_dev->host_physical_device, - &host_time_domain_count, host_time_domains); + res = get_domains(phys_dev->host_physical_device, &host_time_domain_count, host_time_domains); if (res != VK_SUCCESS) { free(host_time_domains); @@ -1432,6 +1431,30 @@ VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice ha return res; } +VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice handle, uint32_t timestamp_count, + const VkCalibratedTimestampInfoEXT *timestamp_infos, + uint64_t *timestamps, uint64_t *max_deviation) +{ + struct wine_device *device = wine_device_from_handle(handle); + + TRACE("%p, %u, %p, %p, %p\n", device, timestamp_count, timestamp_infos, timestamps, max_deviation); + + return wine_vk_get_timestamps(device, timestamp_count, timestamp_infos, timestamps, max_deviation, + device->funcs.p_vkGetCalibratedTimestampsEXT); +} + +VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice handle, + uint32_t *time_domain_count, + VkTimeDomainEXT *time_domains) +{ + struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle); + + TRACE("%p, %p, %p\n", phys_dev, time_domain_count, time_domains); + + return wine_vk_get_time_domains(phys_dev, time_domain_count, time_domains, + phys_dev->instance->funcs.p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); +} + void wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice phys_dev, const VkPhysicalDeviceExternalSemaphoreInfo *info, VkExternalSemaphoreProperties *properties) -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/5016
From: Georg Lehmann <dadschoorse(a)gmail.com> --- dlls/vulkan-1/vulkan-1.spec | 2 +- dlls/winevulkan/loader_thunks.c | 116 ++- dlls/winevulkan/loader_thunks.h | 90 +- dlls/winevulkan/make_vulkan | 5 +- dlls/winevulkan/vulkan.c | 26 + dlls/winevulkan/vulkan_thunks.c | 1460 ++++++++++++++++++++++++++++--- dlls/winevulkan/vulkan_thunks.h | 34 +- dlls/winevulkan/winevulkan.json | 2 +- dlls/winevulkan/winevulkan.spec | 2 +- include/wine/vulkan.h | 392 +++++++-- include/wine/vulkan_driver.h | 2 +- 11 files changed, 1938 insertions(+), 193 deletions(-) diff --git a/dlls/vulkan-1/vulkan-1.spec b/dlls/vulkan-1/vulkan-1.spec index 48ff2af3126..f3d40d95160 100644 --- a/dlls/vulkan-1/vulkan-1.spec +++ b/dlls/vulkan-1/vulkan-1.spec @@ -3,7 +3,7 @@ # This file is generated from Vulkan vk.xml file covered # by the following copyright and permission notice: # -# Copyright 2015-2023 The Khronos Group Inc. +# Copyright 2015-2024 The Khronos Group Inc. # # SPDX-License-Identifier: Apache-2.0 OR MIT # diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index f0f108e15f3..39b17ad3fe4 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -3,7 +3,7 @@ * This file is generated from Vulkan vk.xml file covered * by the following copyright and permission notice: * - * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2024 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -317,6 +317,14 @@ void WINAPI vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32 UNIX_CALL(vkCmdBeginTransformFeedbackEXT, ¶ms); } +void WINAPI vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo) +{ + struct vkCmdBindDescriptorBufferEmbeddedSamplers2EXT_params params; + params.commandBuffer = commandBuffer; + params.pBindDescriptorBufferEmbeddedSamplersInfo = pBindDescriptorBufferEmbeddedSamplersInfo; + UNIX_CALL(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, ¶ms); +} + void WINAPI vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) { struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params params; @@ -350,6 +358,14 @@ void WINAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBin UNIX_CALL(vkCmdBindDescriptorSets, ¶ms); } +void WINAPI vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo) +{ + struct vkCmdBindDescriptorSets2KHR_params params; + params.commandBuffer = commandBuffer; + params.pBindDescriptorSetsInfo = pBindDescriptorSetsInfo; + UNIX_CALL(vkCmdBindDescriptorSets2KHR, ¶ms); +} + void WINAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { struct vkCmdBindIndexBuffer_params params; @@ -1340,6 +1356,22 @@ void WINAPI vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout l UNIX_CALL(vkCmdPushConstants, ¶ms); } +void WINAPI vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR *pPushConstantsInfo) +{ + struct vkCmdPushConstants2KHR_params params; + params.commandBuffer = commandBuffer; + params.pPushConstantsInfo = pPushConstantsInfo; + UNIX_CALL(vkCmdPushConstants2KHR, ¶ms); +} + +void WINAPI vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR *pPushDescriptorSetInfo) +{ + struct vkCmdPushDescriptorSet2KHR_params params; + params.commandBuffer = commandBuffer; + params.pPushDescriptorSetInfo = pPushDescriptorSetInfo; + UNIX_CALL(vkCmdPushDescriptorSet2KHR, ¶ms); +} + void WINAPI vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites) { struct vkCmdPushDescriptorSetKHR_params params; @@ -1352,6 +1384,14 @@ void WINAPI vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineB UNIX_CALL(vkCmdPushDescriptorSetKHR, ¶ms); } +void WINAPI vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR *pPushDescriptorSetWithTemplateInfo) +{ + struct vkCmdPushDescriptorSetWithTemplate2KHR_params params; + params.commandBuffer = commandBuffer; + params.pPushDescriptorSetWithTemplateInfo = pPushDescriptorSetWithTemplateInfo; + UNIX_CALL(vkCmdPushDescriptorSetWithTemplate2KHR, ¶ms); +} + void WINAPI vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData) { struct vkCmdPushDescriptorSetWithTemplateKHR_params params; @@ -1732,6 +1772,14 @@ void WINAPI vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 UNIX_CALL(vkCmdSetDepthWriteEnableEXT, ¶ms); } +void WINAPI vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo) +{ + struct vkCmdSetDescriptorBufferOffsets2EXT_params params; + params.commandBuffer = commandBuffer; + params.pSetDescriptorBufferOffsetsInfo = pSetDescriptorBufferOffsetsInfo; + UNIX_CALL(vkCmdSetDescriptorBufferOffsets2EXT, ¶ms); +} + void WINAPI vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets) { struct vkCmdSetDescriptorBufferOffsetsEXT_params params; @@ -1901,6 +1949,15 @@ void WINAPI vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 UNIX_CALL(vkCmdSetLineStippleEnableEXT, ¶ms); } +void WINAPI vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) +{ + struct vkCmdSetLineStippleKHR_params params; + params.commandBuffer = commandBuffer; + params.lineStippleFactor = lineStippleFactor; + params.lineStipplePattern = lineStipplePattern; + UNIX_CALL(vkCmdSetLineStippleKHR, ¶ms); +} + void WINAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { struct vkCmdSetLineWidth_params params; @@ -2054,6 +2111,22 @@ void WINAPI vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer UNIX_CALL(vkCmdSetRayTracingPipelineStackSizeKHR, ¶ms); } +void WINAPI vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR *pLocationInfo) +{ + struct vkCmdSetRenderingAttachmentLocationsKHR_params params; + params.commandBuffer = commandBuffer; + params.pLocationInfo = pLocationInfo; + UNIX_CALL(vkCmdSetRenderingAttachmentLocationsKHR, ¶ms); +} + +void WINAPI vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *pLocationInfo) +{ + struct vkCmdSetRenderingInputAttachmentIndicesKHR_params params; + params.commandBuffer = commandBuffer; + params.pLocationInfo = pLocationInfo; + UNIX_CALL(vkCmdSetRenderingInputAttachmentIndicesKHR, ¶ms); +} + void WINAPI vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) { struct vkCmdSetRepresentativeFragmentTestEnableNV_params params; @@ -3949,7 +4022,7 @@ VkResult WINAPI vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const return params.result; } -VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) +VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) { struct vkGetCalibratedTimestampsEXT_params params; NTSTATUS status; @@ -3963,6 +4036,20 @@ VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestamp return params.result; } +VkResult WINAPI vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) +{ + struct vkGetCalibratedTimestampsKHR_params params; + NTSTATUS status; + params.device = device; + params.timestampCount = timestampCount; + params.pTimestampInfos = pTimestampInfos; + params.pTimestamps = pTimestamps; + params.pMaxDeviation = pMaxDeviation; + status = UNIX_CALL(vkGetCalibratedTimestampsKHR, ¶ms); + assert(!status && "vkGetCalibratedTimestampsKHR"); + return params.result; +} + VkResult WINAPI vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t *pCacheSize, void *pCacheData) { struct vkGetCudaModuleCacheNV_params params; @@ -4563,7 +4650,7 @@ VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformancePar return params.result; } -VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains) +VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains) { struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params params; NTSTATUS status; @@ -4575,6 +4662,18 @@ VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice return params.result; } +VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains) +{ + struct vkGetPhysicalDeviceCalibrateableTimeDomainsKHR_params params; + NTSTATUS status; + params.physicalDevice = physicalDevice; + params.pTimeDomainCount = pTimeDomainCount; + params.pTimeDomains = pTimeDomains; + status = UNIX_CALL(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, ¶ms); + assert(!status && "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"); + return params.result; +} + VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties) { struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params params; @@ -6082,9 +6181,11 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdBeginRendering", vkCmdBeginRendering}, {"vkCmdBeginRenderingKHR", vkCmdBeginRenderingKHR}, {"vkCmdBeginTransformFeedbackEXT", vkCmdBeginTransformFeedbackEXT}, + {"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", vkCmdBindDescriptorBufferEmbeddedSamplers2EXT}, {"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", vkCmdBindDescriptorBufferEmbeddedSamplersEXT}, {"vkCmdBindDescriptorBuffersEXT", vkCmdBindDescriptorBuffersEXT}, {"vkCmdBindDescriptorSets", vkCmdBindDescriptorSets}, + {"vkCmdBindDescriptorSets2KHR", vkCmdBindDescriptorSets2KHR}, {"vkCmdBindIndexBuffer", vkCmdBindIndexBuffer}, {"vkCmdBindIndexBuffer2KHR", vkCmdBindIndexBuffer2KHR}, {"vkCmdBindInvocationMaskHUAWEI", vkCmdBindInvocationMaskHUAWEI}, @@ -6183,7 +6284,10 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdPipelineBarrier2KHR", vkCmdPipelineBarrier2KHR}, {"vkCmdPreprocessGeneratedCommandsNV", vkCmdPreprocessGeneratedCommandsNV}, {"vkCmdPushConstants", vkCmdPushConstants}, + {"vkCmdPushConstants2KHR", vkCmdPushConstants2KHR}, + {"vkCmdPushDescriptorSet2KHR", vkCmdPushDescriptorSet2KHR}, {"vkCmdPushDescriptorSetKHR", vkCmdPushDescriptorSetKHR}, + {"vkCmdPushDescriptorSetWithTemplate2KHR", vkCmdPushDescriptorSetWithTemplate2KHR}, {"vkCmdPushDescriptorSetWithTemplateKHR", vkCmdPushDescriptorSetWithTemplateKHR}, {"vkCmdResetEvent", vkCmdResetEvent}, {"vkCmdResetEvent2", vkCmdResetEvent2}, @@ -6228,6 +6332,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdSetDepthTestEnableEXT", vkCmdSetDepthTestEnableEXT}, {"vkCmdSetDepthWriteEnable", vkCmdSetDepthWriteEnable}, {"vkCmdSetDepthWriteEnableEXT", vkCmdSetDepthWriteEnableEXT}, + {"vkCmdSetDescriptorBufferOffsets2EXT", vkCmdSetDescriptorBufferOffsets2EXT}, {"vkCmdSetDescriptorBufferOffsetsEXT", vkCmdSetDescriptorBufferOffsetsEXT}, {"vkCmdSetDeviceMask", vkCmdSetDeviceMask}, {"vkCmdSetDeviceMaskKHR", vkCmdSetDeviceMaskKHR}, @@ -6247,6 +6352,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdSetLineRasterizationModeEXT", vkCmdSetLineRasterizationModeEXT}, {"vkCmdSetLineStippleEXT", vkCmdSetLineStippleEXT}, {"vkCmdSetLineStippleEnableEXT", vkCmdSetLineStippleEnableEXT}, + {"vkCmdSetLineStippleKHR", vkCmdSetLineStippleKHR}, {"vkCmdSetLineWidth", vkCmdSetLineWidth}, {"vkCmdSetLogicOpEXT", vkCmdSetLogicOpEXT}, {"vkCmdSetLogicOpEnableEXT", vkCmdSetLogicOpEnableEXT}, @@ -6265,6 +6371,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdSetRasterizerDiscardEnable", vkCmdSetRasterizerDiscardEnable}, {"vkCmdSetRasterizerDiscardEnableEXT", vkCmdSetRasterizerDiscardEnableEXT}, {"vkCmdSetRayTracingPipelineStackSizeKHR", vkCmdSetRayTracingPipelineStackSizeKHR}, + {"vkCmdSetRenderingAttachmentLocationsKHR", vkCmdSetRenderingAttachmentLocationsKHR}, + {"vkCmdSetRenderingInputAttachmentIndicesKHR", vkCmdSetRenderingInputAttachmentIndicesKHR}, {"vkCmdSetRepresentativeFragmentTestEnableNV", vkCmdSetRepresentativeFragmentTestEnableNV}, {"vkCmdSetSampleLocationsEXT", vkCmdSetSampleLocationsEXT}, {"vkCmdSetSampleLocationsEnableEXT", vkCmdSetSampleLocationsEnableEXT}, @@ -6421,6 +6529,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetBufferOpaqueCaptureAddressKHR", vkGetBufferOpaqueCaptureAddressKHR}, {"vkGetBufferOpaqueCaptureDescriptorDataEXT", vkGetBufferOpaqueCaptureDescriptorDataEXT}, {"vkGetCalibratedTimestampsEXT", vkGetCalibratedTimestampsEXT}, + {"vkGetCalibratedTimestampsKHR", vkGetCalibratedTimestampsKHR}, {"vkGetCudaModuleCacheNV", vkGetCudaModuleCacheNV}, {"vkGetDeferredOperationMaxConcurrencyKHR", vkGetDeferredOperationMaxConcurrencyKHR}, {"vkGetDeferredOperationResultKHR", vkGetDeferredOperationResultKHR}, @@ -6564,6 +6673,7 @@ static const struct vulkan_func vk_phys_dev_dispatch_table[] = {"vkEnumerateDeviceLayerProperties", vkEnumerateDeviceLayerProperties}, {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR}, {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", vkGetPhysicalDeviceCalibrateableTimeDomainsEXT}, + {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", vkGetPhysicalDeviceCalibrateableTimeDomainsKHR}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR}, {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", vkGetPhysicalDeviceCooperativeMatrixPropertiesNV}, {"vkGetPhysicalDeviceExternalBufferProperties", vkGetPhysicalDeviceExternalBufferProperties}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index 2c54017e0c9..8b06032c637 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -3,7 +3,7 @@ * This file is generated from Vulkan vk.xml file covered * by the following copyright and permission notice: * - * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2024 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -45,9 +45,11 @@ enum unix_call unix_vkCmdBeginRendering, unix_vkCmdBeginRenderingKHR, unix_vkCmdBeginTransformFeedbackEXT, + unix_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, unix_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, unix_vkCmdBindDescriptorBuffersEXT, unix_vkCmdBindDescriptorSets, + unix_vkCmdBindDescriptorSets2KHR, unix_vkCmdBindIndexBuffer, unix_vkCmdBindIndexBuffer2KHR, unix_vkCmdBindInvocationMaskHUAWEI, @@ -146,7 +148,10 @@ enum unix_call unix_vkCmdPipelineBarrier2KHR, unix_vkCmdPreprocessGeneratedCommandsNV, unix_vkCmdPushConstants, + unix_vkCmdPushConstants2KHR, + unix_vkCmdPushDescriptorSet2KHR, unix_vkCmdPushDescriptorSetKHR, + unix_vkCmdPushDescriptorSetWithTemplate2KHR, unix_vkCmdPushDescriptorSetWithTemplateKHR, unix_vkCmdResetEvent, unix_vkCmdResetEvent2, @@ -191,6 +196,7 @@ enum unix_call unix_vkCmdSetDepthTestEnableEXT, unix_vkCmdSetDepthWriteEnable, unix_vkCmdSetDepthWriteEnableEXT, + unix_vkCmdSetDescriptorBufferOffsets2EXT, unix_vkCmdSetDescriptorBufferOffsetsEXT, unix_vkCmdSetDeviceMask, unix_vkCmdSetDeviceMaskKHR, @@ -210,6 +216,7 @@ enum unix_call unix_vkCmdSetLineRasterizationModeEXT, unix_vkCmdSetLineStippleEXT, unix_vkCmdSetLineStippleEnableEXT, + unix_vkCmdSetLineStippleKHR, unix_vkCmdSetLineWidth, unix_vkCmdSetLogicOpEXT, unix_vkCmdSetLogicOpEnableEXT, @@ -228,6 +235,8 @@ enum unix_call unix_vkCmdSetRasterizerDiscardEnable, unix_vkCmdSetRasterizerDiscardEnableEXT, unix_vkCmdSetRayTracingPipelineStackSizeKHR, + unix_vkCmdSetRenderingAttachmentLocationsKHR, + unix_vkCmdSetRenderingInputAttachmentIndicesKHR, unix_vkCmdSetRepresentativeFragmentTestEnableNV, unix_vkCmdSetSampleLocationsEXT, unix_vkCmdSetSampleLocationsEnableEXT, @@ -402,6 +411,7 @@ enum unix_call unix_vkGetBufferOpaqueCaptureAddressKHR, unix_vkGetBufferOpaqueCaptureDescriptorDataEXT, unix_vkGetCalibratedTimestampsEXT, + unix_vkGetCalibratedTimestampsKHR, unix_vkGetCudaModuleCacheNV, unix_vkGetDeferredOperationMaxConcurrencyKHR, unix_vkGetDeferredOperationResultKHR, @@ -455,6 +465,7 @@ enum unix_call unix_vkGetMicromapBuildSizesEXT, unix_vkGetPerformanceParameterINTEL, unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + unix_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, unix_vkGetPhysicalDeviceExternalBufferProperties, @@ -808,6 +819,12 @@ struct vkCmdBeginTransformFeedbackEXT_params const VkDeviceSize *pCounterBufferOffsets; }; +struct vkCmdBindDescriptorBufferEmbeddedSamplers2EXT_params +{ + VkCommandBuffer commandBuffer; + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo; +}; + struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params { VkCommandBuffer commandBuffer; @@ -835,6 +852,12 @@ struct vkCmdBindDescriptorSets_params const uint32_t *pDynamicOffsets; }; +struct vkCmdBindDescriptorSets2KHR_params +{ + VkCommandBuffer commandBuffer; + const VkBindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo; +}; + struct vkCmdBindIndexBuffer_params { VkCommandBuffer commandBuffer; @@ -1629,6 +1652,18 @@ struct vkCmdPushConstants_params const void *pValues; }; +struct vkCmdPushConstants2KHR_params +{ + VkCommandBuffer commandBuffer; + const VkPushConstantsInfoKHR *pPushConstantsInfo; +}; + +struct vkCmdPushDescriptorSet2KHR_params +{ + VkCommandBuffer commandBuffer; + const VkPushDescriptorSetInfoKHR *pPushDescriptorSetInfo; +}; + struct vkCmdPushDescriptorSetKHR_params { VkCommandBuffer commandBuffer; @@ -1639,6 +1674,12 @@ struct vkCmdPushDescriptorSetKHR_params const VkWriteDescriptorSet *pDescriptorWrites; }; +struct vkCmdPushDescriptorSetWithTemplate2KHR_params +{ + VkCommandBuffer commandBuffer; + const VkPushDescriptorSetWithTemplateInfoKHR *pPushDescriptorSetWithTemplateInfo; +}; + struct vkCmdPushDescriptorSetWithTemplateKHR_params { VkCommandBuffer commandBuffer; @@ -1931,6 +1972,12 @@ struct vkCmdSetDepthWriteEnableEXT_params VkBool32 depthWriteEnable; }; +struct vkCmdSetDescriptorBufferOffsets2EXT_params +{ + VkCommandBuffer commandBuffer; + const VkSetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo; +}; + struct vkCmdSetDescriptorBufferOffsetsEXT_params { VkCommandBuffer commandBuffer; @@ -2062,6 +2109,13 @@ struct vkCmdSetLineStippleEnableEXT_params VkBool32 stippledLineEnable; }; +struct vkCmdSetLineStippleKHR_params +{ + VkCommandBuffer commandBuffer; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +}; + struct vkCmdSetLineWidth_params { VkCommandBuffer commandBuffer; @@ -2173,6 +2227,18 @@ struct vkCmdSetRayTracingPipelineStackSizeKHR_params uint32_t pipelineStackSize; }; +struct vkCmdSetRenderingAttachmentLocationsKHR_params +{ + VkCommandBuffer commandBuffer; + const VkRenderingAttachmentLocationInfoKHR *pLocationInfo; +}; + +struct vkCmdSetRenderingInputAttachmentIndicesKHR_params +{ + VkCommandBuffer commandBuffer; + const VkRenderingInputAttachmentIndexInfoKHR *pLocationInfo; +}; + struct vkCmdSetRepresentativeFragmentTestEnableNV_params { VkCommandBuffer commandBuffer; @@ -3570,7 +3636,17 @@ struct vkGetCalibratedTimestampsEXT_params { VkDevice device; uint32_t timestampCount; - const VkCalibratedTimestampInfoEXT *pTimestampInfos; + const VkCalibratedTimestampInfoKHR *pTimestampInfos; + uint64_t *pTimestamps; + uint64_t *pMaxDeviation; + VkResult result; +}; + +struct vkGetCalibratedTimestampsKHR_params +{ + VkDevice device; + uint32_t timestampCount; + const VkCalibratedTimestampInfoKHR *pTimestampInfos; uint64_t *pTimestamps; uint64_t *pMaxDeviation; VkResult result; @@ -3974,7 +4050,15 @@ struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params { VkPhysicalDevice physicalDevice; uint32_t *pTimeDomainCount; - VkTimeDomainEXT *pTimeDomains; + VkTimeDomainKHR *pTimeDomains; + VkResult result; +}; + +struct vkGetPhysicalDeviceCalibrateableTimeDomainsKHR_params +{ + VkPhysicalDevice physicalDevice; + uint32_t *pTimeDomainCount; + VkTimeDomainKHR *pTimeDomains; VkResult result; }; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index e4a734c284b..3d5a00d6e49 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -64,7 +64,7 @@ from enum import Enum LOGGER = logging.Logger("vulkan") LOGGER.addHandler(logging.StreamHandler()) -VK_XML_VERSION = "1.3.272" +VK_XML_VERSION = "1.3.277" WINE_VK_VERSION = (1, 3) # Filenames to create. @@ -102,6 +102,7 @@ UNSUPPORTED_EXTENSIONS = [ "VK_KHR_external_semaphore_win32", # Relates to external_semaphore and needs type conversions in bitflags. "VK_KHR_shared_presentable_image", # Needs WSI work. + "VK_KHR_video_encode_queue", "VK_KHR_video_queue", # TODO Video extensions use separate headers + xml "VK_KHR_win32_keyed_mutex", "VK_NV_external_memory_rdma", # Needs shared resources work. @@ -244,11 +245,13 @@ MANUAL_UNIX_THUNKS = { "vkFreeCommandBuffers", "vkFreeMemory", "vkGetCalibratedTimestampsEXT", + "vkGetCalibratedTimestampsKHR", "vkGetDeviceProcAddr", "vkGetDeviceQueue", "vkGetDeviceQueue2", "vkGetInstanceProcAddr", "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", + "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", "vkGetPhysicalDeviceExternalBufferProperties", "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "vkGetPhysicalDeviceExternalFenceProperties", diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c index 282c17f430e..d2ef3ba8da2 100644 --- a/dlls/winevulkan/vulkan.c +++ b/dlls/winevulkan/vulkan.c @@ -1443,6 +1443,18 @@ VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice handle, uint32_t timestamp_c device->funcs.p_vkGetCalibratedTimestampsEXT); } +VkResult wine_vkGetCalibratedTimestampsKHR(VkDevice handle, uint32_t timestamp_count, + const VkCalibratedTimestampInfoKHR *timestamp_infos, + uint64_t *timestamps, uint64_t *max_deviation) +{ + struct wine_device *device = wine_device_from_handle(handle); + + TRACE("%p, %u, %p, %p, %p\n", device, timestamp_count, timestamp_infos, timestamps, max_deviation); + + return wine_vk_get_timestamps(device, timestamp_count, timestamp_infos, timestamps, max_deviation, + device->funcs.p_vkGetCalibratedTimestampsKHR); +} + VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice handle, uint32_t *time_domain_count, VkTimeDomainEXT *time_domains) @@ -1455,6 +1467,20 @@ VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice ha phys_dev->instance->funcs.p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); } +VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice handle, + uint32_t *time_domain_count, + VkTimeDomainKHR *time_domains) +{ + struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle); + + TRACE("%p, %p, %p\n", phys_dev, time_domain_count, time_domains); + + return wine_vk_get_time_domains(phys_dev, time_domain_count, time_domains, + phys_dev->instance->funcs.p_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR); +} + + + void wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice phys_dev, const VkPhysicalDeviceExternalSemaphoreInfo *info, VkExternalSemaphoreProperties *properties) diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 9cb270c9dea..7882be6ed95 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -3,7 +3,7 @@ * This file is generated from Vulkan vk.xml file covered * by the following copyright and permission notice: * - * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2024 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -213,6 +213,24 @@ typedef struct VkMultiviewPerViewAttributesInfoNVX32 VkBool32 perViewAttributesPositionXOnly; } VkMultiviewPerViewAttributesInfoNVX32; +typedef struct VkRenderingAttachmentLocationInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentLocations; +} VkRenderingAttachmentLocationInfoKHR32; + +typedef struct VkRenderingInputAttachmentIndexInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentInputIndices; + PTR32 pDepthInputAttachmentIndex; + PTR32 pStencilInputAttachmentIndex; +} VkRenderingInputAttachmentIndexInfoKHR32; + typedef struct VkCommandBufferInheritanceInfo32 { VkStructureType sType; @@ -261,6 +279,13 @@ typedef struct VkBindBufferMemoryDeviceGroupInfo32 } VkBindBufferMemoryDeviceGroupInfo32; typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32; +typedef struct VkBindMemoryStatusKHR32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pResult; +} VkBindMemoryStatusKHR32; + typedef struct VkBindBufferMemoryInfo32 { VkStructureType sType; @@ -563,6 +588,26 @@ typedef struct VkRenderingInfo32 } VkRenderingInfo32; typedef VkRenderingInfo32 VkRenderingInfoKHR32; +typedef struct VkPipelineLayoutCreateInfo32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + PTR32 pSetLayouts; + uint32_t pushConstantRangeCount; + PTR32 pPushConstantRanges; +} VkPipelineLayoutCreateInfo32; + +typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; +} VkBindDescriptorBufferEmbeddedSamplersInfoEXT32; + typedef struct VkBufferUsageFlags2CreateInfoKHR32 { VkStructureType sType; @@ -585,6 +630,19 @@ typedef struct VkDescriptorBufferBindingInfoEXT32 VkBufferUsageFlags usage; } VkDescriptorBufferBindingInfoEXT32; +typedef struct VkBindDescriptorSetsInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + PTR32 pDescriptorSets; + uint32_t dynamicOffsetCount; + PTR32 pDynamicOffsets; +} VkBindDescriptorSetsInfoKHR32; + typedef struct VkCopyCommandTransformInfoQCOM32 { VkStructureType sType; @@ -1033,6 +1091,17 @@ typedef struct VkDependencyInfo32 } VkDependencyInfo32; typedef VkDependencyInfo32 VkDependencyInfoKHR32; +typedef struct VkPushConstantsInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + PTR32 pValues; +} VkPushConstantsInfoKHR32; + typedef struct VkDescriptorImageInfo32 { VkSampler DECLSPEC_ALIGN(8) sampler; @@ -1086,6 +1155,27 @@ typedef struct VkWriteDescriptorSet32 PTR32 pTexelBufferView; } VkWriteDescriptorSet32; +typedef struct VkPushDescriptorSetInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; + uint32_t descriptorWriteCount; + PTR32 pDescriptorWrites; +} VkPushDescriptorSetInfoKHR32; + +typedef struct VkPushDescriptorSetWithTemplateInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; + PTR32 pData; +} VkPushDescriptorSetWithTemplateInfoKHR32; + typedef struct VkImageResolve232 { VkStructureType sType; @@ -1136,6 +1226,18 @@ typedef struct VkDepthBiasInfoEXT32 float depthBiasSlopeFactor; } VkDepthBiasInfoEXT32; +typedef struct VkSetDescriptorBufferOffsetsInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t firstSet; + uint32_t setCount; + PTR32 pBufferIndices; + PTR32 pOffsets; +} VkSetDescriptorBufferOffsetsInfoEXT32; + typedef struct VkPerformanceMarkerInfoINTEL32 { VkStructureType sType; @@ -1795,6 +1897,13 @@ typedef struct VkPhysicalDeviceMaintenance5FeaturesKHR32 VkBool32 maintenance5; } VkPhysicalDeviceMaintenance5FeaturesKHR32; +typedef struct VkPhysicalDeviceMaintenance6FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 maintenance6; +} VkPhysicalDeviceMaintenance6FeaturesKHR32; + typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32 { VkStructureType sType; @@ -1937,13 +2046,14 @@ typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 VkBool32 sparseImageFloat32AtomicMinMax; } VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32; -typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32 { VkStructureType sType; PTR32 pNext; VkBool32 vertexAttributeInstanceRateDivisor; VkBool32 vertexAttributeInstanceRateZeroDivisor; -} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32; +typedef VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32; typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32 { @@ -2250,12 +2360,13 @@ typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32 VkBool32 shaderDeviceClock; } VkPhysicalDeviceShaderClockFeaturesKHR32; -typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 +typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesKHR32 { VkStructureType sType; PTR32 pNext; VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8FeaturesEXT32; +} VkPhysicalDeviceIndexTypeUint8FeaturesKHR32; +typedef VkPhysicalDeviceIndexTypeUint8FeaturesKHR32 VkPhysicalDeviceIndexTypeUint8FeaturesEXT32; typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 { @@ -2320,7 +2431,7 @@ typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32 } VkPhysicalDeviceSubgroupSizeControlFeatures32; typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32; -typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32 +typedef struct VkPhysicalDeviceLineRasterizationFeaturesKHR32 { VkStructureType sType; PTR32 pNext; @@ -2330,7 +2441,8 @@ typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32 VkBool32 stippledRectangularLines; VkBool32 stippledBresenhamLines; VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeaturesEXT32; +} VkPhysicalDeviceLineRasterizationFeaturesKHR32; +typedef VkPhysicalDeviceLineRasterizationFeaturesKHR32 VkPhysicalDeviceLineRasterizationFeaturesEXT32; typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32 { @@ -3091,6 +3203,14 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 VkBool32 descriptorPoolOverallocation; } VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32; +typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 perStageDescriptorSet; + VkBool32 dynamicPipelineLayout; +} VkPhysicalDevicePerStageDescriptorSetFeaturesNV32; + typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV32 { VkStructureType sType; @@ -3112,6 +3232,49 @@ typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 VkBool32 relaxedLineRasterization; } VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32; +typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderMaximalReconvergence; +} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32; + +typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; +} VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32; + +typedef struct VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderExpectAssume; +} VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32; + +typedef struct VkPhysicalDeviceShaderFloatControls2FeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderFloatControls2; +} VkPhysicalDeviceShaderFloatControls2FeaturesKHR32; + +typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 dynamicRenderingLocalRead; +} VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32; + +typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderQuadControl; +} VkPhysicalDeviceShaderQuadControlFeaturesKHR32; + typedef struct VkDeviceCreateInfo32 { VkStructureType sType; @@ -3184,13 +3347,14 @@ typedef struct VkFramebufferCreateInfo32 uint32_t layers; } VkFramebufferCreateInfo32; -typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT32 +typedef struct VkPipelineVertexInputDivisorStateCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; uint32_t vertexBindingDivisorCount; PTR32 pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfoEXT32; +} VkPipelineVertexInputDivisorStateCreateInfoKHR32; +typedef VkPipelineVertexInputDivisorStateCreateInfoKHR32 VkPipelineVertexInputDivisorStateCreateInfoEXT32; typedef struct VkPipelineVertexInputStateCreateInfo32 { @@ -3332,15 +3496,16 @@ typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32 VkBool32 depthClipEnable; } VkPipelineRasterizationDepthClipStateCreateInfoEXT32; -typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32 +typedef struct VkPipelineRasterizationLineStateCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkLineRasterizationModeEXT lineRasterizationMode; + VkLineRasterizationModeKHR lineRasterizationMode; VkBool32 stippledLineEnable; uint32_t lineStippleFactor; uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfoEXT32; +} VkPipelineRasterizationLineStateCreateInfoKHR32; +typedef VkPipelineRasterizationLineStateCreateInfoKHR32 VkPipelineRasterizationLineStateCreateInfoEXT32; typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 { @@ -3830,17 +3995,6 @@ typedef struct VkPipelineCacheCreateInfo32 PTR32 pInitialData; } VkPipelineCacheCreateInfo32; -typedef struct VkPipelineLayoutCreateInfo32 -{ - VkStructureType sType; - PTR32 pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - PTR32 pSetLayouts; - uint32_t pushConstantRangeCount; - PTR32 pPushConstantRanges; -} VkPipelineLayoutCreateInfo32; - typedef struct VkPrivateDataSlotCreateInfo32 { VkStructureType sType; @@ -4478,12 +4632,13 @@ typedef struct VkBufferCaptureDescriptorDataInfoEXT32 VkBuffer DECLSPEC_ALIGN(8) buffer; } VkBufferCaptureDescriptorDataInfoEXT32; -typedef struct VkCalibratedTimestampInfoEXT32 +typedef struct VkCalibratedTimestampInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkTimeDomainEXT timeDomain; -} VkCalibratedTimestampInfoEXT32; + VkTimeDomainKHR timeDomain; +} VkCalibratedTimestampInfoKHR32; +typedef VkCalibratedTimestampInfoKHR32 VkCalibratedTimestampInfoEXT32; typedef struct VkDescriptorAddressInfoEXT32 { @@ -5367,6 +5522,15 @@ typedef struct VkPhysicalDeviceMaintenance5PropertiesKHR32 VkBool32 nonStrictWideLinesUseParallelogram; } VkPhysicalDeviceMaintenance5PropertiesKHR32; +typedef struct VkPhysicalDeviceMaintenance6PropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; +} VkPhysicalDeviceMaintenance6PropertiesKHR32; + typedef struct VkPhysicalDeviceFloatControlsProperties32 { VkStructureType sType; @@ -5486,6 +5650,14 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 uint32_t maxVertexAttribDivisor; } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32; +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR32; + typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32 { VkStructureType sType; @@ -5729,12 +5901,13 @@ typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment; } VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32; -typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT32 +typedef struct VkPhysicalDeviceLineRasterizationPropertiesKHR32 { VkStructureType sType; PTR32 pNext; uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationPropertiesEXT32; +} VkPhysicalDeviceLineRasterizationPropertiesKHR32; +typedef VkPhysicalDeviceLineRasterizationPropertiesKHR32 VkPhysicalDeviceLineRasterizationPropertiesEXT32; typedef struct VkPhysicalDeviceVulkan11Properties32 { @@ -7184,6 +7357,32 @@ static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: + { + VkRenderingAttachmentLocationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingAttachmentLocationInfoKHR32 *in_ext = (const VkRenderingAttachmentLocationInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentLocations = (const uint32_t *)UlongToPtr(in_ext->pColorAttachmentLocations); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: + { + VkRenderingInputAttachmentIndexInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingInputAttachmentIndexInfoKHR32 *in_ext = (const VkRenderingInputAttachmentIndexInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentInputIndices = (const uint32_t *)UlongToPtr(in_ext->pColorAttachmentInputIndices); + out_ext->pDepthInputAttachmentIndex = (const uint32_t *)UlongToPtr(in_ext->pDepthInputAttachmentIndex); + out_ext->pStencilInputAttachmentIndex = (const uint32_t *)UlongToPtr(in_ext->pStencilInputAttachmentIndex); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -7347,6 +7546,17 @@ static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversio out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + { + VkBindMemoryStatusKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBindMemoryStatusKHR32 *in_ext = (const VkBindMemoryStatusKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR; + out_ext->pNext = NULL; + out_ext->pResult = (VkResult *)UlongToPtr(in_ext->pResult); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -7455,6 +7665,17 @@ static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + { + VkBindMemoryStatusKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBindMemoryStatusKHR32 *in_ext = (const VkBindMemoryStatusKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR; + out_ext->pNext = NULL; + out_ext->pResult = (VkResult *)UlongToPtr(in_ext->pResult); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -8051,6 +8272,45 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte } } +static inline void convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 *in, VkBindDescriptorBufferEmbeddedSamplersInfoEXT *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->stageFlags = in->stageFlags; + out->layout = in->layout; + out->set = in->set; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->setLayoutCount = in_ext->setLayoutCount; + out_ext->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in_ext->pSetLayouts); + out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount; + out_ext->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in_ext->pPushConstantRanges); + 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_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out) { const VkBaseInStructure32 *in_header; @@ -8112,6 +8372,49 @@ static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBuffer return out; } +static inline void convert_VkBindDescriptorSetsInfoKHR_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorSetsInfoKHR32 *in, VkBindDescriptorSetsInfoKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->stageFlags = in->stageFlags; + out->layout = in->layout; + out->firstSet = in->firstSet; + out->descriptorSetCount = in->descriptorSetCount; + out->pDescriptorSets = (const VkDescriptorSet *)UlongToPtr(in->pDescriptorSets); + out->dynamicOffsetCount = in->dynamicOffsetCount; + out->pDynamicOffsets = (const uint32_t *)UlongToPtr(in->pDynamicOffsets); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->setLayoutCount = in_ext->setLayoutCount; + out_ext->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in_ext->pSetLayouts); + out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount; + out_ext->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in_ext->pPushConstantRanges); + 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_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out) { const VkBaseInStructure32 *in_header; @@ -9134,6 +9437,47 @@ static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_cont FIXME("Unexpected pNext\n"); } +static inline void convert_VkPushConstantsInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPushConstantsInfoKHR32 *in, VkPushConstantsInfoKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->layout = in->layout; + out->stageFlags = in->stageFlags; + out->offset = in->offset; + out->size = in->size; + out->pValues = (const void *)UlongToPtr(in->pValues); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->setLayoutCount = in_ext->setLayoutCount; + out_ext->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in_ext->pSetLayouts); + out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount; + out_ext->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in_ext->pPushConstantRanges); + 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_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out) { if (!in) return; @@ -9265,6 +9609,87 @@ static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win return out; } +static inline void convert_VkPushDescriptorSetInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetInfoKHR32 *in, VkPushDescriptorSetInfoKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->stageFlags = in->stageFlags; + out->layout = in->layout; + out->set = in->set; + out->descriptorWriteCount = in->descriptorWriteCount; + out->pDescriptorWrites = convert_VkWriteDescriptorSet_array_win32_to_host(ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(in->pDescriptorWrites), in->descriptorWriteCount); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->setLayoutCount = in_ext->setLayoutCount; + out_ext->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in_ext->pSetLayouts); + out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount; + out_ext->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in_ext->pPushConstantRanges); + 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_VkPushDescriptorSetWithTemplateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetWithTemplateInfoKHR32 *in, VkPushDescriptorSetWithTemplateInfoKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->descriptorUpdateTemplate = in->descriptorUpdateTemplate; + out->layout = in->layout; + out->set = in->set; + out->pData = (const void *)UlongToPtr(in->pData); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->setLayoutCount = in_ext->setLayoutCount; + out_ext->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in_ext->pSetLayouts); + out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount; + out_ext->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in_ext->pPushConstantRanges); + 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_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out) { if (!in) return; @@ -9374,6 +9799,48 @@ static inline void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_co } } +static inline void convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkSetDescriptorBufferOffsetsInfoEXT32 *in, VkSetDescriptorBufferOffsetsInfoEXT *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->stageFlags = in->stageFlags; + out->layout = in->layout; + out->firstSet = in->firstSet; + out->setCount = in->setCount; + out->pBufferIndices = (const uint32_t *)UlongToPtr(in->pBufferIndices); + out->pOffsets = (const VkDeviceSize *)UlongToPtr(in->pOffsets); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + VkPipelineLayoutCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLayoutCreateInfo32 *in_ext = (const VkPipelineLayoutCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->setLayoutCount = in_ext->setLayoutCount; + out_ext->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in_ext->pSetLayouts); + out_ext->pushConstantRangeCount = in_ext->pushConstantRangeCount; + out_ext->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in_ext->pPushConstantRanges); + 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_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out) { if (!in) return; @@ -9409,6 +9876,32 @@ static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(cons FIXME("Unexpected pNext\n"); } +static inline void convert_VkRenderingAttachmentLocationInfoKHR_win32_to_host(const VkRenderingAttachmentLocationInfoKHR32 *in, VkRenderingAttachmentLocationInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->colorAttachmentCount = in->colorAttachmentCount; + out->pColorAttachmentLocations = (const uint32_t *)UlongToPtr(in->pColorAttachmentLocations); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkRenderingInputAttachmentIndexInfoKHR_win32_to_host(const VkRenderingInputAttachmentIndexInfoKHR32 *in, VkRenderingInputAttachmentIndexInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->colorAttachmentCount = in->colorAttachmentCount; + out->pColorAttachmentInputIndices = (const uint32_t *)UlongToPtr(in->pColorAttachmentInputIndices); + out->pDepthInputAttachmentIndex = (const uint32_t *)UlongToPtr(in->pDepthInputAttachmentIndex); + out->pStencilInputAttachmentIndex = (const uint32_t *)UlongToPtr(in->pStencilInputAttachmentIndex); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out) { if (!in) return; @@ -10940,6 +11433,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance6FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance6FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance6FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->maintenance6 = in_ext->maintenance6; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -11120,11 +11624,11 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; out_ext->pNext = NULL; out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; @@ -11587,11 +12091,11 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: { - VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; + VkPhysicalDeviceIndexTypeUint8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; out_ext->pNext = NULL; out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header->pNext = (void *)out_ext; @@ -11690,11 +12194,11 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: { - VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; + VkPhysicalDeviceLineRasterizationFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLineRasterizationFeaturesKHR *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; out_ext->pNext = NULL; out_ext->rectangularLines = in_ext->rectangularLines; out_ext->bresenhamLines = in_ext->bresenhamLines; @@ -12803,6 +13307,18 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + { + VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: { VkPhysicalDeviceCudaKernelLaunchFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -12847,6 +13363,73 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + { + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + { + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + { + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + { + VkPhysicalDeviceShaderFloatControls2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: + { + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + { + VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -13098,6 +13681,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance6FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance6FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance6FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->maintenance6 = in_ext->maintenance6; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -13278,11 +13872,11 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; out_ext->pNext = NULL; out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; @@ -13745,11 +14339,11 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: { - VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; + VkPhysicalDeviceIndexTypeUint8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceIndexTypeUint8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; out_ext->pNext = NULL; out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header->pNext = (void *)out_ext; @@ -13848,11 +14442,11 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: { - VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; + VkPhysicalDeviceLineRasterizationFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLineRasterizationFeaturesKHR32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; out_ext->pNext = NULL; out_ext->rectangularLines = in_ext->rectangularLines; out_ext->bresenhamLines = in_ext->bresenhamLines; @@ -14961,6 +15555,18 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + { + VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: { VkPhysicalDeviceCudaKernelLaunchFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15005,6 +15611,73 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + { + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + { + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + { + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + { + VkPhysicalDeviceShaderFloatControls2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloatControls2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: + { + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + { + VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -15182,14 +15855,14 @@ static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(st { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: { - VkPipelineVertexInputDivisorStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT; + VkPipelineVertexInputDivisorStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineVertexInputDivisorStateCreateInfoKHR32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR; out_ext->pNext = NULL; out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount; - out_ext->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionEXT *)UlongToPtr(in_ext->pVertexBindingDivisors); + out_ext->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionKHR *)UlongToPtr(in_ext->pVertexBindingDivisors); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -15548,11 +16221,11 @@ static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host( out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: { - VkPipelineRasterizationLineStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationLineStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT; + VkPipelineRasterizationLineStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationLineStateCreateInfoKHR32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR; out_ext->pNext = NULL; out_ext->lineRasterizationMode = in_ext->lineRasterizationMode; out_ext->stippledLineEnable = in_ext->stippledLineEnable; @@ -16045,6 +16718,32 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: + { + VkRenderingAttachmentLocationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingAttachmentLocationInfoKHR *in_ext = (const VkRenderingAttachmentLocationInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentLocations = in_ext->pColorAttachmentLocations; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: + { + VkRenderingInputAttachmentIndexInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingInputAttachmentIndexInfoKHR *in_ext = (const VkRenderingInputAttachmentIndexInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentInputIndices = in_ext->pColorAttachmentInputIndices; + out_ext->pDepthInputAttachmentIndex = in_ext->pDepthInputAttachmentIndex; + out_ext->pStencilInputAttachmentIndex = in_ext->pStencilInputAttachmentIndex; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -16260,6 +16959,32 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: + { + VkRenderingAttachmentLocationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingAttachmentLocationInfoKHR32 *in_ext = (const VkRenderingAttachmentLocationInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentLocations = (const uint32_t *)UlongToPtr(in_ext->pColorAttachmentLocations); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: + { + VkRenderingInputAttachmentIndexInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingInputAttachmentIndexInfoKHR32 *in_ext = (const VkRenderingInputAttachmentIndexInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentInputIndices = (const uint32_t *)UlongToPtr(in_ext->pColorAttachmentInputIndices); + out_ext->pDepthInputAttachmentIndex = (const uint32_t *)UlongToPtr(in_ext->pDepthInputAttachmentIndex); + out_ext->pStencilInputAttachmentIndex = (const uint32_t *)UlongToPtr(in_ext->pStencilInputAttachmentIndex); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -18653,9 +19378,6 @@ static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_hos out->sType = in->sType; out->pNext = NULL; - out->accelerationStructureSize = in->accelerationStructureSize; - out->updateScratchSize = in->updateScratchSize; - out->buildScratchSize = in->buildScratchSize; if (in->pNext) FIXME("Unexpected pNext\n"); } @@ -18822,7 +19544,7 @@ static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(co FIXME("Unexpected pNext\n"); } -static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCalibratedTimestampInfoEXT32 *in, VkCalibratedTimestampInfoEXT *out) +static inline void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCalibratedTimestampInfoKHR32 *in, VkCalibratedTimestampInfoKHR *out) { if (!in) return; @@ -18833,9 +19555,9 @@ static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCa FIXME("Unexpected pNext\n"); } -static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoEXT32 *in, uint32_t count) +static inline const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR32 *in, uint32_t count) { - VkCalibratedTimestampInfoEXT *out; + VkCalibratedTimestampInfoKHR *out; unsigned int i; if (!in || !count) return NULL; @@ -18843,7 +19565,7 @@ static inline const VkCalibratedTimestampInfoEXT *convert_VkCalibratedTimestampI out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkCalibratedTimestampInfoEXT_win32_to_host(&in[i], &out[i]); + convert_VkCalibratedTimestampInfoKHR_win32_to_host(&in[i], &out[i]); } return out; @@ -19164,10 +19886,8 @@ static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_ out->sType = in->sType; out->pNext = NULL; - memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1); out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1); - out->pVendorBinaryData = (void *)UlongToPtr(in->pVendorBinaryData); if (in->pNext) FIXME("Unexpected pNext\n"); } @@ -19816,15 +20536,6 @@ static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const out->sType = in->sType; out->pNext = NULL; - out->MSize = in->MSize; - out->NSize = in->NSize; - out->KSize = in->KSize; - out->AType = in->AType; - out->BType = in->BType; - out->CType = in->CType; - out->ResultType = in->ResultType; - out->saturatingAccumulation = in->saturatingAccumulation; - out->scope = in->scope; if (in->pNext) FIXME("Unexpected pNext\n"); } @@ -20259,6 +20970,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance6FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance6FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance6FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->maintenance6 = in_ext->maintenance6; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -20439,11 +21161,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; out_ext->pNext = NULL; out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; @@ -20884,11 +21606,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: { - VkPhysicalDeviceIndexTypeUint8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; + VkPhysicalDeviceIndexTypeUint8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceIndexTypeUint8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; out_ext->pNext = NULL; out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header->pNext = (void *)out_ext; @@ -20987,11 +21709,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: { - VkPhysicalDeviceLineRasterizationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; + VkPhysicalDeviceLineRasterizationFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLineRasterizationFeaturesKHR32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; out_ext->pNext = NULL; out_ext->rectangularLines = in_ext->rectangularLines; out_ext->bresenhamLines = in_ext->bresenhamLines; @@ -22089,6 +22811,18 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + { + VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: { VkPhysicalDeviceCudaKernelLaunchFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22122,6 +22856,73 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + { + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + { + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + { + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + { + VkPhysicalDeviceShaderFloatControls2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloatControls2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: + { + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + { + VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -22295,6 +23096,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + { + VkPhysicalDeviceMaintenance6FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR); + const VkPhysicalDeviceMaintenance6FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance6FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; + out_ext->maintenance6 = in_ext->maintenance6; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES); @@ -22451,11 +23261,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT); - const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR); + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; out_header = (void *)out_ext; @@ -22820,11 +23630,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: { - VkPhysicalDeviceIndexTypeUint8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT); - const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; + VkPhysicalDeviceIndexTypeUint8FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR); + const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *in_ext = (const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header = (void *)out_ext; break; @@ -22905,11 +23715,11 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: { - VkPhysicalDeviceLineRasterizationFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT); - const VkPhysicalDeviceLineRasterizationFeaturesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; + VkPhysicalDeviceLineRasterizationFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR); + const VkPhysicalDeviceLineRasterizationFeaturesKHR *in_ext = (const VkPhysicalDeviceLineRasterizationFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; out_ext->rectangularLines = in_ext->rectangularLines; out_ext->bresenhamLines = in_ext->bresenhamLines; out_ext->smoothLines = in_ext->smoothLines; @@ -23833,6 +24643,16 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + { + VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: { VkPhysicalDeviceCudaKernelLaunchFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV); @@ -23860,6 +24680,61 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + { + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + { + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR); + const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + { + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR); + const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + { + VkPhysicalDeviceShaderFloatControls2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR); + const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: + { + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR); + const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + { + VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; + out_header = (void *)out_ext; + break; + } default: break; } @@ -24703,6 +25578,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + { + VkPhysicalDeviceMaintenance6PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24775,6 +25659,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + { + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: { VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24964,10 +25857,10 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: { - VkPhysicalDeviceLineRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT; + VkPhysicalDeviceLineRasterizationPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -25491,6 +26384,17 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + { + VkPhysicalDeviceMaintenance6PropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR); + const VkPhysicalDeviceMaintenance6PropertiesKHR *in_ext = (const VkPhysicalDeviceMaintenance6PropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR; + out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers; + out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount; + out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { VkPhysicalDeviceFloatControlsProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES); @@ -25623,6 +26527,16 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + { + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR); + const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; + out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor; + out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: { VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT); @@ -25905,11 +26819,11 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: { - VkPhysicalDeviceLineRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT); - const VkPhysicalDeviceLineRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT; + VkPhysicalDeviceLineRasterizationPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR); + const VkPhysicalDeviceLineRasterizationPropertiesKHR *in_ext = (const VkPhysicalDeviceLineRasterizationPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR; out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits; out_header = (void *)out_ext; break; @@ -29536,6 +30450,32 @@ static void thunk32_vkCmdBeginTransformFeedbackEXT(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->firstCounterBuffer, params->counterBufferCount, (const VkBuffer *)UlongToPtr(params->pCounterBuffers), (const VkDeviceSize *)UlongToPtr(params->pCounterBufferOffsets)); } +#ifdef _WIN64 +static void thunk64_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(void *args) +{ + struct vkCmdBindDescriptorBufferEmbeddedSamplers2EXT_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pBindDescriptorBufferEmbeddedSamplersInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pBindDescriptorBufferEmbeddedSamplersInfo; + } *params = args; + VkBindDescriptorBufferEmbeddedSamplersInfoEXT pBindDescriptorBufferEmbeddedSamplersInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_to_host(ctx, (const VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 *)UlongToPtr(params->pBindDescriptorBufferEmbeddedSamplersInfo), &pBindDescriptorBufferEmbeddedSamplersInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pBindDescriptorBufferEmbeddedSamplersInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args) { @@ -29611,6 +30551,32 @@ static void thunk32_vkCmdBindDescriptorSets(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, (const VkDescriptorSet *)UlongToPtr(params->pDescriptorSets), params->dynamicOffsetCount, (const uint32_t *)UlongToPtr(params->pDynamicOffsets)); } +#ifdef _WIN64 +static void thunk64_vkCmdBindDescriptorSets2KHR(void *args) +{ + struct vkCmdBindDescriptorSets2KHR_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorSets2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pBindDescriptorSetsInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdBindDescriptorSets2KHR(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pBindDescriptorSetsInfo; + } *params = args; + VkBindDescriptorSetsInfoKHR pBindDescriptorSetsInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkBindDescriptorSetsInfoKHR_win32_to_host(ctx, (const VkBindDescriptorSetsInfoKHR32 *)UlongToPtr(params->pBindDescriptorSetsInfo), &pBindDescriptorSetsInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorSets2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pBindDescriptorSetsInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdBindIndexBuffer(void *args) { @@ -31983,6 +32949,58 @@ static void thunk32_vkCmdPushConstants(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->layout, params->stageFlags, params->offset, params->size, (const void *)UlongToPtr(params->pValues)); } +#ifdef _WIN64 +static void thunk64_vkCmdPushConstants2KHR(void *args) +{ + struct vkCmdPushConstants2KHR_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushConstants2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pPushConstantsInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdPushConstants2KHR(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pPushConstantsInfo; + } *params = args; + VkPushConstantsInfoKHR pPushConstantsInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkPushConstantsInfoKHR_win32_to_host(ctx, (const VkPushConstantsInfoKHR32 *)UlongToPtr(params->pPushConstantsInfo), &pPushConstantsInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushConstants2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pPushConstantsInfo_host); + free_conversion_context(ctx); +} + +#ifdef _WIN64 +static void thunk64_vkCmdPushDescriptorSet2KHR(void *args) +{ + struct vkCmdPushDescriptorSet2KHR_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSet2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pPushDescriptorSetInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdPushDescriptorSet2KHR(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pPushDescriptorSetInfo; + } *params = args; + VkPushDescriptorSetInfoKHR pPushDescriptorSetInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkPushDescriptorSetInfoKHR_win32_to_host(ctx, (const VkPushDescriptorSetInfoKHR32 *)UlongToPtr(params->pPushDescriptorSetInfo), &pPushDescriptorSetInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSet2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pPushDescriptorSetInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdPushDescriptorSetKHR(void *args) { @@ -32013,6 +33031,32 @@ static void thunk32_vkCmdPushDescriptorSetKHR(void *args) free_conversion_context(ctx); } +#ifdef _WIN64 +static void thunk64_vkCmdPushDescriptorSetWithTemplate2KHR(void *args) +{ + struct vkCmdPushDescriptorSetWithTemplate2KHR_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetWithTemplate2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pPushDescriptorSetWithTemplateInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdPushDescriptorSetWithTemplate2KHR(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pPushDescriptorSetWithTemplateInfo; + } *params = args; + VkPushDescriptorSetWithTemplateInfoKHR pPushDescriptorSetWithTemplateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkPushDescriptorSetWithTemplateInfoKHR_win32_to_host(ctx, (const VkPushDescriptorSetWithTemplateInfoKHR32 *)UlongToPtr(params->pPushDescriptorSetWithTemplateInfo), &pPushDescriptorSetWithTemplateInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetWithTemplate2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pPushDescriptorSetWithTemplateInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args) { @@ -32945,6 +33989,32 @@ static void thunk32_vkCmdSetDepthWriteEnableEXT(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->depthWriteEnable); } +#ifdef _WIN64 +static void thunk64_vkCmdSetDescriptorBufferOffsets2EXT(void *args) +{ + struct vkCmdSetDescriptorBufferOffsets2EXT_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDescriptorBufferOffsets2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pSetDescriptorBufferOffsetsInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdSetDescriptorBufferOffsets2EXT(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pSetDescriptorBufferOffsetsInfo; + } *params = args; + VkSetDescriptorBufferOffsetsInfoEXT pSetDescriptorBufferOffsetsInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + init_conversion_context(ctx); + convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(ctx, (const VkSetDescriptorBufferOffsetsInfoEXT32 *)UlongToPtr(params->pSetDescriptorBufferOffsetsInfo), &pSetDescriptorBufferOffsetsInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDescriptorBufferOffsets2EXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pSetDescriptorBufferOffsetsInfo_host); + free_conversion_context(ctx); +} + #ifdef _WIN64 static void thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args) { @@ -33354,6 +34424,27 @@ static void thunk32_vkCmdSetLineStippleEnableEXT(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->stippledLineEnable); } +#ifdef _WIN64 +static void thunk64_vkCmdSetLineStippleKHR(void *args) +{ + struct vkCmdSetLineStippleKHR_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->lineStippleFactor, params->lineStipplePattern); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdSetLineStippleKHR(void *args) +{ + struct + { + PTR32 commandBuffer; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; + } *params = args; + + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->lineStippleFactor, params->lineStipplePattern); +} + #ifdef _WIN64 static void thunk64_vkCmdSetLineWidth(void *args) { @@ -33741,6 +34832,50 @@ static void thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, params->pipelineStackSize); } +#ifdef _WIN64 +static void thunk64_vkCmdSetRenderingAttachmentLocationsKHR(void *args) +{ + struct vkCmdSetRenderingAttachmentLocationsKHR_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRenderingAttachmentLocationsKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pLocationInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdSetRenderingAttachmentLocationsKHR(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pLocationInfo; + } *params = args; + VkRenderingAttachmentLocationInfoKHR pLocationInfo_host; + + convert_VkRenderingAttachmentLocationInfoKHR_win32_to_host((const VkRenderingAttachmentLocationInfoKHR32 *)UlongToPtr(params->pLocationInfo), &pLocationInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRenderingAttachmentLocationsKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pLocationInfo_host); +} + +#ifdef _WIN64 +static void thunk64_vkCmdSetRenderingInputAttachmentIndicesKHR(void *args) +{ + struct vkCmdSetRenderingInputAttachmentIndicesKHR_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRenderingInputAttachmentIndicesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pLocationInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdSetRenderingInputAttachmentIndicesKHR(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pLocationInfo; + } *params = args; + VkRenderingInputAttachmentIndexInfoKHR pLocationInfo_host; + + convert_VkRenderingInputAttachmentIndexInfoKHR_win32_to_host((const VkRenderingInputAttachmentIndexInfoKHR32 *)UlongToPtr(params->pLocationInfo), &pLocationInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRenderingInputAttachmentIndicesKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pLocationInfo_host); +} + #ifdef _WIN64 static void thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args) { @@ -38840,19 +39975,55 @@ static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args) PTR32 pMaxDeviation; VkResult result; } *params = args; - const VkCalibratedTimestampInfoEXT *pTimestampInfos_host; + const VkCalibratedTimestampInfoKHR *pTimestampInfos_host; struct conversion_context local_ctx; struct conversion_context *ctx = &local_ctx; TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation); init_conversion_context(ctx); - pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(ctx, (const VkCalibratedTimestampInfoEXT32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount); + pTimestampInfos_host = convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(ctx, (const VkCalibratedTimestampInfoKHR32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount); params->result = wine_vkGetCalibratedTimestampsEXT((VkDevice)UlongToPtr(params->device), params->timestampCount, pTimestampInfos_host, (uint64_t *)UlongToPtr(params->pTimestamps), (uint64_t *)UlongToPtr(params->pMaxDeviation)); free_conversion_context(ctx); return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetCalibratedTimestampsKHR(void *args) +{ + struct vkGetCalibratedTimestampsKHR_params *params = args; + + TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation); + + params->result = wine_vkGetCalibratedTimestampsKHR(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetCalibratedTimestampsKHR(void *args) +{ + struct + { + PTR32 device; + uint32_t timestampCount; + PTR32 pTimestampInfos; + PTR32 pTimestamps; + PTR32 pMaxDeviation; + VkResult result; + } *params = args; + const VkCalibratedTimestampInfoKHR *pTimestampInfos_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation); + + init_conversion_context(ctx); + pTimestampInfos_host = convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(ctx, (const VkCalibratedTimestampInfoKHR32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount); + params->result = wine_vkGetCalibratedTimestampsKHR((VkDevice)UlongToPtr(params->device), params->timestampCount, pTimestampInfos_host, (uint64_t *)UlongToPtr(params->pTimestamps), (uint64_t *)UlongToPtr(params->pMaxDeviation)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetCudaModuleCacheNV(void *args) { @@ -40558,7 +41729,35 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *arg TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains); - params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainEXT *)UlongToPtr(params->pTimeDomains)); + params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainKHR *)UlongToPtr(params->pTimeDomains)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(void *args) +{ + struct vkGetPhysicalDeviceCalibrateableTimeDomainsKHR_params *params = args; + + TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains); + + params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(void *args) +{ + struct + { + PTR32 physicalDevice; + PTR32 pTimeDomainCount; + PTR32 pTimeDomains; + VkResult result; + } *params = args; + + TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains); + + params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainKHR *)UlongToPtr(params->pTimeDomains)); return STATUS_SUCCESS; } @@ -44671,6 +45870,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_acceleration_structure", "VK_KHR_bind_memory2", "VK_KHR_buffer_device_address", + "VK_KHR_calibrated_timestamps", "VK_KHR_cooperative_matrix", "VK_KHR_copy_commands2", "VK_KHR_create_renderpass2", @@ -44682,6 +45882,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_draw_indirect_count", "VK_KHR_driver_properties", "VK_KHR_dynamic_rendering", + "VK_KHR_dynamic_rendering_local_read", "VK_KHR_external_fence", "VK_KHR_external_memory", "VK_KHR_external_semaphore", @@ -44693,11 +45894,15 @@ static const char * const vk_device_extensions[] = "VK_KHR_image_format_list", "VK_KHR_imageless_framebuffer", "VK_KHR_incremental_present", + "VK_KHR_index_type_uint8", + "VK_KHR_line_rasterization", + "VK_KHR_load_store_op_none", "VK_KHR_maintenance1", "VK_KHR_maintenance2", "VK_KHR_maintenance3", "VK_KHR_maintenance4", "VK_KHR_maintenance5", + "VK_KHR_maintenance6", "VK_KHR_map_memory2", "VK_KHR_multiview", "VK_KHR_performance_query", @@ -44717,11 +45922,16 @@ static const char * const vk_device_extensions[] = "VK_KHR_shader_atomic_int64", "VK_KHR_shader_clock", "VK_KHR_shader_draw_parameters", + "VK_KHR_shader_expect_assume", "VK_KHR_shader_float16_int8", "VK_KHR_shader_float_controls", + "VK_KHR_shader_float_controls2", "VK_KHR_shader_integer_dot_product", + "VK_KHR_shader_maximal_reconvergence", "VK_KHR_shader_non_semantic_info", + "VK_KHR_shader_quad_control", "VK_KHR_shader_subgroup_extended_types", + "VK_KHR_shader_subgroup_rotate", "VK_KHR_shader_subgroup_uniform_control_flow", "VK_KHR_shader_terminate_invocation", "VK_KHR_spirv_1_4", @@ -44732,6 +45942,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_timeline_semaphore", "VK_KHR_uniform_buffer_standard_layout", "VK_KHR_variable_pointers", + "VK_KHR_vertex_attribute_divisor", "VK_KHR_vulkan_memory_model", "VK_KHR_workgroup_memory_explicit_layout", "VK_KHR_zero_initialize_workgroup_memory", @@ -44767,6 +45978,7 @@ static const char * const vk_device_extensions[] = "VK_NV_memory_decompression", "VK_NV_mesh_shader", "VK_NV_optical_flow", + "VK_NV_per_stage_descriptor_set", "VK_NV_present_barrier", "VK_NV_ray_tracing", "VK_NV_ray_tracing_invocation_reorder", @@ -44890,9 +46102,11 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdBeginRendering, (void *)thunk64_vkCmdBeginRenderingKHR, (void *)thunk64_vkCmdBeginTransformFeedbackEXT, + (void *)thunk64_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, (void *)thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, (void *)thunk64_vkCmdBindDescriptorBuffersEXT, (void *)thunk64_vkCmdBindDescriptorSets, + (void *)thunk64_vkCmdBindDescriptorSets2KHR, (void *)thunk64_vkCmdBindIndexBuffer, (void *)thunk64_vkCmdBindIndexBuffer2KHR, (void *)thunk64_vkCmdBindInvocationMaskHUAWEI, @@ -44991,7 +46205,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdPipelineBarrier2KHR, (void *)thunk64_vkCmdPreprocessGeneratedCommandsNV, (void *)thunk64_vkCmdPushConstants, + (void *)thunk64_vkCmdPushConstants2KHR, + (void *)thunk64_vkCmdPushDescriptorSet2KHR, (void *)thunk64_vkCmdPushDescriptorSetKHR, + (void *)thunk64_vkCmdPushDescriptorSetWithTemplate2KHR, (void *)thunk64_vkCmdPushDescriptorSetWithTemplateKHR, (void *)thunk64_vkCmdResetEvent, (void *)thunk64_vkCmdResetEvent2, @@ -45036,6 +46253,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdSetDepthTestEnableEXT, (void *)thunk64_vkCmdSetDepthWriteEnable, (void *)thunk64_vkCmdSetDepthWriteEnableEXT, + (void *)thunk64_vkCmdSetDescriptorBufferOffsets2EXT, (void *)thunk64_vkCmdSetDescriptorBufferOffsetsEXT, (void *)thunk64_vkCmdSetDeviceMask, (void *)thunk64_vkCmdSetDeviceMaskKHR, @@ -45055,6 +46273,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdSetLineRasterizationModeEXT, (void *)thunk64_vkCmdSetLineStippleEXT, (void *)thunk64_vkCmdSetLineStippleEnableEXT, + (void *)thunk64_vkCmdSetLineStippleKHR, (void *)thunk64_vkCmdSetLineWidth, (void *)thunk64_vkCmdSetLogicOpEXT, (void *)thunk64_vkCmdSetLogicOpEnableEXT, @@ -45073,6 +46292,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdSetRasterizerDiscardEnable, (void *)thunk64_vkCmdSetRasterizerDiscardEnableEXT, (void *)thunk64_vkCmdSetRayTracingPipelineStackSizeKHR, + (void *)thunk64_vkCmdSetRenderingAttachmentLocationsKHR, + (void *)thunk64_vkCmdSetRenderingInputAttachmentIndicesKHR, (void *)thunk64_vkCmdSetRepresentativeFragmentTestEnableNV, (void *)thunk64_vkCmdSetSampleLocationsEXT, (void *)thunk64_vkCmdSetSampleLocationsEnableEXT, @@ -45247,6 +46468,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetBufferOpaqueCaptureAddressKHR, thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT, thunk64_vkGetCalibratedTimestampsEXT, + thunk64_vkGetCalibratedTimestampsKHR, thunk64_vkGetCudaModuleCacheNV, thunk64_vkGetDeferredOperationMaxConcurrencyKHR, thunk64_vkGetDeferredOperationResultKHR, @@ -45300,6 +46522,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetMicromapBuildSizesEXT, thunk64_vkGetPerformanceParameterINTEL, thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, thunk64_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, thunk64_vkGetPhysicalDeviceExternalBufferProperties, @@ -45468,9 +46691,11 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdBeginRendering, (void *)thunk32_vkCmdBeginRenderingKHR, (void *)thunk32_vkCmdBeginTransformFeedbackEXT, + (void *)thunk32_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, (void *)thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, (void *)thunk32_vkCmdBindDescriptorBuffersEXT, (void *)thunk32_vkCmdBindDescriptorSets, + (void *)thunk32_vkCmdBindDescriptorSets2KHR, (void *)thunk32_vkCmdBindIndexBuffer, (void *)thunk32_vkCmdBindIndexBuffer2KHR, (void *)thunk32_vkCmdBindInvocationMaskHUAWEI, @@ -45569,7 +46794,10 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdPipelineBarrier2KHR, (void *)thunk32_vkCmdPreprocessGeneratedCommandsNV, (void *)thunk32_vkCmdPushConstants, + (void *)thunk32_vkCmdPushConstants2KHR, + (void *)thunk32_vkCmdPushDescriptorSet2KHR, (void *)thunk32_vkCmdPushDescriptorSetKHR, + (void *)thunk32_vkCmdPushDescriptorSetWithTemplate2KHR, (void *)thunk32_vkCmdPushDescriptorSetWithTemplateKHR, (void *)thunk32_vkCmdResetEvent, (void *)thunk32_vkCmdResetEvent2, @@ -45614,6 +46842,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdSetDepthTestEnableEXT, (void *)thunk32_vkCmdSetDepthWriteEnable, (void *)thunk32_vkCmdSetDepthWriteEnableEXT, + (void *)thunk32_vkCmdSetDescriptorBufferOffsets2EXT, (void *)thunk32_vkCmdSetDescriptorBufferOffsetsEXT, (void *)thunk32_vkCmdSetDeviceMask, (void *)thunk32_vkCmdSetDeviceMaskKHR, @@ -45633,6 +46862,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdSetLineRasterizationModeEXT, (void *)thunk32_vkCmdSetLineStippleEXT, (void *)thunk32_vkCmdSetLineStippleEnableEXT, + (void *)thunk32_vkCmdSetLineStippleKHR, (void *)thunk32_vkCmdSetLineWidth, (void *)thunk32_vkCmdSetLogicOpEXT, (void *)thunk32_vkCmdSetLogicOpEnableEXT, @@ -45651,6 +46881,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdSetRasterizerDiscardEnable, (void *)thunk32_vkCmdSetRasterizerDiscardEnableEXT, (void *)thunk32_vkCmdSetRayTracingPipelineStackSizeKHR, + (void *)thunk32_vkCmdSetRenderingAttachmentLocationsKHR, + (void *)thunk32_vkCmdSetRenderingInputAttachmentIndicesKHR, (void *)thunk32_vkCmdSetRepresentativeFragmentTestEnableNV, (void *)thunk32_vkCmdSetSampleLocationsEXT, (void *)thunk32_vkCmdSetSampleLocationsEnableEXT, @@ -45825,6 +47057,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetBufferOpaqueCaptureAddressKHR, thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT, thunk32_vkGetCalibratedTimestampsEXT, + thunk32_vkGetCalibratedTimestampsKHR, thunk32_vkGetCudaModuleCacheNV, thunk32_vkGetDeferredOperationMaxConcurrencyKHR, thunk32_vkGetDeferredOperationResultKHR, @@ -45878,6 +47111,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetMicromapBuildSizesEXT, thunk32_vkGetPerformanceParameterINTEL, thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, thunk32_vkGetPhysicalDeviceExternalBufferProperties, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 8b0d43fadf5..d70a694b1e2 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -3,7 +3,7 @@ * This file is generated from Vulkan vk.xml file covered * by the following copyright and permission notice: * - * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2024 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -42,10 +42,12 @@ VkResult wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t * VkResult wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices); void wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers); void wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator); -VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation); +VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation); +VkResult wine_vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation); void wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue); void wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue); -VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains); +VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); +VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); void wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties); void wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties); void wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties); @@ -92,9 +94,11 @@ struct vulkan_device_funcs void (*p_vkCmdBeginRendering)(VkCommandBuffer, const VkRenderingInfo *); void (*p_vkCmdBeginRenderingKHR)(VkCommandBuffer, const VkRenderingInfo *); void (*p_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); + void (*p_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *); void (*p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t); void (*p_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer, uint32_t, const VkDescriptorBufferBindingInfoEXT *); void (*p_vkCmdBindDescriptorSets)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t *); + void (*p_vkCmdBindDescriptorSets2KHR)(VkCommandBuffer, const VkBindDescriptorSetsInfoKHR *); void (*p_vkCmdBindIndexBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkIndexType); void (*p_vkCmdBindIndexBuffer2KHR)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, VkIndexType); void (*p_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer, VkImageView, VkImageLayout); @@ -193,7 +197,10 @@ struct vulkan_device_funcs void (*p_vkCmdPipelineBarrier2KHR)(VkCommandBuffer, const VkDependencyInfo *); void (*p_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer, const VkGeneratedCommandsInfoNV *); void (*p_vkCmdPushConstants)(VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, uint32_t, const void *); + void (*p_vkCmdPushConstants2KHR)(VkCommandBuffer, const VkPushConstantsInfoKHR *); + void (*p_vkCmdPushDescriptorSet2KHR)(VkCommandBuffer, const VkPushDescriptorSetInfoKHR *); void (*p_vkCmdPushDescriptorSetKHR)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkWriteDescriptorSet *); + void (*p_vkCmdPushDescriptorSetWithTemplate2KHR)(VkCommandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR *); void (*p_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer, VkDescriptorUpdateTemplate, VkPipelineLayout, uint32_t, const void *); void (*p_vkCmdResetEvent)(VkCommandBuffer, VkEvent, VkPipelineStageFlags); void (*p_vkCmdResetEvent2)(VkCommandBuffer, VkEvent, VkPipelineStageFlags2); @@ -238,6 +245,7 @@ struct vulkan_device_funcs void (*p_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthWriteEnable)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer, VkBool32); + void (*p_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT *); void (*p_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const uint32_t *, const VkDeviceSize *); void (*p_vkCmdSetDeviceMask)(VkCommandBuffer, uint32_t); void (*p_vkCmdSetDeviceMaskKHR)(VkCommandBuffer, uint32_t); @@ -257,6 +265,7 @@ struct vulkan_device_funcs void (*p_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer, VkLineRasterizationModeEXT); void (*p_vkCmdSetLineStippleEXT)(VkCommandBuffer, uint32_t, uint16_t); void (*p_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer, VkBool32); + void (*p_vkCmdSetLineStippleKHR)(VkCommandBuffer, uint32_t, uint16_t); void (*p_vkCmdSetLineWidth)(VkCommandBuffer, float); void (*p_vkCmdSetLogicOpEXT)(VkCommandBuffer, VkLogicOp); void (*p_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer, VkBool32); @@ -275,6 +284,8 @@ struct vulkan_device_funcs void (*p_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer, uint32_t); + void (*p_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer, const VkRenderingAttachmentLocationInfoKHR *); + void (*p_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *); void (*p_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer, VkBool32); void (*p_vkCmdSetSampleLocationsEXT)(VkCommandBuffer, const VkSampleLocationsInfoEXT *); void (*p_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer, VkBool32); @@ -430,7 +441,8 @@ struct vulkan_device_funcs uint64_t (*p_vkGetBufferOpaqueCaptureAddress)(VkDevice, const VkBufferDeviceAddressInfo *); uint64_t (*p_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice, const VkBufferDeviceAddressInfo *); VkResult (*p_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkBufferCaptureDescriptorDataInfoEXT *, void *); - VkResult (*p_vkGetCalibratedTimestampsEXT)(VkDevice, uint32_t, const VkCalibratedTimestampInfoEXT *, uint64_t *, uint64_t *); + VkResult (*p_vkGetCalibratedTimestampsEXT)(VkDevice, uint32_t, const VkCalibratedTimestampInfoKHR *, uint64_t *, uint64_t *); + VkResult (*p_vkGetCalibratedTimestampsKHR)(VkDevice, uint32_t, const VkCalibratedTimestampInfoKHR *, uint64_t *, uint64_t *); VkResult (*p_vkGetCudaModuleCacheNV)(VkDevice, VkCudaModuleNV, size_t *, void *); uint32_t (*p_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice, VkDeferredOperationKHR); VkResult (*p_vkGetDeferredOperationResultKHR)(VkDevice, VkDeferredOperationKHR); @@ -584,7 +596,8 @@ struct vulkan_instance_funcs VkResult (*p_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice, const char *, uint32_t *, VkExtensionProperties *); VkResult (*p_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice, uint32_t *, VkLayerProperties *); VkResult (*p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice, uint32_t, uint32_t *, VkPerformanceCounterKHR *, VkPerformanceCounterDescriptionKHR *); - VkResult (*p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *); + VkResult (*p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); + VkResult (*p_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *); VkResult (*p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *); void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *); @@ -654,9 +667,11 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdBeginRendering) \ USE_VK_FUNC(vkCmdBeginRenderingKHR) \ USE_VK_FUNC(vkCmdBeginTransformFeedbackEXT) \ + USE_VK_FUNC(vkCmdBindDescriptorBufferEmbeddedSamplers2EXT) \ USE_VK_FUNC(vkCmdBindDescriptorBufferEmbeddedSamplersEXT) \ USE_VK_FUNC(vkCmdBindDescriptorBuffersEXT) \ USE_VK_FUNC(vkCmdBindDescriptorSets) \ + USE_VK_FUNC(vkCmdBindDescriptorSets2KHR) \ USE_VK_FUNC(vkCmdBindIndexBuffer) \ USE_VK_FUNC(vkCmdBindIndexBuffer2KHR) \ USE_VK_FUNC(vkCmdBindInvocationMaskHUAWEI) \ @@ -755,7 +770,10 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdPipelineBarrier2KHR) \ USE_VK_FUNC(vkCmdPreprocessGeneratedCommandsNV) \ USE_VK_FUNC(vkCmdPushConstants) \ + USE_VK_FUNC(vkCmdPushConstants2KHR) \ + USE_VK_FUNC(vkCmdPushDescriptorSet2KHR) \ USE_VK_FUNC(vkCmdPushDescriptorSetKHR) \ + USE_VK_FUNC(vkCmdPushDescriptorSetWithTemplate2KHR) \ USE_VK_FUNC(vkCmdPushDescriptorSetWithTemplateKHR) \ USE_VK_FUNC(vkCmdResetEvent) \ USE_VK_FUNC(vkCmdResetEvent2) \ @@ -800,6 +818,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdSetDepthTestEnableEXT) \ USE_VK_FUNC(vkCmdSetDepthWriteEnable) \ USE_VK_FUNC(vkCmdSetDepthWriteEnableEXT) \ + USE_VK_FUNC(vkCmdSetDescriptorBufferOffsets2EXT) \ USE_VK_FUNC(vkCmdSetDescriptorBufferOffsetsEXT) \ USE_VK_FUNC(vkCmdSetDeviceMask) \ USE_VK_FUNC(vkCmdSetDeviceMaskKHR) \ @@ -819,6 +838,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdSetLineRasterizationModeEXT) \ USE_VK_FUNC(vkCmdSetLineStippleEXT) \ USE_VK_FUNC(vkCmdSetLineStippleEnableEXT) \ + USE_VK_FUNC(vkCmdSetLineStippleKHR) \ USE_VK_FUNC(vkCmdSetLineWidth) \ USE_VK_FUNC(vkCmdSetLogicOpEXT) \ USE_VK_FUNC(vkCmdSetLogicOpEnableEXT) \ @@ -837,6 +857,8 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdSetRasterizerDiscardEnable) \ USE_VK_FUNC(vkCmdSetRasterizerDiscardEnableEXT) \ USE_VK_FUNC(vkCmdSetRayTracingPipelineStackSizeKHR) \ + USE_VK_FUNC(vkCmdSetRenderingAttachmentLocationsKHR) \ + USE_VK_FUNC(vkCmdSetRenderingInputAttachmentIndicesKHR) \ USE_VK_FUNC(vkCmdSetRepresentativeFragmentTestEnableNV) \ USE_VK_FUNC(vkCmdSetSampleLocationsEXT) \ USE_VK_FUNC(vkCmdSetSampleLocationsEnableEXT) \ @@ -993,6 +1015,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetBufferOpaqueCaptureAddressKHR) \ USE_VK_FUNC(vkGetBufferOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetCalibratedTimestampsEXT) \ + USE_VK_FUNC(vkGetCalibratedTimestampsKHR) \ USE_VK_FUNC(vkGetCudaModuleCacheNV) \ USE_VK_FUNC(vkGetDeferredOperationMaxConcurrencyKHR) \ USE_VK_FUNC(vkGetDeferredOperationResultKHR) \ @@ -1144,6 +1167,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkEnumerateDeviceLayerProperties) \ USE_VK_FUNC(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) \ + USE_VK_FUNC(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \ diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index a4ae238dfba..c6dc93ff0c1 100644 --- a/dlls/winevulkan/winevulkan.json +++ b/dlls/winevulkan/winevulkan.json @@ -2,6 +2,6 @@ "file_format_version": "1.0.0", "ICD": { "library_path": ".\\winevulkan.dll", - "api_version": "1.3.272" + "api_version": "1.3.277" } } diff --git a/dlls/winevulkan/winevulkan.spec b/dlls/winevulkan/winevulkan.spec index e8b58b018e5..5d71d6350dd 100644 --- a/dlls/winevulkan/winevulkan.spec +++ b/dlls/winevulkan/winevulkan.spec @@ -3,7 +3,7 @@ # This file is generated from Vulkan vk.xml file covered # by the following copyright and permission notice: # -# Copyright 2015-2023 The Khronos Group Inc. +# Copyright 2015-2024 The Khronos Group Inc. # # SPDX-License-Identifier: Apache-2.0 OR MIT # diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index a8bf4ad4df0..759380c118b 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -3,7 +3,7 @@ * This file is generated from Vulkan vk.xml file covered * by the following copyright and permission notice: * - * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2024 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * @@ -65,6 +65,7 @@ #define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR 16 #define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE_KHR #define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT 32 +#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7 #define VK_SHADER_INDEX_UNUSED_AMDX (~0U) #define VK_KHR_SURFACE_SPEC_VERSION 25 #define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" @@ -356,8 +357,12 @@ #define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2" #define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1 #define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory" +#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1 +#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read" #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 #define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" +#define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1 +#define VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME "VK_KHR_shader_quad_control" #define VK_KHR_SPIRV_1_4_SPEC_VERSION 1 #define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4" #define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 @@ -426,7 +431,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 3 +#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 4 #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" @@ -478,7 +483,7 @@ #define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" #define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1 #define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2" -#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1 +#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 2 #define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands" #define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 #define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" @@ -554,6 +559,8 @@ #define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4" #define VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 #define VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_ARM_shader_core_properties" +#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2 +#define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate" #define VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION 1 #define VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME "VK_ARM_scheduling_controls" #define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION 1 @@ -574,6 +581,8 @@ #define VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME "VK_NV_device_generated_commands_compute" #define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1 #define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment" +#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION 1 +#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME "VK_KHR_shader_maximal_reconvergence" #define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION 1 #define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME "VK_EXT_image_compression_control_swapchain" #define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1 @@ -626,6 +635,8 @@ #define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix" #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 #define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" +#define VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION 1 +#define VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME "VK_NV_per_stage_descriptor_set" #define VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION 1 #define VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME "VK_QCOM_image_processing2" #define VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION 1 @@ -636,8 +647,24 @@ #define VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME "VK_QCOM_filter_cubic_clamp" #define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION 1 #define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_dynamic_state" +#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1 +#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_KHR_vertex_attribute_divisor" +#define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1 +#define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none" +#define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2" #define VK_MSFT_LAYERED_DRIVER_SPEC_VERSION 1 #define VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME "VK_MSFT_layered_driver" +#define VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION 1 +#define VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_KHR_index_type_uint8" +#define VK_KHR_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME "VK_KHR_line_rasterization" +#define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1 +#define VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_KHR_calibrated_timestamps" +#define VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION 1 +#define VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME "VK_KHR_shader_expect_assume" +#define VK_KHR_MAINTENANCE_6_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_6_EXTENSION_NAME "VK_KHR_maintenance6" #define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION 1 #define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation" #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 @@ -666,7 +693,7 @@ #define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0) #define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0) #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0) -#define VK_HEADER_VERSION 272 +#define VK_HEADER_VERSION 277 #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; #define VK_USE_64_BIT_PTR_DEFINES 0 @@ -958,14 +985,14 @@ typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; typedef VkFlags VkVideoEncodeContentFlagsKHR; typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; typedef VkFlags VkVideoEncodeFlagsKHR; -typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; -typedef VkFlags VkVideoEncodeH264RateControlFlagsEXT; -typedef VkFlags VkVideoEncodeH264StdFlagsEXT; -typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; -typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; -typedef VkFlags VkVideoEncodeH265RateControlFlagsEXT; -typedef VkFlags VkVideoEncodeH265StdFlagsEXT; -typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; +typedef VkFlags VkVideoEncodeH264CapabilityFlagsKHR; +typedef VkFlags VkVideoEncodeH264RateControlFlagsKHR; +typedef VkFlags VkVideoEncodeH264StdFlagsKHR; +typedef VkFlags VkVideoEncodeH265CapabilityFlagsKHR; +typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR; +typedef VkFlags VkVideoEncodeH265RateControlFlagsKHR; +typedef VkFlags VkVideoEncodeH265StdFlagsKHR; +typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR; typedef VkFlags VkVideoEncodeRateControlFlagsKHR; typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; typedef VkFlags VkVideoEncodeUsageFlagsKHR; @@ -1148,7 +1175,8 @@ typedef enum VkAttachmentLoadOp VK_ATTACHMENT_LOAD_OP_LOAD = 0, VK_ATTACHMENT_LOAD_OP_CLEAR = 1, VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000, + VK_ATTACHMENT_LOAD_OP_NONE_KHR = 1000400000, + VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE_KHR, VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7fffffff, } VkAttachmentLoadOp; @@ -1729,6 +1757,7 @@ typedef enum VkDescriptorSetLayoutCreateFlagBits VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV = 0x00000040, VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080, VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, @@ -1895,7 +1924,7 @@ typedef enum VkDynamicState VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, - VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, + VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = 1000259000, VK_DYNAMIC_STATE_CULL_MODE = 1000267000, VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, @@ -1948,6 +1977,7 @@ typedef enum VkDynamicState VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, + VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR, VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, @@ -2712,6 +2742,7 @@ typedef enum VkImageLayout VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = 1000232000, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, @@ -2792,8 +2823,9 @@ typedef enum VkIndexType VK_INDEX_TYPE_UINT16 = 0, VK_INDEX_TYPE_UINT32 = 1, VK_INDEX_TYPE_NONE_KHR = 1000165000, - VK_INDEX_TYPE_UINT8_EXT = 1000265000, + VK_INDEX_TYPE_UINT8_KHR = 1000265000, VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, + VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8_KHR, VK_INDEX_TYPE_MAX_ENUM = 0x7fffffff, } VkIndexType; @@ -2876,14 +2908,19 @@ typedef enum VkLayeredDriverUnderlyingApiMSFT VK_LAYERED_DRIVER_UNDERLYING_API_MSFT_MAX_ENUM = 0x7fffffff, } VkLayeredDriverUnderlyingApiMSFT; -typedef enum VkLineRasterizationModeEXT +typedef enum VkLineRasterizationModeKHR { - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, - VK_LINE_RASTERIZATION_MODE_EXT_MAX_ENUM = 0x7fffffff, -} VkLineRasterizationModeEXT; + VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = 3, + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR, + VK_LINE_RASTERIZATION_MODE_KHR_MAX_ENUM = 0x7fffffff, +} VkLineRasterizationModeKHR; +typedef VkLineRasterizationModeKHR VkLineRasterizationModeEXT; typedef enum VkLogicOp { @@ -3191,11 +3228,9 @@ typedef enum VkPerformanceValueTypeINTEL VK_PERFORMANCE_VALUE_TYPE_INTEL_MAX_ENUM = 0x7fffffff, } VkPerformanceValueTypeINTEL; -typedef enum VkPhysicalDeviceSchedulingControlsFlagBitsARM -{ - VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001, - VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FLAG_BITS_ARM_MAX_ENUM = 0x7fffffff, -} VkPhysicalDeviceSchedulingControlsFlagBitsARM; +typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM; + +static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001ull; typedef enum VkPhysicalDeviceType { @@ -4306,12 +4341,12 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, - VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = 1000190002, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, @@ -4356,7 +4391,11 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = 1000232000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = 1000232001, + VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = 1000232002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, @@ -4387,12 +4426,12 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = 1000259002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = 1000265000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, @@ -4592,6 +4631,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = 1000416000, VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, @@ -4613,6 +4653,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, @@ -4675,6 +4716,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001, VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002, @@ -4685,7 +4727,19 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = 1000525000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = 1000528000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = 1000544000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = 1000545000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = 1000545001, + VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = 1000545002, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR = 1000545003, + VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = 1000545004, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = 1000545005, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = 1000545006, + VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_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, @@ -4786,6 +4840,9 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, @@ -4818,7 +4875,11 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_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, @@ -4876,6 +4937,8 @@ typedef enum VkSubgroupFeatureFlagBits VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = 0x00000200, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = 0x00000400, VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7fffffff, } VkSubgroupFeatureFlagBits; @@ -4971,14 +5034,19 @@ typedef enum VkTessellationDomainOrigin } VkTessellationDomainOrigin; typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; -typedef enum VkTimeDomainEXT +typedef enum VkTimeDomainKHR { - VK_TIME_DOMAIN_DEVICE_EXT = 0, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, - VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, - VK_TIME_DOMAIN_EXT_MAX_ENUM = 0x7fffffff, -} VkTimeDomainEXT; + VK_TIME_DOMAIN_DEVICE_KHR = 0, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3, + VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, + VK_TIME_DOMAIN_KHR_MAX_ENUM = 0x7fffffff, +} VkTimeDomainKHR; +typedef VkTimeDomainKHR VkTimeDomainEXT; typedef enum VkToolPurposeFlagBits { @@ -5340,6 +5408,28 @@ typedef struct VkBindBufferMemoryInfo } VkBindBufferMemoryInfo; typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; +typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + uint32_t set; +} VkBindDescriptorBufferEmbeddedSamplersInfoEXT; + +typedef struct VkBindDescriptorSetsInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + const VkDescriptorSet *pDescriptorSets; + uint32_t dynamicOffsetCount; + const uint32_t *pDynamicOffsets; +} VkBindDescriptorSetsInfoKHR; + typedef struct VkBindImageMemoryInfo { VkStructureType sType; @@ -5373,6 +5463,13 @@ typedef struct VkBindIndexBufferIndirectCommandNV VkIndexType indexType; } VkBindIndexBufferIndirectCommandNV; +typedef struct VkBindMemoryStatusKHR +{ + VkStructureType sType; + const void *pNext; + VkResult *pResult; +} VkBindMemoryStatusKHR; + typedef struct VkBindPipelineIndirectCommandNV { VkDeviceAddress WINE_VK_ALIGN(8) pipelineAddress; @@ -5512,12 +5609,13 @@ typedef struct VkBufferViewCreateInfo VkDeviceSize WINE_VK_ALIGN(8) range; } VkBufferViewCreateInfo; -typedef struct VkCalibratedTimestampInfoEXT +typedef struct VkCalibratedTimestampInfoKHR { VkStructureType sType; const void *pNext; - VkTimeDomainEXT timeDomain; -} VkCalibratedTimestampInfoEXT; + VkTimeDomainKHR timeDomain; +} VkCalibratedTimestampInfoKHR; +typedef VkCalibratedTimestampInfoKHR VkCalibratedTimestampInfoEXT; typedef struct VkCheckpointData2NV { @@ -7880,6 +7978,13 @@ typedef struct VkPhysicalDeviceDynamicRenderingFeatures } VkPhysicalDeviceDynamicRenderingFeatures; typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR; +typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 dynamicRenderingLocalRead; +} VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR; + typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT { VkStructureType sType; @@ -8422,12 +8527,13 @@ typedef struct VkPhysicalDeviceImagelessFramebufferFeatures } VkPhysicalDeviceImagelessFramebufferFeatures; typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR; -typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT +typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesKHR { VkStructureType sType; void *pNext; VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; +} VkPhysicalDeviceIndexTypeUint8FeaturesKHR; +typedef VkPhysicalDeviceIndexTypeUint8FeaturesKHR VkPhysicalDeviceIndexTypeUint8FeaturesEXT; typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV { @@ -8588,7 +8694,7 @@ typedef struct VkPhysicalDeviceLimits VkDeviceSize WINE_VK_ALIGN(8) nonCoherentAtomSize; } VkPhysicalDeviceLimits; -typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT +typedef struct VkPhysicalDeviceLineRasterizationFeaturesKHR { VkStructureType sType; void *pNext; @@ -8598,14 +8704,16 @@ typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT VkBool32 stippledRectangularLines; VkBool32 stippledBresenhamLines; VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeaturesEXT; +} VkPhysicalDeviceLineRasterizationFeaturesKHR; +typedef VkPhysicalDeviceLineRasterizationFeaturesKHR VkPhysicalDeviceLineRasterizationFeaturesEXT; -typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT +typedef struct VkPhysicalDeviceLineRasterizationPropertiesKHR { VkStructureType sType; void *pNext; uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationPropertiesEXT; +} VkPhysicalDeviceLineRasterizationPropertiesKHR; +typedef VkPhysicalDeviceLineRasterizationPropertiesKHR VkPhysicalDeviceLineRasterizationPropertiesEXT; typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { @@ -8658,6 +8766,22 @@ typedef struct VkPhysicalDeviceMaintenance5PropertiesKHR VkBool32 nonStrictWideLinesUseParallelogram; } VkPhysicalDeviceMaintenance5PropertiesKHR; +typedef struct VkPhysicalDeviceMaintenance6FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 maintenance6; +} VkPhysicalDeviceMaintenance6FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance6PropertiesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; +} VkPhysicalDeviceMaintenance6PropertiesKHR; + typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { VkStructureType sType; @@ -8919,6 +9043,14 @@ typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT VkBool32 pageableDeviceLocalMemory; } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; +typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV +{ + VkStructureType sType; + void *pNext; + VkBool32 perStageDescriptorSet; + VkBool32 dynamicPipelineLayout; +} VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { VkStructureType sType; @@ -9397,6 +9529,13 @@ typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD VkBool32 shaderEarlyAndLateFragmentTests; } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; +typedef struct VkPhysicalDeviceShaderExpectAssumeFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderExpectAssume; +} VkPhysicalDeviceShaderExpectAssumeFeaturesKHR; + typedef struct VkPhysicalDeviceShaderFloat16Int8Features { VkStructureType sType; @@ -9407,6 +9546,13 @@ typedef struct VkPhysicalDeviceShaderFloat16Int8Features typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; +typedef struct VkPhysicalDeviceShaderFloatControls2FeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderFloatControls2; +} VkPhysicalDeviceShaderFloatControls2FeaturesKHR; + typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { VkStructureType sType; @@ -9474,6 +9620,13 @@ typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL VkBool32 shaderIntegerFunctions2; } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; +typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderMaximalReconvergence; +} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { VkStructureType sType; @@ -9503,6 +9656,13 @@ typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT uint32_t shaderBinaryVersion; } VkPhysicalDeviceShaderObjectPropertiesEXT; +typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderQuadControl; +} VkPhysicalDeviceShaderQuadControlFeaturesKHR; + typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { VkStructureType sType; @@ -9526,6 +9686,14 @@ typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; +typedef struct VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR +{ + VkStructureType sType; + void *pNext; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; +} VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR; + typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { VkStructureType sType; @@ -9775,13 +9943,14 @@ typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointer typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; -typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR { VkStructureType sType; void *pNext; VkBool32 vertexAttributeInstanceRateDivisor; VkBool32 vertexAttributeInstanceRateZeroDivisor; -} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR; +typedef VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { @@ -9790,6 +9959,14 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT uint32_t maxVertexAttribDivisor; } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; + typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { VkStructureType sType; @@ -10320,15 +10497,16 @@ typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT VkBool32 depthClipEnable; } VkPipelineRasterizationDepthClipStateCreateInfoEXT; -typedef struct VkPipelineRasterizationLineStateCreateInfoEXT +typedef struct VkPipelineRasterizationLineStateCreateInfoKHR { VkStructureType sType; const void *pNext; - VkLineRasterizationModeEXT lineRasterizationMode; + VkLineRasterizationModeKHR lineRasterizationMode; VkBool32 stippledLineEnable; uint32_t lineStippleFactor; uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfoEXT; +} VkPipelineRasterizationLineStateCreateInfoKHR; +typedef VkPipelineRasterizationLineStateCreateInfoKHR VkPipelineRasterizationLineStateCreateInfoEXT; typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { @@ -10489,6 +10667,27 @@ typedef struct VkPushConstantRange uint32_t size; } VkPushConstantRange; +typedef struct VkPushConstantsInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + const void *pValues; +} VkPushConstantsInfoKHR; + +typedef struct VkPushDescriptorSetWithTemplateInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkDescriptorUpdateTemplate WINE_VK_ALIGN(8) descriptorUpdateTemplate; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + uint32_t set; + const void *pData; +} VkPushDescriptorSetWithTemplateInfoKHR; + typedef struct VkQueryLowLatencySupportNV { VkStructureType sType; @@ -10716,6 +10915,14 @@ typedef struct VkRenderingAttachmentInfo } VkRenderingAttachmentInfo; typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR; +typedef struct VkRenderingAttachmentLocationInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t colorAttachmentCount; + const uint32_t *pColorAttachmentLocations; +} VkRenderingAttachmentLocationInfoKHR; + typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT { VkStructureType sType; @@ -10748,6 +10955,16 @@ typedef struct VkRenderingInfo } VkRenderingInfo; typedef VkRenderingInfo VkRenderingInfoKHR; +typedef struct VkRenderingInputAttachmentIndexInfoKHR +{ + VkStructureType sType; + const void *pNext; + uint32_t colorAttachmentCount; + const uint32_t *pColorAttachmentInputIndices; + const uint32_t *pDepthInputAttachmentIndex; + const uint32_t *pStencilInputAttachmentIndex; +} VkRenderingInputAttachmentIndexInfoKHR; + typedef struct VkSRTDataNV { float sx; @@ -10938,6 +11155,18 @@ typedef struct VkSemaphoreWaitInfo } VkSemaphoreWaitInfo; typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR; +typedef struct VkSetDescriptorBufferOffsetsInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + uint32_t firstSet; + uint32_t setCount; + const uint32_t *pBufferIndices; + const VkDeviceSize *pOffsets; +} VkSetDescriptorBufferOffsetsInfoEXT; + typedef struct VkSetLatencyMarkerInfoNV { VkStructureType sType; @@ -11489,11 +11718,12 @@ typedef struct VkVertexInputBindingDescription2EXT uint32_t divisor; } VkVertexInputBindingDescription2EXT; -typedef struct VkVertexInputBindingDivisorDescriptionEXT +typedef struct VkVertexInputBindingDivisorDescriptionKHR { uint32_t binding; uint32_t divisor; -} VkVertexInputBindingDivisorDescriptionEXT; +} VkVertexInputBindingDivisorDescriptionKHR; +typedef VkVertexInputBindingDivisorDescriptionKHR VkVertexInputBindingDivisorDescriptionEXT; typedef struct VkViewport { @@ -12257,13 +12487,14 @@ typedef struct VkPipelineSampleLocationsStateCreateInfoEXT VkSampleLocationsInfoEXT sampleLocationsInfo; } VkPipelineSampleLocationsStateCreateInfoEXT; -typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT +typedef struct VkPipelineVertexInputDivisorStateCreateInfoKHR { VkStructureType sType; const void *pNext; uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfoEXT; + const VkVertexInputBindingDivisorDescriptionKHR *pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoKHR; +typedef VkPipelineVertexInputDivisorStateCreateInfoKHR VkPipelineVertexInputDivisorStateCreateInfoEXT; typedef struct VkPipelineVertexInputStateCreateInfo { @@ -12336,6 +12567,17 @@ typedef struct VkPresentRegionsKHR const VkPresentRegionKHR *pRegions; } VkPresentRegionsKHR; +typedef struct VkPushDescriptorSetInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout WINE_VK_ALIGN(8) layout; + uint32_t set; + uint32_t descriptorWriteCount; + const VkWriteDescriptorSet *pDescriptorWrites; +} VkPushDescriptorSetInfoKHR; + typedef struct VkRenderPassCreateInfo { VkStructureType sType; @@ -12738,9 +12980,11 @@ typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer, const Vk typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer, const VkRenderingInfo *); typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer, const VkRenderingInfo *); typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer, uint32_t, uint32_t, const VkBuffer *, const VkDeviceSize *); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer, uint32_t, const VkDescriptorBufferBindingInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkDescriptorSet *, uint32_t, const uint32_t *); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2KHR)(VkCommandBuffer, const VkBindDescriptorSetsInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkIndexType); typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer2KHR)(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, VkIndexType); typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer, VkImageView, VkImageLayout); @@ -12839,7 +13083,10 @@ typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer, const VkDep typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer, const VkDependencyInfo *); typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer, const VkGeneratedCommandsInfoNV *); typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer, VkPipelineLayout, VkShaderStageFlags, uint32_t, uint32_t, const void *); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2KHR)(VkCommandBuffer, const VkPushConstantsInfoKHR *); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2KHR)(VkCommandBuffer, const VkPushDescriptorSetInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const VkWriteDescriptorSet *); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2KHR)(VkCommandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer, VkDescriptorUpdateTemplate, VkPipelineLayout, uint32_t, const void *); typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer, VkEvent, VkPipelineStageFlags); typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer, VkEvent, VkPipelineStageFlags2); @@ -12884,6 +13131,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer, VkBool32) typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer, VkBool32); +typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer, VkPipelineBindPoint, VkPipelineLayout, uint32_t, uint32_t, const uint32_t *, const VkDeviceSize *); typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer, uint32_t); typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer, uint32_t); @@ -12903,6 +13151,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer, VkFrontFace) typedef void (VKAPI_PTR *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer, VkLineRasterizationModeEXT); typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer, uint32_t, uint16_t); typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer, VkBool32); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer, uint32_t, uint16_t); typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer, float); typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer, VkLogicOp); typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer, VkBool32); @@ -12921,6 +13170,8 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer, ui typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer, uint32_t); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer, const VkRenderingAttachmentLocationInfoKHR *); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *); typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer, VkBool32); typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer, const VkSampleLocationsInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer, VkBool32); @@ -13095,7 +13346,8 @@ typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice, const typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice, const VkBufferDeviceAddressInfo *); typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice, const VkBufferDeviceAddressInfo *); typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkBufferCaptureDescriptorDataInfoEXT *, void *); -typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice, uint32_t, const VkCalibratedTimestampInfoEXT *, uint64_t *, uint64_t *); +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 VkResult (VKAPI_PTR *PFN_vkGetCudaModuleCacheNV)(VkDevice, VkCudaModuleNV, size_t *, void *); typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice, VkDeferredOperationKHR); typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice, VkDeferredOperationKHR); @@ -13152,7 +13404,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMe typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, HANDLE, VkMemoryWin32HandlePropertiesKHR *); typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *); typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainEXT *); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice, uint32_t *, VkTimeDomainKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice, uint32_t *, VkCooperativeMatrixPropertiesNV *); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice, const VkPhysicalDeviceExternalBufferInfo *, VkExternalBufferProperties *); @@ -13309,9 +13562,11 @@ void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const Vk void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo); void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo); void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets); +void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo); void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos); void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets); +void VKAPI_CALL vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo); void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); void VKAPI_CALL vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); @@ -13410,7 +13665,10 @@ void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDep void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo); void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo); void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues); +void VKAPI_CALL vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR *pPushConstantsInfo); +void VKAPI_CALL vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR *pPushDescriptorSetInfo); void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites); +void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR *pPushDescriptorSetWithTemplateInfo); void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData); void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); void VKAPI_CALL vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); @@ -13455,6 +13713,7 @@ void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo); void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets); void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask); void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask); @@ -13474,6 +13733,7 @@ void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +void VKAPI_CALL vkCmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth); void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp); void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); @@ -13492,6 +13752,8 @@ void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, ui void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); +void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR *pLocationInfo); +void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR *pLocationInfo); void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo); void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); @@ -13666,7 +13928,8 @@ void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBuffe uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo); uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo); VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData); -VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation); +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); VkResult VKAPI_CALL vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t *pCacheSize, void *pCacheData); uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation); VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation); @@ -13723,7 +13986,8 @@ VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGet VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties); void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo); VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue); -VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains); +VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); +VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties); VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties); void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties); diff --git a/include/wine/vulkan_driver.h b/include/wine/vulkan_driver.h index 7e2e2e5ea70..57ab6d519d6 100644 --- a/include/wine/vulkan_driver.h +++ b/include/wine/vulkan_driver.h @@ -3,7 +3,7 @@ * This file is generated from Vulkan vk.xml file covered * by the following copyright and permission notice: * - * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2024 The Khronos Group Inc. * * SPDX-License-Identifier: Apache-2.0 OR MIT * -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/5016
From: Georg Lehmann <dadschoorse(a)gmail.com> --- dlls/winevulkan/make_vulkan | 1 - dlls/winevulkan/vulkan_thunks.c | 182 +++++++++++++++++++++++++++++++- include/wine/vulkan.h | 45 ++++++++ 3 files changed, 223 insertions(+), 5 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 3d5a00d6e49..ab9760125ff 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -95,7 +95,6 @@ UNSUPPORTED_EXTENSIONS = [ # Device extensions "VK_AMD_display_native_hdr", - "VK_ARM_render_pass_striped", # XML bug, see https://github.com/KhronosGroup/Vulkan-Docs/pull/2279 "VK_EXT_full_screen_exclusive", "VK_GOOGLE_display_timing", "VK_KHR_external_fence_win32", diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 7882be6ed95..6d3afe7030b 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -470,6 +470,13 @@ typedef struct VkSubpassSampleLocationsEXT32 VkSampleLocationsInfoEXT32 sampleLocationsInfo; } VkSubpassSampleLocationsEXT32; +typedef struct VkRenderPassStripeInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkRect2D stripeArea; +} VkRenderPassStripeInfoARM32; + typedef struct VkDeviceGroupRenderPassBeginInfo32 { VkStructureType sType; @@ -514,6 +521,14 @@ typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 PTR32 pPerViewRenderAreas; } VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32; +typedef struct VkRenderPassStripeBeginInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t stripeInfoCount; + PTR32 pStripeInfos; +} VkRenderPassStripeBeginInfoARM32; + typedef struct VkRenderPassBeginInfo32 { VkStructureType sType; @@ -3232,6 +3247,13 @@ typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 VkBool32 relaxedLineRasterization; } VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32; +typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 renderPassStriped; +} VkPhysicalDeviceRenderPassStripedFeaturesARM32; + typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 { VkStructureType sType; @@ -6355,6 +6377,14 @@ typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM32 VkPhysicalDeviceSchedulingControlsFlagsARM DECLSPEC_ALIGN(8) schedulingControlsFlags; } VkPhysicalDeviceSchedulingControlsPropertiesARM32; +typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkExtent2D renderPassStripeGranularity; + uint32_t maxRenderPassStripes; +} VkPhysicalDeviceRenderPassStripedPropertiesARM32; + typedef struct VkPhysicalDeviceProperties232 { VkStructureType sType; @@ -6844,6 +6874,14 @@ typedef struct VkSemaphoreSubmitInfo32 } VkSemaphoreSubmitInfo32; typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32; +typedef struct VkRenderPassStripeSubmitInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t stripeSemaphoreInfoCount; + PTR32 pStripeSemaphoreInfos; +} VkRenderPassStripeSubmitInfoARM32; + typedef struct VkCommandBufferSubmitInfo32 { VkStructureType sType; @@ -8036,6 +8074,33 @@ static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocation return out; } +static inline void convert_VkRenderPassStripeInfoARM_win32_to_host(const VkRenderPassStripeInfoARM32 *in, VkRenderPassStripeInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->stripeArea = in->stripeArea; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline const VkRenderPassStripeInfoARM *convert_VkRenderPassStripeInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkRenderPassStripeInfoARM32 *in, uint32_t count) +{ + VkRenderPassStripeInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkRenderPassStripeInfoARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out) { const VkBaseInStructure32 *in_header; @@ -8117,6 +8182,18 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + { + VkRenderPassStripeBeginInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassStripeBeginInfoARM32 *in_ext = (const VkRenderPassStripeBeginInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; + out_ext->pNext = NULL; + out_ext->stripeInfoCount = in_ext->stripeInfoCount; + out_ext->pStripeInfos = convert_VkRenderPassStripeInfoARM_array_win32_to_host(ctx, (const VkRenderPassStripeInfoARM32 *)UlongToPtr(in_ext->pStripeInfos), in_ext->stripeInfoCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -8265,6 +8342,18 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + { + VkRenderPassStripeBeginInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassStripeBeginInfoARM32 *in_ext = (const VkRenderPassStripeBeginInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; + out_ext->pNext = NULL; + out_ext->stripeInfoCount = in_ext->stripeInfoCount; + out_ext->pStripeInfos = convert_VkRenderPassStripeInfoARM_array_win32_to_host(ctx, (const VkRenderPassStripeInfoARM32 *)UlongToPtr(in_ext->pStripeInfos), in_ext->stripeInfoCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -13363,6 +13452,17 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + { + VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->renderPassStriped = in_ext->renderPassStriped; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15611,6 +15711,17 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + { + VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->renderPassStriped = in_ext->renderPassStriped; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22856,6 +22967,17 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + { + VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->renderPassStriped = in_ext->renderPassStriped; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24680,6 +24802,15 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + { + VkPhysicalDeviceRenderPassStripedFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM); + const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + out_ext->renderPassStriped = in_ext->renderPassStriped; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR); @@ -26172,6 +26303,15 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + { + VkPhysicalDeviceRenderPassStripedPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -27337,6 +27477,16 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + { + VkPhysicalDeviceRenderPassStripedPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM); + const VkPhysicalDeviceRenderPassStripedPropertiesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; + out_ext->renderPassStripeGranularity = in_ext->renderPassStripeGranularity; + out_ext->maxRenderPassStripes = in_ext->maxRenderPassStripes; + out_header = (void *)out_ext; + break; + } default: break; } @@ -29066,16 +29216,39 @@ static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkComma } #endif /* _WIN64 */ -static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out) +static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return; out->sType = in->sType; out->pNext = NULL; out->commandBuffer = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(in->commandBuffer))->host_command_buffer; out->deviceMask = in->deviceMask; - 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_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + { + VkRenderPassStripeSubmitInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassStripeSubmitInfoARM32 *in_ext = (const VkRenderPassStripeSubmitInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; + out_ext->pNext = NULL; + out_ext->stripeSemaphoreInfoCount = in_ext->stripeSemaphoreInfoCount; + out_ext->pStripeSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in_ext->pStripeSemaphoreInfos), in_ext->stripeSemaphoreInfoCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } } #ifdef _WIN64 @@ -29106,7 +29279,7 @@ static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkCommandBufferSubmitInfo_win32_to_host(&in[i], &out[i]); + convert_VkCommandBufferSubmitInfo_win32_to_host(ctx, &in[i], &out[i]); } return out; @@ -45747,6 +45920,7 @@ static const char * const vk_device_extensions[] = "VK_AMD_shader_trinary_minmax", "VK_AMD_texture_gather_bias_lod", "VK_ARM_rasterization_order_attachment_access", + "VK_ARM_render_pass_striped", "VK_ARM_scheduling_controls", "VK_ARM_shader_core_builtins", "VK_ARM_shader_core_properties", diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 759380c118b..c07c576c01b 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -571,6 +571,8 @@ #define VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_EXT_depth_clamp_zero_one" #define VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION 1 #define VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME "VK_EXT_non_seamless_cube_map" +#define VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION 1 +#define VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME "VK_ARM_render_pass_striped" #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 #define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" #define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 @@ -4642,6 +4644,11 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM = 1000424000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM = 1000424001, + VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002, + VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003, + VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, @@ -9317,6 +9324,21 @@ typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG VkBool32 relaxedLineRasterization; } VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; +typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM +{ + VkStructureType sType; + void *pNext; + VkBool32 renderPassStriped; +} VkPhysicalDeviceRenderPassStripedFeaturesARM; + +typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM +{ + VkStructureType sType; + void *pNext; + VkExtent2D renderPassStripeGranularity; + uint32_t maxRenderPassStripes; +} VkPhysicalDeviceRenderPassStripedPropertiesARM; + typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { VkStructureType sType; @@ -10875,6 +10897,13 @@ typedef struct VkRenderPassMultiviewCreateInfo } VkRenderPassMultiviewCreateInfo; typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; +typedef struct VkRenderPassStripeInfoARM +{ + VkStructureType sType; + const void *pNext; + VkRect2D stripeArea; +} VkRenderPassStripeInfoARM; + typedef struct VkRenderPassSubpassFeedbackInfoEXT { VkSubpassMergeStatusEXT subpassMergeStatus; @@ -12624,6 +12653,22 @@ typedef struct VkRenderPassSampleLocationsBeginInfoEXT const VkSubpassSampleLocationsEXT *pPostSubpassSampleLocations; } VkRenderPassSampleLocationsBeginInfoEXT; +typedef struct VkRenderPassStripeBeginInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t stripeInfoCount; + const VkRenderPassStripeInfoARM *pStripeInfos; +} VkRenderPassStripeBeginInfoARM; + +typedef struct VkRenderPassStripeSubmitInfoARM +{ + VkStructureType sType; + const void *pNext; + uint32_t stripeSemaphoreInfoCount; + const VkSemaphoreSubmitInfo *pStripeSemaphoreInfos; +} VkRenderPassStripeSubmitInfoARM; + typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT { VkStructureType sType; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/5016
I found no other way to fix the 32bit gcc `-Wmaybe-uninitialized`warning than to use calloc instead of malloc. Pretty sure this is a gcc. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/5016#note_60288
This merge request was approved by Jacek Caban. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/5016
participants (3)
-
Georg Lehmann -
Georg Lehmann (＠DadSchoorse)
-
Jacek Caban (＠jacek)