[PATCH v3 0/1] MR4643: winevulkan: Update to VK spec version 1.3.272.

List overview All Threads

newer

older

[PATCH 0/1] MR4600: winegstreamer:...

[PATCH 0/5] MR4624: wined3d: More...

Georg Lehmann (＠DadSchoorse)

7 Dec 2023 7 Dec '23

8:15 p.m.

-- v3: winevulkan: Update to VK spec version 1.3.272.

https://gitlab.winehq.org/wine/wine/-/merge_requests/4643

Show replies by date

Georg Lehmann

7 Dec 7 Dec

8:15 p.m.

New subject: [PATCH v3 1/1] winevulkan: Update to VK spec version 1.3.272.

From: Georg Lehmann dadschoorse@gmail.com

--- dlls/winevulkan/loader_thunks.c | 78 ++++- dlls/winevulkan/loader_thunks.h | 54 ++- dlls/winevulkan/make_vulkan | 3 +- dlls/winevulkan/vulkan_thunks.c | 591 +++++++++++++++++++++++++++++++- dlls/winevulkan/vulkan_thunks.h | 14 +- dlls/winevulkan/winevulkan.json | 2 +- include/wine/vulkan.h | 173 +++++++++- 7 files changed, 895 insertions(+), 20 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index 2fbdda50b0b..f0f108e15f3 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -793,6 +793,14 @@ void WINAPI vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaun UNIX_CALL(vkCmdCuLaunchKernelNVX, &params); }

+void WINAPI vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV *pLaunchInfo) +{ + struct vkCmdCudaLaunchKernelNV_params params; + params.commandBuffer = commandBuffer; + params.pLaunchInfo = pLaunchInfo; + UNIX_CALL(vkCmdCudaLaunchKernelNV, &params); +} + void WINAPI vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) { struct vkCmdDebugMarkerBeginEXT_params params; @@ -2684,6 +2692,32 @@ VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoN return params.result; }

+VkResult WINAPI vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaFunctionNV *pFunction) +{ + struct vkCreateCudaFunctionNV_params params; + NTSTATUS status; + params.device = device; + params.pCreateInfo = pCreateInfo; + params.pAllocator = pAllocator; + params.pFunction = pFunction; + status = UNIX_CALL(vkCreateCudaFunctionNV, &params); + assert(!status && "vkCreateCudaFunctionNV"); + return params.result; +} + +VkResult WINAPI vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaModuleNV *pModule) +{ + struct vkCreateCudaModuleNV_params params; + NTSTATUS status; + params.device = device; + params.pCreateInfo = pCreateInfo; + params.pAllocator = pAllocator; + params.pModule = pModule; + status = UNIX_CALL(vkCreateCudaModuleNV, &params); + assert(!status && "vkCreateCudaModuleNV"); + return params.result; +} + VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) { struct vkCreateDebugReportCallbackEXT_params params; @@ -3261,6 +3295,28 @@ void WINAPI vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const Vk assert(!status && "vkDestroyCuModuleNVX"); }

+void WINAPI vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks *pAllocator) +{ + struct vkDestroyCudaFunctionNV_params params; + NTSTATUS status; + params.device = device; + params.function = function; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkDestroyCudaFunctionNV, &params); + assert(!status && "vkDestroyCudaFunctionNV"); +} + +void WINAPI vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks *pAllocator) +{ + struct vkDestroyCudaModuleNV_params params; + NTSTATUS status; + params.device = device; + params.module = module; + params.pAllocator = pAllocator; + status = UNIX_CALL(vkDestroyCudaModuleNV, &params); + assert(!status && "vkDestroyCudaModuleNV"); +} + void WINAPI vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) { struct vkDestroyDebugReportCallbackEXT_params params; @@ -3907,6 +3963,19 @@ VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestamp return params.result; }

+VkResult WINAPI vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t *pCacheSize, void *pCacheData) +{ + struct vkGetCudaModuleCacheNV_params params; + NTSTATUS status; + params.device = device; + params.module = module; + params.pCacheSize = pCacheSize; + params.pCacheData = pCacheData; + status = UNIX_CALL(vkGetCudaModuleCacheNV, &params); + assert(!status && "vkGetCudaModuleCacheNV"); + return params.result; +} + uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) { struct vkGetDeferredOperationMaxConcurrencyKHR_params params; @@ -4446,13 +4515,12 @@ VkResult WINAPI vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, co return params.result; }

