From: Rémi Bernon <rbernon@codeweavers.com> --- dlls/vulkan-1/tests/vulkan.c | 93 +++++ dlls/winevulkan/loader_thunks.c | 54 +++ dlls/winevulkan/loader_thunks.h | 38 ++ dlls/winevulkan/make_vulkan | 2 +- dlls/winevulkan/vulkan.c | 43 +++ dlls/winevulkan/vulkan_thunks.c | 633 +++++++++++++++++++++++++++++++- dlls/winevulkan/vulkan_thunks.h | 1 + include/wine/vulkan.h | 156 ++++++++ 8 files changed, 1013 insertions(+), 7 deletions(-) diff --git a/dlls/vulkan-1/tests/vulkan.c b/dlls/vulkan-1/tests/vulkan.c index d4d5cc86ab0..79a85086e9f 100644 --- a/dlls/vulkan-1/tests/vulkan.c +++ b/dlls/vulkan-1/tests/vulkan.c @@ -484,6 +484,97 @@ static void test_private_data(VkPhysicalDevice vk_physical_device) vkDestroyDevice(vk_device, NULL); } +static void test_present_timing(VkInstance instance, VkPhysicalDevice physical_device) +{ + static const char *const device_extensions[] = {"VK_KHR_swapchain", "VK_EXT_present_timing"}; + + VkSwapchainTimeDomainPropertiesEXT properties = {.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT}; + VkCommandBufferAllocateInfo allocate_info = {.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO}; + VkWin32SurfaceCreateInfoKHR create_info = {.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR}; + VkCommandPoolCreateInfo pool_create_info = {.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO}; + PFN_vkGetSwapchainTimeDomainPropertiesEXT p_vkGetSwapchainTimeDomainPropertiesEXT; + VkCommandBuffer command_buffer; + BOOL has_stage_local = FALSE; + uint32_t queue_family_index; + VkCommandPool command_pool; + VkSwapchainKHR swapchain; + VkSurfaceKHR surface; + uint64_t counter; + VkDevice device; + VkQueue queue; + VkResult vr; + HWND hwnd; + + if ((vr = create_device(physical_device, ARRAY_SIZE(device_extensions), device_extensions, NULL, &device)) < 0) + { + skip("Failed to create device with VK_EXT_present_timing, VkResult %d.\n", vr); + return; + } + + p_vkGetSwapchainTimeDomainPropertiesEXT = (void *)vkGetDeviceProcAddr(device, "vkGetSwapchainTimeDomainPropertiesEXT"); + find_queue_family(physical_device, VK_QUEUE_GRAPHICS_BIT, &queue_family_index); + vkGetDeviceQueue(device, queue_family_index, 0, &queue); + + pool_create_info.queueFamilyIndex = queue_family_index; + pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + vr = vkCreateCommandPool(device, &pool_create_info, NULL, &command_pool); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + + allocate_info.commandPool = command_pool; + allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocate_info.commandBufferCount = 1; + vr = vkAllocateCommandBuffers(device, &allocate_info, &command_buffer); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + + hwnd = CreateWindowW(L"static", L"static", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 100, 100, 200, 200, + 0, 0, 0, NULL); + ok(hwnd != 0, "CreateWindowExW failed, error %lu\n", GetLastError()); + + surface = 0xdeadbeef; + create_info.hwnd = hwnd; + vr = vkCreateWin32SurfaceKHR(instance, &create_info, NULL, &surface); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(surface != 0xdeadbeef, "Surface not created.\n"); + + swapchain = 0xdeadbeef; + vr = create_swapchain(physical_device, surface, device, hwnd, &swapchain); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(swapchain != 0xdeadbeef, "Swapchain not created.\n"); + + vr = p_vkGetSwapchainTimeDomainPropertiesEXT(device, swapchain, &properties, NULL); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(properties.timeDomainCount > 0, "got %u\n", properties.timeDomainCount); + + counter = 0xdeadbeef; + properties.timeDomainCount = 0; + vr = p_vkGetSwapchainTimeDomainPropertiesEXT(device, swapchain, &properties, &counter); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(properties.timeDomainCount > 0, "got %u\n", properties.timeDomainCount); + ok(counter != 0, "got %I64x\n", counter); + + counter = 0xdeadbeef; + properties.pTimeDomainIds = calloc(properties.timeDomainCount, sizeof(*properties.pTimeDomainIds)); + properties.pTimeDomains = calloc(properties.timeDomainCount, sizeof(*properties.pTimeDomains)); + vr = p_vkGetSwapchainTimeDomainPropertiesEXT(device, swapchain, &properties, &counter); + ok(vr == VK_SUCCESS, "Got unexpected vr %d.\n", vr); + ok(properties.timeDomainCount > 0, "got %u\n", properties.timeDomainCount); + ok(counter != 0, "got %I64x\n", counter); + for (UINT i = 0; i < properties.timeDomainCount; i++) + { + ok(properties.pTimeDomains[i] != VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT, "got %#x\n", properties.pTimeDomains[i]); + ok(properties.pTimeDomains[i] != VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT, "got %#x\n", properties.pTimeDomains[i]); + if (properties.pTimeDomains[i] == VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT) has_stage_local = TRUE; + } + ok(has_stage_local, "missing VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT\n"); + + vkDestroySwapchainKHR(device, swapchain, NULL); + + vkDestroySurfaceKHR(instance, surface, NULL); + DestroyWindow(hwnd); + + vkDestroyDevice(device, NULL); +} + static const char *test_win32_surface_extensions[] = { "VK_KHR_surface", @@ -1085,6 +1176,8 @@ static void test_win32_surface(VkInstance instance, VkPhysicalDevice physical_de vkDestroyCommandPool(device, command_pool, NULL); vkDestroyDevice(device, NULL); + + test_present_timing(instance, physical_device); } static uint32_t find_memory_type(VkPhysicalDevice vk_physical_device, VkMemoryPropertyFlagBits flags, uint32_t mask) diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index a403d3b9ae8..2ab2d92b87c 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -5403,6 +5403,18 @@ void WINAPI vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, assert(!status && "vkGetPartitionedAccelerationStructuresBuildSizesNV"); } +VkResult WINAPI vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT *pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT *pPastPresentationTimingProperties) +{ + struct vkGetPastPresentationTimingEXT_params params; + NTSTATUS status; + params.device = device; + params.pPastPresentationTimingInfo = pPastPresentationTimingInfo; + params.pPastPresentationTimingProperties = pPastPresentationTimingProperties; + status = UNIX_CALL(vkGetPastPresentationTimingEXT, ¶ms); + assert(!status && "vkGetPastPresentationTimingEXT"); + return params.result; +} + VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue) { struct vkGetPerformanceParameterINTEL_params params; @@ -6434,6 +6446,32 @@ VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchai return params.result; } +VkResult WINAPI vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT *pSwapchainTimeDomainProperties, uint64_t *pTimeDomainsCounter) +{ + struct vkGetSwapchainTimeDomainPropertiesEXT_params params; + NTSTATUS status; + params.device = device; + params.swapchain = swapchain; + params.pSwapchainTimeDomainProperties = pSwapchainTimeDomainProperties; + params.pTimeDomainsCounter = pTimeDomainsCounter; + status = UNIX_CALL(vkGetSwapchainTimeDomainPropertiesEXT, ¶ms); + assert(!status && "vkGetSwapchainTimeDomainPropertiesEXT"); + return params.result; +} + +VkResult WINAPI vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT *pSwapchainTimingProperties, uint64_t *pSwapchainTimingPropertiesCounter) +{ + struct vkGetSwapchainTimingPropertiesEXT_params params; + NTSTATUS status; + params.device = device; + params.swapchain = swapchain; + params.pSwapchainTimingProperties = pSwapchainTimingProperties; + params.pSwapchainTimingPropertiesCounter = pSwapchainTimingPropertiesCounter; + status = UNIX_CALL(vkGetSwapchainTimingPropertiesEXT, ¶ms); + assert(!status && "vkGetSwapchainTimingPropertiesEXT"); + return params.result; +} + void WINAPI vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { struct vkGetTensorMemoryRequirementsARM_params params; @@ -7009,6 +7047,18 @@ VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, ui return params.result; } +VkResult WINAPI vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size) +{ + struct vkSetSwapchainPresentTimingQueueSizeEXT_params params; + NTSTATUS status; + params.device = device; + params.swapchain = swapchain; + params.size = size; + status = UNIX_CALL(vkSetSwapchainPresentTimingQueueSizeEXT, ¶ms); + assert(!status && "vkSetSwapchainPresentTimingQueueSizeEXT"); + return params.result; +} + VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) { struct vkSignalSemaphore_params params; @@ -7831,6 +7881,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetMemoryWin32HandlePropertiesKHR", vkGetMemoryWin32HandlePropertiesKHR}, {"vkGetMicromapBuildSizesEXT", vkGetMicromapBuildSizesEXT}, {"vkGetPartitionedAccelerationStructuresBuildSizesNV", vkGetPartitionedAccelerationStructuresBuildSizesNV}, + {"vkGetPastPresentationTimingEXT", vkGetPastPresentationTimingEXT}, {"vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL}, {"vkGetPipelineBinaryDataKHR", vkGetPipelineBinaryDataKHR}, {"vkGetPipelineCacheData", vkGetPipelineCacheData}, @@ -7862,6 +7913,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetShaderModuleCreateInfoIdentifierEXT", vkGetShaderModuleCreateInfoIdentifierEXT}, {"vkGetShaderModuleIdentifierEXT", vkGetShaderModuleIdentifierEXT}, {"vkGetSwapchainImagesKHR", vkGetSwapchainImagesKHR}, + {"vkGetSwapchainTimeDomainPropertiesEXT", vkGetSwapchainTimeDomainPropertiesEXT}, + {"vkGetSwapchainTimingPropertiesEXT", vkGetSwapchainTimingPropertiesEXT}, {"vkGetTensorMemoryRequirementsARM", vkGetTensorMemoryRequirementsARM}, {"vkGetTensorOpaqueCaptureDataARM", vkGetTensorOpaqueCaptureDataARM}, {"vkGetTensorOpaqueCaptureDescriptorDataARM", vkGetTensorOpaqueCaptureDescriptorDataARM}, @@ -7911,6 +7964,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkSetLatencySleepModeNV", vkSetLatencySleepModeNV}, {"vkSetPrivateData", vkSetPrivateData}, {"vkSetPrivateDataEXT", vkSetPrivateDataEXT}, + {"vkSetSwapchainPresentTimingQueueSizeEXT", vkSetSwapchainPresentTimingQueueSizeEXT}, {"vkSignalSemaphore", vkSignalSemaphore}, {"vkSignalSemaphoreKHR", vkSignalSemaphoreKHR}, {"vkTransitionImageLayout", vkTransitionImageLayout}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index b80445ed55e..46b19a0e95f 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -544,6 +544,7 @@ enum unix_call unix_vkGetMemoryWin32HandlePropertiesKHR, unix_vkGetMicromapBuildSizesEXT, unix_vkGetPartitionedAccelerationStructuresBuildSizesNV, + unix_vkGetPastPresentationTimingEXT, unix_vkGetPerformanceParameterINTEL, unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, unix_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, @@ -630,6 +631,8 @@ enum unix_call unix_vkGetShaderModuleCreateInfoIdentifierEXT, unix_vkGetShaderModuleIdentifierEXT, unix_vkGetSwapchainImagesKHR, + unix_vkGetSwapchainTimeDomainPropertiesEXT, + unix_vkGetSwapchainTimingPropertiesEXT, unix_vkGetTensorMemoryRequirementsARM, unix_vkGetTensorOpaqueCaptureDataARM, unix_vkGetTensorOpaqueCaptureDescriptorDataARM, @@ -679,6 +682,7 @@ enum unix_call unix_vkSetLatencySleepModeNV, unix_vkSetPrivateData, unix_vkSetPrivateDataEXT, + unix_vkSetSwapchainPresentTimingQueueSizeEXT, unix_vkSignalSemaphore, unix_vkSignalSemaphoreKHR, unix_vkSubmitDebugUtilsMessageEXT, @@ -4695,6 +4699,14 @@ struct vkGetPartitionedAccelerationStructuresBuildSizesNV_params VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo; }; +struct vkGetPastPresentationTimingEXT_params +{ + VkDevice device; + const VkPastPresentationTimingInfoEXT *pPastPresentationTimingInfo; + VkPastPresentationTimingPropertiesEXT *pPastPresentationTimingProperties; + VkResult result; +}; + struct vkGetPerformanceParameterINTEL_params { VkDevice device; @@ -5382,6 +5394,24 @@ struct vkGetSwapchainImagesKHR_params VkResult result; }; +struct vkGetSwapchainTimeDomainPropertiesEXT_params +{ + VkDevice device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + VkSwapchainTimeDomainPropertiesEXT *pSwapchainTimeDomainProperties; + uint64_t *pTimeDomainsCounter; + VkResult result; +}; + +struct vkGetSwapchainTimingPropertiesEXT_params +{ + VkDevice device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + VkSwapchainTimingPropertiesEXT *pSwapchainTimingProperties; + uint64_t *pSwapchainTimingPropertiesCounter; + VkResult result; +}; + struct vkGetTensorMemoryRequirementsARM_params { VkDevice device; @@ -5761,6 +5791,14 @@ struct vkSetPrivateDataEXT_params VkResult result; }; +struct vkSetSwapchainPresentTimingQueueSizeEXT_params +{ + VkDevice device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + uint32_t size; + VkResult result; +}; + struct vkSignalSemaphore_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index a468ed7270e..fbdbe2e5a61 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -92,7 +92,6 @@ UNSUPPORTED_EXTENSIONS = { # Device extensions "VK_AMD_display_native_hdr", "VK_EXT_full_screen_exclusive", - "VK_EXT_present_timing", # Needs time conversion "VK_GOOGLE_display_timing", # Relates to external_semaphore and needs type conversions in bitflags. "VK_KHR_shared_presentable_image", # Needs WSI work. @@ -271,6 +270,7 @@ MANUAL_UNIX_THUNKS = { "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", "vkGetPhysicalDeviceExternalFenceProperties", "vkGetPhysicalDeviceExternalFencePropertiesKHR", + "vkGetSwapchainTimeDomainPropertiesEXT", } # loader functions which are entirely manually implemented diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c index 5484c6d7f4d..119cba7a3ff 100644 --- a/dlls/winevulkan/vulkan.c +++ b/dlls/winevulkan/vulkan.c @@ -778,7 +778,50 @@ VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice cl instance->p_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR); } +VkResult wine_vkGetSwapchainTimeDomainPropertiesEXT(VkDevice client_device, VkSwapchainKHR client_swapchain, VkSwapchainTimeDomainPropertiesEXT *properties, uint64_t *counter) +{ + struct vulkan_swapchain *swapchain = vulkan_swapchain_from_handle(client_swapchain); + struct vulkan_device *device = vulkan_device_from_handle(client_device); + VkSwapchainTimeDomainPropertiesEXT host_properties = *properties; + uint64_t capacity = properties->timeDomainCount; + VkResult res; + + TRACE("device %p, swapchain %p, properties %p, counter %p\n", device, swapchain, properties, counter); + + host_properties.timeDomainCount = 0; + host_properties.pTimeDomainIds = NULL; + host_properties.pTimeDomains = NULL; + + res = device->p_vkGetSwapchainTimeDomainPropertiesEXT(device->host.device, swapchain->host.swapchain, &host_properties, counter); + if (res && res != VK_INCOMPLETE) return res; + + if (!(host_properties.pTimeDomainIds = calloc(host_properties.timeDomainCount, sizeof(*host_properties.pTimeDomainIds)))) + return VK_ERROR_OUT_OF_HOST_MEMORY; + if (!(host_properties.pTimeDomains = calloc(host_properties.timeDomainCount, sizeof(*host_properties.pTimeDomains)))) + { + free(host_properties.pTimeDomainIds); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + res = device->p_vkGetSwapchainTimeDomainPropertiesEXT(device->host.device, swapchain->host.swapchain, &host_properties, counter); + if (res && res != VK_INCOMPLETE) goto done; + + properties->timeDomainCount = 0; + for (uint64_t i = 0; i < host_properties.timeDomainCount; i++) + { + if (host_properties.pTimeDomains[i] == VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR) continue; + if (host_properties.pTimeDomains[i] == VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR) continue; + if (++properties->timeDomainCount > capacity) continue; + if (properties->pTimeDomains) properties->pTimeDomains[properties->timeDomainCount - 1] = host_properties.pTimeDomains[i]; + if (properties->pTimeDomainIds) properties->pTimeDomainIds[properties->timeDomainCount - 1] = host_properties.pTimeDomainIds[i]; + } + if (!properties->pTimeDomains && !properties->pTimeDomainIds) res = VK_SUCCESS; + else res = properties->timeDomainCount > capacity ? VK_INCOMPLETE : VK_SUCCESS; +done: + free(host_properties.pTimeDomainIds); + free(host_properties.pTimeDomains); + return res; +} void wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice client_physical_device, const VkPhysicalDeviceExternalSemaphoreInfo *info, diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index f6392da8c34..303e6c5735f 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -690,6 +690,12 @@ typedef struct VkPipelineVertexInputStateCreateInfo32 PTR32 pVertexAttributeDescriptions; } VkPipelineVertexInputStateCreateInfo32; +typedef struct VkPresentStageTimeEXT32 +{ + VkPresentStageFlagsEXT stage; + uint64_t DECLSPEC_ALIGN(8) time; +} VkPresentStageTimeEXT32; + typedef struct VkSampleLocationsInfoEXT32 { VkStructureType sType; @@ -1374,6 +1380,19 @@ typedef struct VkPartitionedAccelerationStructureInstancesInputNV32 uint32_t maxInstanceInGlobalPartitionCount; } VkPartitionedAccelerationStructureInstancesInputNV32; +typedef struct VkPastPresentationTimingEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint64_t DECLSPEC_ALIGN(8) presentId; + uint64_t DECLSPEC_ALIGN(8) targetTime; + uint32_t presentStageCount; + PTR32 pPresentStages; + VkTimeDomainKHR timeDomain; + uint64_t DECLSPEC_ALIGN(8) timeDomainId; + VkBool32 reportComplete; +} VkPastPresentationTimingEXT32; + typedef union VkPerformanceValueDataINTEL32 { uint32_t value32; @@ -1547,6 +1566,17 @@ typedef struct VkPresentRegionKHR32 PTR32 pRectangles; } VkPresentRegionKHR32; +typedef struct VkPresentTimingInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkPresentTimingInfoFlagsEXT flags; + uint64_t DECLSPEC_ALIGN(8) targetTime; + uint64_t DECLSPEC_ALIGN(8) timeDomainId; + VkPresentStageFlagsEXT presentStageQueries; + VkPresentStageFlagsEXT targetTimeDomainPresentStage; +} VkPresentTimingInfoEXT32; + typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32 { VkStructureType sType; @@ -4358,6 +4388,24 @@ typedef struct VkPartitionedAccelerationStructureFlagsNV32 VkBool32 enablePartitionTranslation; } VkPartitionedAccelerationStructureFlagsNV32; +typedef struct VkPastPresentationTimingInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkPastPresentationTimingFlagsEXT flags; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; +} VkPastPresentationTimingInfoEXT32; + +typedef struct VkPastPresentationTimingPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint64_t DECLSPEC_ALIGN(8) timingPropertiesCounter; + uint64_t DECLSPEC_ALIGN(8) timeDomainsCounter; + uint32_t presentationTimingCount; + PTR32 pPresentationTimings; +} VkPastPresentationTimingPropertiesEXT32; + typedef struct VkPerTileBeginInfoQCOM32 { VkStructureType sType; @@ -6415,6 +6463,15 @@ typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 } VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32; typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32; +typedef struct VkPhysicalDevicePresentTimingFeaturesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 presentTiming; + VkBool32 presentAtAbsoluteTime; + VkBool32 presentAtRelativeTime; +} VkPhysicalDevicePresentTimingFeaturesEXT32; + typedef struct VkPhysicalDevicePresentWait2FeaturesKHR32 { VkStructureType sType; @@ -8324,6 +8381,24 @@ typedef struct VkPresentRegionsKHR32 PTR32 pRegions; } VkPresentRegionsKHR32; +typedef struct VkPresentTimingSurfaceCapabilitiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 presentTimingSupported; + VkBool32 presentAtAbsoluteTimeSupported; + VkBool32 presentAtRelativeTimeSupported; + VkPresentStageFlagsEXT presentStageQueries; +} VkPresentTimingSurfaceCapabilitiesEXT32; + +typedef struct VkPresentTimingsInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t swapchainCount; + PTR32 pTimingInfos; +} VkPresentTimingsInfoEXT32; + typedef struct VkPresentWait2InfoKHR32 { VkStructureType sType; @@ -9207,6 +9282,15 @@ typedef struct VkSurfacePresentScalingCapabilitiesKHR32 } VkSurfacePresentScalingCapabilitiesKHR32; typedef VkSurfacePresentScalingCapabilitiesKHR32 VkSurfacePresentScalingCapabilitiesEXT32; +typedef struct VkSwapchainCalibratedTimestampInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + VkPresentStageFlagsEXT presentStage; + uint64_t DECLSPEC_ALIGN(8) timeDomainId; +} VkSwapchainCalibratedTimestampInfoEXT32; + typedef struct VkSwapchainCreateInfoKHR32 { VkStructureType sType; @@ -9280,6 +9364,23 @@ typedef struct VkSwapchainPresentScalingCreateInfoKHR32 } VkSwapchainPresentScalingCreateInfoKHR32; typedef VkSwapchainPresentScalingCreateInfoKHR32 VkSwapchainPresentScalingCreateInfoEXT32; +typedef struct VkSwapchainTimeDomainPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t timeDomainCount; + PTR32 pTimeDomains; + PTR32 pTimeDomainIds; +} VkSwapchainTimeDomainPropertiesEXT32; + +typedef struct VkSwapchainTimingPropertiesEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint64_t DECLSPEC_ALIGN(8) refreshDuration; + uint64_t DECLSPEC_ALIGN(8) refreshInterval; +} VkSwapchainTimingPropertiesEXT32; + typedef struct VkTensorCaptureDescriptorDataInfoARM32 { VkStructureType sType; @@ -19370,6 +19471,19 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + { + VkPhysicalDevicePresentTimingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentTimingFeaturesEXT *in_ext = (const VkPhysicalDevicePresentTimingFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->presentTiming = in_ext->presentTiming; + out_ext->presentAtAbsoluteTime = in_ext->presentAtAbsoluteTime; + out_ext->presentAtRelativeTime = in_ext->presentAtRelativeTime; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22465,6 +22579,19 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + { + VkPhysicalDevicePresentTimingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentTimingFeaturesEXT32 *in_ext = (const VkPhysicalDevicePresentTimingFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->presentTiming = in_ext->presentTiming; + out_ext->presentAtAbsoluteTime = in_ext->presentAtAbsoluteTime; + out_ext->presentAtRelativeTime = in_ext->presentAtRelativeTime; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -28716,15 +28843,94 @@ static void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkB FIXME("Unexpected pNext\n"); } -static void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCalibratedTimestampInfoKHR32 *in, VkCalibratedTimestampInfoKHR *out) +#ifdef _WIN64 +static void convert_VkCalibratedTimestampInfoKHR_win64_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR *in, VkCalibratedTimestampInfoKHR *out) { + const VkBaseInStructure *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return; out->sType = in->sType; out->pNext = NULL; out->timeDomain = in->timeDomain; - if (in->pNext) - FIXME("Unexpected pNext\n"); + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + { + VkSwapchainCalibratedTimestampInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainCalibratedTimestampInfoEXT *in_ext = (const VkSwapchainCalibratedTimestampInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT; + out_ext->pNext = NULL; + out_ext->swapchain = vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain; + out_ext->presentStage = in_ext->presentStage; + out_ext->timeDomainId = in_ext->timeDomainId; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR *in, uint32_t count) +{ + VkCalibratedTimestampInfoKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkCalibratedTimestampInfoKHR_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static void convert_VkCalibratedTimestampInfoKHR_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR32 *in, VkCalibratedTimestampInfoKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->timeDomain = in->timeDomain; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: + { + VkSwapchainCalibratedTimestampInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainCalibratedTimestampInfoEXT32 *in_ext = (const VkSwapchainCalibratedTimestampInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT; + out_ext->pNext = NULL; + out_ext->swapchain = vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain; + out_ext->presentStage = in_ext->presentStage; + out_ext->timeDomainId = in_ext->timeDomainId; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } } static const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR32 *in, uint32_t count) @@ -28737,7 +28943,7 @@ static const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_ out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkCalibratedTimestampInfoKHR_win32_to_host(&in[i], &out[i]); + convert_VkCalibratedTimestampInfoKHR_win32_to_host(ctx, &in[i], &out[i]); } return out; @@ -30138,6 +30344,133 @@ static void convert_VkPartitionedAccelerationStructureInstancesInputNV_host_to_w } +#ifdef _WIN64 +static void convert_VkPastPresentationTimingInfoEXT_win64_to_host(const VkPastPresentationTimingInfoEXT *in, VkPastPresentationTimingInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->flags = in->flags; + out->swapchain = vulkan_swapchain_from_handle(in->swapchain)->host.swapchain; +} +#endif /* _WIN64 */ + +static void convert_VkPastPresentationTimingInfoEXT_win32_to_host(const VkPastPresentationTimingInfoEXT32 *in, VkPastPresentationTimingInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->swapchain = vulkan_swapchain_from_handle(in->swapchain)->host.swapchain; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static VkPresentStageTimeEXT *convert_VkPresentStageTimeEXT_array_win32_to_host(struct conversion_context *ctx, const VkPresentStageTimeEXT32 *in, uint32_t count) +{ + VkPresentStageTimeEXT *out; + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + + return out; +} + +static void convert_VkPastPresentationTimingEXT_win32_to_host(struct conversion_context *ctx, const VkPastPresentationTimingEXT32 *in, VkPastPresentationTimingEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pPresentStages = convert_VkPresentStageTimeEXT_array_win32_to_host(ctx, (VkPresentStageTimeEXT32 *)UlongToPtr(in->pPresentStages), in->presentStageCount); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static VkPastPresentationTimingEXT *convert_VkPastPresentationTimingEXT_array_win32_to_host(struct conversion_context *ctx, const VkPastPresentationTimingEXT32 *in, uint32_t count) +{ + VkPastPresentationTimingEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPastPresentationTimingEXT_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkPastPresentationTimingPropertiesEXT_win32_to_host(struct conversion_context *ctx, const VkPastPresentationTimingPropertiesEXT32 *in, VkPastPresentationTimingPropertiesEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pPresentationTimings = convert_VkPastPresentationTimingEXT_array_win32_to_host(ctx, (VkPastPresentationTimingEXT32 *)UlongToPtr(in->pPresentationTimings), in->presentationTimingCount); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkPresentStageTimeEXT_host_to_win32(const VkPresentStageTimeEXT *in, VkPresentStageTimeEXT32 *out) +{ + if (!in) return; + + out->stage = in->stage; + out->time = in->time; +} + +static void convert_VkPresentStageTimeEXT_array_host_to_win32(const VkPresentStageTimeEXT *in, VkPresentStageTimeEXT32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkPresentStageTimeEXT_host_to_win32(&in[i], &out[i]); + } +} + +static void convert_VkPastPresentationTimingEXT_host_to_win32(const VkPastPresentationTimingEXT *in, VkPastPresentationTimingEXT32 *out) +{ + if (!in) return; + + out->presentId = in->presentId; + out->targetTime = in->targetTime; + out->presentStageCount = in->presentStageCount; + convert_VkPresentStageTimeEXT_array_host_to_win32(in->pPresentStages, (VkPresentStageTimeEXT32 *)UlongToPtr(out->pPresentStages), in->presentStageCount); + out->timeDomain = in->timeDomain; + out->timeDomainId = in->timeDomainId; + out->reportComplete = in->reportComplete; +} + +static void convert_VkPastPresentationTimingEXT_array_host_to_win32(const VkPastPresentationTimingEXT *in, VkPastPresentationTimingEXT32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkPastPresentationTimingEXT_host_to_win32(&in[i], &out[i]); + } +} + +static void convert_VkPastPresentationTimingPropertiesEXT_host_to_win32(const VkPastPresentationTimingPropertiesEXT *in, VkPastPresentationTimingPropertiesEXT32 *out) +{ + if (!in) return; + + out->timingPropertiesCounter = in->timingPropertiesCounter; + out->timeDomainsCounter = in->timeDomainsCounter; + out->presentationTimingCount = in->presentationTimingCount; + convert_VkPastPresentationTimingEXT_array_host_to_win32(in->pPresentationTimings, (VkPastPresentationTimingEXT32 *)UlongToPtr(out->pPresentationTimings), in->presentationTimingCount); +} + static void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector) { if (!in) return; @@ -32179,6 +32512,19 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + { + VkPhysicalDevicePresentTimingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentTimingFeaturesEXT32 *in_ext = (const VkPhysicalDevicePresentTimingFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->presentTiming = in_ext->presentTiming; + out_ext->presentAtAbsoluteTime = in_ext->presentAtAbsoluteTime; + out_ext->presentAtRelativeTime = in_ext->presentAtRelativeTime; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -34812,6 +35158,17 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: + { + VkPhysicalDevicePresentTimingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT); + const VkPhysicalDevicePresentTimingFeaturesEXT *in_ext = (const VkPhysicalDevicePresentTimingFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + out_ext->presentTiming = in_ext->presentTiming; + out_ext->presentAtAbsoluteTime = in_ext->presentAtAbsoluteTime; + out_ext->presentAtRelativeTime = in_ext->presentAtRelativeTime; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { VkPhysicalDevicePresentWait2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR); @@ -39705,6 +40062,15 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + { + VkPresentTimingSurfaceCapabilitiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: { VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39793,6 +40159,18 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: + { + VkPresentTimingSurfaceCapabilitiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT); + const VkPresentTimingSurfaceCapabilitiesEXT *in_ext = (const VkPresentTimingSurfaceCapabilitiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; + out_ext->presentTimingSupported = in_ext->presentTimingSupported; + out_ext->presentAtAbsoluteTimeSupported = in_ext->presentAtAbsoluteTimeSupported; + out_ext->presentAtRelativeTimeSupported = in_ext->presentAtRelativeTimeSupported; + out_ext->presentStageQueries = in_ext->presentStageQueries; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: { VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV); @@ -40952,6 +41330,43 @@ static void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModu memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t)); } +static void convert_VkSwapchainTimeDomainPropertiesEXT_win32_to_host(const VkSwapchainTimeDomainPropertiesEXT32 *in, VkSwapchainTimeDomainPropertiesEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkSwapchainTimeDomainPropertiesEXT_host_to_win32(const VkSwapchainTimeDomainPropertiesEXT *in, VkSwapchainTimeDomainPropertiesEXT32 *out) +{ + if (!in) return; + + out->timeDomainCount = in->timeDomainCount; + out->pTimeDomains = PtrToUlong(in->pTimeDomains); + out->pTimeDomainIds = PtrToUlong(in->pTimeDomainIds); +} + +static void convert_VkSwapchainTimingPropertiesEXT_win32_to_host(const VkSwapchainTimingPropertiesEXT32 *in, VkSwapchainTimingPropertiesEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkSwapchainTimingPropertiesEXT_host_to_win32(const VkSwapchainTimingPropertiesEXT *in, VkSwapchainTimingPropertiesEXT32 *out) +{ + if (!in) return; + + out->refreshDuration = in->refreshDuration; + out->refreshInterval = in->refreshInterval; +} + static void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const VkTensorMemoryRequirementsInfoARM32 *in, VkTensorMemoryRequirementsInfoARM *out) { if (!in) return; @@ -41760,6 +42175,18 @@ static void convert_VkPresentInfoKHR_win64_to_unwrapped_host(struct conversion_c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + { + VkPresentTimingsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPresentTimingsInfoEXT *in_ext = (const VkPresentTimingsInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; + out_ext->pNext = NULL; + out_ext->swapchainCount = in_ext->swapchainCount; + out_ext->pTimingInfos = in_ext->pTimingInfos; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: { VkSwapchainPresentFenceInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -41848,6 +42275,37 @@ static const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host( return out; } +static void convert_VkPresentTimingInfoEXT_win32_to_host(const VkPresentTimingInfoEXT32 *in, VkPresentTimingInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->targetTime = in->targetTime; + out->timeDomainId = in->timeDomainId; + out->presentStageQueries = in->presentStageQueries; + out->targetTimeDomainPresentStage = in->targetTimeDomainPresentStage; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkPresentTimingInfoEXT *convert_VkPresentTimingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkPresentTimingInfoEXT32 *in, uint32_t count) +{ + VkPresentTimingInfoEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPresentTimingInfoEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static const VkFence *convert_VkFence_array_win32_to_host(struct conversion_context *ctx, const VkFence *in, uint32_t count) { VkFence *out; @@ -41964,6 +42422,18 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: + { + VkPresentTimingsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPresentTimingsInfoEXT32 *in_ext = (const VkPresentTimingsInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; + out_ext->pNext = NULL; + out_ext->swapchainCount = in_ext->swapchainCount; + out_ext->pTimingInfos = convert_VkPresentTimingInfoEXT_array_win32_to_host(ctx, (const VkPresentTimingInfoEXT32 *)UlongToPtr(in_ext->pTimingInfos), in_ext->swapchainCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: { VkSwapchainPresentFenceInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -55713,10 +56183,16 @@ static NTSTATUS thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT(void *args) static NTSTATUS thunk64_vkGetCalibratedTimestampsEXT(void *args) { struct vkGetCalibratedTimestampsEXT_params *params = args; + const VkCalibratedTimestampInfoKHR *pTimestampInfos_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation); - params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation); + init_conversion_context(ctx); + pTimestampInfos_host = convert_VkCalibratedTimestampInfoKHR_array_win64_to_host(ctx, params->pTimestampInfos, params->timestampCount); + params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, pTimestampInfos_host, params->pTimestamps, params->pMaxDeviation); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -55749,10 +56225,16 @@ static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args) static NTSTATUS thunk64_vkGetCalibratedTimestampsKHR(void *args) { struct vkGetCalibratedTimestampsKHR_params *params = args; + const VkCalibratedTimestampInfoKHR *pTimestampInfos_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; 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); + init_conversion_context(ctx); + pTimestampInfos_host = convert_VkCalibratedTimestampInfoKHR_array_win64_to_host(ctx, params->pTimestampInfos, params->timestampCount); + params->result = wine_vkGetCalibratedTimestampsKHR(params->device, params->timestampCount, pTimestampInfos_host, params->pTimestamps, params->pMaxDeviation); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -58049,6 +58531,45 @@ static NTSTATUS thunk32_vkGetPartitionedAccelerationStructuresBuildSizesNV(void return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetPastPresentationTimingEXT(void *args) +{ + struct vkGetPastPresentationTimingEXT_params *params = args; + VkPastPresentationTimingInfoEXT pPastPresentationTimingInfo_host; + + TRACE("%p, %p, %p\n", params->device, params->pPastPresentationTimingInfo, params->pPastPresentationTimingProperties); + + convert_VkPastPresentationTimingInfoEXT_win64_to_host(params->pPastPresentationTimingInfo, &pPastPresentationTimingInfo_host); + params->result = vulkan_device_from_handle(params->device)->p_vkGetPastPresentationTimingEXT(vulkan_device_from_handle(params->device)->host.device, &pPastPresentationTimingInfo_host, params->pPastPresentationTimingProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetPastPresentationTimingEXT(void *args) +{ + struct + { + PTR32 device; + PTR32 pPastPresentationTimingInfo; + PTR32 pPastPresentationTimingProperties; + VkResult result; + } *params = args; + VkPastPresentationTimingInfoEXT pPastPresentationTimingInfo_host; + VkPastPresentationTimingPropertiesEXT pPastPresentationTimingProperties_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; + + TRACE("%#x, %#x, %#x\n", params->device, params->pPastPresentationTimingInfo, params->pPastPresentationTimingProperties); + + init_conversion_context(ctx); + convert_VkPastPresentationTimingInfoEXT_win32_to_host((const VkPastPresentationTimingInfoEXT32 *)UlongToPtr(params->pPastPresentationTimingInfo), &pPastPresentationTimingInfo_host); + convert_VkPastPresentationTimingPropertiesEXT_win32_to_host(ctx, (VkPastPresentationTimingPropertiesEXT32 *)UlongToPtr(params->pPastPresentationTimingProperties), &pPastPresentationTimingProperties_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetPastPresentationTimingEXT(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pPastPresentationTimingInfo_host, &pPastPresentationTimingProperties_host); + convert_VkPastPresentationTimingPropertiesEXT_host_to_win32(&pPastPresentationTimingProperties_host, (VkPastPresentationTimingPropertiesEXT32 *)UlongToPtr(params->pPastPresentationTimingProperties)); + free_conversion_context(ctx); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetPerformanceParameterINTEL(void *args) { @@ -60884,6 +61405,70 @@ static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetSwapchainTimeDomainPropertiesEXT(void *args) +{ + struct vkGetSwapchainTimeDomainPropertiesEXT_params *params = args; + + TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainTimeDomainProperties, params->pTimeDomainsCounter); + + params->result = wine_vkGetSwapchainTimeDomainPropertiesEXT(params->device, params->swapchain, params->pSwapchainTimeDomainProperties, params->pTimeDomainsCounter); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetSwapchainTimeDomainPropertiesEXT(void *args) +{ + struct + { + PTR32 device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + PTR32 pSwapchainTimeDomainProperties; + PTR32 pTimeDomainsCounter; + VkResult result; + } *params = args; + VkSwapchainTimeDomainPropertiesEXT pSwapchainTimeDomainProperties_host; + + TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainTimeDomainProperties, params->pTimeDomainsCounter); + + convert_VkSwapchainTimeDomainPropertiesEXT_win32_to_host((VkSwapchainTimeDomainPropertiesEXT32 *)UlongToPtr(params->pSwapchainTimeDomainProperties), &pSwapchainTimeDomainProperties_host); + params->result = wine_vkGetSwapchainTimeDomainPropertiesEXT((VkDevice)UlongToPtr(params->device), params->swapchain, &pSwapchainTimeDomainProperties_host, (uint64_t *)UlongToPtr(params->pTimeDomainsCounter)); + convert_VkSwapchainTimeDomainPropertiesEXT_host_to_win32(&pSwapchainTimeDomainProperties_host, (VkSwapchainTimeDomainPropertiesEXT32 *)UlongToPtr(params->pSwapchainTimeDomainProperties)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetSwapchainTimingPropertiesEXT(void *args) +{ + struct vkGetSwapchainTimingPropertiesEXT_params *params = args; + + TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainTimingProperties, params->pSwapchainTimingPropertiesCounter); + + params->result = vulkan_device_from_handle(params->device)->p_vkGetSwapchainTimingPropertiesEXT(vulkan_device_from_handle(params->device)->host.device, vulkan_swapchain_from_handle(params->swapchain)->host.swapchain, params->pSwapchainTimingProperties, params->pSwapchainTimingPropertiesCounter); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetSwapchainTimingPropertiesEXT(void *args) +{ + struct + { + PTR32 device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + PTR32 pSwapchainTimingProperties; + PTR32 pSwapchainTimingPropertiesCounter; + VkResult result; + } *params = args; + VkSwapchainTimingPropertiesEXT pSwapchainTimingProperties_host; + + TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainTimingProperties, params->pSwapchainTimingPropertiesCounter); + + convert_VkSwapchainTimingPropertiesEXT_win32_to_host((VkSwapchainTimingPropertiesEXT32 *)UlongToPtr(params->pSwapchainTimingProperties), &pSwapchainTimingProperties_host); + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetSwapchainTimingPropertiesEXT(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, vulkan_swapchain_from_handle(params->swapchain)->host.swapchain, &pSwapchainTimingProperties_host, (uint64_t *)UlongToPtr(params->pSwapchainTimingPropertiesCounter)); + convert_VkSwapchainTimingPropertiesEXT_host_to_win32(&pSwapchainTimingProperties_host, (VkSwapchainTimingPropertiesEXT32 *)UlongToPtr(params->pSwapchainTimingProperties)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetTensorMemoryRequirementsARM(void *args) { @@ -62426,6 +63011,34 @@ static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkSetSwapchainPresentTimingQueueSizeEXT(void *args) +{ + struct vkSetSwapchainPresentTimingQueueSizeEXT_params *params = args; + + TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->swapchain), params->size); + + params->result = vulkan_device_from_handle(params->device)->p_vkSetSwapchainPresentTimingQueueSizeEXT(vulkan_device_from_handle(params->device)->host.device, vulkan_swapchain_from_handle(params->swapchain)->host.swapchain, params->size); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkSetSwapchainPresentTimingQueueSizeEXT(void *args) +{ + struct + { + PTR32 device; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + uint32_t size; + VkResult result; + } *params = args; + + TRACE("%#x, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->swapchain), params->size); + + params->result = vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkSetSwapchainPresentTimingQueueSizeEXT(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, vulkan_swapchain_from_handle(params->swapchain)->host.swapchain, params->size); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkSignalSemaphore(void *args) { @@ -63824,6 +64437,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetMemoryWin32HandlePropertiesKHR, thunk64_vkGetMicromapBuildSizesEXT, thunk64_vkGetPartitionedAccelerationStructuresBuildSizesNV, + thunk64_vkGetPastPresentationTimingEXT, thunk64_vkGetPerformanceParameterINTEL, thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, thunk64_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, @@ -63910,6 +64524,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetShaderModuleCreateInfoIdentifierEXT, thunk64_vkGetShaderModuleIdentifierEXT, thunk64_vkGetSwapchainImagesKHR, + thunk64_vkGetSwapchainTimeDomainPropertiesEXT, + thunk64_vkGetSwapchainTimingPropertiesEXT, thunk64_vkGetTensorMemoryRequirementsARM, thunk64_vkGetTensorOpaqueCaptureDataARM, thunk64_vkGetTensorOpaqueCaptureDescriptorDataARM, @@ -63959,6 +64575,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkSetLatencySleepModeNV, thunk64_vkSetPrivateData, thunk64_vkSetPrivateDataEXT, + thunk64_vkSetSwapchainPresentTimingQueueSizeEXT, thunk64_vkSignalSemaphore, thunk64_vkSignalSemaphoreKHR, thunk64_vkSubmitDebugUtilsMessageEXT, @@ -64521,6 +65138,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetMemoryWin32HandlePropertiesKHR, thunk32_vkGetMicromapBuildSizesEXT, thunk32_vkGetPartitionedAccelerationStructuresBuildSizesNV, + thunk32_vkGetPastPresentationTimingEXT, thunk32_vkGetPerformanceParameterINTEL, thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, @@ -64607,6 +65225,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetShaderModuleCreateInfoIdentifierEXT, thunk32_vkGetShaderModuleIdentifierEXT, thunk32_vkGetSwapchainImagesKHR, + thunk32_vkGetSwapchainTimeDomainPropertiesEXT, + thunk32_vkGetSwapchainTimingPropertiesEXT, thunk32_vkGetTensorMemoryRequirementsARM, thunk32_vkGetTensorOpaqueCaptureDataARM, thunk32_vkGetTensorOpaqueCaptureDescriptorDataARM, @@ -64656,6 +65276,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkSetLatencySleepModeNV, thunk32_vkSetPrivateData, thunk32_vkSetPrivateDataEXT, + thunk32_vkSetSwapchainPresentTimingQueueSizeEXT, thunk32_vkSignalSemaphore, thunk32_vkSignalSemaphoreKHR, thunk32_vkSubmitDebugUtilsMessageEXT, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 730283818a2..f2d54c40d16 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -44,5 +44,6 @@ VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice ph VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); void wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties); void wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties); +VkResult wine_vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT *pSwapchainTimeDomainProperties, uint64_t *pTimeDomainsCounter); #endif /* __WINE_VULKAN_THUNKS_H */ diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 15cafddcd57..53bed1e0535 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -480,6 +480,8 @@ typedef void* VkRemoteAddressNV; #define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 #define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_EXT_present_mode_fifo_latest_ready" #define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 +#define VK_EXT_PRESENT_TIMING_EXTENSION_NAME "VK_EXT_present_timing" +#define VK_EXT_PRESENT_TIMING_SPEC_VERSION 3 #define VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME "VK_EXT_primitives_generated_query" #define VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION 1 #define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart" @@ -1126,6 +1128,7 @@ typedef VkFlags VkMemoryPropertyFlags; typedef VkFlags VkPipelineShaderStageCreateFlags; typedef VkFlags VkPipelineTessellationStateCreateFlags; typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPresentStageFlagsEXT; typedef VkFlags VkSparseImageFormatFlags; typedef VkFlags VkSparseMemoryBindFlags; typedef VkFlags64 VkTensorUsageFlagsARM; @@ -1165,6 +1168,7 @@ typedef VkFlags VkPipelineStageFlags; typedef VkFlags64 VkPipelineStageFlags2; typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR; typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPresentTimingInfoFlagsEXT; typedef VkFlags VkQueryControlFlags; typedef VkFlags VkQueryPipelineStatisticFlags; typedef VkFlags VkQueueFlags; @@ -1242,6 +1246,7 @@ typedef VkFlags VkOpticalFlowGridSizeFlagsNV; typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; typedef VkFlags VkOpticalFlowUsageFlagsNV; typedef VkFlags VkPartitionedAccelerationStructureInstanceFlagsNV; +typedef VkFlags VkPastPresentationTimingFlagsEXT; typedef VkFlags VkPerformanceCounterDescriptionFlagsARM; typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; @@ -4343,6 +4348,13 @@ typedef enum VkPartitionedAccelerationStructureOpTypeNV VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_NV_MAX_ENUM = 0x7fffffff, } VkPartitionedAccelerationStructureOpTypeNV; +typedef enum VkPastPresentationTimingFlagBitsEXT +{ + VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT = 0x00000001, + VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT = 0x00000002, + VK_PAST_PRESENTATION_TIMING_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} VkPastPresentationTimingFlagBitsEXT; + typedef enum VkPeerMemoryFeatureFlagBits { VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, @@ -4860,6 +4872,22 @@ typedef enum VkPresentScalingFlagBitsKHR } VkPresentScalingFlagBitsKHR; typedef VkPresentScalingFlagBitsKHR VkPresentScalingFlagBitsEXT; +typedef enum VkPresentStageFlagBitsEXT +{ + VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT = 0x00000001, + VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT = 0x00000002, + VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT = 0x00000004, + VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT = 0x00000008, + VK_PRESENT_STAGE_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} VkPresentStageFlagBitsEXT; + +typedef enum VkPresentTimingInfoFlagBitsEXT +{ + VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT = 0x00000001, + VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT = 0x00000002, + VK_PRESENT_TIMING_INFO_FLAG_BITS_EXT_MAX_ENUM = 0x7fffffff, +} VkPresentTimingInfoFlagBitsEXT; + typedef enum VkPrimitiveTopology { VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, @@ -5100,6 +5128,7 @@ typedef enum VkResult VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT = -1000208000, VK_ERROR_NOT_PERMITTED = -1000174001, VK_ERROR_FRAGMENTATION = -1000161000, VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, @@ -5829,6 +5858,16 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT = 1000208000, + VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT = 1000208001, + VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT = 1000208002, + VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT = 1000208003, + VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT = 1000208004, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT = 1000208005, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT = 1000208006, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT = 1000208007, + VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT = 1000208008, + VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT = 1000208009, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, @@ -6796,6 +6835,7 @@ typedef enum VkSwapchainCreateFlagBitsKHR VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, + VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT = 0x00000200, VK_SWAPCHAIN_CREATE_FLAG_BITS_KHR_MAX_ENUM = 0x7fffffff, VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, } VkSwapchainCreateFlagBitsKHR; @@ -6859,6 +6899,8 @@ typedef enum VkTimeDomainKHR 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_PRESENT_STAGE_LOCAL_EXT = 1000208000, + VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT = 1000208001, VK_TIME_DOMAIN_KHR_MAX_ENUM = 0x7fffffff, VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR, VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, @@ -9104,6 +9146,12 @@ typedef struct VkPipelineVertexInputStateCreateInfo const VkVertexInputAttributeDescription *pVertexAttributeDescriptions; } VkPipelineVertexInputStateCreateInfo; +typedef struct VkPresentStageTimeEXT +{ + VkPresentStageFlagsEXT stage; + uint64_t WINE_VK_ALIGN(8) time; +} VkPresentStageTimeEXT; + typedef struct VkRect2D { VkOffset2D offset; @@ -10045,6 +10093,19 @@ typedef struct VkPartitionedAccelerationStructureInstancesInputNV uint32_t maxInstanceInGlobalPartitionCount; } VkPartitionedAccelerationStructureInstancesInputNV; +typedef struct VkPastPresentationTimingEXT +{ + VkStructureType sType; + void *pNext; + uint64_t WINE_VK_ALIGN(8) presentId; + uint64_t WINE_VK_ALIGN(8) targetTime; + uint32_t presentStageCount; + VkPresentStageTimeEXT *pPresentStages; + VkTimeDomainKHR timeDomain; + uint64_t WINE_VK_ALIGN(8) timeDomainId; + VkBool32 reportComplete; +} VkPastPresentationTimingEXT; + typedef union VkPerformanceValueDataINTEL { uint32_t value32; @@ -10299,6 +10360,17 @@ typedef struct VkPresentRegionKHR const VkRectLayerKHR *pRectangles; } VkPresentRegionKHR; +typedef struct VkPresentTimingInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkPresentTimingInfoFlagsEXT flags; + uint64_t WINE_VK_ALIGN(8) targetTime; + uint64_t WINE_VK_ALIGN(8) timeDomainId; + VkPresentStageFlagsEXT presentStageQueries; + VkPresentStageFlagsEXT targetTimeDomainPresentStage; +} VkPresentTimingInfoEXT; + typedef struct VkQueueFamilyProperties { VkQueueFlags queueFlags; @@ -13728,6 +13800,24 @@ typedef struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV float partitionTranslation[3]; } VkPartitionedAccelerationStructureWritePartitionTranslationDataNV; +typedef struct VkPastPresentationTimingInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkPastPresentationTimingFlagsEXT flags; + VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; +} VkPastPresentationTimingInfoEXT; + +typedef struct VkPastPresentationTimingPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint64_t WINE_VK_ALIGN(8) timingPropertiesCounter; + uint64_t WINE_VK_ALIGN(8) timeDomainsCounter; + uint32_t presentationTimingCount; + VkPastPresentationTimingEXT *pPresentationTimings; +} VkPastPresentationTimingPropertiesEXT; + typedef struct VkPerTileBeginInfoQCOM { VkStructureType sType; @@ -15828,6 +15918,15 @@ typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR } VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; +typedef struct VkPhysicalDevicePresentTimingFeaturesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 presentTiming; + VkBool32 presentAtAbsoluteTime; + VkBool32 presentAtRelativeTime; +} VkPhysicalDevicePresentTimingFeaturesEXT; + typedef struct VkPhysicalDevicePresentWait2FeaturesKHR { VkStructureType sType; @@ -17753,6 +17852,24 @@ typedef struct VkPresentRegionsKHR const VkPresentRegionKHR *pRegions; } VkPresentRegionsKHR; +typedef struct VkPresentTimingSurfaceCapabilitiesEXT +{ + VkStructureType sType; + void *pNext; + VkBool32 presentTimingSupported; + VkBool32 presentAtAbsoluteTimeSupported; + VkBool32 presentAtRelativeTimeSupported; + VkPresentStageFlagsEXT presentStageQueries; +} VkPresentTimingSurfaceCapabilitiesEXT; + +typedef struct VkPresentTimingsInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t swapchainCount; + const VkPresentTimingInfoEXT *pTimingInfos; +} VkPresentTimingsInfoEXT; + typedef struct VkPresentWait2InfoKHR { VkStructureType sType; @@ -18660,6 +18777,15 @@ typedef struct VkSurfacePresentScalingCapabilitiesKHR } VkSurfacePresentScalingCapabilitiesKHR; typedef VkSurfacePresentScalingCapabilitiesKHR VkSurfacePresentScalingCapabilitiesEXT; +typedef struct VkSwapchainCalibratedTimestampInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkSwapchainKHR WINE_VK_ALIGN(8) swapchain; + VkPresentStageFlagsEXT presentStage; + uint64_t WINE_VK_ALIGN(8) timeDomainId; +} VkSwapchainCalibratedTimestampInfoEXT; + typedef struct VkSwapchainCreateInfoKHR { VkStructureType sType; @@ -18733,6 +18859,23 @@ typedef struct VkSwapchainPresentScalingCreateInfoKHR } VkSwapchainPresentScalingCreateInfoKHR; typedef VkSwapchainPresentScalingCreateInfoKHR VkSwapchainPresentScalingCreateInfoEXT; +typedef struct VkSwapchainTimeDomainPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t timeDomainCount; + VkTimeDomainKHR *pTimeDomains; + uint64_t *pTimeDomainIds; +} VkSwapchainTimeDomainPropertiesEXT; + +typedef struct VkSwapchainTimingPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint64_t WINE_VK_ALIGN(8) refreshDuration; + uint64_t WINE_VK_ALIGN(8) refreshInterval; +} VkSwapchainTimingPropertiesEXT; + typedef struct VkTensorCaptureDescriptorDataInfoARM { VkStructureType sType; @@ -20226,6 +20369,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, con typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties); typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo); typedef void (VKAPI_PTR *PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV *pInfo, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingEXT)(VkDevice device, const VkPastPresentationTimingInfoEXT *pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT *pPastPresentationTimingProperties); typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); @@ -20315,6 +20459,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier); typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier); typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimeDomainPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT *pSwapchainTimeDomainProperties, uint64_t *pTimeDomainsCounter); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimingPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT *pSwapchainTimingProperties, uint64_t *pSwapchainTimingPropertiesCounter); typedef void (VKAPI_PTR *PFN_vkGetTensorMemoryRequirementsARM)(VkDevice device, const VkTensorMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements); typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDataARM)(VkDevice device, uint32_t tensorCount, const VkTensorARM *pTensors, VkHostAddressRangeEXT *pDatas); typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM *pInfo, void *pData); @@ -20366,6 +20512,7 @@ typedef void (VKAPI_PTR *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainK typedef VkResult (VKAPI_PTR *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo); typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +typedef VkResult (VKAPI_PTR *PFN_vkSetSwapchainPresentTimingQueueSizeEXT)(VkDevice device, VkSwapchainKHR swapchain, uint32_t size); typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo); typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo); typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData); @@ -20930,6 +21077,7 @@ 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); void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV *pInfo, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo); +VkResult VKAPI_CALL vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT *pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT *pPastPresentationTimingProperties); VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue); VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); @@ -21019,6 +21167,8 @@ VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkS void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier); void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier); VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages); +VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT *pSwapchainTimeDomainProperties, uint64_t *pTimeDomainsCounter); +VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT *pSwapchainTimingProperties, uint64_t *pSwapchainTimingPropertiesCounter); void VKAPI_CALL vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements); VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, const VkTensorARM *pTensors, VkHostAddressRangeEXT *pDatas); VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM *pInfo, void *pData); @@ -21070,6 +21220,7 @@ void VKAPI_CALL vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, VkResult VKAPI_CALL vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo); VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size); VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo); VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo); void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData); @@ -21608,6 +21759,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkGetMemoryWin32HandlePropertiesKHR) \ USE_VK_FUNC(vkGetMicromapBuildSizesEXT) \ USE_VK_FUNC(vkGetPartitionedAccelerationStructuresBuildSizesNV) \ + USE_VK_FUNC(vkGetPastPresentationTimingEXT) \ USE_VK_FUNC(vkGetPerformanceParameterINTEL) \ USE_VK_FUNC(vkGetPipelineBinaryDataKHR) \ USE_VK_FUNC(vkGetPipelineCacheData) \ @@ -21640,6 +21792,8 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkGetShaderModuleCreateInfoIdentifierEXT) \ USE_VK_FUNC(vkGetShaderModuleIdentifierEXT) \ USE_VK_FUNC(vkGetSwapchainImagesKHR) \ + USE_VK_FUNC(vkGetSwapchainTimeDomainPropertiesEXT) \ + USE_VK_FUNC(vkGetSwapchainTimingPropertiesEXT) \ USE_VK_FUNC(vkGetTensorMemoryRequirementsARM) \ USE_VK_FUNC(vkGetTensorOpaqueCaptureDataARM) \ USE_VK_FUNC(vkGetTensorOpaqueCaptureDescriptorDataARM) \ @@ -21691,6 +21845,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_FUNC(vkSetLatencySleepModeNV) \ USE_VK_FUNC(vkSetPrivateData) \ USE_VK_FUNC(vkSetPrivateDataEXT) \ + USE_VK_FUNC(vkSetSwapchainPresentTimingQueueSizeEXT) \ USE_VK_FUNC(vkSignalSemaphore) \ USE_VK_FUNC(vkSignalSemaphoreKHR) \ USE_VK_FUNC(vkTransitionImageLayout) \ @@ -21828,6 +21983,7 @@ VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT(VkDevice device, uint32_t sampl USE_VK_EXT(VK_EXT_pipeline_robustness) \ USE_VK_EXT(VK_EXT_post_depth_coverage) \ USE_VK_EXT(VK_EXT_present_mode_fifo_latest_ready) \ + USE_VK_EXT(VK_EXT_present_timing) \ USE_VK_EXT(VK_EXT_primitive_topology_list_restart) \ USE_VK_EXT(VK_EXT_primitives_generated_query) \ USE_VK_EXT(VK_EXT_private_data) \ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/10152