diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 01a48129..e7c5aa1d 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -90,6 +90,9 @@ static const struct vkd3d_optional_extension_info optional_device_extensions[] = VK_EXTENSION(KHR_UNIFORM_BUFFER_STANDARD_LAYOUT, KHR_uniform_buffer_standard_layout), VK_EXTENSION(KHR_MAINTENANCE_4, KHR_maintenance4), VK_EXTENSION(KHR_FRAGMENT_SHADER_BARYCENTRIC, KHR_fragment_shader_barycentric), +#ifdef _WIN32 + VK_EXTENSION(KHR_EXTERNAL_MEMORY_WIN32, KHR_external_memory_win32), +#endif /* EXT extensions */ VK_EXTENSION(EXT_CALIBRATED_TIMESTAMPS, EXT_calibrated_timestamps), VK_EXTENSION(EXT_CONDITIONAL_RENDERING, EXT_conditional_rendering), @@ -4400,19 +4403,189 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateSharedHandle(d3d12_device_if ID3D12DeviceChild *object, const SECURITY_ATTRIBUTES *attributes, DWORD access, const WCHAR *name, HANDLE *handle) { - FIXME("iface %p, object %p, attributes %p, access %#x, name %s, handle %p stub!\n", +#ifdef _WIN32 + struct d3d12_device *device = impl_from_ID3D12Device(iface); + const struct vkd3d_vk_device_procs *vk_procs; + struct DxvkSharedTextureMetadata metadata; + ID3D12Resource *resource_iface; + + vk_procs = &device->vk_procs; + + TRACE("iface %p, object %p, attributes %p, access %#x, name %s, handle %p\n", iface, object, attributes, access, debugstr_w(name), handle); + if (SUCCEEDED(ID3D12DeviceChild_QueryInterface(object, &IID_ID3D12Resource, (void**)&resource_iface))) + { + struct d3d12_resource *resource = impl_from_ID3D12Resource(resource_iface); + VkMemoryGetWin32HandleInfoKHR win32_handle_info; + VkResult vr; + + if (!(resource->heap_flags & D3D12_HEAP_FLAG_SHARED)) + { + ID3D12Resource_Release(resource_iface); + return DXGI_ERROR_INVALID_CALL; + } + + if (attributes) + FIXME("attributes %p not handled.\n", attributes); + if (access) + FIXME("access %#x not handled.\n", access); + if (name) + FIXME("name %s not handled.\n", debugstr_w(name)); + + win32_handle_info.sType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR; + win32_handle_info.pNext = NULL; + win32_handle_info.memory = resource->mem.device_allocation.vk_memory; + win32_handle_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; + + vr = VK_CALL(vkGetMemoryWin32HandleKHR(device->vk_device, &win32_handle_info, handle)); + + if (vr == VK_SUCCESS) + { + if (resource->desc.Dimension != D3D12_RESOURCE_DIMENSION_TEXTURE2D) + { + FIXME("Shared texture metadata structure only supports 2D textures."); + } + else + { + metadata.Width = resource->desc.Width; + metadata.Height = resource->desc.Height; + metadata.MipLevels = resource->desc.MipLevels; + metadata.ArraySize = resource->desc.DepthOrArraySize; + metadata.Format = resource->desc.Format; + metadata.SampleDesc = resource->desc.SampleDesc; + metadata.Usage = D3D11_USAGE_DEFAULT; + metadata.BindFlags = D3D11_BIND_SHADER_RESOURCE; + metadata.CPUAccessFlags = 0; + metadata.MiscFlags = D3D11_RESOURCE_MISC_SHARED_NTHANDLE; + + if (resource->desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) + metadata.BindFlags |= D3D11_BIND_RENDER_TARGET; + if (resource->desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL) + metadata.BindFlags |= D3D11_BIND_DEPTH_STENCIL; + if (resource->desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS) + metadata.BindFlags |= D3D11_BIND_UNORDERED_ACCESS; + if (resource->desc.Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE) + metadata.BindFlags &= ~D3D11_BIND_SHADER_RESOURCE; + + if (!vkd3d_set_shared_metadata(*handle, &metadata, sizeof(metadata))) + ERR("Failed to set metadata for shared resource, importing created handle will fail.\n"); + } + } + + ID3D12Resource_Release(resource_iface); + return vr ? E_FAIL : S_OK; + } + + FIXME("Creating shared handle for type of object %p unsupported.\n", object); return E_NOTIMPL; +#else + FIXME("CreateSharedHandle can only be implemented in native Win32.\n"); + return E_NOTIMPL; +#endif +} + +static inline bool handle_is_kmt_style(HANDLE handle) +{ + return ((ULONG_PTR)handle & 0x40000000) && ((ULONG_PTR)handle - 2) % 4 == 0; } static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandle(d3d12_device_iface *iface, HANDLE handle, REFIID riid, void **object) { - FIXME("iface %p, handle %p, riid %s, object %p stub!\n", +#ifdef _WIN32 + struct d3d12_device *device = impl_from_ID3D12Device(iface); + HRESULT hr; + + TRACE("iface %p, handle %p, riid %s, object %p\n", iface, handle, debugstr_guid(riid), object); + if (IsEqualGUID(riid, &IID_ID3D12Resource)) + { + struct DxvkSharedTextureMetadata metadata; + D3D12_HEAP_PROPERTIES heap_props; + struct d3d12_resource *resource; + D3D12_RESOURCE_DESC1 desc; + bool kmt_handle = false; + + if (handle_is_kmt_style(handle)) + { + handle = vkd3d_open_kmt_handle(handle); + kmt_handle = true; + + if (handle == INVALID_HANDLE_VALUE) + { + WARN("Failed to open KMT-style ID3D12Resource shared handle.\n"); + *object = NULL; + return E_INVALIDARG; + } + } + + if (!vkd3d_get_shared_metadata(handle, &metadata, sizeof(metadata), NULL)) + { + WARN("Failed to get ID3D12Resource shared handle metadata.\n"); + if (kmt_handle) + CloseHandle(handle); + + *object = NULL; + return E_INVALIDARG; + } + + desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + desc.Alignment = 0; + desc.Width = metadata.Width; + desc.Height = metadata.Height; + desc.DepthOrArraySize = metadata.ArraySize; + desc.MipLevels = metadata.MipLevels; + desc.Format = metadata.Format; + desc.SampleDesc = metadata.SampleDesc; + switch (metadata.TextureLayout) + { + case D3D11_TEXTURE_LAYOUT_UNDEFINED: desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; break; + case D3D11_TEXTURE_LAYOUT_ROW_MAJOR: desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; break; + case D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE: desc.Layout = D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE; break; + default: desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + } + desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS; + if (metadata.BindFlags & D3D11_BIND_RENDER_TARGET) + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; + if (metadata.BindFlags & D3D11_BIND_DEPTH_STENCIL) + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; + if (metadata.BindFlags & D3D11_BIND_UNORDERED_ACCESS) + desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; + if ((metadata.BindFlags & D3D11_BIND_DEPTH_STENCIL) && !(metadata.BindFlags & D3D11_BIND_SHADER_RESOURCE)) + desc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; + desc.SamplerFeedbackMipRegion.Width = 0; + desc.SamplerFeedbackMipRegion.Height = 0; + desc.SamplerFeedbackMipRegion.Depth = 0; + + heap_props.Type = D3D12_HEAP_TYPE_DEFAULT; + heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN; + heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN; + heap_props.CreationNodeMask = 0; + heap_props.VisibleNodeMask = 0; + + hr = d3d12_resource_create_committed(device, &desc, &heap_props, + D3D12_HEAP_FLAG_SHARED, D3D12_RESOURCE_STATE_COMMON, NULL, handle, &resource); + if (kmt_handle) + CloseHandle(handle); + + if (FAILED(hr)) + { + WARN("Failed to open shared ID3D12Resource, hr %#x.\n", hr); + *object = NULL; + return hr; + } + + return return_interface(&resource->ID3D12Resource_iface, &IID_ID3D12Resource, riid, object); + } + + FIXME("Opening shared handle type %s unsupported\n", debugstr_guid(riid)); return E_NOTIMPL; +#else + FIXME("OpenSharedhandle can only be implemented in native Win32.\n"); + return E_NOTIMPL; +#endif } static HRESULT STDMETHODCALLTYPE d3d12_device_OpenSharedHandleByName(d3d12_device_iface *iface, @@ -5149,7 +5322,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateCommittedResource2(d3d12_dev FIXME("Ignoring protected session %p.\n", protected_session); if (FAILED(hr = d3d12_resource_create_committed(device, desc, heap_properties, - heap_flags, initial_state, optimized_clear_value, &object))) + heap_flags, initial_state, optimized_clear_value, NULL, &object))) { *resource = NULL; return hr; diff --git a/libs/vkd3d/meson.build b/libs/vkd3d/meson.build index 7644ed61..e45479b8 100644 --- a/libs/vkd3d/meson.build +++ b/libs/vkd3d/meson.build @@ -67,6 +67,10 @@ if enable_breadcrumbs vkd3d_src += ['breadcrumbs.c'] endif +if vkd3d_platform == 'windows' + vkd3d_src += ['shared_metadata.c'] +endif + if not enable_d3d12 vkd3d_lib = shared_library('vkd3d-proton', vkd3d_src, glsl_generator.process(vkd3d_shaders), vkd3d_build, vkd3d_version, dependencies : [ vkd3d_common_dep, vkd3d_shader_dep ] + vkd3d_extra_libs, diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index a8c7b187..49cfeae4 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -488,6 +488,7 @@ static bool vkd3d_format_check_usage_support(struct d3d12_device *device, VkForm struct vkd3d_image_create_info { struct vkd3d_format_compatibility_list format_compat_list; + VkExternalMemoryImageCreateInfo external_info; VkImageFormatListCreateInfoKHR format_list; VkImageCreateInfo image_info; }; @@ -498,6 +499,7 @@ static HRESULT vkd3d_get_image_create_info(struct d3d12_device *device, struct vkd3d_image_create_info *create_info) { struct vkd3d_format_compatibility_list *compat_list = &create_info->format_compat_list; + VkExternalMemoryImageCreateInfo *external_info = &create_info->external_info; VkImageFormatListCreateInfoKHR *format_list = &create_info->format_list; const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; VkImageCreateInfo *image_info = &create_info->image_info; @@ -522,12 +524,22 @@ static HRESULT vkd3d_get_image_create_info(struct d3d12_device *device, image_info->sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; image_info->pNext = NULL; image_info->flags = 0; + + if (resource && (resource->heap_flags & D3D12_HEAP_FLAG_SHARED)) + { + external_info->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + external_info->pNext = NULL; + external_info->handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; + + image_info->pNext = external_info; + } + if (!(desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)) { if (vkd3d_get_format_compatibility_list(device, desc, compat_list)) { format_list->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR; - format_list->pNext = NULL; + format_list->pNext = image_info->pNext; format_list->viewFormatCount = compat_list->format_count; format_list->pViewFormats = compat_list->vk_formats; @@ -2701,7 +2713,7 @@ static HRESULT d3d12_resource_create(struct d3d12_device *device, uint32_t flags HRESULT d3d12_resource_create_committed(struct d3d12_device *device, const D3D12_RESOURCE_DESC1 *desc, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) + const D3D12_CLEAR_VALUE *optimized_clear_value, HANDLE shared_handle, struct d3d12_resource **resource) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; struct d3d12_resource *object; @@ -2718,10 +2730,15 @@ HRESULT d3d12_resource_create_committed(struct d3d12_device *device, const D3D12 VkMemoryDedicatedAllocateInfo dedicated_info; VkImageMemoryRequirementsInfo2 image_info; VkMemoryRequirements2 memory_requirements; + VkExportMemoryAllocateInfo export_info; VkBindImageMemoryInfo bind_info; bool use_dedicated_allocation; VkResult vr; +#ifdef _WIN32 + VkImportMemoryWin32HandleInfoKHR import_info; +#endif + if (FAILED(hr = d3d12_resource_create_vk_resource(object, device))) goto fail; @@ -2754,10 +2771,36 @@ HRESULT d3d12_resource_create_committed(struct d3d12_device *device, const D3D12 else allocate_info.heap_flags |= D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES; + if (heap_flags & D3D12_HEAP_FLAG_SHARED) + { +#ifdef _WIN32 + use_dedicated_allocation = true; + + if (shared_handle && shared_handle != INVALID_HANDLE_VALUE) + { + import_info.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + import_info.pNext = allocate_info.pNext; + import_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; + import_info.handle = shared_handle; + import_info.name = NULL; + allocate_info.pNext = &import_info; + } + else + { + export_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; + export_info.pNext = allocate_info.pNext; + export_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT; + allocate_info.pNext = &export_info; + } +#else + FIXME("D3D12_HEAP_FLAG_SHARED can only be implemented in native Win32.\n"); +#endif + } + if (use_dedicated_allocation) { dedicated_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; - dedicated_info.pNext = NULL; + dedicated_info.pNext = allocate_info.pNext; dedicated_info.image = object->res.vk_image; dedicated_info.buffer = VK_NULL_HANDLE; allocate_info.pNext = &dedicated_info; @@ -2886,7 +2929,7 @@ HRESULT d3d12_resource_create_placed(struct d3d12_device *device, const D3D12_RE heap->desc.Flags & ~(D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES), - initial_state, optimized_clear_value, resource))) + initial_state, optimized_clear_value, NULL, resource))) { ERR("Failed to create fallback committed resource.\n"); } diff --git a/libs/vkd3d/shared_metadata.c b/libs/vkd3d/shared_metadata.c new file mode 100644 index 00000000..9882fc9a --- /dev/null +++ b/libs/vkd3d/shared_metadata.c @@ -0,0 +1,68 @@ +/* + * Copyright 2021 Derek Lesho for Codeweavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define VKD3D_DBG_CHANNEL VKD3D_DBG_CHANNEL_API +#include "vkd3d_private.h" + +#include "winioctl.h" + +#define IOCTL_SHARED_GPU_RESOURCE_SET_METADATA CTL_CODE(FILE_DEVICE_VIDEO, 4, METHOD_BUFFERED, FILE_WRITE_ACCESS) +#define IOCTL_SHARED_GPU_RESOURCE_GET_METADATA CTL_CODE(FILE_DEVICE_VIDEO, 5, METHOD_BUFFERED, FILE_READ_ACCESS) +#define IOCTL_SHARED_GPU_RESOURCE_OPEN CTL_CODE(FILE_DEVICE_VIDEO, 1, METHOD_BUFFERED, FILE_WRITE_ACCESS) + +bool vkd3d_set_shared_metadata(HANDLE handle, void *buf, uint32_t buf_size) +{ + DWORD ret_size; + + return DeviceIoControl(handle, IOCTL_SHARED_GPU_RESOURCE_SET_METADATA, buf, buf_size, NULL, 0, &ret_size, NULL); +} + +bool vkd3d_get_shared_metadata(HANDLE handle, void *buf, uint32_t buf_size, uint32_t *metadata_size) +{ + DWORD ret_size; + + bool ret = DeviceIoControl(handle, IOCTL_SHARED_GPU_RESOURCE_GET_METADATA, NULL, 0, buf, buf_size, &ret_size, NULL); + + if (metadata_size) + *metadata_size = ret_size; + + return ret; +} + +HANDLE vkd3d_open_kmt_handle(HANDLE kmt_handle) +{ + struct + { + unsigned int kmt_handle; + /* the following parameter represents a larger sized string for a dynamically allocated struct for use when opening an object by name */ + WCHAR name[1]; + } shared_resource_open; + + HANDLE nt_handle = CreateFileA("\\\\.\\SharedGpuResource", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (nt_handle == INVALID_HANDLE_VALUE) + return nt_handle; + + shared_resource_open.kmt_handle = (ULONG_PTR)kmt_handle; + shared_resource_open.name[0] = 0; + if (!DeviceIoControl(nt_handle, IOCTL_SHARED_GPU_RESOURCE_OPEN, &shared_resource_open, sizeof(shared_resource_open), NULL, 0, NULL, NULL)) + { + CloseHandle(nt_handle); + return INVALID_HANDLE_VALUE; + } + return nt_handle; +} diff --git a/libs/vkd3d/swapchain.c b/libs/vkd3d/swapchain.c index 5e943a6b..0532f787 100644 --- a/libs/vkd3d/swapchain.c +++ b/libs/vkd3d/swapchain.c @@ -959,7 +959,7 @@ static HRESULT d3d12_swapchain_create_user_buffers(struct d3d12_swapchain *swapc { if (FAILED(hr = d3d12_resource_create_committed(d3d12_swapchain_device(swapchain), &resource_desc, &heap_properties, D3D12_HEAP_FLAG_NONE, - D3D12_RESOURCE_STATE_PRESENT, NULL, &object))) + D3D12_RESOURCE_STATE_PRESENT, NULL, NULL, &object))) { ERR("Failed to create image for swapchain buffer"); return hr; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 02d68e40..86869b0a 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -135,6 +135,7 @@ struct vkd3d_vulkan_info bool KHR_maintenance4; bool KHR_ray_tracing_maintenance1; bool KHR_fragment_shader_barycentric; + bool KHR_external_memory_win32; /* EXT device extensions */ bool EXT_calibrated_timestamps; bool EXT_conditional_rendering; @@ -908,7 +909,7 @@ VkImageSubresource vk_image_subresource_from_d3d12( HRESULT d3d12_resource_create_committed(struct d3d12_device *device, const D3D12_RESOURCE_DESC1 *desc, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); + const D3D12_CLEAR_VALUE *optimized_clear_value, HANDLE shared_handle, struct d3d12_resource **resource); HRESULT d3d12_resource_create_placed(struct d3d12_device *device, const D3D12_RESOURCE_DESC1 *desc, struct d3d12_heap *heap, uint64_t heap_offset, D3D12_RESOURCE_STATES initial_state, const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); @@ -3914,6 +3915,74 @@ void vkd3d_acceleration_structure_copy( D3D12_GPU_VIRTUAL_ADDRESS dst, D3D12_GPU_VIRTUAL_ADDRESS src, D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE mode); +typedef enum D3D11_USAGE +{ + D3D11_USAGE_DEFAULT, + D3D11_USAGE_IMMUTABLE, + D3D11_USAGE_DYNAMIC, + D3D11_USAGE_STAGING, +} D3D11_USAGE; + +typedef enum D3D11_BIND_FLAG +{ + D3D11_BIND_VERTEX_BUFFER = 0x0001, + D3D11_BIND_INDEX_BUFFER = 0x0002, + D3D11_BIND_CONSTANT_BUFFER = 0x0004, + D3D11_BIND_SHADER_RESOURCE = 0x0008, + D3D11_BIND_STREAM_OUTPUT = 0x0010, + D3D11_BIND_RENDER_TARGET = 0x0020, + D3D11_BIND_DEPTH_STENCIL = 0x0040, + D3D11_BIND_UNORDERED_ACCESS = 0x0080, + D3D11_BIND_DECODER = 0x0200, + D3D11_BIND_VIDEO_ENCODER = 0x0400 +} D3D11_BIND_FLAG; + +typedef enum D3D11_TEXTURE_LAYOUT +{ + D3D11_TEXTURE_LAYOUT_UNDEFINED = 0x0, + D3D11_TEXTURE_LAYOUT_ROW_MAJOR = 0x1, + D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE = 0x2, +} D3D11_TEXTURE_LAYOUT; + +typedef enum D3D11_RESOURCE_MISC_FLAG +{ + D3D11_RESOURCE_MISC_GENERATE_MIPS = 0x1, + D3D11_RESOURCE_MISC_SHARED = 0x2, + D3D11_RESOURCE_MISC_TEXTURECUBE = 0x4, + D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS = 0x10, + D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS = 0x20, + D3D11_RESOURCE_MISC_BUFFER_STRUCTURED = 0x40, + D3D11_RESOURCE_MISC_RESOURCE_CLAMP = 0x80, + D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX = 0x100, + D3D11_RESOURCE_MISC_GDI_COMPATIBLE = 0x200, + D3D11_RESOURCE_MISC_SHARED_NTHANDLE = 0x800, + D3D11_RESOURCE_MISC_RESTRICTED_CONTENT = 0x1000, + D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE = 0x2000, + D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER = 0x4000, + D3D11_RESOURCE_MISC_GUARDED = 0x8000, + D3D11_RESOURCE_MISC_TILE_POOL = 0x20000, + D3D11_RESOURCE_MISC_TILED = 0x40000, + D3D11_RESOURCE_MISC_HW_PROTECTED = 0x80000, +} D3D11_RESOURCE_MISC_FLAG; + +struct DxvkSharedTextureMetadata { + UINT Width; + UINT Height; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + D3D11_TEXTURE_LAYOUT TextureLayout; +}; + +bool vkd3d_set_shared_metadata(HANDLE handle, void *buf, uint32_t buf_size); +bool vkd3d_get_shared_metadata(HANDLE handle, void *buf, uint32_t buf_size, uint32_t *metadata_size); +HANDLE vkd3d_open_kmt_handle(HANDLE kmt_handle); + #define VKD3D_VENDOR_ID_NVIDIA 0x10DE #define VKD3D_VENDOR_ID_AMD 0x1002 #define VKD3D_VENDOR_ID_INTEL 0x8086 diff --git a/libs/vkd3d/vulkan_procs.h b/libs/vkd3d/vulkan_procs.h index e7a1b2e4..9a1ab874 100644 --- a/libs/vkd3d/vulkan_procs.h +++ b/libs/vkd3d/vulkan_procs.h @@ -223,6 +223,12 @@ VK_DEVICE_EXT_PFN(vkGetDeviceBufferMemoryRequirementsKHR) VK_DEVICE_EXT_PFN(vkGetDeviceImageMemoryRequirementsKHR) VK_DEVICE_EXT_PFN(vkGetDeviceImageSparseMemoryRequirementsKHR) +#ifdef VK_KHR_external_memory_win32 +/* VK_KHR_external_memory_win32 */ +VK_DEVICE_EXT_PFN(vkGetMemoryWin32HandleKHR) +VK_DEVICE_EXT_PFN(vkGetMemoryWin32HandlePropertiesKHR) +#endif + /* VK_EXT_calibrated_timestamps */ VK_DEVICE_EXT_PFN(vkGetCalibratedTimestampsEXT) VK_INSTANCE_EXT_PFN(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)