-void WINAPI vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pTimingCount, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo) +void WINAPI vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo) { struct vkGetLatencyTimingsNV_params params; NTSTATUS status; params.device = device; params.swapchain = swapchain; - params.pTimingCount = pTimingCount; params.pLatencyMarkerInfo = pLatencyMarkerInfo; status = UNIX_CALL(vkGetLatencyTimingsNV, &params); assert(!status && "vkGetLatencyTimingsNV"); @@ -6061,6 +6129,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCmdCopyMicromapToMemoryEXT", vkCmdCopyMicromapToMemoryEXT}, {"vkCmdCopyQueryPoolResults", vkCmdCopyQueryPoolResults}, {"vkCmdCuLaunchKernelNVX", vkCmdCuLaunchKernelNVX}, + {"vkCmdCudaLaunchKernelNV", vkCmdCudaLaunchKernelNV}, {"vkCmdDebugMarkerBeginEXT", vkCmdDebugMarkerBeginEXT}, {"vkCmdDebugMarkerEndEXT", vkCmdDebugMarkerEndEXT}, {"vkCmdDebugMarkerInsertEXT", vkCmdDebugMarkerInsertEXT}, @@ -6256,6 +6325,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkCreateComputePipelines", vkCreateComputePipelines}, {"vkCreateCuFunctionNVX", vkCreateCuFunctionNVX}, {"vkCreateCuModuleNVX", vkCreateCuModuleNVX}, + {"vkCreateCudaFunctionNV", vkCreateCudaFunctionNV}, + {"vkCreateCudaModuleNV", vkCreateCudaModuleNV}, {"vkCreateDeferredOperationKHR", vkCreateDeferredOperationKHR}, {"vkCreateDescriptorPool", vkCreateDescriptorPool}, {"vkCreateDescriptorSetLayout", vkCreateDescriptorSetLayout}, @@ -6298,6 +6369,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkDestroyCommandPool", vkDestroyCommandPool}, {"vkDestroyCuFunctionNVX", vkDestroyCuFunctionNVX}, {"vkDestroyCuModuleNVX", vkDestroyCuModuleNVX}, + {"vkDestroyCudaFunctionNV", vkDestroyCudaFunctionNV}, + {"vkDestroyCudaModuleNV", vkDestroyCudaModuleNV}, {"vkDestroyDeferredOperationKHR", vkDestroyDeferredOperationKHR}, {"vkDestroyDescriptorPool", vkDestroyDescriptorPool}, {"vkDestroyDescriptorSetLayout", vkDestroyDescriptorSetLayout}, @@ -6348,6 +6421,7 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetBufferOpaqueCaptureAddressKHR", vkGetBufferOpaqueCaptureAddressKHR}, {"vkGetBufferOpaqueCaptureDescriptorDataEXT", vkGetBufferOpaqueCaptureDescriptorDataEXT}, {"vkGetCalibratedTimestampsEXT", vkGetCalibratedTimestampsEXT}, + {"vkGetCudaModuleCacheNV", vkGetCudaModuleCacheNV}, {"vkGetDeferredOperationMaxConcurrencyKHR", vkGetDeferredOperationMaxConcurrencyKHR}, {"vkGetDeferredOperationResultKHR", vkGetDeferredOperationResultKHR}, {"vkGetDescriptorEXT", vkGetDescriptorEXT}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index 07b53017143..2c54017e0c9 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -92,6 +92,7 @@ enum unix_call unix_vkCmdCopyMicromapToMemoryEXT, unix_vkCmdCopyQueryPoolResults, unix_vkCmdCuLaunchKernelNVX, + unix_vkCmdCudaLaunchKernelNV, unix_vkCmdDebugMarkerBeginEXT, unix_vkCmdDebugMarkerEndEXT, unix_vkCmdDebugMarkerInsertEXT, @@ -287,6 +288,8 @@ enum unix_call unix_vkCreateComputePipelines, unix_vkCreateCuFunctionNVX, unix_vkCreateCuModuleNVX, + unix_vkCreateCudaFunctionNV, + unix_vkCreateCudaModuleNV, unix_vkCreateDebugReportCallbackEXT, unix_vkCreateDebugUtilsMessengerEXT, unix_vkCreateDeferredOperationKHR, @@ -335,6 +338,8 @@ enum unix_call unix_vkDestroyCommandPool, unix_vkDestroyCuFunctionNVX, unix_vkDestroyCuModuleNVX, + unix_vkDestroyCudaFunctionNV, + unix_vkDestroyCudaModuleNV, unix_vkDestroyDebugReportCallbackEXT, unix_vkDestroyDebugUtilsMessengerEXT, unix_vkDestroyDeferredOperationKHR, @@ -397,6 +402,7 @@ enum unix_call unix_vkGetBufferOpaqueCaptureAddressKHR, unix_vkGetBufferOpaqueCaptureDescriptorDataEXT, unix_vkGetCalibratedTimestampsEXT, + unix_vkGetCudaModuleCacheNV, unix_vkGetDeferredOperationMaxConcurrencyKHR, unix_vkGetDeferredOperationResultKHR, unix_vkGetDescriptorEXT, @@ -1184,6 +1190,12 @@ struct vkCmdCuLaunchKernelNVX_params const VkCuLaunchInfoNVX *pLaunchInfo; };

+struct vkCmdCudaLaunchKernelNV_params +{ + VkCommandBuffer commandBuffer; + const VkCudaLaunchInfoNV *pLaunchInfo; +}; + struct vkCmdDebugMarkerBeginEXT_params { VkCommandBuffer commandBuffer; @@ -2657,6 +2669,24 @@ struct vkCreateCuModuleNVX_params VkResult result; };

+struct vkCreateCudaFunctionNV_params +{ + VkDevice device; + const VkCudaFunctionCreateInfoNV *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkCudaFunctionNV *pFunction; + VkResult result; +}; + +struct vkCreateCudaModuleNV_params +{ + VkDevice device; + const VkCudaModuleCreateInfoNV *pCreateInfo; + const VkAllocationCallbacks *pAllocator; + VkCudaModuleNV *pModule; + VkResult result; +}; + struct vkCreateDebugReportCallbackEXT_params { VkInstance instance; @@ -3080,6 +3110,20 @@ struct vkDestroyCuModuleNVX_params const VkAllocationCallbacks *pAllocator; };

+struct vkDestroyCudaFunctionNV_params +{ + VkDevice device; + VkCudaFunctionNV DECLSPEC_ALIGN(8) function; + const VkAllocationCallbacks *pAllocator; +}; + +struct vkDestroyCudaModuleNV_params +{ + VkDevice device; + VkCudaModuleNV DECLSPEC_ALIGN(8) module; + const VkAllocationCallbacks *pAllocator; +}; + struct vkDestroyDebugReportCallbackEXT_params { VkInstance instance; @@ -3532,6 +3576,15 @@ struct vkGetCalibratedTimestampsEXT_params VkResult result; };

+struct vkGetCudaModuleCacheNV_params +{ + VkDevice device; + VkCudaModuleNV DECLSPEC_ALIGN(8) module; + size_t *pCacheSize; + void *pCacheData; + VkResult result; +}; + struct vkGetDeferredOperationMaxConcurrencyKHR_params { VkDevice device; @@ -3889,7 +3942,6 @@ struct vkGetLatencyTimingsNV_params { VkDevice device; VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; - uint32_t *pTimingCount; VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo; };

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 65b79bc25af..ecc84b54a51 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.267" +VK_XML_VERSION = "1.3.272" WINE_VK_VERSION = (1, 3)

# Filenames to create. @@ -95,6 +95,7 @@ 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 113b529c560..166ce23ad03 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -849,6 +849,24 @@ typedef struct VkCuLaunchInfoNVX32 PTR32 pExtras; } VkCuLaunchInfoNVX32;

+typedef struct VkCudaLaunchInfoNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkCudaFunctionNV DECLSPEC_ALIGN(8) function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + PTR32 paramCount; + PTR32 pParams; + PTR32 extraCount; + PTR32 pExtras; +} VkCudaLaunchInfoNV32; + typedef struct VkDebugMarkerMarkerInfoEXT32 { VkStructureType sType; @@ -1473,6 +1491,22 @@ typedef struct VkCuModuleCreateInfoNVX32 PTR32 pData; } VkCuModuleCreateInfoNVX32;

+typedef struct VkCudaFunctionCreateInfoNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkCudaModuleNV DECLSPEC_ALIGN(8) module; + PTR32 pName; +} VkCudaFunctionCreateInfoNV32; + +typedef struct VkCudaModuleCreateInfoNV32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 dataSize; + PTR32 pData; +} VkCudaModuleCreateInfoNV32; + typedef struct VkDebugReportCallbackCreateInfoEXT32 { VkStructureType sType; @@ -1588,6 +1622,13 @@ typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR32 } VkDeviceQueueGlobalPriorityCreateInfoKHR32; typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;

+typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t shaderCoreCount; +} VkDeviceQueueShaderCoreControlCreateInfoARM32; + typedef struct VkDeviceQueueCreateInfo32 { VkStructureType sType; @@ -3050,6 +3091,27 @@ typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 VkBool32 descriptorPoolOverallocation; } VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32;

+typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 cudaKernelLaunchFeatures; +} VkPhysicalDeviceCudaKernelLaunchFeaturesNV32; + +typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 schedulingControls; +} VkPhysicalDeviceSchedulingControlsFeaturesARM32; + +typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 relaxedLineRasterization; +} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32; + typedef struct VkDeviceCreateInfo32 { VkStructureType sType; @@ -3665,6 +3727,15 @@ typedef struct VkIndirectCommandsLayoutCreateInfoNV32 PTR32 pStreamStrides; } VkIndirectCommandsLayoutCreateInfoNV32;

+typedef struct VkLayerSettingEXT32 +{ + PTR32 pLayerName; + PTR32 pSettingName; + VkLayerSettingTypeEXT type; + uint32_t valueCount; + PTR32 pValues; +} VkLayerSettingEXT32; + typedef struct VkApplicationInfo32 { VkStructureType sType; @@ -3694,6 +3765,14 @@ typedef struct VkValidationFeaturesEXT32 PTR32 pDisabledValidationFeatures; } VkValidationFeaturesEXT32;

+typedef struct VkLayerSettingsCreateInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t settingCount; + PTR32 pSettings; +} VkLayerSettingsCreateInfoEXT32; + typedef struct VkInstanceCreateInfo32 { VkStructureType sType; @@ -4721,6 +4800,7 @@ typedef struct VkGetLatencyMarkerInfoNV32 { VkStructureType sType; PTR32 pNext; + uint32_t timingCount; PTR32 pTimings; } VkGetLatencyMarkerInfoNV32;

@@ -6087,6 +6167,21 @@ typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT32 VkLayeredDriverUnderlyingApiMSFT underlyingAPI; } VkPhysicalDeviceLayeredDriverPropertiesMSFT32;

+typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t computeCapabilityMinor; + uint32_t computeCapabilityMajor; +} VkPhysicalDeviceCudaKernelLaunchPropertiesNV32; + +typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM32 +{ + VkStructureType sType; + PTR32 pNext; + VkPhysicalDeviceSchedulingControlsFlagsARM DECLSPEC_ALIGN(8) schedulingControlsFlags; +} VkPhysicalDeviceSchedulingControlsPropertiesARM32; + typedef struct VkPhysicalDeviceProperties232 { VkStructureType sType; @@ -8522,6 +8617,28 @@ static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoN FIXME("Unexpected pNext\n"); }

+static inline void convert_VkCudaLaunchInfoNV_win32_to_host(const VkCudaLaunchInfoNV32 *in, VkCudaLaunchInfoNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->function = in->function; + out->gridDimX = in->gridDimX; + out->gridDimY = in->gridDimY; + out->gridDimZ = in->gridDimZ; + out->blockDimX = in->blockDimX; + out->blockDimY = in->blockDimY; + out->blockDimZ = in->blockDimZ; + out->sharedMemBytes = in->sharedMemBytes; + out->paramCount = in->paramCount; + out->pParams = (const void * const *)UlongToPtr(in->pParams); + out->extraCount = in->extraCount; + out->pExtras = (const void * const *)UlongToPtr(in->pExtras); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out) { if (!in) return; @@ -10221,6 +10338,30 @@ static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModul FIXME("Unexpected pNext\n"); }

