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

@@ -143,6 +143,29 @@ A new standalone example, `examples/standalone/03_hdr_surface`, prints a surface
 
 By @stuartparmenter in [#9658](https://github.com/gfx-rs/wgpu/pull/9658).
 
+#### DXGI flip-model swapchain for Vulkan on Windows
+
+The Vulkan backend can now present on Windows through a DXGI flip-model swapchain that wgpu drives directly, rather than the native `VK_KHR_swapchain`. The native swapchain is implemented by the driver on its own DXGI swapchain, which wgpu cannot configure and which often paces frames poorly. Driving the flip-model swapchain ourselves gives the same presentation control the DX12 backend has, so frame pacing is steadier and present latency is lower. This is opt-in; the native swapchain stays the default.
+
+Turn it on at instance creation, or 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()
+  });
+```
+
+A DXGI kind needs a device LUID, timeline semaphores, and `VK_KHR_external_memory_win32` / `VK_KHR_external_semaphore_win32`; adapters without them cannot present under it.
+
+By @cwfitzgerald in [#XXXX](https://github.com/gfx-rs/wgpu/pull/XXXX).
+
 ### Added/New Features
 
 #### General

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/vulkan/adapter.rs

@@ -1185,6 +1185,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.
@@ -1340,6 +1344,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);
@@ -1973,6 +1982,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)
                 };
@@ -2422,6 +2438,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 {
@@ -2662,6 +2681,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;
@@ -2917,6 +2945,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,
@@ -2933,6 +2962,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
@@ -247,10 +258,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,35 @@ 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
+    /// - `VK_KHR_external_memory_win32` must be enabled.
+    /// - 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 +484,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)]
         {
@@ -3042,6 +3050,59 @@ impl super::DeviceShared {
         }
     }
 
+    /// Creates a timeline semaphore with the given initial value.
+    ///
+    /// When the semaphore is to be backed by an imported D3D11/D3D12 fence, pass the value `0` and
+    /// feed the result to [`Self::import_timeline_semaphore_d3d12_fence`], which replaces the
+    /// payload with the shared fence.
+    #[cfg(windows)]
+    pub(super) fn new_timeline_semaphore(
+        &self,
+        initial_value: u64,
+        name: &str,
+    ) -> Result<vk::Semaphore, crate::DeviceError> {
+        let mut type_info = vk::SemaphoreTypeCreateInfo::default()
+            .semaphore_type(vk::SemaphoreType::TIMELINE)
+            .initial_value(initial_value);
+        let info = vk::SemaphoreCreateInfo::default().push_next(&mut type_info);
+        let semaphore = unsafe { self.raw.create_semaphore(&info, None) }
+            .map_err(super::map_host_device_oom_err)?;
+        unsafe { self.set_object_name(semaphore, name) };
+        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,

wgpu-hal/src/vulkan/instance.rs

@@ -368,6 +368,22 @@ impl super::Instance {
 
         let drop_guard = crate::DropGuard::from_option(drop_callback);
 
+        // Resolve the DXGI swapchain backend. A requested DXGI kind degrades to `Native` when DXGI
+        // is unavailable (instance-wide, terminal for the DXGI path).
+        #[cfg(windows)]
+        let (swapchain_kind, dxgi_instance) =
+            super::swapchain::init_dxgi_instance(swapchain_kind, flags);
+        #[cfg(not(windows))]
+        let swapchain_kind = if swapchain_kind == wgt::VulkanSwapchainKind::Native {
+            swapchain_kind
+        } else {
+            log::warn!(
+                "VulkanSwapchainKind::{swapchain_kind:?} is only supported on Windows; \
+                 using the native Vulkan swapchain"
+            );
+            wgt::VulkanSwapchainKind::Native
+        };
+
         Ok(Self {
             shared: Arc::new(super::InstanceShared {
                 raw: raw_instance,
@@ -382,6 +398,8 @@ impl super::Instance {
                 instance_api_version,
                 android_sdk_version,
                 swapchain_kind,
+                #[cfg(windows)]
+                dxgi_instance,
             }),
         })
     }
@@ -490,13 +508,31 @@ impl super::Instance {
         hinstance: vk::HINSTANCE,
         hwnd: vk::HWND,
     ) -> Result<super::Surface, crate::InstanceError> {
-        // Scaffold: the DXGI swapchain surface does not exist yet, so a requested DXGI kind
-        // falls back to the native surface. Removed once `DxgiSurface` lands.
-        if self.shared.swapchain_kind != wgt::VulkanSwapchainKind::Native {
-            log::warn!(
-                "VulkanSwapchainKind::{:?} is not yet implemented; using the native swapchain",
-                self.shared.swapchain_kind
-            );
+        // The swapchain backend is fixed here and immutable for the surface's lifetime.
+        #[cfg(windows)]
+        match self.shared.swapchain_kind {
+            wgt::VulkanSwapchainKind::Native => {}
+            kind @ (wgt::VulkanSwapchainKind::DxgiFromHwnd
+            | wgt::VulkanSwapchainKind::DxgiFromVisual) => {
+                use windows::Win32::Foundation::HWND;
+                let hwnd = HWND(hwnd as _);
+                let target = match kind {
+                    wgt::VulkanSwapchainKind::DxgiFromHwnd => {
+                        crate::auxil::dxgi::swapchain::SurfaceTarget::WndHandle(hwnd)
+                    }
+                    _ => crate::auxil::dxgi::swapchain::SurfaceTarget::VisualFromWndHandle {
+                        handle: hwnd,
+                        dcomp_state: parking_lot::Mutex::new(Default::default()),
+                    },
+                };
+                return Ok(super::Surface {
+                    swapchain: RwLock::new(None),
+                    inner: Box::new(super::swapchain::DxgiSurface::new(
+                        Arc::clone(&self.shared),
+                        target,
+                    )),
+                });
+            }
         }
 
         if !self.shared.extensions.contains(&khr::win32_surface::NAME) {
@@ -1008,6 +1044,32 @@ impl crate::Instance for super::Instance {
             }
         }
 
+        // When a DXGI swapchain is selected, an adapter that lacks the interop prerequisites
+        // (a valid LUID, timeline semaphores, and both external-memory/semaphore win32 extensions)
+        // cannot present through the DXGI path, and there is no per-surface native fallback.
+        #[cfg(windows)]
+        if self.shared.swapchain_kind != wgt::VulkanSwapchainKind::Native {
+            for exposed in exposed_adapters.iter_mut() {
+                let interop_capable = exposed.adapter.private_caps.device_luid.is_some()
+                    && exposed.adapter.private_caps.timeline_semaphores
+                    && exposed
+                        .adapter
+                        .phd_capabilities
+                        .supports_extension(khr::external_memory_win32::NAME)
+                    && exposed
+                        .adapter
+                        .phd_capabilities
+                        .supports_extension(khr::external_semaphore_win32::NAME);
+                if !interop_capable {
+                    log::warn!(
+                        "Disabling presentation on '{}': missing DXGI interop prerequisites",
+                        exposed.info.name
+                    );
+                    exposed.adapter.private_caps.can_present = false;
+                }
+            }
+        }
+
         exposed_adapters
     }
 }