dxgi: move the d3d12.dll loader to auxil::dxgi, share across DX12/Vulkan

The DX12 backend's d3d12.dll loader (D3D12Lib) and its error types move to auxil::dxgi::library so the Vulkan DXGI interop path can create its interop device through the same runtime-loaded entry points. Each entry point resolves against the windows-crate PFN_* alias. DX12 keeps using the loader via a re-export, so its call sites and public API are unchanged.

Enable Win32_Graphics_Direct3D12 for the vulkan feature on Windows (replacing Win32_Graphics_Direct3D11) so the shared loader compiles in vulkan-only builds.

Author: cwfitzgerald

wgpu-hal/Cargo.toml

@@ -109,7 +109,7 @@ vulkan = [
     # Windows-only: shared DXGI presentation path (`auxil::dxgi`) for the opt-in
     # DXGI flip-model swapchain. Inert on non-Windows targets.
     "windows/Win32_Graphics_Direct3D",
-    "windows/Win32_Graphics_Direct3D11",
+    "windows/Win32_Graphics_Direct3D12",
     "windows/Win32_Graphics_DirectComposition",
     "windows/Win32_Graphics_Dxgi",
     "windows/Win32_Graphics_Dxgi_Common",

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

@@ -1,8 +1,11 @@
-use core::ffi;
+use core::{error::Error, ffi, fmt};
 
-use windows::{core::Interface as _, Win32::Graphics::Dxgi};
+use windows::{
+    core::{IUnknown, Interface as _, Ref},
+    Win32::Graphics::{Direct3D, Direct3D12, Dxgi},
+};
 
-use crate::auxil::dxgi::result::HResult as _;
+use crate::auxil::dxgi::{factory::DxgiAdapter, result::HResult as _};
 
 #[derive(Debug)]
 pub(crate) struct DynLib {
@@ -122,3 +125,181 @@ impl DxgiLib {
         result__.ok_or(crate::DeviceError::Unexpected)
     }
 }
+
+/// Loads `d3d12.dll` at runtime, the same way [`DxgiLib`] loads `dxgi.dll`, so the DLL is never a
+/// load-time import. This keeps the binary loadable on systems without D3D12 (e.g. Windows 7/8),
+/// where a DXGI/D3D12 swapchain simply isn't available. Shared by the DX12 backend and the Vulkan
+/// DXGI interop swapchain.
+#[derive(Debug)]
+pub(crate) struct D3D12Lib {
+    lib: DynLib,
+}
+
+impl D3D12Lib {
+    pub(crate) fn new() -> Result<Self, libloading::Error> {
+        unsafe { DynLib::new("d3d12.dll").map(|lib| Self { lib }) }
+    }
+
+    pub(crate) fn create_device(
+        &self,
+        adapter: &DxgiAdapter,
+        feature_level: Direct3D::D3D_FEATURE_LEVEL,
+    ) -> Result<Direct3D12::ID3D12Device, CreateDeviceError> {
+        // Calls windows::Win32::Graphics::Direct3D12::D3D12CreateDevice on d3d12.dll.
+        let func: libloading::Symbol<Direct3D12::PFN_D3D12_CREATE_DEVICE> =
+            unsafe { self.lib.get(c"D3D12CreateDevice".to_bytes()) }
+                .map_err(|_| CreateDeviceError::GetProcAddress)?;
+        let func = (*func).ok_or(CreateDeviceError::GetProcAddress)?;
+
+        // `Ref<IUnknown>` is a `repr(transparent)` non-owning borrow of the COM pointer (it does not
+        // touch the refcount); the adapter outlives this synchronous call.
+        let adapter: Ref<IUnknown> = unsafe { core::mem::transmute(adapter.as_raw()) };
+
+        let mut result__: Option<Direct3D12::ID3D12Device> = None;
+        let res = unsafe {
+            func(
+                adapter,
+                feature_level,
+                &Direct3D12::ID3D12Device::IID,
+                <*mut _>::cast(&mut result__),
+            )
+        };
+
+        if res.is_err() {
+            return Err(CreateDeviceError::D3D12CreateDevice(res));
+        }
+        result__.ok_or(CreateDeviceError::RetDeviceIsNull)
+    }
+
+    #[cfg(dx12)]
+    pub(crate) fn serialize_root_signature(
+        &self,
+        version: Direct3D12::D3D_ROOT_SIGNATURE_VERSION,
+        parameters: &[Direct3D12::D3D12_ROOT_PARAMETER],
+        static_samplers: &[Direct3D12::D3D12_STATIC_SAMPLER_DESC],
+        flags: Direct3D12::D3D12_ROOT_SIGNATURE_FLAGS,
+    ) -> Result<Direct3D::ID3DBlob, crate::DeviceError> {
+        // Calls windows::Win32::Graphics::Direct3D12::D3D12SerializeRootSignature on d3d12.dll.
+        let func: libloading::Symbol<Direct3D12::PFN_D3D12_SERIALIZE_ROOT_SIGNATURE> =
+            unsafe { self.lib.get(c"D3D12SerializeRootSignature".to_bytes()) }?;
+        let func = (*func).ok_or(crate::DeviceError::Unexpected)?;
+
+        let desc = Direct3D12::D3D12_ROOT_SIGNATURE_DESC {
+            NumParameters: parameters.len() as _,
+            pParameters: parameters.as_ptr(),
+            NumStaticSamplers: static_samplers.len() as _,
+            pStaticSamplers: static_samplers.as_ptr(),
+            Flags: flags,
+        };
+
+        let mut blob: Option<Direct3D::ID3DBlob> = None;
+        let mut error: Option<Direct3D::ID3DBlob> = None;
+        unsafe { func(&desc, version, (&mut blob).into(), (&mut error).into()) }
+            .ok()
+            .into_device_result("Root signature serialization")?;
+
+        if let Some(error) = error {
+            let message = unsafe {
+                let slice = core::slice::from_raw_parts(
+                    error.GetBufferPointer().cast::<u8>(),
+                    error.GetBufferSize(),
+                );
+                ffi::CStr::from_bytes_until_nul(slice)
+            };
+            log::error!(
+                "Root signature serialization error: {:?}",
+                message.unwrap().to_str().unwrap()
+            );
+            return Err(crate::DeviceError::Unexpected); // could be hal_usage_error or hal_internal_error
+        }
+
+        blob.ok_or(crate::DeviceError::Unexpected)
+    }
+
+    pub(crate) fn debug_interface(
+        &self,
+    ) -> Result<Option<Direct3D12::ID3D12Debug>, crate::DeviceError> {
+        // Calls windows::Win32::Graphics::Direct3D12::D3D12GetDebugInterface on d3d12.dll.
+        let func: libloading::Symbol<Direct3D12::PFN_D3D12_GET_DEBUG_INTERFACE> =
+            unsafe { self.lib.get(c"D3D12GetDebugInterface".to_bytes()) }?;
+        let func = (*func).ok_or(crate::DeviceError::Unexpected)?;
+
+        let mut result__ = None;
+        let res =
+            unsafe { func(&Direct3D12::ID3D12Debug::IID, <*mut _>::cast(&mut result__)) }.ok();
+
+        if let Err(ref err) = res {
+            if err.code() == Dxgi::DXGI_ERROR_SDK_COMPONENT_MISSING {
+                return Ok(None);
+            }
+        }
+
+        res.into_device_result("GetDebugInterface")?;
+
+        result__.ok_or(crate::DeviceError::Unexpected).map(Some)
+    }
+
+    /// Calls D3D12GetInterface to obtain a COM interface by CLSID and IID.
+    ///
+    /// This is used by the Independent Devices API to obtain `ID3D12SDKConfiguration1`.
+    #[cfg(dx12)]
+    pub(crate) fn get_interface<T: windows_core::Interface>(
+        &self,
+        clsid: &windows_core::GUID,
+    ) -> Result<T, GetInterfaceError> {
+        // Calls windows::Win32::Graphics::Direct3D12::D3D12GetInterface on d3d12.dll.
+        let func: libloading::Symbol<Direct3D12::PFN_D3D12_GET_INTERFACE> =
+            unsafe { self.lib.get(c"D3D12GetInterface".to_bytes()) }
+                .map_err(|_| GetInterfaceError::GetProcAddress)?;
+        let func = (*func).ok_or(GetInterfaceError::GetProcAddress)?;
+
+        let mut result__: Option<T> = None;
+        let res = unsafe { func(clsid, &T::IID, <*mut _>::cast(&mut result__)) };
+
+        if res.is_err() {
+            return Err(GetInterfaceError::D3D12GetInterface(res));
+        }
+        result__.ok_or(GetInterfaceError::RetIsNull)
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum CreateDeviceError {
+    GetProcAddress,
+    D3D12CreateDevice(windows_core::HRESULT),
+    RetDeviceIsNull,
+}
+
+impl fmt::Display for CreateDeviceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::GetProcAddress => write!(f, "D3D12CreateDevice not found in d3d12.dll"),
+            Self::D3D12CreateDevice(hr) => write!(f, "D3D12CreateDevice failed: {hr}"),
+            Self::RetDeviceIsNull => write!(f, "D3D12CreateDevice returned null"),
+        }
+    }
+}
+
+impl Error for CreateDeviceError {}
+
+#[cfg(dx12)]
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum GetInterfaceError {
+    GetProcAddress,
+    D3D12GetInterface(windows_core::HRESULT),
+    RetIsNull,
+}
+
+#[cfg(dx12)]
+impl fmt::Display for GetInterfaceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::GetProcAddress => write!(f, "D3D12GetInterface not found in d3d12.dll"),
+            Self::D3D12GetInterface(hr) => write!(f, "D3D12GetInterface failed: {hr}"),
+            Self::RetIsNull => write!(f, "D3D12GetInterface returned null"),
+        }
+    }
+}
+
+#[cfg(dx12)]
+impl Error for GetInterfaceError {}

wgpu-hal/src/dx12/device.rs

@@ -20,7 +20,7 @@ use windows::{
     },
 };
 
-use super::{conv, descriptor, D3D12Lib};
+use super::{conv, descriptor, D3D12Lib, D3DBlob};
 use crate::{
     auxil::{
         self,
@@ -1378,12 +1378,12 @@ impl crate::Device for super::Device {
             (None, None)
         };
 
-        let blob = self.library.serialize_root_signature(
+        let blob = D3DBlob(self.library.serialize_root_signature(
             Direct3D12::D3D_ROOT_SIGNATURE_VERSION_1_0,
             &parameters,
             &[],
             Direct3D12::D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT,
-        )?;
+        )?);
 
         let raw = unsafe {
             self.raw