+static inline void convert_VkCudaFunctionCreateInfoNV_win32_to_host(const VkCudaFunctionCreateInfoNV32 *in, VkCudaFunctionCreateInfoNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->module = in->module; + out->pName = (const char *)UlongToPtr(in->pName); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static inline void convert_VkCudaModuleCreateInfoNV_win32_to_host(const VkCudaModuleCreateInfoNV32 *in, VkCudaModuleCreateInfoNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->dataSize = in->dataSize; + out->pData = (const void *)UlongToPtr(in->pData); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out) { if (!in) return; @@ -10505,6 +10646,17 @@ static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversi out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + { + VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->shaderCoreCount = in_ext->shaderCoreCount; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -12651,6 +12803,50 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co 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)); + const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *in_ext = (const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cudaKernelLaunchFeatures = in_ext->cudaKernelLaunchFeatures; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + { + VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceQueueShaderCoreControlCreateInfoARM *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->shaderCoreCount = in_ext->shaderCoreCount; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + { + VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->schedulingControls = in_ext->schedulingControls; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + out_ext->pNext = NULL; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -14765,6 +14961,50 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co 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)); + const VkPhysicalDeviceCudaKernelLaunchFeaturesNV32 *in_ext = (const VkPhysicalDeviceCudaKernelLaunchFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cudaKernelLaunchFeatures = in_ext->cudaKernelLaunchFeatures; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + { + VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->shaderCoreCount = in_ext->shaderCoreCount; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + { + VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->schedulingControls = in_ext->schedulingControls; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + out_ext->pNext = NULL; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -16388,6 +16628,33 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(st FIXME("Unexpected pNext\n"); }

+static inline void convert_VkLayerSettingEXT_win32_to_host(const VkLayerSettingEXT32 *in, VkLayerSettingEXT *out) +{ + if (!in) return; + + out->pLayerName = (const char *)UlongToPtr(in->pLayerName); + out->pSettingName = (const char *)UlongToPtr(in->pSettingName); + out->type = in->type; + out->valueCount = in->valueCount; + out->pValues = (const void *)UlongToPtr(in->pValues); +} + +static inline const VkLayerSettingEXT *convert_VkLayerSettingEXT_array_win32_to_host(struct conversion_context *ctx, const VkLayerSettingEXT32 *in, uint32_t count) +{ + VkLayerSettingEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkLayerSettingEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out) { if (!in) return; @@ -16481,6 +16748,18 @@ static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + { + VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkLayerSettingsCreateInfoEXT *in_ext = (const VkLayerSettingsCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->settingCount = in_ext->settingCount; + out_ext->pSettings = in_ext->pSettings; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: { VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -16565,6 +16844,18 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + { + VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkLayerSettingsCreateInfoEXT32 *in_ext = (const VkLayerSettingsCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->settingCount = in_ext->settingCount; + out_ext->pSettings = convert_VkLayerSettingEXT_array_win32_to_host(ctx, (const VkLayerSettingEXT32 *)UlongToPtr(in_ext->pSettings), in_ext->settingCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: { VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -19428,7 +19719,8 @@ static inline void convert_VkGetLatencyMarkerInfoNV_win32_to_host(struct convers

out->sType = in->sType; out->pNext = NULL; - out->pTimings = convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(ctx, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(in->pTimings), 1); + out->timingCount = in->timingCount; + out->pTimings = convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(ctx, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(in->pTimings), in->timingCount); if (in->pNext) FIXME("Unexpected pNext\n"); } @@ -19437,7 +19729,8 @@ static inline void convert_VkGetLatencyMarkerInfoNV_host_to_win32(const VkGetLat { if (!in) return;

- convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(in->pTimings, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(out->pTimings), 1); + out->timingCount = in->timingCount; + convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(in->pTimings, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(out->pTimings), in->timingCount); }

static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out) @@ -21796,6 +22089,39 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver 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)); + const VkPhysicalDeviceCudaKernelLaunchFeaturesNV32 *in_ext = (const VkPhysicalDeviceCudaKernelLaunchFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->cudaKernelLaunchFeatures = in_ext->cudaKernelLaunchFeatures; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + { + VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + out_ext->pNext = NULL; + out_ext->schedulingControls = in_ext->schedulingControls; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + out_ext->pNext = NULL; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -23507,6 +23833,33 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi 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); + const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *in_ext = (const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; + out_ext->cudaKernelLaunchFeatures = in_ext->cudaKernelLaunchFeatures; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + { + VkPhysicalDeviceSchedulingControlsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM); + const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + out_ext->schedulingControls = in_ext->schedulingControls; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + out_header = (void *)out_ext; + break; + } default: break; } @@ -24906,6 +25259,26 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + { + VkPhysicalDeviceCudaKernelLaunchPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + { + VkPhysicalDeviceSchedulingControlsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSchedulingControlsPropertiesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsPropertiesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; + out_ext->pNext = NULL; + out_ext->schedulingControlsFlags = in_ext->schedulingControlsFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -26031,6 +26404,25 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + { + VkPhysicalDeviceCudaKernelLaunchPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV); + const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *in_ext = (const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; + out_ext->computeCapabilityMinor = in_ext->computeCapabilityMinor; + out_ext->computeCapabilityMajor = in_ext->computeCapabilityMajor; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + { + VkPhysicalDeviceSchedulingControlsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM); + const VkPhysicalDeviceSchedulingControlsPropertiesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; + out_ext->schedulingControlsFlags = in_ext->schedulingControlsFlags; + out_header = (void *)out_ext; + break; + } default: break; } @@ -30306,6 +30698,28 @@ static void thunk32_vkCmdCuLaunchKernelNVX(void *args) wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pLaunchInfo_host); }

+#ifdef _WIN64 +static void thunk64_vkCmdCudaLaunchKernelNV(void *args) +{ + struct vkCmdCudaLaunchKernelNV_params *params = args; + + wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCudaLaunchKernelNV(wine_cmd_buffer_from_handle(params->commandBuffer)->host_command_buffer, params->pLaunchInfo); +} +#endif /* _WIN64 */ + +static void thunk32_vkCmdCudaLaunchKernelNV(void *args) +{ + struct + { + PTR32 commandBuffer; + PTR32 pLaunchInfo; + } *params = args; + VkCudaLaunchInfoNV pLaunchInfo_host; + + convert_VkCudaLaunchInfoNV_win32_to_host((const VkCudaLaunchInfoNV32 *)UlongToPtr(params->pLaunchInfo), &pLaunchInfo_host); + wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCudaLaunchKernelNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->host_command_buffer, &pLaunchInfo_host); +} + #ifdef _WIN64 static void thunk64_vkCmdDebugMarkerBeginEXT(void *args) { @@ -34898,6 +35312,68 @@ static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateCudaFunctionNV(void *args) +{ + struct vkCreateCudaFunctionNV_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCudaFunctionNV(wine_device_from_handle(params->device)->host_device, params->pCreateInfo, NULL, params->pFunction); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateCudaFunctionNV(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pFunction; + VkResult result; + } *params = args; + VkCudaFunctionCreateInfoNV pCreateInfo_host; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction); + + convert_VkCudaFunctionCreateInfoNV_win32_to_host((const VkCudaFunctionCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateCudaFunctionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, (VkCudaFunctionNV *)UlongToPtr(params->pFunction)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkCreateCudaModuleNV(void *args) +{ + struct vkCreateCudaModuleNV_params *params = args; + + TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCudaModuleNV(wine_device_from_handle(params->device)->host_device, params->pCreateInfo, NULL, params->pModule); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkCreateCudaModuleNV(void *args) +{ + struct + { + PTR32 device; + PTR32 pCreateInfo; + PTR32 pAllocator; + PTR32 pModule; + VkResult result; + } *params = args; + VkCudaModuleCreateInfoNV pCreateInfo_host; + + TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule); + + convert_VkCudaModuleCreateInfoNV_win32_to_host((const VkCudaModuleCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateCudaModuleNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, &pCreateInfo_host, NULL, (VkCudaModuleNV *)UlongToPtr(params->pModule)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkCreateDebugReportCallbackEXT(void *args) { @@ -36514,6 +36990,60 @@ static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyCudaFunctionNV(void *args) +{ + struct vkDestroyCudaFunctionNV_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator); + + wine_device_from_handle(params->device)->funcs.p_vkDestroyCudaFunctionNV(wine_device_from_handle(params->device)->host_device, params->function, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyCudaFunctionNV(void *args) +{ + struct + { + PTR32 device; + VkCudaFunctionNV DECLSPEC_ALIGN(8) function; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator); + + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCudaFunctionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->function, NULL); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkDestroyCudaModuleNV(void *args) +{ + struct vkDestroyCudaModuleNV_params *params = args; + + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator); + + wine_device_from_handle(params->device)->funcs.p_vkDestroyCudaModuleNV(wine_device_from_handle(params->device)->host_device, params->module, NULL); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkDestroyCudaModuleNV(void *args) +{ + struct + { + PTR32 device; + VkCudaModuleNV DECLSPEC_ALIGN(8) module; + PTR32 pAllocator; + } *params = args; + + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator); + + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCudaModuleNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->module, NULL); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkDestroyDebugReportCallbackEXT(void *args) { @@ -38323,6 +38853,38 @@ static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args) return STATUS_SUCCESS; }

+#ifdef _WIN64 +static NTSTATUS thunk64_vkGetCudaModuleCacheNV(void *args) +{ + struct vkGetCudaModuleCacheNV_params *params = args; + + TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pCacheSize, params->pCacheData); + + params->result = wine_device_from_handle(params->device)->funcs.p_vkGetCudaModuleCacheNV(wine_device_from_handle(params->device)->host_device, params->module, params->pCacheSize, params->pCacheData); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetCudaModuleCacheNV(void *args) +{ + struct + { + PTR32 device; + VkCudaModuleNV DECLSPEC_ALIGN(8) module; + PTR32 pCacheSize; + PTR32 pCacheData; + VkResult result; + } *params = args; + size_t pCacheSize_host; + + TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->module), params->pCacheSize, params->pCacheData); + + pCacheSize_host = *(PTR32 *)UlongToPtr(params->pCacheSize); + params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetCudaModuleCacheNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->module, &pCacheSize_host, (void *)UlongToPtr(params->pCacheData)); + *(PTR32 *)UlongToPtr(params->pCacheSize) = pCacheSize_host; + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetDeferredOperationMaxConcurrencyKHR(void *args) { @@ -39844,9 +40406,9 @@ static NTSTATUS thunk64_vkGetLatencyTimingsNV(void *args) { struct vkGetLatencyTimingsNV_params *params = args;

- TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pTimingCount, params->pLatencyMarkerInfo); + TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pLatencyMarkerInfo);

- wine_device_from_handle(params->device)->funcs.p_vkGetLatencyTimingsNV(wine_device_from_handle(params->device)->host_device, params->swapchain, params->pTimingCount, params->pLatencyMarkerInfo); + wine_device_from_handle(params->device)->funcs.p_vkGetLatencyTimingsNV(wine_device_from_handle(params->device)->host_device, params->swapchain, params->pLatencyMarkerInfo); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -39857,18 +40419,17 @@ static NTSTATUS thunk32_vkGetLatencyTimingsNV(void *args) { PTR32 device; VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; - PTR32 pTimingCount; PTR32 pLatencyMarkerInfo; } *params = args; VkGetLatencyMarkerInfoNV pLatencyMarkerInfo_host; struct conversion_context local_ctx; struct conversion_context *ctx = &local_ctx;

- TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pTimingCount, params->pLatencyMarkerInfo); + TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pLatencyMarkerInfo);

init_conversion_context(ctx); convert_VkGetLatencyMarkerInfoNV_win32_to_host(ctx, (VkGetLatencyMarkerInfoNV32 *)UlongToPtr(params->pLatencyMarkerInfo), &pLatencyMarkerInfo_host); - wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetLatencyTimingsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->swapchain, (uint32_t *)UlongToPtr(params->pTimingCount), &pLatencyMarkerInfo_host); + wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetLatencyTimingsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->host_device, params->swapchain, &pLatencyMarkerInfo_host); convert_VkGetLatencyMarkerInfoNV_host_to_win32(&pLatencyMarkerInfo_host, (VkGetLatencyMarkerInfoNV32 *)UlongToPtr(params->pLatencyMarkerInfo)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -43987,6 +44548,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_scheduling_controls", "VK_ARM_shader_core_builtins", "VK_ARM_shader_core_properties", "VK_EXT_4444_formats", @@ -44101,6 +44663,7 @@ static const char * const vk_device_extensions[] = "VK_HUAWEI_subpass_shading", "VK_IMG_filter_cubic", "VK_IMG_format_pvrtc", + "VK_IMG_relaxed_line_rasterization", "VK_INTEL_performance_query", "VK_INTEL_shader_integer_functions2", "VK_KHR_16bit_storage", @@ -44181,6 +44744,7 @@ static const char * const vk_device_extensions[] = "VK_NV_copy_memory_indirect", "VK_NV_corner_sampled_image", "VK_NV_coverage_reduction_mode", + "VK_NV_cuda_kernel_launch", "VK_NV_dedicated_allocation", "VK_NV_dedicated_allocation_image_aliasing", "VK_NV_descriptor_pool_overallocation", @@ -44237,6 +44801,7 @@ static const char * const vk_instance_extensions[] = { "VK_EXT_debug_report", "VK_EXT_debug_utils", + "VK_EXT_layer_settings", "VK_EXT_surface_maintenance1", "VK_EXT_swapchain_colorspace", "VK_EXT_validation_features", @@ -44372,6 +44937,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk64_vkCmdCopyMicromapToMemoryEXT, (void *)thunk64_vkCmdCopyQueryPoolResults, (void *)thunk64_vkCmdCuLaunchKernelNVX, + (void *)thunk64_vkCmdCudaLaunchKernelNV, (void *)thunk64_vkCmdDebugMarkerBeginEXT, (void *)thunk64_vkCmdDebugMarkerEndEXT, (void *)thunk64_vkCmdDebugMarkerInsertEXT, @@ -44567,6 +45133,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkCreateComputePipelines, thunk64_vkCreateCuFunctionNVX, thunk64_vkCreateCuModuleNVX, + thunk64_vkCreateCudaFunctionNV, + thunk64_vkCreateCudaModuleNV, thunk64_vkCreateDebugReportCallbackEXT, thunk64_vkCreateDebugUtilsMessengerEXT, thunk64_vkCreateDeferredOperationKHR, @@ -44615,6 +45183,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkDestroyCommandPool, thunk64_vkDestroyCuFunctionNVX, thunk64_vkDestroyCuModuleNVX, + thunk64_vkDestroyCudaFunctionNV, + thunk64_vkDestroyCudaModuleNV, thunk64_vkDestroyDebugReportCallbackEXT, thunk64_vkDestroyDebugUtilsMessengerEXT, thunk64_vkDestroyDeferredOperationKHR, @@ -44677,6 +45247,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetBufferOpaqueCaptureAddressKHR, thunk64_vkGetBufferOpaqueCaptureDescriptorDataEXT, thunk64_vkGetCalibratedTimestampsEXT, + thunk64_vkGetCudaModuleCacheNV, thunk64_vkGetDeferredOperationMaxConcurrencyKHR, thunk64_vkGetDeferredOperationResultKHR, (void *)thunk64_vkGetDescriptorEXT, @@ -44944,6 +45515,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = (void *)thunk32_vkCmdCopyMicromapToMemoryEXT, (void *)thunk32_vkCmdCopyQueryPoolResults, (void *)thunk32_vkCmdCuLaunchKernelNVX, + (void *)thunk32_vkCmdCudaLaunchKernelNV, (void *)thunk32_vkCmdDebugMarkerBeginEXT, (void *)thunk32_vkCmdDebugMarkerEndEXT, (void *)thunk32_vkCmdDebugMarkerInsertEXT, @@ -45139,6 +45711,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkCreateComputePipelines, thunk32_vkCreateCuFunctionNVX, thunk32_vkCreateCuModuleNVX, + thunk32_vkCreateCudaFunctionNV, + thunk32_vkCreateCudaModuleNV, thunk32_vkCreateDebugReportCallbackEXT, thunk32_vkCreateDebugUtilsMessengerEXT, thunk32_vkCreateDeferredOperationKHR, @@ -45187,6 +45761,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkDestroyCommandPool, thunk32_vkDestroyCuFunctionNVX, thunk32_vkDestroyCuModuleNVX, + thunk32_vkDestroyCudaFunctionNV, + thunk32_vkDestroyCudaModuleNV, thunk32_vkDestroyDebugReportCallbackEXT, thunk32_vkDestroyDebugUtilsMessengerEXT, thunk32_vkDestroyDeferredOperationKHR, @@ -45249,6 +45825,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetBufferOpaqueCaptureAddressKHR, thunk32_vkGetBufferOpaqueCaptureDescriptorDataEXT, thunk32_vkGetCalibratedTimestampsEXT, + thunk32_vkGetCudaModuleCacheNV, thunk32_vkGetDeferredOperationMaxConcurrencyKHR, thunk32_vkGetDeferredOperationResultKHR, (void *)thunk32_vkGetDescriptorEXT, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 7fe9190aaa6..8b0d43fadf5 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -139,6 +139,7 @@ struct vulkan_device_funcs void (*p_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer, const VkCopyMicromapToMemoryInfoEXT *); void (*p_vkCmdCopyQueryPoolResults)(VkCommandBuffer, VkQueryPool, uint32_t, uint32_t, VkBuffer, VkDeviceSize, VkDeviceSize, VkQueryResultFlags); void (*p_vkCmdCuLaunchKernelNVX)(VkCommandBuffer, const VkCuLaunchInfoNVX *); + void (*p_vkCmdCudaLaunchKernelNV)(VkCommandBuffer, const VkCudaLaunchInfoNV *); void (*p_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT *); void (*p_vkCmdDebugMarkerEndEXT)(VkCommandBuffer); void (*p_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT *); @@ -334,6 +335,8 @@ struct vulkan_device_funcs VkResult (*p_vkCreateComputePipelines)(VkDevice, VkPipelineCache, uint32_t, const VkComputePipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *); VkResult (*p_vkCreateCuFunctionNVX)(VkDevice, const VkCuFunctionCreateInfoNVX *, const VkAllocationCallbacks *, VkCuFunctionNVX *); VkResult (*p_vkCreateCuModuleNVX)(VkDevice, const VkCuModuleCreateInfoNVX *, const VkAllocationCallbacks *, VkCuModuleNVX *); + VkResult (*p_vkCreateCudaFunctionNV)(VkDevice, const VkCudaFunctionCreateInfoNV *, const VkAllocationCallbacks *, VkCudaFunctionNV *); + VkResult (*p_vkCreateCudaModuleNV)(VkDevice, const VkCudaModuleCreateInfoNV *, const VkAllocationCallbacks *, VkCudaModuleNV *); VkResult (*p_vkCreateDeferredOperationKHR)(VkDevice, const VkAllocationCallbacks *, VkDeferredOperationKHR *); VkResult (*p_vkCreateDescriptorPool)(VkDevice, const VkDescriptorPoolCreateInfo *, const VkAllocationCallbacks *, VkDescriptorPool *); VkResult (*p_vkCreateDescriptorSetLayout)(VkDevice, const VkDescriptorSetLayoutCreateInfo *, const VkAllocationCallbacks *, VkDescriptorSetLayout *); @@ -376,6 +379,8 @@ struct vulkan_device_funcs void (*p_vkDestroyCommandPool)(VkDevice, VkCommandPool, const VkAllocationCallbacks *); void (*p_vkDestroyCuFunctionNVX)(VkDevice, VkCuFunctionNVX, const VkAllocationCallbacks *); void (*p_vkDestroyCuModuleNVX)(VkDevice, VkCuModuleNVX, const VkAllocationCallbacks *); + void (*p_vkDestroyCudaFunctionNV)(VkDevice, VkCudaFunctionNV, const VkAllocationCallbacks *); + void (*p_vkDestroyCudaModuleNV)(VkDevice, VkCudaModuleNV, const VkAllocationCallbacks *); void (*p_vkDestroyDeferredOperationKHR)(VkDevice, VkDeferredOperationKHR, const VkAllocationCallbacks *); void (*p_vkDestroyDescriptorPool)(VkDevice, VkDescriptorPool, const VkAllocationCallbacks *); void (*p_vkDestroyDescriptorSetLayout)(VkDevice, VkDescriptorSetLayout, const VkAllocationCallbacks *); @@ -426,6 +431,7 @@ struct vulkan_device_funcs 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_vkGetCudaModuleCacheNV)(VkDevice, VkCudaModuleNV, size_t *, void *); uint32_t (*p_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice, VkDeferredOperationKHR); VkResult (*p_vkGetDeferredOperationResultKHR)(VkDevice, VkDeferredOperationKHR); void (*p_vkGetDescriptorEXT)(VkDevice, const VkDescriptorGetInfoEXT *, size_t, void *); @@ -473,7 +479,7 @@ struct vulkan_device_funcs VkResult (*p_vkGetImageViewAddressNVX)(VkDevice, VkImageView, VkImageViewAddressPropertiesNVX *); uint32_t (*p_vkGetImageViewHandleNVX)(VkDevice, const VkImageViewHandleInfoNVX *); VkResult (*p_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageViewCaptureDescriptorDataInfoEXT *, void *); - void (*p_vkGetLatencyTimingsNV)(VkDevice, VkSwapchainKHR, uint32_t *, VkGetLatencyMarkerInfoNV *); + void (*p_vkGetLatencyTimingsNV)(VkDevice, VkSwapchainKHR, VkGetLatencyMarkerInfoNV *); VkResult (*p_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *); void (*p_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *); VkResult (*p_vkGetPerformanceParameterINTEL)(VkDevice, VkPerformanceParameterTypeINTEL, VkPerformanceValueINTEL *); @@ -695,6 +701,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCmdCopyMicromapToMemoryEXT) \ USE_VK_FUNC(vkCmdCopyQueryPoolResults) \ USE_VK_FUNC(vkCmdCuLaunchKernelNVX) \ + USE_VK_FUNC(vkCmdCudaLaunchKernelNV) \ USE_VK_FUNC(vkCmdDebugMarkerBeginEXT) \ USE_VK_FUNC(vkCmdDebugMarkerEndEXT) \ USE_VK_FUNC(vkCmdDebugMarkerInsertEXT) \ @@ -890,6 +897,8 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkCreateComputePipelines) \ USE_VK_FUNC(vkCreateCuFunctionNVX) \ USE_VK_FUNC(vkCreateCuModuleNVX) \ + USE_VK_FUNC(vkCreateCudaFunctionNV) \ + USE_VK_FUNC(vkCreateCudaModuleNV) \ USE_VK_FUNC(vkCreateDeferredOperationKHR) \ USE_VK_FUNC(vkCreateDescriptorPool) \ USE_VK_FUNC(vkCreateDescriptorSetLayout) \ @@ -932,6 +941,8 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkDestroyCommandPool) \ USE_VK_FUNC(vkDestroyCuFunctionNVX) \ USE_VK_FUNC(vkDestroyCuModuleNVX) \ + USE_VK_FUNC(vkDestroyCudaFunctionNV) \ + USE_VK_FUNC(vkDestroyCudaModuleNV) \ USE_VK_FUNC(vkDestroyDeferredOperationKHR) \ USE_VK_FUNC(vkDestroyDescriptorPool) \ USE_VK_FUNC(vkDestroyDescriptorSetLayout) \ @@ -982,6 +993,7 @@ struct vulkan_instance_funcs USE_VK_FUNC(vkGetBufferOpaqueCaptureAddressKHR) \ USE_VK_FUNC(vkGetBufferOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetCalibratedTimestampsEXT) \ + USE_VK_FUNC(vkGetCudaModuleCacheNV) \ USE_VK_FUNC(vkGetDeferredOperationMaxConcurrencyKHR) \ USE_VK_FUNC(vkGetDeferredOperationResultKHR) \ USE_VK_FUNC(vkGetDescriptorEXT) \ diff --git a/dlls/winevulkan/winevulkan.json b/dlls/winevulkan/winevulkan.json index 03c47f5176e..a4ae238dfba 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.267" + "api_version": "1.3.272" } } diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index d76d1fc1f45..a8bf4ad4df0 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -126,7 +126,7 @@ #define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" #define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4 #define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" -#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 3 #define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" #define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 #define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" @@ -194,6 +194,8 @@ #define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer" #define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 #define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" +#define VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME "VK_IMG_relaxed_line_rasterization" #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 @@ -372,7 +374,7 @@ #define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info" #define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 #define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" -#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5 +#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 6 #define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" #define VK_KHR_PRESENT_WAIT_SPEC_VERSION 1 #define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait" @@ -450,6 +452,8 @@ #define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config" #define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2 #define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" +#define VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION 2 +#define VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME "VK_NV_cuda_kernel_launch" #define VK_NV_LOW_LATENCY_SPEC_VERSION 1 #define VK_NV_LOW_LATENCY_EXTENSION_NAME "VK_NV_low_latency" #define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 @@ -540,7 +544,7 @@ #define VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME "VK_EXT_opacity_micromap" #define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1 #define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none" -#define VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION 2 +#define VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION 3 #define VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME "VK_HUAWEI_cluster_culling_shader" #define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1 #define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle" @@ -550,6 +554,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_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 #define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_sliced_view_of_3d" #define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1 @@ -606,13 +612,15 @@ #define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME "VK_NV_extended_sparse_address_space" #define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 #define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type" +#define VK_EXT_LAYER_SETTINGS_SPEC_VERSION 2 +#define VK_EXT_LAYER_SETTINGS_EXTENSION_NAME "VK_EXT_layer_settings" #define VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION 2 #define VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME "VK_ARM_shader_core_builtins" #define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION 1 #define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME "VK_EXT_pipeline_library_group_handles" #define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION 1 #define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME "VK_EXT_dynamic_rendering_unused_attachments" -#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 1 +#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 2 #define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2" #define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2 #define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix" @@ -658,7 +666,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 267 +#define VK_HEADER_VERSION 272 #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 @@ -693,6 +701,8 @@ VK_DEFINE_HANDLE(VkCommandBuffer) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaFunctionNV) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaModuleNV) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) @@ -860,6 +870,7 @@ typedef VkFlags VkOpticalFlowUsageFlagsNV; typedef VkFlags VkPeerMemoryFeatureFlags; typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; +typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; typedef VkFlags VkPipelineCacheCreateFlags; typedef VkFlags VkPipelineColorBlendStateCreateFlags; typedef VkFlags VkPipelineColorBlendStateCreateFlags; @@ -1639,6 +1650,8 @@ typedef enum VkDebugReportObjectTypeEXT VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, + VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT = 1000307000, + VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT = 1000307001, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, @@ -2843,6 +2856,19 @@ typedef enum VkLatencyMarkerNV VK_LATENCY_MARKER_NV_MAX_ENUM = 0x7fffffff, } VkLatencyMarkerNV;

+typedef enum VkLayerSettingTypeEXT +{ + VK_LAYER_SETTING_TYPE_BOOL32_EXT = 0, + VK_LAYER_SETTING_TYPE_INT32_EXT = 1, + VK_LAYER_SETTING_TYPE_INT64_EXT = 2, + VK_LAYER_SETTING_TYPE_UINT32_EXT = 3, + VK_LAYER_SETTING_TYPE_UINT64_EXT = 4, + VK_LAYER_SETTING_TYPE_FLOAT32_EXT = 5, + VK_LAYER_SETTING_TYPE_FLOAT64_EXT = 6, + VK_LAYER_SETTING_TYPE_STRING_EXT = 7, + VK_LAYER_SETTING_TYPE_EXT_MAX_ENUM = 0x7fffffff, +} VkLayerSettingTypeEXT; + typedef enum VkLayeredDriverUnderlyingApiMSFT { VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0, @@ -2980,6 +3006,8 @@ typedef enum VkObjectType VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, + VK_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, + VK_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, @@ -3163,6 +3191,12 @@ 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 enum VkPhysicalDeviceType { VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, @@ -4154,6 +4188,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG = 1000110000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, @@ -4424,6 +4459,11 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, + VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV = 1000307001, + VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV = 1000307002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV = 1000307003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004, VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, @@ -4543,6 +4583,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI = 1000404002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, @@ -4551,6 +4592,9 @@ 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_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, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, @@ -4612,6 +4656,7 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001, + VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT = 1000496000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, @@ -5756,6 +5801,40 @@ typedef struct VkCuModuleCreateInfoNVX const void *pData; } VkCuModuleCreateInfoNVX;

+typedef struct VkCudaFunctionCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + VkCudaModuleNV WINE_VK_ALIGN(8) module; + const char *pName; +} VkCudaFunctionCreateInfoNV; + +typedef struct VkCudaLaunchInfoNV +{ + VkStructureType sType; + const void *pNext; + VkCudaFunctionNV WINE_VK_ALIGN(8) function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + size_t paramCount; + const void * const *pParams; + size_t extraCount; + const void * const *pExtras; +} VkCudaLaunchInfoNV; + +typedef struct VkCudaModuleCreateInfoNV +{ + VkStructureType sType; + const void *pNext; + size_t dataSize; + const void *pData; +} VkCudaModuleCreateInfoNV; + typedef struct VkDebugMarkerMarkerInfoEXT { VkStructureType sType; @@ -6208,6 +6287,13 @@ typedef struct VkDeviceQueueInfo2 uint32_t queueIndex; } VkDeviceQueueInfo2;

+typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM +{ + VkStructureType sType; + void *pNext; + uint32_t shaderCoreCount; +} VkDeviceQueueShaderCoreControlCreateInfoARM; + typedef struct VkDispatchIndirectCommand { uint32_t x; @@ -6851,6 +6937,23 @@ typedef struct VkLayerProperties char description[VK_MAX_DESCRIPTION_SIZE]; } VkLayerProperties;

+typedef struct VkLayerSettingEXT +{ + const char *pLayerName; + const char *pSettingName; + VkLayerSettingTypeEXT type; + uint32_t valueCount; + const void *pValues; +} VkLayerSettingEXT; + +typedef struct VkLayerSettingsCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t settingCount; + const VkLayerSettingEXT *pSettings; +} VkLayerSettingsCreateInfoEXT; + typedef struct VkMappedMemoryRange { VkStructureType sType; @@ -7383,6 +7486,13 @@ typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI VkDeviceSize WINE_VK_ALIGN(8) indirectBufferOffsetAlignment; } VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI;

+typedef struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI +{ + VkStructureType sType; + void *pNext; + VkBool32 clusterShadingRate; +} VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { VkStructureType sType; @@ -7500,6 +7610,21 @@ typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM VkBool32 selectableCubicWeights; } VkPhysicalDeviceCubicWeightsFeaturesQCOM;

+typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV +{ + VkStructureType sType; + void *pNext; + VkBool32 cudaKernelLaunchFeatures; +} VkPhysicalDeviceCudaKernelLaunchFeaturesNV; + +typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV +{ + VkStructureType sType; + void *pNext; + uint32_t computeCapabilityMinor; + uint32_t computeCapabilityMajor; +} VkPhysicalDeviceCudaKernelLaunchPropertiesNV; + typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { VkStructureType sType; @@ -9053,6 +9178,13 @@ typedef struct VkPhysicalDeviceRayTracingPropertiesNV uint32_t maxDescriptorSetAccelerationStructures; } VkPhysicalDeviceRayTracingPropertiesNV;

+typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG +{ + VkStructureType sType; + void *pNext; + VkBool32 relaxedLineRasterization; +} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { VkStructureType sType; @@ -9113,6 +9245,20 @@ typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures } VkPhysicalDeviceScalarBlockLayoutFeatures; typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;

+typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM +{ + VkStructureType sType; + void *pNext; + VkBool32 schedulingControls; +} VkPhysicalDeviceSchedulingControlsFeaturesARM; + +typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM +{ + VkStructureType sType; + void *pNext; + VkPhysicalDeviceSchedulingControlsFlagsARM WINE_VK_ALIGN(8) schedulingControlsFlags; +} VkPhysicalDeviceSchedulingControlsPropertiesARM; + typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { VkStructureType sType; @@ -11827,6 +11973,7 @@ typedef struct VkGetLatencyMarkerInfoNV { VkStructureType sType; const void *pNext; + uint32_t timingCount; VkLatencyTimingsFrameReportNV *pTimings; } VkGetLatencyMarkerInfoNV;

@@ -12638,6 +12785,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer, const VkCopy typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer, const VkCopyMicromapToMemoryInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer, VkQueryPool, uint32_t, uint32_t, VkBuffer, VkDeviceSize, VkDeviceSize, VkQueryResultFlags); typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer, const VkCuLaunchInfoNVX *); +typedef void (VKAPI_PTR *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer, const VkCudaLaunchInfoNV *); typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT *); typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer); typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT *); @@ -12833,6 +12981,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice, const VkCommandP typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice, VkPipelineCache, uint32_t, const VkComputePipelineCreateInfo *, const VkAllocationCallbacks *, VkPipeline *); typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice, const VkCuFunctionCreateInfoNVX *, const VkAllocationCallbacks *, VkCuFunctionNVX *); typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice, const VkCuModuleCreateInfoNVX *, const VkAllocationCallbacks *, VkCuModuleNVX *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaFunctionNV)(VkDevice, const VkCudaFunctionCreateInfoNV *, const VkAllocationCallbacks *, VkCudaFunctionNV *); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaModuleNV)(VkDevice, const VkCudaModuleCreateInfoNV *, const VkAllocationCallbacks *, VkCudaModuleNV *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance, const VkDebugReportCallbackCreateInfoEXT *, const VkAllocationCallbacks *, VkDebugReportCallbackEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance, const VkDebugUtilsMessengerCreateInfoEXT *, const VkAllocationCallbacks *, VkDebugUtilsMessengerEXT *); typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice, const VkAllocationCallbacks *, VkDeferredOperationKHR *); @@ -12881,6 +13031,8 @@ typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice, VkBufferView, const typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice, VkCommandPool, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice, VkCuFunctionNVX, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice, VkCuModuleNVX, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyCudaFunctionNV)(VkDevice, VkCudaFunctionNV, const VkAllocationCallbacks *); +typedef void (VKAPI_PTR *PFN_vkDestroyCudaModuleNV)(VkDevice, VkCudaModuleNV, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance, VkDebugReportCallbackEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance, VkDebugUtilsMessengerEXT, const VkAllocationCallbacks *); typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice, VkDeferredOperationKHR, const VkAllocationCallbacks *); @@ -12944,6 +13096,7 @@ typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice, cons 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_vkGetCudaModuleCacheNV)(VkDevice, VkCudaModuleNV, size_t *, void *); typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice, VkDeferredOperationKHR); typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice, VkDeferredOperationKHR); typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice, const VkDescriptorGetInfoEXT *, size_t, void *); @@ -12993,7 +13146,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice, VkImageView typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice, const VkImageViewHandleInfoNVX *); typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkImageViewCaptureDescriptorDataInfoEXT *, void *); typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance, const char *); -typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsNV)(VkDevice, VkSwapchainKHR, uint32_t *, VkGetLatencyMarkerInfoNV *); +typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsNV)(VkDevice, VkSwapchainKHR, VkGetLatencyMarkerInfoNV *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMemoryGetWin32HandleInfoKHR *, HANDLE *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, HANDLE, VkMemoryWin32HandlePropertiesKHR *); @@ -13203,6 +13356,7 @@ void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopy void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo); void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo); +void VKAPI_CALL vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV *pLaunchInfo); void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo); void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer); void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo); @@ -13398,6 +13552,8 @@ VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCrea VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines); VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction); VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule); +VkResult VKAPI_CALL vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaFunctionNV *pFunction); +VkResult VKAPI_CALL vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaModuleNV *pModule); VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback); VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger); VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation); @@ -13446,6 +13602,8 @@ void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, co void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks *pAllocator); +void VKAPI_CALL vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator); void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator); @@ -13509,6 +13667,7 @@ uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBuf 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 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); void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor); @@ -13558,7 +13717,7 @@ VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageV uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo); VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData); PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName); -void VKAPI_CALL vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pTimingCount, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo); +void VKAPI_CALL vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo); VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties); VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle); VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties);

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/4643

Georg Lehmann (＠DadSchoorse)

8:15 p.m.

On Thu Dec 7 20:15:46 2023 +0000, Jacek Caban wrote:

...

It seems that you didn't update vulkan.h after make_vulkan change. I guess it doesn't matter much as Alexandre probably runs make_vulkan himself anyway, but CI doesn't. Looks good to me otherwise.

Fixed.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/4643#note_55435

Jacek Caban (＠jacek)

8:27 p.m.

New subject: [PATCH v3 0/1] MR4643: winevulkan: Update to VK spec version 1.3.272. - approved

This merge request was approved by Jacek Caban.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/4643

427

Age (days ago)

427

Last active (days ago)

wine-gitlab@winehq.org

3 comments

3 participants

tags (0)

participants (3)

Georg Lehmann
Georg Lehmann (＠DadSchoorse)
Jacek Caban (＠jacek)