[PATCH v3 0/6] MR8909: win32u: Hook VK_KHR_external_memory_win32 functions.
-- v3: win32u: Hook VK_KHR_external_memory_win32 functions. win32u: Strip unsupported structs from vkCreateImage chain. win32u: Strip unsupported structs from vkCreateBuffer chain. win32u: Strip unsupported structs from vkAllocateMemory chain. winevulkan: Force copy some memory, buffer and image struct chains. winevulkan: Generate structs for external memory fds. https://gitlab.winehq.org/wine/wine/-/merge_requests/8909
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/winevulkan/make_vulkan | 12 +- include/wine/vulkan.h | 211 ++++++++++++++++++++++++++++++++++++ 2 files changed, 217 insertions(+), 6 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 6eb466b8937..78540f5da2f 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -109,15 +109,9 @@ UNSUPPORTED_EXTENSIONS = [ "VK_NV_external_compute_queue", # Has a new dispatchable handle # Extensions for other platforms - "VK_EXT_external_memory_dma_buf", - "VK_EXT_image_drm_format_modifier", "VK_EXT_metal_objects", "VK_EXT_physical_device_drm", "VK_GOOGLE_surfaceless_query", - "VK_KHR_external_fence_fd", - "VK_KHR_external_memory_fd", - "VK_EXT_external_memory_metal", - "VK_KHR_external_semaphore_fd", "VK_SEC_amigo_profiling", # Angle specific. # Extensions which require callback handling @@ -136,7 +130,13 @@ UNEXPOSED_EXTENSIONS = { "VK_KHR_external_memory_win32", "VK_EXT_headless_surface", # Extensions for other platforms + "VK_EXT_external_memory_dma_buf", + "VK_EXT_image_drm_format_modifier", "VK_EXT_metal_surface", + "VK_KHR_external_fence_fd", + "VK_KHR_external_memory_fd", + "VK_EXT_external_memory_metal", + "VK_KHR_external_semaphore_fd", "VK_KHR_wayland_surface", "VK_KHR_xlib_surface", "VK_MVK_macos_surface", diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index 76c2da1244d..e5c44057f52 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -178,10 +178,14 @@ typedef struct _XDisplay Display; #define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" #define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" #define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" #define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 @@ -226,6 +230,8 @@ typedef struct _XDisplay Display; #define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" #define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 #define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" #define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 #define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" #define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION @@ -238,6 +244,8 @@ typedef struct _XDisplay Display; #define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" #define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3 #define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" #define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 #define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" #define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 @@ -284,6 +292,8 @@ typedef struct _XDisplay Display; #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" #define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 #define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" #define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 #define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" #define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 @@ -789,6 +799,8 @@ typedef struct _XDisplay Display; #define VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME "VK_NV_cooperative_matrix2" #define VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION 1 #define VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME "VK_ARM_pipeline_opacity_micromap" +#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal" #define VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 #define VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_KHR_depth_clamp_zero_one" #define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1 @@ -2973,6 +2985,10 @@ typedef enum VkExternalMemoryHandleTypeFlagBits VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 0x00010000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 0x00020000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT = 0x00040000, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, @@ -3614,6 +3630,10 @@ typedef enum VkImageAspectFlagBits VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, + VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, + VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, + VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, @@ -3742,6 +3762,7 @@ typedef enum VkImageTiling { VK_IMAGE_TILING_OPTIMAL = 0, VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, VK_IMAGE_TILING_MAX_ENUM = 0x7fffffff, } VkImageTiling; @@ -4930,6 +4951,7 @@ typedef enum VkResult VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, VK_ERROR_NOT_PERMITTED = -1000174001, VK_ERROR_FRAGMENTATION = -1000161000, + VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, @@ -5425,9 +5447,14 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES = 1000080000, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, @@ -5461,6 +5488,8 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, @@ -5540,6 +5569,12 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, @@ -6169,6 +6204,9 @@ typedef enum VkStructureType VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000, + VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001, + VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000, @@ -9244,6 +9282,20 @@ typedef struct VkDeviceQueueCreateInfo const float *pQueuePriorities; } VkDeviceQueueCreateInfo; +typedef struct VkDrmFormatModifierProperties2EXT +{ + uint64_t WINE_VK_ALIGN(8) drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags2 WINE_VK_ALIGN(8) drmFormatModifierTilingFeatures; +} VkDrmFormatModifierProperties2EXT; + +typedef struct VkDrmFormatModifierPropertiesEXT +{ + uint64_t WINE_VK_ALIGN(8) drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags drmFormatModifierTilingFeatures; +} VkDrmFormatModifierPropertiesEXT; + typedef struct VkExtensionProperties { char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; @@ -11888,6 +11940,22 @@ typedef struct VkDrawMeshTasksIndirectCommandNV uint32_t firstTask; } VkDrawMeshTasksIndirectCommandNV; +typedef struct VkDrmFormatModifierPropertiesList2EXT +{ + VkStructureType sType; + void *pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierProperties2EXT *pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesList2EXT; + +typedef struct VkDrmFormatModifierPropertiesListEXT +{ + VkStructureType sType; + void *pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT *pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesListEXT; + typedef struct VkEventCreateInfo { VkStructureType sType; @@ -12008,6 +12076,14 @@ typedef struct VkFenceCreateInfo VkFenceCreateFlags flags; } VkFenceCreateInfo; +typedef struct VkFenceGetFdInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkFence WINE_VK_ALIGN(8) fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { VkStructureType sType; @@ -12312,6 +12388,30 @@ typedef struct VkImageCopy VkExtent3D extent; } VkImageCopy; +typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint64_t WINE_VK_ALIGN(8) drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const VkSubresourceLayout *pPlaneLayouts; +} VkImageDrmFormatModifierExplicitCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierListCreateInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint32_t drmFormatModifierCount; + const uint64_t *pDrmFormatModifiers; +} VkImageDrmFormatModifierListCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierPropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint64_t WINE_VK_ALIGN(8) drmFormatModifier; +} VkImageDrmFormatModifierPropertiesEXT; + typedef struct VkImageFormatListCreateInfo { VkStructureType sType; @@ -12466,6 +12566,24 @@ typedef struct VkImageViewUsageCreateInfo } VkImageViewUsageCreateInfo; typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; +typedef struct VkImportFenceFdInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkFence WINE_VK_ALIGN(8) fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkImportMemoryFdInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + typedef struct VkImportMemoryHostPointerInfoEXT { VkStructureType sType; @@ -12474,6 +12592,14 @@ typedef struct VkImportMemoryHostPointerInfoEXT void *pHostPointer; } VkImportMemoryHostPointerInfoEXT; +typedef struct VkImportMemoryMetalHandleInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void *handle; +} VkImportMemoryMetalHandleInfoEXT; + typedef struct VkImportMemoryWin32HandleInfoKHR { VkStructureType sType; @@ -12483,6 +12609,16 @@ typedef struct VkImportMemoryWin32HandleInfoKHR LPCWSTR name; } VkImportMemoryWin32HandleInfoKHR; +typedef struct VkImportSemaphoreFdInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkSemaphore WINE_VK_ALIGN(8) semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + typedef struct VkIndirectCommandsLayoutCreateInfoEXT { VkStructureType sType; @@ -12657,6 +12793,29 @@ typedef struct VkMemoryDedicatedRequirements } VkMemoryDedicatedRequirements; typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; +typedef struct VkMemoryFdPropertiesKHR +{ + VkStructureType sType; + void *pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkDeviceMemory WINE_VK_ALIGN(8) memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + +typedef struct VkMemoryGetMetalHandleInfoEXT +{ + VkStructureType sType; + const void *pNext; + VkDeviceMemory WINE_VK_ALIGN(8) memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetMetalHandleInfoEXT; + typedef struct VkMemoryGetWin32HandleInfoKHR { VkStructureType sType; @@ -12690,6 +12849,13 @@ typedef struct VkMemoryMapPlacedInfoEXT void *pPlacedAddress; } VkMemoryMapPlacedInfoEXT; +typedef struct VkMemoryMetalHandlePropertiesEXT +{ + VkStructureType sType; + void *pNext; + uint32_t memoryTypeBits; +} VkMemoryMetalHandlePropertiesEXT; + typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { VkStructureType sType; @@ -14156,6 +14322,16 @@ typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT VkBool32 imageCompressionControlSwapchain; } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; +typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT +{ + VkStructureType sType; + const void *pNext; + uint64_t WINE_VK_ALIGN(8) drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t *pQueueFamilyIndices; +} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + typedef struct VkPhysicalDeviceImageFormatInfo2 { VkStructureType sType; @@ -17264,6 +17440,14 @@ typedef struct VkSemaphoreCreateInfo VkSemaphoreCreateFlags flags; } VkSemaphoreCreateInfo; +typedef struct VkSemaphoreGetFdInfoKHR +{ + VkStructureType sType; + const void *pNext; + VkSemaphore WINE_VK_ALIGN(8) semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + typedef struct VkSemaphoreSignalInfo { VkStructureType sType; @@ -19024,10 +19208,12 @@ typedef void (VKAPI_PTR *PFN_vkGetDeviceTensorMemoryRequirementsARM)(VkDevice, c typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice, const VkRenderingInfo *, VkTilePropertiesQCOM *); typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice, const VkVideoEncodeSessionParametersGetInfoKHR *, VkVideoEncodeSessionParametersFeedbackInfoKHR *, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice, VkEvent); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice, const VkFenceGetFdInfoKHR *, int *); typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice, VkFence); typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice, VkFramebuffer, uint32_t *, VkTilePropertiesQCOM *); typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoEXT *, VkMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoNV *, VkMemoryRequirements2 *); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice, VkImage, VkImageDrmFormatModifierPropertiesEXT *); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice, VkImage, VkMemoryRequirements *); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice, const VkImageMemoryRequirementsInfo2 *, VkMemoryRequirements2 *); @@ -19045,7 +19231,11 @@ typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice, const VkImag 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, VkGetLatencyMarkerInfoNV *); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice, const VkMemoryGetFdInfoKHR *, int *); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, int, VkMemoryFdPropertiesKHR *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryHostPointerPropertiesEXT *); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice, const VkMemoryGetMetalHandleInfoEXT *, void **); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void *, VkMemoryMetalHandlePropertiesEXT *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice, const VkMemoryGetWin32HandleInfoKHR *, HANDLE *); typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice, VkExternalMemoryHandleTypeFlagBits, HANDLE, VkMemoryWin32HandlePropertiesKHR *); typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice, VkAccelerationStructureBuildTypeKHR, const VkMicromapBuildInfoEXT *, VkMicromapBuildSizesInfoEXT *); @@ -19131,6 +19321,7 @@ typedef void (VKAPI_PTR *PFN_vkGetRenderingAreaGranularityKHR)(VkDevice, const V typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice, const VkSamplerCaptureDescriptorDataInfoEXT *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice, VkSemaphore, uint64_t *); typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice, VkSemaphore, uint64_t *); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice, const VkSemaphoreGetFdInfoKHR *, int *); typedef VkResult (VKAPI_PTR *PFN_vkGetShaderBinaryDataEXT)(VkDevice, VkShaderEXT, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice, VkPipeline, VkShaderStageFlagBits, VkShaderInfoTypeAMD, size_t *, void *); typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice, const VkShaderModuleCreateInfo *, VkShaderModuleIdentifierEXT *); @@ -19141,6 +19332,8 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)(VkDe typedef VkResult (VKAPI_PTR *PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)(VkDevice, const VkTensorViewCaptureDescriptorDataInfoARM *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice, VkValidationCacheEXT, size_t *, void *); typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice, VkVideoSessionKHR, uint32_t *, VkVideoSessionMemoryRequirementsKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice, const VkImportFenceFdInfoKHR *); +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice, const VkImportSemaphoreFdInfoKHR *); typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice, const VkInitializePerformanceApiInfoINTEL *); typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice, uint32_t, const VkMappedMemoryRange *); typedef VkResult (VKAPI_PTR *PFN_vkLatencySleepNV)(VkDevice, VkSwapchainKHR, const VkLatencySleepInfoNV *); @@ -19696,10 +19889,12 @@ void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const Vk VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties); VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event); +VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd); VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence); VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties); void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements); +VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties); void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements); void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements); @@ -19717,7 +19912,11 @@ uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHa 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, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo); +VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd); +VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties); VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties); +VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT(VkDevice device, const VkMemoryGetMetalHandleInfoEXT *pGetMetalHandleInfo, void **pHandle); +VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHandle, VkMemoryMetalHandlePropertiesEXT *pMemoryMetalHandleProperties); VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle); 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); @@ -19803,6 +20002,7 @@ void VKAPI_CALL vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRender VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData); VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue); VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue); +VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd); VkResult VKAPI_CALL vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo); void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier); @@ -19813,6 +20013,8 @@ VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, c VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM *pInfo, void *pData); VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData); VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements); +VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo); +VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo); VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo); VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges); VkResult VKAPI_CALL vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV *pSleepInfo); @@ -20344,10 +20546,12 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetDynamicRenderingTilePropertiesQCOM) \ USE_VK_FUNC(vkGetEncodedVideoSessionParametersKHR) \ USE_VK_FUNC(vkGetEventStatus) \ + USE_VK_FUNC(vkGetFenceFdKHR) \ USE_VK_FUNC(vkGetFenceStatus) \ USE_VK_FUNC(vkGetFramebufferTilePropertiesQCOM) \ USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsEXT) \ USE_VK_FUNC(vkGetGeneratedCommandsMemoryRequirementsNV) \ + USE_VK_FUNC(vkGetImageDrmFormatModifierPropertiesEXT) \ USE_VK_FUNC(vkGetImageMemoryRequirements) \ USE_VK_FUNC(vkGetImageMemoryRequirements2) \ USE_VK_FUNC(vkGetImageMemoryRequirements2KHR) \ @@ -20364,7 +20568,11 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetImageViewHandleNVX) \ USE_VK_FUNC(vkGetImageViewOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetLatencyTimingsNV) \ + USE_VK_FUNC(vkGetMemoryFdKHR) \ + USE_VK_FUNC(vkGetMemoryFdPropertiesKHR) \ USE_VK_FUNC(vkGetMemoryHostPointerPropertiesEXT) \ + USE_VK_FUNC(vkGetMemoryMetalHandleEXT) \ + USE_VK_FUNC(vkGetMemoryMetalHandlePropertiesEXT) \ USE_VK_FUNC(vkGetMemoryWin32HandleKHR) \ USE_VK_FUNC(vkGetMemoryWin32HandlePropertiesKHR) \ USE_VK_FUNC(vkGetMicromapBuildSizesEXT) \ @@ -20394,6 +20602,7 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetSamplerOpaqueCaptureDescriptorDataEXT) \ USE_VK_FUNC(vkGetSemaphoreCounterValue) \ USE_VK_FUNC(vkGetSemaphoreCounterValueKHR) \ + USE_VK_FUNC(vkGetSemaphoreFdKHR) \ USE_VK_FUNC(vkGetShaderBinaryDataEXT) \ USE_VK_FUNC(vkGetShaderInfoAMD) \ USE_VK_FUNC(vkGetShaderModuleCreateInfoIdentifierEXT) \ @@ -20404,6 +20613,8 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetTensorViewOpaqueCaptureDescriptorDataARM) \ USE_VK_FUNC(vkGetValidationCacheDataEXT) \ USE_VK_FUNC(vkGetVideoSessionMemoryRequirementsKHR) \ + USE_VK_FUNC(vkImportFenceFdKHR) \ + USE_VK_FUNC(vkImportSemaphoreFdKHR) \ USE_VK_FUNC(vkInitializePerformanceApiINTEL) \ USE_VK_FUNC(vkInvalidateMappedMemoryRanges) \ USE_VK_FUNC(vkLatencySleepNV) \ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8909
From: Rémi Bernon <rbernon(a)codeweavers.com> So that we can edit them in place in win32u. --- dlls/winevulkan/make_vulkan | 14 +- dlls/winevulkan/vulkan_thunks.c | 285 +++++++++++++++++++++++++++++++- 2 files changed, 291 insertions(+), 8 deletions(-) diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 78540f5da2f..d15e40f01cf 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -302,9 +302,14 @@ MANUAL_LOADER_THUNKS = { } STRUCT_CHAIN_CONVERSIONS = { + # Force making copies of some struct chains + "VkMemoryAllocateInfo": {}, + "VkBufferCreateInfo": {}, + "VkImageCreateInfo": {}, + # Ignore to not confuse host loader. - "VkDeviceCreateInfo": ["VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"], - "VkInstanceCreateInfo": ["VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"], + "VkDeviceCreateInfo": {"strip": ["VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"]}, + "VkInstanceCreateInfo": {"strip": ["VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO"]}, } # Some struct members are conditionally ignored and callers are free to leave them uninitialized. @@ -2294,8 +2299,9 @@ class StructConversionFunction(object): ident = " " - if self.direction == Direction.INPUT and self.type in STRUCT_CHAIN_CONVERSIONS: - for i in STRUCT_CHAIN_CONVERSIONS[self.type]: + if self.direction == Direction.INPUT and self.type in STRUCT_CHAIN_CONVERSIONS \ + and "strip" in STRUCT_CHAIN_CONVERSIONS[self.type]: + for i in STRUCT_CHAIN_CONVERSIONS[self.type]["strip"]: body += " case {0}:\n".format(i) body += ident + "break;\n" diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index ac5604c80e5..99f247f4e46 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -9618,6 +9618,123 @@ static void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_ } } +#ifdef _WIN64 +static void convert_VkMemoryAllocateInfo_win64_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo *in, VkMemoryAllocateInfo *out) +{ + const VkBaseInStructure *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->allocationSize = in->allocationSize; + out->memoryTypeIndex = in->memoryTypeIndex; + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + { + VkDedicatedAllocationMemoryAllocateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDedicatedAllocationMemoryAllocateInfoNV *in_ext = (const VkDedicatedAllocationMemoryAllocateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->image = in_ext->image; + out_ext->buffer = in_ext->buffer; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + { + VkExportMemoryAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExportMemoryAllocateInfo *in_ext = (const VkExportMemoryAllocateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; + out_ext->pNext = NULL; + out_ext->handleTypes = in_ext->handleTypes; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + { + VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImportMemoryHostPointerInfoEXT *in_ext = (const VkImportMemoryHostPointerInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; + out_ext->pNext = NULL; + out_ext->handleType = in_ext->handleType; + out_ext->pHostPointer = in_ext->pHostPointer; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + { + VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryAllocateFlagsInfo *in_ext = (const VkMemoryAllocateFlagsInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->deviceMask = in_ext->deviceMask; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + { + VkMemoryDedicatedAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryDedicatedAllocateInfo *in_ext = (const VkMemoryDedicatedAllocateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; + out_ext->pNext = NULL; + out_ext->image = in_ext->image; + out_ext->buffer = in_ext->buffer; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + { + VkMemoryDedicatedAllocateInfoTensorARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryDedicatedAllocateInfoTensorARM *in_ext = (const VkMemoryDedicatedAllocateInfoTensorARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; + out_ext->pNext = NULL; + out_ext->tensor = in_ext->tensor; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + { + VkMemoryOpaqueCaptureAddressAllocateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryOpaqueCaptureAddressAllocateInfo *in_ext = (const VkMemoryOpaqueCaptureAddressAllocateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; + out_ext->pNext = NULL; + out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + { + VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryPriorityAllocateInfoEXT *in_ext = (const VkMemoryPriorityAllocateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->priority = in_ext->priority; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} +#endif /* _WIN64 */ + static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out) { const VkBaseInStructure32 *in_header; @@ -14744,6 +14861,113 @@ static void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct con } } +#ifdef _WIN64 +static void convert_VkBufferCreateInfo_win64_to_host(struct conversion_context *ctx, const VkBufferCreateInfo *in, VkBufferCreateInfo *out) +{ + const VkBaseInStructure *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->size = in->size; + out->usage = in->usage; + out->sharingMode = in->sharingMode; + out->queueFamilyIndexCount = in->queueFamilyIndexCount; + out->pQueueFamilyIndices = in->pQueueFamilyIndices; + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + { + VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBufferDeviceAddressCreateInfoEXT *in_ext = (const VkBufferDeviceAddressCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->deviceAddress = in_ext->deviceAddress; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + { + VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBufferOpaqueCaptureAddressCreateInfo *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + { + VkBufferUsageFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBufferUsageFlags2CreateInfo *in_ext = (const VkBufferUsageFlags2CreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + { + VkDedicatedAllocationBufferCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDedicatedAllocationBufferCreateInfoNV *in_ext = (const VkDedicatedAllocationBufferCreateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->dedicatedAllocation = in_ext->dedicatedAllocation; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + { + VkExternalMemoryBufferCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExternalMemoryBufferCreateInfo *in_ext = (const VkExternalMemoryBufferCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->handleTypes = in_ext->handleTypes; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = in_ext->opaqueCaptureDescriptorData; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + { + VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoProfileListInfoKHR *in_ext = (const VkVideoProfileListInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + out_ext->pNext = NULL; + out_ext->profileCount = in_ext->profileCount; + out_ext->pProfiles = in_ext->pProfiles; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} +#endif /* _WIN64 */ + static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, VkVideoProfileInfoKHR *out) { const VkBaseInStructure32 *in_header; @@ -27253,6 +27477,35 @@ static void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const Vk FIXME("Unexpected pNext\n"); } +#ifdef _WIN64 +static const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkBufferCreateInfo *in, uint32_t count) +{ + VkBufferCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkBufferCreateInfo_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static void convert_VkDeviceBufferMemoryRequirements_win64_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements *in, VkDeviceBufferMemoryRequirements *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->pCreateInfo = convert_VkBufferCreateInfo_array_win64_to_host(ctx, in->pCreateInfo, 1); +} +#endif /* _WIN64 */ + static const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count) { VkBufferCreateInfo *out; @@ -40130,10 +40383,16 @@ static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args) static NTSTATUS thunk64_vkAllocateMemory(void *args) { struct vkAllocateMemory_params *params = args; + VkMemoryAllocateInfo pAllocateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory); - params->result = vk_funcs->p_vkAllocateMemory(params->device, params->pAllocateInfo, params->pAllocator, params->pMemory); + init_conversion_context(ctx); + convert_VkMemoryAllocateInfo_win64_to_host(ctx, params->pAllocateInfo, &pAllocateInfo_host); + params->result = vk_funcs->p_vkAllocateMemory(params->device, &pAllocateInfo_host, params->pAllocator, params->pMemory); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -47593,10 +47852,16 @@ static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args) static NTSTATUS thunk64_vkCreateBuffer(void *args) { struct vkCreateBuffer_params *params = args; + VkBufferCreateInfo pCreateInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer); - params->result = vk_funcs->p_vkCreateBuffer(params->device, params->pCreateInfo, params->pAllocator, params->pBuffer); + init_conversion_context(ctx); + convert_VkBufferCreateInfo_win64_to_host(ctx, params->pCreateInfo, &pCreateInfo_host); + params->result = vk_funcs->p_vkCreateBuffer(params->device, &pCreateInfo_host, params->pAllocator, params->pBuffer); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -52291,10 +52556,16 @@ static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *a static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args) { struct vkGetDeviceBufferMemoryRequirements_params *params = args; + VkDeviceBufferMemoryRequirements pInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements); - vulkan_device_from_handle(params->device)->p_vkGetDeviceBufferMemoryRequirements(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pMemoryRequirements); + init_conversion_context(ctx); + convert_VkDeviceBufferMemoryRequirements_win64_to_host(ctx, params->pInfo, &pInfo_host); + vulkan_device_from_handle(params->device)->p_vkGetDeviceBufferMemoryRequirements(vulkan_device_from_handle(params->device)->host.device, &pInfo_host, params->pMemoryRequirements); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -52327,10 +52598,16 @@ static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args) static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args) { struct vkGetDeviceBufferMemoryRequirementsKHR_params *params = args; + VkDeviceBufferMemoryRequirements pInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements); - vulkan_device_from_handle(params->device)->p_vkGetDeviceBufferMemoryRequirementsKHR(vulkan_device_from_handle(params->device)->host.device, params->pInfo, params->pMemoryRequirements); + init_conversion_context(ctx); + convert_VkDeviceBufferMemoryRequirements_win64_to_host(ctx, params->pInfo, &pInfo_host); + vulkan_device_from_handle(params->device)->p_vkGetDeviceBufferMemoryRequirementsKHR(vulkan_device_from_handle(params->device)->host.device, &pInfo_host, params->pMemoryRequirements); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8909
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/win32u/vulkan.c | 34 +++++++++++++++++++++++++++------- 1 file changed, 27 insertions(+), 7 deletions(-) diff --git a/dlls/win32u/vulkan.c b/dlls/win32u/vulkan.c index 6503b217d1c..079cb470856 100644 --- a/dlls/win32u/vulkan.c +++ b/dlls/win32u/vulkan.c @@ -160,33 +160,53 @@ static VkResult allocate_external_host_memory( struct vulkan_device *device, VkM static VkResult win32u_vkAllocateMemory( VkDevice client_device, const VkMemoryAllocateInfo *alloc_info, const VkAllocationCallbacks *allocator, VkDeviceMemory *ret ) { + VkBaseOutStructure **next, *prev = (VkBaseOutStructure *)alloc_info; /* cast away const, chain has been copied in the thunks */ struct vulkan_device *device = vulkan_device_from_handle( client_device ); struct vulkan_physical_device *physical_device = device->physical_device; struct vulkan_instance *instance = device->physical_device->instance; - VkImportMemoryHostPointerInfoEXT host_pointer_info; - VkMemoryAllocateInfo info = *alloc_info; + VkImportMemoryHostPointerInfoEXT host_pointer_info, *pointer_info = NULL; VkDeviceMemory host_device_memory; struct device_memory *memory; uint32_t mem_flags; void *mapping = NULL; VkResult res; + for (next = &prev->pNext; *next; prev = *next, next = &(*next)->pNext) + { + switch ((*next)->sType) + { + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + FIXME( "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + pointer_info = (VkImportMemoryHostPointerInfoEXT *)*next; + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: break; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: break; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: break; + default: FIXME( "Unhandled sType %u.\n", (*next)->sType ); break; + } + } + /* For host visible memory, we try to use VK_EXT_external_memory_host on wow64 to ensure that mapped pointer is 32-bit. */ mem_flags = physical_device->memory_properties.memoryTypes[alloc_info->memoryTypeIndex].propertyFlags; - if (physical_device->external_memory_align && (mem_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && - !find_next_struct( alloc_info->pNext, VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT ) && - (res = allocate_external_host_memory( device, &info, &host_pointer_info ))) + if (physical_device->external_memory_align && (mem_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) && !pointer_info && + (res = allocate_external_host_memory( device, (VkMemoryAllocateInfo *)alloc_info, &host_pointer_info ))) return res; if (!(memory = malloc( sizeof(*memory) ))) return VK_ERROR_OUT_OF_HOST_MEMORY; - if ((res = device->p_vkAllocateMemory( device->host.device, &info, NULL, &host_device_memory ))) + if ((res = device->p_vkAllocateMemory( device->host.device, alloc_info, NULL, &host_device_memory ))) { free( memory ); return res; } vulkan_object_init( &memory->obj.obj, host_device_memory ); - memory->size = info.allocationSize; + memory->size = alloc_info->allocationSize; memory->vm_map = mapping; instance->p_insert_object( instance, &memory->obj.obj ); -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8909
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/win32u/vulkan.c | 36 +++++++++++++++++++++++++++--------- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/dlls/win32u/vulkan.c b/dlls/win32u/vulkan.c index 079cb470856..ffda0fb0f84 100644 --- a/dlls/win32u/vulkan.c +++ b/dlls/win32u/vulkan.c @@ -381,21 +381,39 @@ static void win32u_vkUnmapMemory( VkDevice client_device, VkDeviceMemory client_ static VkResult win32u_vkCreateBuffer( VkDevice client_device, const VkBufferCreateInfo *create_info, const VkAllocationCallbacks *allocator, VkBuffer *buffer ) { + VkBaseOutStructure **next, *prev = (VkBaseOutStructure *)create_info; /* cast away const, chain has been copied in the thunks */ struct vulkan_device *device = vulkan_device_from_handle( client_device ); struct vulkan_physical_device *physical_device = device->physical_device; - VkExternalMemoryBufferCreateInfo external_memory_info; - VkBufferCreateInfo info = *create_info; + VkExternalMemoryBufferCreateInfo host_external_info, *external_info = NULL; - if (physical_device->external_memory_align && - !find_next_struct( info.pNext, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO )) + for (next = &prev->pNext; *next; prev = *next, next = &(*next)->pNext) { - external_memory_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; - external_memory_info.pNext = info.pNext; - external_memory_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; - info.pNext = &external_memory_info; + switch ((*next)->sType) + { + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + external_info = (VkExternalMemoryBufferCreateInfo *)*next; + FIXME( "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: break; + default: FIXME( "Unhandled sType %u.\n", (*next)->sType ); break; + } + } + + if (physical_device->external_memory_align && !external_info) + { + host_external_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + host_external_info.pNext = create_info->pNext; + host_external_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; + ((VkBufferCreateInfo *)create_info)->pNext = &host_external_info; /* cast away const, it has been copied in the thunks */ } - return device->p_vkCreateBuffer( device->host.device, &info, NULL, buffer ); + return device->p_vkCreateBuffer( device->host.device, create_info, NULL, buffer ); } static VkResult win32u_vkCreateImage( VkDevice client_device, const VkImageCreateInfo *create_info, -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8909
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/win32u/vulkan.c | 46 +++++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 16 deletions(-) diff --git a/dlls/win32u/vulkan.c b/dlls/win32u/vulkan.c index ffda0fb0f84..a893d5d10d9 100644 --- a/dlls/win32u/vulkan.c +++ b/dlls/win32u/vulkan.c @@ -85,13 +85,6 @@ static struct swapchain *swapchain_from_handle( VkSwapchainKHR handle ) return CONTAINING_RECORD( obj, struct swapchain, obj ); } -static inline const void *find_next_struct( const void *head, VkStructureType type ) -{ - const VkBaseInStructure *header; - for (header = head; header; header = header->pNext) if (header->sType == type) return header; - return NULL; -} - static VkResult allocate_external_host_memory( struct vulkan_device *device, VkMemoryAllocateInfo *alloc_info, VkImportMemoryHostPointerInfoEXT *import_info ) { @@ -419,21 +412,42 @@ static VkResult win32u_vkCreateBuffer( VkDevice client_device, const VkBufferCre static VkResult win32u_vkCreateImage( VkDevice client_device, const VkImageCreateInfo *create_info, const VkAllocationCallbacks *allocator, VkImage *image ) { + VkBaseOutStructure **next, *prev = (VkBaseOutStructure *)create_info; /* cast away const, chain has been copied in the thunks */ struct vulkan_device *device = vulkan_device_from_handle( client_device ); struct vulkan_physical_device *physical_device = device->physical_device; - VkExternalMemoryImageCreateInfo external_memory_info; - VkImageCreateInfo info = *create_info; + VkExternalMemoryImageCreateInfo host_external_info, *external_info = NULL; - if (physical_device->external_memory_align && - !find_next_struct( info.pNext, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO )) + for (next = &prev->pNext; *next; prev = *next, next = &(*next)->pNext) { - external_memory_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; - external_memory_info.pNext = info.pNext; - external_memory_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; - info.pNext = &external_memory_info; + switch ((*next)->sType) + { + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + external_info = (VkExternalMemoryImageCreateInfo *)*next; + FIXME( "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: break; + default: FIXME( "Unhandled sType %u.\n", (*next)->sType ); break; + } + } + + if (physical_device->external_memory_align && !external_info) + { + host_external_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + host_external_info.pNext = create_info->pNext; + host_external_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT; + ((VkImageCreateInfo *)create_info)->pNext = &host_external_info; /* cast away const, it has been copied in the thunks */ } - return device->p_vkCreateImage( device->host.device, &info, NULL, image ); + return device->p_vkCreateImage( device->host.device, create_info, NULL, image ); } static VkResult win32u_vkCreateWin32SurfaceKHR( VkInstance client_instance, const VkWin32SurfaceCreateInfoKHR *create_info, -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8909
From: Rémi Bernon <rbernon(a)codeweavers.com> --- dlls/win32u/vulkan.c | 170 ++++++++++++++ dlls/winevulkan/loader_thunks.c | 27 +++ dlls/winevulkan/loader_thunks.h | 19 ++ dlls/winevulkan/make_vulkan | 20 +- dlls/winevulkan/vulkan_thunks.c | 379 ++++++++++++++++++++++++++++++-- dlls/winevulkan/vulkan_thunks.h | 4 - include/wine/vulkan.h | 2 + include/wine/vulkan_driver.h | 9 + 8 files changed, 603 insertions(+), 27 deletions(-) diff --git a/dlls/win32u/vulkan.c b/dlls/win32u/vulkan.c index a893d5d10d9..3bc08d17ae8 100644 --- a/dlls/win32u/vulkan.c +++ b/dlls/win32u/vulkan.c @@ -46,6 +46,13 @@ WINE_DECLARE_DEBUG_CHANNEL(fps); static const struct vulkan_driver_funcs *driver_funcs; +static const UINT EXTERNAL_MEMORY_WIN32_BITS = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT | + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT | + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT | + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT | + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT | + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT; + struct device_memory { struct vulkan_device_memory obj; @@ -158,6 +165,7 @@ static VkResult win32u_vkAllocateMemory( VkDevice client_device, const VkMemoryA struct vulkan_physical_device *physical_device = device->physical_device; struct vulkan_instance *instance = device->physical_device->instance; VkImportMemoryHostPointerInfoEXT host_pointer_info, *pointer_info = NULL; + VkExportMemoryAllocateInfo *export_info = NULL; VkDeviceMemory host_device_memory; struct device_memory *memory; uint32_t mem_flags; @@ -170,12 +178,23 @@ static VkResult win32u_vkAllocateMemory( VkDevice client_device, const VkMemoryA { case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: break; case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + export_info = (VkExportMemoryAllocateInfo *)*next; + if (!(export_info->handleTypes & EXTERNAL_MEMORY_WIN32_BITS)) + FIXME( "Unsupported handle types %#x\n", export_info->handleTypes ); FIXME( "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO not implemented!\n" ); *next = (*next)->pNext; next = &prev; break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + FIXME( "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: pointer_info = (VkImportMemoryHostPointerInfoEXT *)*next; break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + FIXME( "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: break; case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: break; case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: break; @@ -240,6 +259,25 @@ static void win32u_vkFreeMemory( VkDevice client_device, VkDeviceMemory client_m free( memory ); } +static VkResult win32u_vkGetMemoryWin32HandleKHR( VkDevice client_device, const VkMemoryGetWin32HandleInfoKHR *handle_info, HANDLE *handle ) +{ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + + FIXME( "device %p, handle_info %p, handle %p stub!\n", device, handle_info, handle ); + + return VK_ERROR_INCOMPATIBLE_DRIVER; +} + +static VkResult win32u_vkGetMemoryWin32HandlePropertiesKHR( VkDevice client_device, VkExternalMemoryHandleTypeFlagBits handle_type, HANDLE handle, + VkMemoryWin32HandlePropertiesKHR *handle_properties ) +{ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + + FIXME( "device %p, handle_type %#x, handle %p, handle_properties %p stub!\n", device, handle_type, handle, handle_properties ); + + return VK_ERROR_INCOMPATIBLE_DRIVER; +} + static VkResult win32u_vkMapMemory2KHR( VkDevice client_device, const VkMemoryMapInfoKHR *map_info, void **data ) { struct vulkan_device *device = vulkan_device_from_handle( client_device ); @@ -389,6 +427,8 @@ static VkResult win32u_vkCreateBuffer( VkDevice client_device, const VkBufferCre case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: break; case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: external_info = (VkExternalMemoryBufferCreateInfo *)*next; + if (!(external_info->handleTypes & EXTERNAL_MEMORY_WIN32_BITS)) + FIXME( "Unsupported handle types %#x\n", external_info->handleTypes ); FIXME( "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO not implemented!\n" ); *next = (*next)->pNext; next = &prev; break; @@ -409,6 +449,55 @@ static VkResult win32u_vkCreateBuffer( VkDevice client_device, const VkBufferCre return device->p_vkCreateBuffer( device->host.device, create_info, NULL, buffer ); } +static void win32u_vkGetDeviceBufferMemoryRequirements( VkDevice client_device, const VkDeviceBufferMemoryRequirements *buffer_requirements, + VkMemoryRequirements2 *memory_requirements ) +{ + VkBaseOutStructure **next, *prev = (VkBaseOutStructure *)buffer_requirements->pCreateInfo; /* cast away const, chain has been copied in the thunks */ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + VkExternalMemoryBufferCreateInfo *external_info; + + TRACE( "device %p, buffer_requirements %p, memory_requirements %p\n", device, buffer_requirements, memory_requirements ); + + for (next = &prev->pNext; *next; prev = *next, next = &(*next)->pNext) + { + switch ((*next)->sType) + { + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + external_info = (VkExternalMemoryBufferCreateInfo *)*next; + if (!(external_info->handleTypes & EXTERNAL_MEMORY_WIN32_BITS)) + FIXME( "Unsupported handle types %#x\n", external_info->handleTypes ); + FIXME( "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: break; + default: FIXME( "Unhandled sType %u.\n", (*next)->sType ); break; + } + } + + device->p_vkGetDeviceBufferMemoryRequirements( device->host.device, buffer_requirements, memory_requirements ); +} + +static void win32u_vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice client_physical_device, const VkPhysicalDeviceExternalBufferInfo *buffer_info, + VkExternalBufferProperties *buffer_properies ) +{ + struct vulkan_physical_device *physical_device = vulkan_physical_device_from_handle( client_physical_device ); + struct vulkan_instance *instance = physical_device->instance; + + TRACE( "physical_device %p, buffer_info %p, buffer_properies %p\n", physical_device, buffer_info, buffer_properies ); + + if (!(buffer_info->handleType & EXTERNAL_MEMORY_WIN32_BITS)) + FIXME( "Unsupported handle type %#x\n", buffer_info->handleType ); + FIXME( "VkPhysicalDeviceExternalBufferInfo Win32 handleType not implemented!\n" ); + ((VkPhysicalDeviceExternalBufferInfo *)buffer_info)->handleType = 0; /* cast away const, it has been copied in the thunks */ + + return instance->p_vkGetPhysicalDeviceExternalBufferProperties( physical_device->host.physical_device, buffer_info, buffer_properies ); +} + static VkResult win32u_vkCreateImage( VkDevice client_device, const VkImageCreateInfo *create_info, const VkAllocationCallbacks *allocator, VkImage *image ) { @@ -424,6 +513,8 @@ static VkResult win32u_vkCreateImage( VkDevice client_device, const VkImageCreat case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: break; case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: external_info = (VkExternalMemoryImageCreateInfo *)*next; + if (!(external_info->handleTypes & EXTERNAL_MEMORY_WIN32_BITS)) + FIXME( "Unsupported handle types %#x\n", external_info->handleTypes ); FIXME( "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO not implemented!\n" ); *next = (*next)->pNext; next = &prev; break; @@ -450,6 +541,76 @@ static VkResult win32u_vkCreateImage( VkDevice client_device, const VkImageCreat return device->p_vkCreateImage( device->host.device, create_info, NULL, image ); } +static void win32u_vkGetDeviceImageMemoryRequirements( VkDevice client_device, const VkDeviceImageMemoryRequirements *image_requirements, + VkMemoryRequirements2 *memory_requirements ) +{ + VkBaseOutStructure **next, *prev = (VkBaseOutStructure *)image_requirements->pCreateInfo; /* cast away const, chain has been copied in the thunks */ + struct vulkan_device *device = vulkan_device_from_handle( client_device ); + VkExternalMemoryImageCreateInfo *external_info; + + TRACE( "device %p, image_requirements %p, memory_requirements %p\n", device, image_requirements, memory_requirements ); + + for (next = &prev->pNext; *next; prev = *next, next = &(*next)->pNext) + { + switch ((*next)->sType) + { + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + external_info = (VkExternalMemoryImageCreateInfo *)*next; + if (!(external_info->handleTypes & EXTERNAL_MEMORY_WIN32_BITS)) + FIXME( "Unsupported handle types %#x\n", external_info->handleTypes ); + FIXME( "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: break; + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: break; + default: FIXME( "Unhandled sType %u.\n", (*next)->sType ); break; + } + } + + device->p_vkGetDeviceImageMemoryRequirements( device->host.device, image_requirements, memory_requirements ); +} + +static VkResult win32u_vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice client_physical_device, const VkPhysicalDeviceImageFormatInfo2 *format_info, + VkImageFormatProperties2 *format_properies ) +{ + VkBaseOutStructure **next, *prev = (VkBaseOutStructure *)format_info; /* cast away const, chain has been copied in the thunks */ + struct vulkan_physical_device *physical_device = vulkan_physical_device_from_handle( client_physical_device ); + struct vulkan_instance *instance = physical_device->instance; + VkPhysicalDeviceExternalImageFormatInfo *external_info; + + TRACE( "physical_device %p, format_info %p, format_properies %p\n", physical_device, format_info, format_properies ); + + for (next = &prev->pNext; *next; prev = *next, next = &(*next)->pNext) + { + switch ((*next)->sType) + { + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + external_info = (VkPhysicalDeviceExternalImageFormatInfo *)*next; + if (!(external_info->handleType & EXTERNAL_MEMORY_WIN32_BITS)) + FIXME( "Unsupported handle type %#x\n", external_info->handleType ); + FIXME( "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO not implemented!\n" ); + *next = (*next)->pNext; next = &prev; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: break; + default: FIXME( "Unhandled sType %u.\n", (*next)->sType ); break; + } + } + + return instance->p_vkGetPhysicalDeviceImageFormatProperties2( physical_device->host.physical_device, format_info, format_properies ); +} + static VkResult win32u_vkCreateWin32SurfaceKHR( VkInstance client_instance, const VkWin32SurfaceCreateInfoKHR *create_info, const VkAllocationCallbacks *allocator, VkSurfaceKHR *ret ) { @@ -871,6 +1032,15 @@ static struct vulkan_funcs vulkan_funcs = .p_vkDestroySurfaceKHR = win32u_vkDestroySurfaceKHR, .p_vkDestroySwapchainKHR = win32u_vkDestroySwapchainKHR, .p_vkFreeMemory = win32u_vkFreeMemory, + .p_vkGetDeviceBufferMemoryRequirements = win32u_vkGetDeviceBufferMemoryRequirements, + .p_vkGetDeviceBufferMemoryRequirementsKHR = win32u_vkGetDeviceBufferMemoryRequirements, + .p_vkGetDeviceImageMemoryRequirements = win32u_vkGetDeviceImageMemoryRequirements, + .p_vkGetMemoryWin32HandleKHR = win32u_vkGetMemoryWin32HandleKHR, + .p_vkGetMemoryWin32HandlePropertiesKHR = win32u_vkGetMemoryWin32HandlePropertiesKHR, + .p_vkGetPhysicalDeviceExternalBufferProperties = win32u_vkGetPhysicalDeviceExternalBufferProperties, + .p_vkGetPhysicalDeviceExternalBufferPropertiesKHR = win32u_vkGetPhysicalDeviceExternalBufferProperties, + .p_vkGetPhysicalDeviceImageFormatProperties2 = win32u_vkGetPhysicalDeviceImageFormatProperties2, + .p_vkGetPhysicalDeviceImageFormatProperties2KHR = win32u_vkGetPhysicalDeviceImageFormatProperties2, .p_vkGetPhysicalDevicePresentRectanglesKHR = win32u_vkGetPhysicalDevicePresentRectanglesKHR, .p_vkGetPhysicalDeviceSurfaceCapabilities2KHR = win32u_vkGetPhysicalDeviceSurfaceCapabilities2KHR, .p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = win32u_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c index e932ec46476..3da89090ee8 100644 --- a/dlls/winevulkan/loader_thunks.c +++ b/dlls/winevulkan/loader_thunks.c @@ -5233,6 +5233,31 @@ VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalM return params.result; } +VkResult WINAPI vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) +{ + struct vkGetMemoryWin32HandleKHR_params params; + NTSTATUS status; + params.device = device; + params.pGetWin32HandleInfo = pGetWin32HandleInfo; + params.pHandle = pHandle; + status = UNIX_CALL(vkGetMemoryWin32HandleKHR, ¶ms); + assert(!status && "vkGetMemoryWin32HandleKHR"); + return params.result; +} + +VkResult WINAPI vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) +{ + struct vkGetMemoryWin32HandlePropertiesKHR_params params; + NTSTATUS status; + params.device = device; + params.handleType = handleType; + params.handle = handle; + params.pMemoryWin32HandleProperties = pMemoryWin32HandleProperties; + status = UNIX_CALL(vkGetMemoryWin32HandlePropertiesKHR, ¶ms); + assert(!status && "vkGetMemoryWin32HandlePropertiesKHR"); + return params.result; +} + void WINAPI vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo) { struct vkGetMicromapBuildSizesEXT_params params; @@ -7544,6 +7569,8 @@ static const struct vulkan_func vk_device_dispatch_table[] = {"vkGetImageViewOpaqueCaptureDescriptorDataEXT", vkGetImageViewOpaqueCaptureDescriptorDataEXT}, {"vkGetLatencyTimingsNV", vkGetLatencyTimingsNV}, {"vkGetMemoryHostPointerPropertiesEXT", vkGetMemoryHostPointerPropertiesEXT}, + {"vkGetMemoryWin32HandleKHR", vkGetMemoryWin32HandleKHR}, + {"vkGetMemoryWin32HandlePropertiesKHR", vkGetMemoryWin32HandlePropertiesKHR}, {"vkGetMicromapBuildSizesEXT", vkGetMicromapBuildSizesEXT}, {"vkGetPartitionedAccelerationStructuresBuildSizesNV", vkGetPartitionedAccelerationStructuresBuildSizesNV}, {"vkGetPerformanceParameterINTEL", vkGetPerformanceParameterINTEL}, diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h index 7bf58a83988..ebfc3dce3a8 100644 --- a/dlls/winevulkan/loader_thunks.h +++ b/dlls/winevulkan/loader_thunks.h @@ -526,6 +526,8 @@ enum unix_call unix_vkGetImageViewOpaqueCaptureDescriptorDataEXT, unix_vkGetLatencyTimingsNV, unix_vkGetMemoryHostPointerPropertiesEXT, + unix_vkGetMemoryWin32HandleKHR, + unix_vkGetMemoryWin32HandlePropertiesKHR, unix_vkGetMicromapBuildSizesEXT, unix_vkGetPartitionedAccelerationStructuresBuildSizesNV, unix_vkGetPerformanceParameterINTEL, @@ -4542,6 +4544,23 @@ struct vkGetMemoryHostPointerPropertiesEXT_params VkResult result; }; +struct vkGetMemoryWin32HandleKHR_params +{ + VkDevice device; + const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo; + HANDLE *pHandle; + VkResult result; +}; + +struct vkGetMemoryWin32HandlePropertiesKHR_params +{ + VkDevice device; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties; + VkResult result; +}; + struct vkGetMicromapBuildSizesEXT_params { VkDevice device; diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index d15e40f01cf..83ec38fd520 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -127,7 +127,6 @@ UNSUPPORTED_EXTENSIONS = [ # but not expose to applications (useful for test commits) UNEXPOSED_EXTENSIONS = { "VK_EXT_map_memory_placed", - "VK_KHR_external_memory_win32", "VK_EXT_headless_surface", # Extensions for other platforms "VK_EXT_external_memory_dma_buf", @@ -191,7 +190,6 @@ FUNCTION_OVERRIDES = { # Instance functions "vkCreateDevice" : {"extra_param" : "client_ptr"}, - "vkGetPhysicalDeviceExternalBufferProperties" : {"dispatch" : False}, "vkGetPhysicalDeviceExternalFenceProperties" : {"dispatch" : False}, "vkGetPhysicalDeviceExternalSemaphoreProperties" : {"dispatch" : False}, @@ -202,9 +200,6 @@ FUNCTION_OVERRIDES = { # VK_KHR_external_fence_capabilities "vkGetPhysicalDeviceExternalFencePropertiesKHR" : {"dispatch" : False}, - # VK_KHR_external_memory_capabilities - "vkGetPhysicalDeviceExternalBufferPropertiesKHR" : {"dispatch" : False}, - # VK_KHR_external_semaphore_capabilities "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" : {"dispatch" : False}, } @@ -221,8 +216,17 @@ USER_DRIVER_FUNCS = { "vkDestroySurfaceKHR", "vkDestroySwapchainKHR", "vkFreeMemory", + "vkGetDeviceBufferMemoryRequirements", + "vkGetDeviceBufferMemoryRequirementsKHR", + "vkGetDeviceImageMemoryRequirements", "vkGetDeviceProcAddr", "vkGetInstanceProcAddr", + "vkGetMemoryWin32HandleKHR", + "vkGetMemoryWin32HandlePropertiesKHR", + "vkGetPhysicalDeviceExternalBufferProperties", + "vkGetPhysicalDeviceExternalBufferPropertiesKHR", + "vkGetPhysicalDeviceImageFormatProperties2", + "vkGetPhysicalDeviceImageFormatProperties2KHR", "vkGetPhysicalDevicePresentRectanglesKHR", "vkGetPhysicalDeviceSurfaceCapabilities2KHR", "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", @@ -268,14 +272,10 @@ MANUAL_UNIX_THUNKS = { "vkGetInstanceProcAddr", "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", - "vkGetPhysicalDeviceExternalBufferProperties", - "vkGetPhysicalDeviceExternalBufferPropertiesKHR", "vkGetPhysicalDeviceExternalFenceProperties", "vkGetPhysicalDeviceExternalFencePropertiesKHR", "vkGetPhysicalDeviceExternalSemaphoreProperties", "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", - "vkGetPhysicalDeviceImageFormatProperties2", - "vkGetPhysicalDeviceImageFormatProperties2KHR", } # loader functions which are entirely manually implemented @@ -306,6 +306,8 @@ STRUCT_CHAIN_CONVERSIONS = { "VkMemoryAllocateInfo": {}, "VkBufferCreateInfo": {}, "VkImageCreateInfo": {}, + "VkPhysicalDeviceExternalBufferInfo": {}, + "VkPhysicalDeviceImageFormatInfo2": {}, # Ignore to not confuse host loader. "VkDeviceCreateInfo": {"strip": ["VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO"]}, diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 99f247f4e46..816da31f22c 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -3102,6 +3102,15 @@ typedef struct VkExportMemoryAllocateInfo32 } VkExportMemoryAllocateInfo32; typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32; +typedef struct VkExportMemoryWin32HandleInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR32; + typedef struct VkExportSemaphoreCreateInfo32 { VkStructureType sType; @@ -3623,6 +3632,15 @@ typedef struct VkImportMemoryHostPointerInfoEXT32 PTR32 pHostPointer; } VkImportMemoryHostPointerInfoEXT32; +typedef struct VkImportMemoryWin32HandleInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR32; + typedef struct VkIndirectCommandsLayoutCreateInfoEXT32 { VkStructureType sType; @@ -3781,6 +3799,14 @@ typedef struct VkMemoryDedicatedRequirements32 } VkMemoryDedicatedRequirements32; typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32; +typedef struct VkMemoryGetWin32HandleInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetWin32HandleInfoKHR32; + typedef struct VkMemoryHostPointerPropertiesEXT32 { VkStructureType sType; @@ -3832,6 +3858,13 @@ typedef struct VkMemoryUnmapInfo32 } VkMemoryUnmapInfo32; typedef VkMemoryUnmapInfo32 VkMemoryUnmapInfoKHR32; +typedef struct VkMemoryWin32HandlePropertiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR32; + typedef struct VkMicromapBuildInfoEXT32 { VkStructureType sType; @@ -9658,6 +9691,19 @@ static void convert_VkMemoryAllocateInfo_win64_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + { + VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExportMemoryWin32HandleInfoKHR *in_ext = (const VkExportMemoryWin32HandleInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pAttributes = in_ext->pAttributes; + out_ext->dwAccess = in_ext->dwAccess; + out_ext->name = in_ext->name; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: { VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -9670,6 +9716,19 @@ static void convert_VkMemoryAllocateInfo_win64_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + { + VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImportMemoryWin32HandleInfoKHR *in_ext = (const VkImportMemoryWin32HandleInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->handleType = in_ext->handleType; + out_ext->handle = in_ext->handle; + out_ext->name = in_ext->name; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: { VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -9774,6 +9833,19 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + { + VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pAttributes = UlongToPtr(in_ext->pAttributes); + out_ext->dwAccess = in_ext->dwAccess; + out_ext->name = in_ext->name; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: { VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -9786,6 +9858,19 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + { + VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->handleType = in_ext->handleType; + out_ext->handle = in_ext->handle; + out_ext->name = in_ext->name; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: { VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -28435,6 +28520,35 @@ static void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemor out->memoryTypeBits = in->memoryTypeBits; } +static void convert_VkMemoryGetWin32HandleInfoKHR_win32_to_unwrapped_host(const VkMemoryGetWin32HandleInfoKHR32 *in, VkMemoryGetWin32HandleInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->memory = in->memory; + out->handleType = in->handleType; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkMemoryWin32HandlePropertiesKHR_win32_to_host(const VkMemoryWin32HandlePropertiesKHR32 *in, VkMemoryWin32HandlePropertiesKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkMemoryWin32HandlePropertiesKHR_host_to_win32(const VkMemoryWin32HandlePropertiesKHR *in, VkMemoryWin32HandlePropertiesKHR32 *out) +{ + if (!in) return; + + out->memoryTypeBits = in->memoryTypeBits; +} + static void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out) { if (!in) return; @@ -28700,6 +28814,43 @@ static void convert_VkCooperativeVectorPropertiesNV_array_host_to_win32(const Vk } } +#ifdef _WIN64 +static void convert_VkPhysicalDeviceExternalBufferInfo_win64_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalBufferInfo *in, VkPhysicalDeviceExternalBufferInfo *out) +{ + const VkBaseInStructure *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->usage = in->usage; + out->handleType = in->handleType; + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: + { + VkBufferUsageFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBufferUsageFlags2CreateInfo *in_ext = (const VkBufferUsageFlags2CreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} +#endif /* _WIN64 */ + static void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out) { const VkBaseInStructure32 *in_header; @@ -33979,6 +34130,115 @@ static void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatPro out->maxResourceSize = in->maxResourceSize; } +#ifdef _WIN64 +static void convert_VkPhysicalDeviceImageFormatInfo2_win64_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo2 *in, VkPhysicalDeviceImageFormatInfo2 *out) +{ + const VkBaseInStructure *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->format = in->format; + out->type = in->type; + out->tiling = in->tiling; + out->usage = in->usage; + out->flags = in->flags; + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + { + VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCompressionControlEXT *in_ext = (const VkImageCompressionControlEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; + out_ext->pFixedRateFlags = in_ext->pFixedRateFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + { + VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageFormatListCreateInfo *in_ext = (const VkImageFormatListCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->viewFormatCount = in_ext->viewFormatCount; + out_ext->pViewFormats = in_ext->pViewFormats; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + { + VkImageStencilUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageStencilUsageCreateInfo *in_ext = (const VkImageStencilUsageCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->stencilUsage = in_ext->stencilUsage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + { + VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpticalFlowImageFormatInfoNV *in_ext = (const VkOpticalFlowImageFormatInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; + out_ext->pNext = NULL; + out_ext->usage = in_ext->usage; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + { + VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExternalImageFormatInfo *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; + out_ext->pNext = NULL; + out_ext->handleType = in_ext->handleType; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + { + VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageViewImageFormatInfoEXT *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; + out_ext->pNext = NULL; + out_ext->imageViewType = in_ext->imageViewType; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + { + VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoProfileListInfoKHR *in_ext = (const VkVideoProfileListInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + out_ext->pNext = NULL; + out_ext->profileCount = in_ext->profileCount; + out_ext->pProfiles = in_ext->pProfiles; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} +#endif /* _WIN64 */ + static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out) { const VkBaseInStructure32 *in_header; @@ -52564,7 +52824,7 @@ static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirements(void *args) init_conversion_context(ctx); convert_VkDeviceBufferMemoryRequirements_win64_to_host(ctx, params->pInfo, &pInfo_host); - vulkan_device_from_handle(params->device)->p_vkGetDeviceBufferMemoryRequirements(vulkan_device_from_handle(params->device)->host.device, &pInfo_host, params->pMemoryRequirements); + vk_funcs->p_vkGetDeviceBufferMemoryRequirements(params->device, &pInfo_host, params->pMemoryRequirements); free_conversion_context(ctx); return STATUS_SUCCESS; } @@ -52588,7 +52848,7 @@ static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args) init_conversion_context(ctx); convert_VkDeviceBufferMemoryRequirements_win32_to_host(ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host); convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host); - vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetDeviceBufferMemoryRequirements(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, &pMemoryRequirements_host); + vk_funcs->p_vkGetDeviceBufferMemoryRequirements((VkDevice)UlongToPtr(params->device), &pInfo_host, &pMemoryRequirements_host); convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -52606,7 +52866,7 @@ static NTSTATUS thunk64_vkGetDeviceBufferMemoryRequirementsKHR(void *args) init_conversion_context(ctx); convert_VkDeviceBufferMemoryRequirements_win64_to_host(ctx, params->pInfo, &pInfo_host); - vulkan_device_from_handle(params->device)->p_vkGetDeviceBufferMemoryRequirementsKHR(vulkan_device_from_handle(params->device)->host.device, &pInfo_host, params->pMemoryRequirements); + vk_funcs->p_vkGetDeviceBufferMemoryRequirementsKHR(params->device, &pInfo_host, params->pMemoryRequirements); free_conversion_context(ctx); return STATUS_SUCCESS; } @@ -52630,7 +52890,7 @@ static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args) init_conversion_context(ctx); convert_VkDeviceBufferMemoryRequirements_win32_to_host(ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host); convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host); - vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetDeviceBufferMemoryRequirementsKHR(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, &pMemoryRequirements_host); + vk_funcs->p_vkGetDeviceBufferMemoryRequirementsKHR((VkDevice)UlongToPtr(params->device), &pInfo_host, &pMemoryRequirements_host); convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -52806,7 +53066,7 @@ static NTSTATUS thunk64_vkGetDeviceImageMemoryRequirements(void *args) init_conversion_context(ctx); convert_VkDeviceImageMemoryRequirements_win64_to_host(ctx, params->pInfo, &pInfo_host); - vulkan_device_from_handle(params->device)->p_vkGetDeviceImageMemoryRequirements(vulkan_device_from_handle(params->device)->host.device, &pInfo_host, params->pMemoryRequirements); + vk_funcs->p_vkGetDeviceImageMemoryRequirements(params->device, &pInfo_host, params->pMemoryRequirements); free_conversion_context(ctx); return STATUS_SUCCESS; } @@ -52830,7 +53090,7 @@ static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args) init_conversion_context(ctx); convert_VkDeviceImageMemoryRequirements_win32_to_host(ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host); convert_VkMemoryRequirements2_win32_to_host(ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host); - vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->p_vkGetDeviceImageMemoryRequirements(vulkan_device_from_handle((VkDevice)UlongToPtr(params->device))->host.device, &pInfo_host, &pMemoryRequirements_host); + vk_funcs->p_vkGetDeviceImageMemoryRequirements((VkDevice)UlongToPtr(params->device), &pInfo_host, &pMemoryRequirements_host); convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -54105,6 +54365,68 @@ static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args) return STATUS_SUCCESS; } +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetMemoryWin32HandleKHR(void *args) +{ + struct vkGetMemoryWin32HandleKHR_params *params = args; + + TRACE("%p, %p, %p\n", params->device, params->pGetWin32HandleInfo, params->pHandle); + + params->result = vk_funcs->p_vkGetMemoryWin32HandleKHR(params->device, params->pGetWin32HandleInfo, params->pHandle); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetMemoryWin32HandleKHR(void *args) +{ + struct + { + PTR32 device; + PTR32 pGetWin32HandleInfo; + PTR32 pHandle; + VkResult result; + } *params = args; + VkMemoryGetWin32HandleInfoKHR pGetWin32HandleInfo_host; + + TRACE("%#x, %#x, %#x\n", params->device, params->pGetWin32HandleInfo, params->pHandle); + + convert_VkMemoryGetWin32HandleInfoKHR_win32_to_unwrapped_host((const VkMemoryGetWin32HandleInfoKHR32 *)UlongToPtr(params->pGetWin32HandleInfo), &pGetWin32HandleInfo_host); + params->result = vk_funcs->p_vkGetMemoryWin32HandleKHR((VkDevice)UlongToPtr(params->device), &pGetWin32HandleInfo_host, (HANDLE *)UlongToPtr(params->pHandle)); + return STATUS_SUCCESS; +} + +#ifdef _WIN64 +static NTSTATUS thunk64_vkGetMemoryWin32HandlePropertiesKHR(void *args) +{ + struct vkGetMemoryWin32HandlePropertiesKHR_params *params = args; + + TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->handle, params->pMemoryWin32HandleProperties); + + params->result = vk_funcs->p_vkGetMemoryWin32HandlePropertiesKHR(params->device, params->handleType, params->handle, params->pMemoryWin32HandleProperties); + return STATUS_SUCCESS; +} +#endif /* _WIN64 */ + +static NTSTATUS thunk32_vkGetMemoryWin32HandlePropertiesKHR(void *args) +{ + struct + { + PTR32 device; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + PTR32 pMemoryWin32HandleProperties; + VkResult result; + } *params = args; + VkMemoryWin32HandlePropertiesKHR pMemoryWin32HandleProperties_host; + + TRACE("%#x, %#x, %p, %#x\n", params->device, params->handleType, params->handle, params->pMemoryWin32HandleProperties); + + convert_VkMemoryWin32HandlePropertiesKHR_win32_to_host((VkMemoryWin32HandlePropertiesKHR32 *)UlongToPtr(params->pMemoryWin32HandleProperties), &pMemoryWin32HandleProperties_host); + params->result = vk_funcs->p_vkGetMemoryWin32HandlePropertiesKHR((VkDevice)UlongToPtr(params->device), params->handleType, params->handle, &pMemoryWin32HandleProperties_host); + convert_VkMemoryWin32HandlePropertiesKHR_host_to_win32(&pMemoryWin32HandleProperties_host, (VkMemoryWin32HandlePropertiesKHR32 *)UlongToPtr(params->pMemoryWin32HandleProperties)); + return STATUS_SUCCESS; +} + #ifdef _WIN64 static NTSTATUS thunk64_vkGetMicromapBuildSizesEXT(void *args) { @@ -54409,10 +54731,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeVectorPropertiesNV(void *a static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferProperties(void *args) { struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args; + VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties); - wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties); + init_conversion_context(ctx); + convert_VkPhysicalDeviceExternalBufferInfo_win64_to_host(ctx, params->pExternalBufferInfo, &pExternalBufferInfo_host); + vk_funcs->p_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, &pExternalBufferInfo_host, params->pExternalBufferProperties); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -54435,7 +54763,7 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args) init_conversion_context(ctx); convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host); convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host); - wine_vkGetPhysicalDeviceExternalBufferProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host); + vk_funcs->p_vkGetPhysicalDeviceExternalBufferProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host); convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -54445,10 +54773,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args) static NTSTATUS thunk64_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args) { struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args; + VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties); - wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties); + init_conversion_context(ctx); + convert_VkPhysicalDeviceExternalBufferInfo_win64_to_host(ctx, params->pExternalBufferInfo, &pExternalBufferInfo_host); + vk_funcs->p_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, &pExternalBufferInfo_host, params->pExternalBufferProperties); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -54471,7 +54805,7 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *arg init_conversion_context(ctx); convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(ctx, (const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host); convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host); - wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host); + vk_funcs->p_vkGetPhysicalDeviceExternalBufferPropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host); convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -54909,10 +55243,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args) static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2(void *args) { struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args; + VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties); - params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties); + init_conversion_context(ctx); + convert_VkPhysicalDeviceImageFormatInfo2_win64_to_host(ctx, params->pImageFormatInfo, &pImageFormatInfo_host); + params->result = vk_funcs->p_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, &pImageFormatInfo_host, params->pImageFormatProperties); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -54936,7 +55276,7 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args) init_conversion_context(ctx); convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host); convert_VkImageFormatProperties2_win32_to_host(ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host); - params->result = wine_vkGetPhysicalDeviceImageFormatProperties2((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host); + params->result = vk_funcs->p_vkGetPhysicalDeviceImageFormatProperties2((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host); convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -54946,10 +55286,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args) static NTSTATUS thunk64_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args) { struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args; + VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host; + struct conversion_context local_ctx; + struct conversion_context *ctx = &local_ctx; TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties); - params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties); + init_conversion_context(ctx); + convert_VkPhysicalDeviceImageFormatInfo2_win64_to_host(ctx, params->pImageFormatInfo, &pImageFormatInfo_host); + params->result = vk_funcs->p_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, &pImageFormatInfo_host, params->pImageFormatProperties); + free_conversion_context(ctx); return STATUS_SUCCESS; } #endif /* _WIN64 */ @@ -54973,7 +55319,7 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args) init_conversion_context(ctx); convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host); convert_VkImageFormatProperties2_win32_to_host(ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host); - params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host); + params->result = vk_funcs->p_vkGetPhysicalDeviceImageFormatProperties2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host); convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties)); free_conversion_context(ctx); return STATUS_SUCCESS; @@ -59240,6 +59586,7 @@ static const char * const vk_device_extensions[] = "VK_KHR_dynamic_rendering_local_read", "VK_KHR_external_fence", "VK_KHR_external_memory", + "VK_KHR_external_memory_win32", "VK_KHR_external_semaphore", "VK_KHR_format_feature_flags2", "VK_KHR_fragment_shader_barycentric", @@ -59999,6 +60346,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk64_vkGetImageViewOpaqueCaptureDescriptorDataEXT, thunk64_vkGetLatencyTimingsNV, thunk64_vkGetMemoryHostPointerPropertiesEXT, + thunk64_vkGetMemoryWin32HandleKHR, + thunk64_vkGetMemoryWin32HandlePropertiesKHR, thunk64_vkGetMicromapBuildSizesEXT, thunk64_vkGetPartitionedAccelerationStructuresBuildSizesNV, thunk64_vkGetPerformanceParameterINTEL, @@ -60671,6 +61020,8 @@ const unixlib_entry_t __wine_unix_call_funcs[] = thunk32_vkGetImageViewOpaqueCaptureDescriptorDataEXT, thunk32_vkGetLatencyTimingsNV, thunk32_vkGetMemoryHostPointerPropertiesEXT, + thunk32_vkGetMemoryWin32HandleKHR, + thunk32_vkGetMemoryWin32HandlePropertiesKHR, thunk32_vkGetMicromapBuildSizesEXT, thunk32_vkGetPartitionedAccelerationStructuresBuildSizesNV, thunk32_vkGetPerformanceParameterINTEL, diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h index 4f5abf6cabc..a7736bb7923 100644 --- a/dlls/winevulkan/vulkan_thunks.h +++ b/dlls/winevulkan/vulkan_thunks.h @@ -48,13 +48,9 @@ void wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t void wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue); VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains); -void wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties); -void wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties); void wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties); void wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties); void wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties); void wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties); -VkResult wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties); -VkResult wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties); #endif /* __WINE_VULKAN_THUNKS_H */ diff --git a/include/wine/vulkan.h b/include/wine/vulkan.h index e5c44057f52..4336a154ecc 100644 --- a/include/wine/vulkan.h +++ b/include/wine/vulkan.h @@ -20707,6 +20707,8 @@ VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micr USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV) \ USE_VK_FUNC(vkGetPhysicalDeviceCooperativeVectorPropertiesNV) \ + USE_VK_FUNC(vkGetPhysicalDeviceExternalBufferProperties) \ + USE_VK_FUNC(vkGetPhysicalDeviceExternalBufferPropertiesKHR) \ USE_VK_FUNC(vkGetPhysicalDeviceExternalTensorPropertiesARM) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures) \ USE_VK_FUNC(vkGetPhysicalDeviceFeatures2) \ diff --git a/include/wine/vulkan_driver.h b/include/wine/vulkan_driver.h index c373f639451..c9c76d87171 100644 --- a/include/wine/vulkan_driver.h +++ b/include/wine/vulkan_driver.h @@ -185,8 +185,17 @@ struct vulkan_funcs PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR; PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR; PFN_vkFreeMemory p_vkFreeMemory; + PFN_vkGetDeviceBufferMemoryRequirements p_vkGetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceBufferMemoryRequirementsKHR p_vkGetDeviceBufferMemoryRequirementsKHR; + PFN_vkGetDeviceImageMemoryRequirements p_vkGetDeviceImageMemoryRequirements; PFN_vkGetDeviceProcAddr p_vkGetDeviceProcAddr; PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr; + PFN_vkGetMemoryWin32HandleKHR p_vkGetMemoryWin32HandleKHR; + PFN_vkGetMemoryWin32HandlePropertiesKHR p_vkGetMemoryWin32HandlePropertiesKHR; + PFN_vkGetPhysicalDeviceExternalBufferProperties p_vkGetPhysicalDeviceExternalBufferProperties; + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR p_vkGetPhysicalDeviceExternalBufferPropertiesKHR; + PFN_vkGetPhysicalDeviceImageFormatProperties2 p_vkGetPhysicalDeviceImageFormatProperties2; + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR p_vkGetPhysicalDeviceImageFormatProperties2KHR; PFN_vkGetPhysicalDevicePresentRectanglesKHR p_vkGetPhysicalDevicePresentRectanglesKHR; PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR p_vkGetPhysicalDeviceSurfaceCapabilities2KHR; PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; -- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8909
v2: Avoid skipping next element in the chain when removing one. -- https://gitlab.winehq.org/wine/wine/-/merge_requests/8909#note_114975
participants (1)
-
Rémi Bernon