vulkan: add DXGI flip-model interop swapchain via D3D12 direct back-buffer sharing (Windows)

Vulkan renders directly into the DXGI flip-model back buffers, which are created on a LUID-matched interop D3D12 device and shared into Vulkan as external-memory images (no copy). A shared D3D12 fence orders Vulkan rendering ahead of a no-op present command list that binds each back buffer and transitions it to PRESENT. Opt-in via VulkanSwapchainKind / WGPU_VULKAN_SWAPCHAIN_KIND; the native VK_KHR_swapchain path stays the default.

Author: cwfitzgerald

CHANGELOG.md

@@ -42,6 +42,31 @@ Bottom level categories:
 
 ## Unreleased
 
+### Major changes
+
+#### DXGI swapchain for Vulkan on Windows
+
+The Vulkan backend can now present via a D3D12 swapchain on Windows. D3D12 swapchains generally perform more consistently, give more control over frame pacing, and may use optimizations that are not available to native vulkan swapchains. For now this is default-off feature, though in the future it may be enabled by default.
+
+Turn it on at instance creation, or if your program is using wgpu environment variables set `WGPU_VULKAN_SWAPCHAIN_KIND` to `native`, `dxgi-hwnd`, or `dxgi-visual`:
+
+```diff
+  let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+      backends: wgpu::Backends::VULKAN,
++     backend_options: wgpu::BackendOptions {
++         vulkan: wgpu::VulkanBackendOptions {
++             swapchain_kind: wgpu::VulkanSwapchainKind::DxgiFromHwnd,
++         },
++         ..Default::default()
++     },
+      ..Default::default()
+  });
+```
+
+While all graphics debuggers still broadly function, Nsight and Radeon GPU Profiler work as expected, but RenderDoc will only capture the D3D12 work, unless you explicitly use `Device::start_graphics_debugger_capture` on the wgpu device which will capture the vulkan work. The interop D3D12 device honors the same Agility SDK configuration as the DX12 backend, via `VulkanBackendOptions::agility_sdk`.
+
+By @cwfitzgerald in [#8388](https://github.com/gfx-rs/wgpu/pull/8388).
+
 ### Added/New Features
 
 #### Hal

wgpu-hal/src/auxil/dxgi/conv.rs

@@ -120,9 +120,8 @@ pub fn map_texture_format_nosrgb(format: wgt::TextureFormat) -> Dxgi::Common::DX
 /// The typeless DXGI format family for `format`, for the color formats wgpu may view as both their
 /// sRGB and non-sRGB form. Returns `None` for formats with no such castable typeless family.
 ///
-/// Shared by the DX12 resource-creation path ([`map_texture_format_for_resource`]) and the Windows
-/// Vulkan DXGI interop swapchain, which creates its shared interop textures typeless so the imported
-/// Vulkan image can be viewed through either form.
+/// Used by the DX12 resource-creation path ([`map_texture_format_for_resource`]).
+#[cfg(dx12)]
 pub fn map_texture_format_typeless(
     format: wgt::TextureFormat,
 ) -> Option<Dxgi::Common::DXGI_FORMAT> {

wgpu-hal/src/auxil/dxgi/handles.rs

@@ -0,0 +1,16 @@
+use windows::Win32::Foundation::{CloseHandle, HANDLE};
+
+/// An owned Win32 NT handle that closes itself on drop.
+pub struct OwnedHandle(pub HANDLE);
+
+// The handle is just an opaque OS resource; sharing it across threads is sound.
+unsafe impl Send for OwnedHandle {}
+unsafe impl Sync for OwnedHandle {}
+
+impl Drop for OwnedHandle {
+    fn drop(&mut self) {
+        if !self.0.is_invalid() {
+            let _ = unsafe { CloseHandle(self.0) };
+        }
+    }
+}

wgpu-hal/src/auxil/dxgi/mod.rs

@@ -7,6 +7,7 @@ pub mod device_factory;
 #[cfg(dx12)]
 pub mod exception;
 pub mod factory;
+pub mod handles;
 pub mod hdr;
 pub mod library;
 #[cfg(dx12)]

wgpu-hal/src/vulkan/adapter.rs

@@ -1186,6 +1186,10 @@ pub struct PhysicalDeviceProperties {
     /// `VK_EXT_pci_bus_info` extension.
     pci_bus_info: Option<vk::PhysicalDevicePCIBusInfoPropertiesEXT<'static>>,
 
+    /// Device identity properties from Vulkan 1.1, including the device LUID used to
+    /// match the Vulkan physical device against a DXGI adapter for interop.
+    id: Option<vk::PhysicalDeviceIDProperties<'static>>,
+
     /// The device API version.
     ///
     /// Which is the version of Vulkan supported for device-level functionality.
@@ -1341,6 +1345,11 @@ impl PhysicalDeviceProperties {
             extensions.push(khr::external_memory_win32::NAME);
         }
 
+        // Optional `VK_KHR_external_semaphore_win32`
+        if self.supports_extension(khr::external_semaphore_win32::NAME) {
+            extensions.push(khr::external_semaphore_win32::NAME);
+        }
+
         // Optional `VK_KHR_external_memory_fd`
         if self.supports_extension(khr::external_memory_fd::NAME) {
             extensions.push(khr::external_memory_fd::NAME);
@@ -1975,6 +1984,13 @@ impl super::InstanceShared {
                     properties2 = properties2.push_next(next);
                 }
 
+                if capabilities.device_api_version >= vk::API_VERSION_1_1 {
+                    let next = capabilities
+                        .id
+                        .insert(vk::PhysicalDeviceIDProperties::default());
+                    properties2 = properties2.push_next(next);
+                }
+
                 unsafe {
                     get_device_properties.get_physical_device_properties2(phd, &mut properties2)
                 };
@@ -2424,6 +2440,9 @@ impl super::Instance {
             max_draw_indirect_count: phd_capabilities.properties.limits.max_draw_indirect_count,
             non_coherent_map_mask: phd_capabilities.properties.limits.non_coherent_atom_size - 1,
             can_present: true,
+            device_luid: phd_capabilities
+                .id
+                .and_then(|id| (id.device_luid_valid == vk::TRUE).then_some(id.device_luid)),
             //TODO: make configurable
             robust_buffer_access: phd_features.core.robust_buffer_access != 0,
             robust_image_access: match phd_features.robustness2 {
@@ -2664,6 +2683,15 @@ impl super::Adapter {
         } else {
             None
         };
+        let external_semaphore_win32_fn =
+            if enabled_extensions.contains(&khr::external_semaphore_win32::NAME) {
+                Some(khr::external_semaphore_win32::Device::new(
+                    &self.instance.raw,
+                    &raw_device,
+                ))
+            } else {
+                None
+            };
 
         let naga_options = {
             use naga::back::spv;
@@ -2919,6 +2947,7 @@ impl super::Adapter {
                 ray_tracing_pipelines: ray_tracing_pipeline_fns,
                 mesh_shading: mesh_shading_fns,
                 external_memory_fd: external_memory_fd_fn,
+                external_semaphore_win32: external_semaphore_win32_fn,
             },
             pipeline_cache_validation_key,
             vendor_id: self.phd_capabilities.properties.vendor_id,
@@ -2935,6 +2964,8 @@ impl super::Adapter {
             texture_identity_factory: super::ResourceIdentityFactory::new(),
             texture_view_identity_factory: super::ResourceIdentityFactory::new(),
             empty_descriptor_set_layout,
+            #[cfg(windows)]
+            dxgi_interop: once_cell::sync::OnceCell::new(),
         });
 
         let relay_semaphores = super::RelaySemaphores::new(&shared)?;

wgpu-hal/src/vulkan/command.rs

@@ -7,6 +7,17 @@ use hashbrown::hash_map::Entry;
 const ALLOCATION_GRANULARITY: u32 = 16;
 const DST_IMAGE_LAYOUT: vk::ImageLayout = vk::ImageLayout::TRANSFER_DST_OPTIMAL;
 
+/// The layout for `usage`, honoring a texture's overridden present layout. Identical to
+/// [`conv::derive_image_layout`] except that `TextureUses::PRESENT` resolves to the texture's own
+/// `present_layout` (`GENERAL` for DXGI interop images rather than `PRESENT_SRC_KHR`).
+fn barrier_image_layout(texture: &super::Texture, usage: wgt::TextureUses) -> vk::ImageLayout {
+    if usage == wgt::TextureUses::PRESENT {
+        texture.present_layout
+    } else {
+        conv::derive_image_layout(usage, texture.format)
+    }
+}
+
 impl super::Texture {
     fn map_buffer_copies<T>(&self, regions: T) -> impl Iterator<Item = vk::BufferImageCopy>
     where
@@ -248,10 +259,10 @@ impl crate::CommandEncoder for super::CommandEncoder {
                 &self.device.private_caps,
             );
             let (src_stage, src_access) = conv::map_texture_usage_to_barrier(bar.usage.from);
-            let src_layout = conv::derive_image_layout(bar.usage.from, bar.texture.format);
+            let src_layout = barrier_image_layout(bar.texture, bar.usage.from);
             src_stages |= src_stage;
             let (dst_stage, dst_access) = conv::map_texture_usage_to_barrier(bar.usage.to);
-            let dst_layout = conv::derive_image_layout(bar.usage.to, bar.texture.format);
+            let dst_layout = barrier_image_layout(bar.texture, bar.usage.to);
             dst_stages |= dst_stage;
 
             vk_barriers.push(

wgpu-hal/src/vulkan/device.rs

@@ -314,6 +314,7 @@ impl super::Device {
             format: desc.format,
             copy_size: desc.copy_extent(),
             identity,
+            present_layout: vk::ImageLayout::PRESENT_SRC_KHR,
         }
     }
 
@@ -444,28 +445,34 @@ impl super::Device {
         })
     }
 
+    /// Create a [`super::Texture`] backed by a D3D11 texture or D3D12 resource shared via an NT
+    /// handle.
+    ///
+    /// `handle_type` selects how `handle` is interpreted: `D3D11_TEXTURE` for an `ID3D11Texture2D`
+    /// shared handle, or `D3D12_RESOURCE` for an `ID3D12Resource` shared handle.
+    ///
     /// # Safety
     ///
-    /// - Vulkan (with VK_KHR_external_memory_win32)
-    /// - The `d3d11_shared_handle` must be valid and respecting `desc`
-    /// - `VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT` flag is used because we need to hold a reference to the handle
+    /// - The texture must be imported on the same physical device that owns the shared resource.
+    /// - `handle` must be a valid shared NT handle whose resource matches `desc` and `handle_type`.
     #[cfg(windows)]
-    pub unsafe fn texture_from_d3d11_shared_handle(
+    pub unsafe fn texture_from_shared_handle(
         &self,
-        d3d11_shared_handle: windows::Win32::Foundation::HANDLE,
+        handle: windows::Win32::Foundation::HANDLE,
+        handle_type: vk::ExternalMemoryHandleTypeFlags,
         desc: &crate::TextureDescriptor,
     ) -> Result<super::Texture, crate::DeviceError> {
         if !self
             .shared
-            .features
-            .contains(wgt::Features::VULKAN_EXTERNAL_MEMORY_WIN32)
+            .enabled_extensions
+            .contains(&ash::khr::external_memory_win32::NAME)
         {
             log::error!("Vulkan driver does not support VK_KHR_external_memory_win32");
             return Err(crate::DeviceError::Unexpected);
         }
 
-        let mut external_memory_image_info = vk::ExternalMemoryImageCreateInfo::default()
-            .handle_types(vk::ExternalMemoryHandleTypeFlags::D3D11_TEXTURE);
+        let mut external_memory_image_info =
+            vk::ExternalMemoryImageCreateInfo::default().handle_types(handle_type);
 
         let image =
             self.create_image_without_memory(desc, Some(&mut external_memory_image_info))?;
@@ -476,8 +483,8 @@ impl super::Device {
             vk::MemoryDedicatedAllocateInfo::default().image(image.raw);
 
         let mut import_memory_info = vk::ImportMemoryWin32HandleInfoKHR::default()
-            .handle_type(vk::ExternalMemoryHandleTypeFlags::D3D11_TEXTURE)
-            .handle(d3d11_shared_handle.0 as _);
+            .handle_type(handle_type)
+            .handle(handle.0 as _);
         // TODO: We should use `push_next` instead, but currently ash does not provide this method for the `ImportMemoryWin32HandleInfoKHR` type.
         #[allow(clippy::unnecessary_mut_passed)]
         {
@@ -3055,6 +3062,37 @@ impl super::DeviceShared {
         Ok(semaphore)
     }
 
+    /// Imports a shared D3D11/D3D12 fence (an `ID3D11Fence`/`ID3D12Fence` NT handle) into an
+    /// existing timeline `semaphore`, so the same monotonic counter is visible to both APIs.
+    ///
+    /// # Safety
+    ///
+    /// - `handle` must be a valid shared NT handle to an `ID3D11Fence`/`ID3D12Fence`.
+    /// - `semaphore` must be a timeline semaphore with no pending operations.
+    #[cfg(windows)]
+    pub(super) unsafe fn import_timeline_semaphore_d3d12_fence(
+        &self,
+        semaphore: vk::Semaphore,
+        handle: windows::Win32::Foundation::HANDLE,
+    ) -> Result<(), crate::DeviceError> {
+        let ext = self
+            .extension_fns
+            .external_semaphore_win32
+            .as_ref()
+            .ok_or_else(|| {
+                log::error!("Vulkan driver does not support VK_KHR_external_semaphore_win32");
+                crate::DeviceError::Unexpected
+            })?;
+
+        let import_info = vk::ImportSemaphoreWin32HandleInfoKHR::default()
+            .semaphore(semaphore)
+            .handle_type(vk::ExternalSemaphoreHandleTypeFlags::D3D12_FENCE)
+            .handle(handle.0 as _);
+
+        unsafe { ext.import_semaphore_win32_handle(&import_info) }
+            .map_err(super::map_host_device_oom_err)?;
+        Ok(())
+    }
     pub(super) fn wait_for_fence(
         &self,
         fence: &super::Fence,