Add support for using DirectComposition with DirectX 12.

Author: vorporeal

deno_webgpu/lib.rs

@@ -394,6 +394,7 @@ pub fn op_webgpu_request_adapter(
                 backend_options: wgpu_types::BackendOptions {
                     dx12: wgpu_types::Dx12BackendOptions {
                         shader_compiler: wgpu_types::Dx12Compiler::Fxc,
+                        use_dcomp: false,
                     },
                     gl: wgpu_types::GlBackendOptions {
                         gles_minor_version: wgpu_types::Gles3MinorVersion::default(),

examples/src/framework.rs

@@ -551,7 +551,7 @@ impl<E: Example + wgpu::WasmNotSendSync> From<ExampleTestParams<E>>
                         height: params.height,
                         desired_maximum_frame_latency: 2,
                         present_mode: wgpu::PresentMode::Fifo,
-                        alpha_mode: wgpu::CompositeAlphaMode::Auto,
+                        alpha_mode: wgpu::CompositeAlphaMode::Opaque,
                         view_formats: vec![format],
                     },
                     &ctx.adapter,

tests/src/init.rs

@@ -43,6 +43,7 @@ pub fn initialize_instance(backends: wgpu::Backends, force_fxc: bool) -> Instanc
         backend_options: wgpu::BackendOptions {
             dx12: wgpu::Dx12BackendOptions {
                 shader_compiler: dx12_shader_compiler,
+                use_dcomp: false,
             },
             gl: wgpu::GlBackendOptions { gles_minor_version },
         },

wgpu-core/src/instance.rs

@@ -78,6 +78,7 @@ impl Instance {
                         .dx12
                         .shader_compiler
                         .clone(),
+                    dx12_use_dcomp: instance_desc.backend_options.dx12.use_dcomp,
                     gles_minor_version: instance_desc.backend_options.gl.gles_minor_version,
                 };
 

wgpu-hal/Cargo.toml

@@ -82,6 +82,8 @@ dx12 = [
     "windows/Win32_Graphics_Direct3D_Fxc",
     "windows/Win32_Graphics_Direct3D_Dxc",
     "windows/Win32_Graphics_Direct3D",
+    "windows/Win32_Graphics_Direct3D11",
+    "windows/Win32_Graphics_Direct3D11on12",
     "windows/Win32_Graphics_Direct3D12",
     "windows/Win32_Graphics_DirectComposition",
     "windows/Win32_Graphics_Dxgi_Common",

wgpu-hal/examples/halmark/main.rs

@@ -98,6 +98,7 @@ impl<A: hal::Api> Example<A> {
             flags: wgt::InstanceFlags::from_build_config().with_env(),
             // Can't rely on having DXC available, so use FXC instead
             dx12_shader_compiler: wgt::Dx12Compiler::Fxc,
+            dx12_use_dcomp: false,
             gles_minor_version: wgt::Gles3MinorVersion::default(),
         };
         let instance = unsafe { A::Instance::init(&instance_desc)? };

wgpu-hal/examples/ray-traced-triangle/main.rs

@@ -243,6 +243,7 @@ impl<A: hal::Api> Example<A> {
                 dxc_path: "dxcompiler.dll".to_string(),
                 dxil_path: "dxil.dll".to_string(),
             },
+            dx12_use_dcomp: false,
             gles_minor_version: wgt::Gles3MinorVersion::default(),
         };
         let instance = unsafe { A::Instance::init(&instance_desc)? };

wgpu-hal/src/dx12/adapter.rs

@@ -787,7 +787,10 @@ impl crate::Adapter for super::Adapter {
     ) -> Option<crate::SurfaceCapabilities> {
         let current_extent = {
             match surface.target {
-                SurfaceTarget::WndHandle(wnd_handle) => {
+                SurfaceTarget::WndHandle(wnd_handle)
+                | SurfaceTarget::VisualFromWndHandle {
+                    handle: wnd_handle, ..
+                } => {
                     let mut rect = Default::default();
                     if unsafe { WindowsAndMessaging::GetClientRect(wnd_handle, &mut rect) }.is_ok()
                     {
@@ -831,6 +834,7 @@ impl crate::Adapter for super::Adapter {
             composite_alpha_modes: match surface.target {
                 SurfaceTarget::WndHandle(_) => vec![wgt::CompositeAlphaMode::Opaque],
                 SurfaceTarget::Visual(_)
+                | SurfaceTarget::VisualFromWndHandle { .. }
                 | SurfaceTarget::SurfaceHandle(_)
                 | SurfaceTarget::SwapChainPanel(_) => vec![
                     wgt::CompositeAlphaMode::Auto,

wgpu-hal/src/dx12/instance.rs

@@ -108,6 +108,7 @@ impl crate::Instance for super::Instance {
             library: Arc::new(lib_main),
             _lib_dxgi: lib_dxgi,
             supports_allow_tearing,
+            use_dcomp: desc.dx12_use_dcomp,
             flags: desc.flags,
             dxc_container,
         })
@@ -119,14 +120,26 @@ impl crate::Instance for super::Instance {
         window_handle: raw_window_handle::RawWindowHandle,
     ) -> Result<super::Surface, crate::InstanceError> {
         match window_handle {
-            raw_window_handle::RawWindowHandle::Win32(handle) => Ok(super::Surface {
-                factory: self.factory.clone(),
-                factory_media: self.factory_media.clone(),
+            raw_window_handle::RawWindowHandle::Win32(handle) => {
                 // https://github.com/rust-windowing/raw-window-handle/issues/171
-                target: SurfaceTarget::WndHandle(Foundation::HWND(handle.hwnd.get() as *mut _)),
-                supports_allow_tearing: self.supports_allow_tearing,
-                swap_chain: RwLock::new(None),
-            }),
+                let handle = Foundation::HWND(handle.hwnd.get() as *mut _);
+                let target = if self.use_dcomp {
+                    SurfaceTarget::VisualFromWndHandle {
+                        handle,
+                        dcomp_state: Default::default(),
+                    }
+                } else {
+                    SurfaceTarget::WndHandle(handle)
+                };
+                Ok(super::Surface {
+                    factory: self.factory.clone(),
+                    factory_media: self.factory_media.clone(),
+
+                    target,
+                    supports_allow_tearing: self.supports_allow_tearing,
+                    swap_chain: RwLock::new(None),
+                })
+            }
             _ => Err(crate::InstanceError::new(format!(
                 "window handle {window_handle:?} is not a Win32 handle"
             ))),

wgpu-hal/src/dx12/mod.rs

@@ -52,7 +52,7 @@ use windows::{
     core::{Free, Interface},
     Win32::{
         Foundation,
-        Graphics::{Direct3D, Direct3D12, DirectComposition, Dxgi},
+        Graphics::{Direct3D, Direct3D11, Direct3D11on12, Direct3D12, DirectComposition, Dxgi},
         System::Threading,
     },
 };
@@ -410,6 +410,7 @@ pub struct Instance {
     factory_media: Option<Dxgi::IDXGIFactoryMedia>,
     library: Arc<D3D12Lib>,
     supports_allow_tearing: bool,
+    use_dcomp: bool,
     _lib_dxgi: DxgiLib,
     flags: wgt::InstanceFlags,
     dxc_container: Option<Arc<shader_compilation::DxcContainer>>,
@@ -479,9 +480,21 @@ struct SwapChain {
     size: wgt::Extent3d,
 }
 
+struct DCompState {
+    visual: DirectComposition::IDCompositionVisual,
+    device: DirectComposition::IDCompositionDevice,
+    // Must be kept alive but is otherwise unused after initialization.
+    _target: DirectComposition::IDCompositionTarget,
+}
+
 enum SurfaceTarget {
     /// Borrowed, lifetime externally managed
     WndHandle(Foundation::HWND),
+    /// `handle` is borrowed, lifetime externally managed
+    VisualFromWndHandle {
+        handle: Foundation::HWND,
+        dcomp_state: RwLock<Option<DCompState>>,
+    },
     Visual(DirectComposition::IDCompositionVisual),
     /// Borrowed, lifetime externally managed
     SurfaceHandle(Foundation::HANDLE),
@@ -1147,6 +1160,61 @@ impl crate::Surface for Surface {
                             )
                         }
                     }
+                    SurfaceTarget::VisualFromWndHandle {
+                        handle,
+                        ref dcomp_state,
+                    } => unsafe {
+                        macro_rules! call {
+                            ($name:literal, $e:expr) => {{
+                                profiling::scope!($name);
+                                ($e).map_err(|_| crate::SurfaceError::Other($name))?
+                            }};
+                        }
+
+                        let mut d3d11_device = None;
+                        call!(
+                            "Direct3D11on12::D3D11On12CreateDevice",
+                            Direct3D11on12::D3D11On12CreateDevice(
+                                &device.raw,
+                                Direct3D11::D3D11_CREATE_DEVICE_BGRA_SUPPORT.0,
+                                None,
+                                None,
+                                0,
+                                Some(&mut d3d11_device),
+                                None,
+                                None,
+                            )
+                        );
+                        let d3d11_device = d3d11_device.unwrap();
+                        let dxgi_device: Dxgi::IDXGIDevice =
+                            call!("IDXGIDevice::QueryInterface", d3d11_device.cast());
+                        let dcomp_device: DirectComposition::IDCompositionDevice = call!(
+                            "DirectComposition::DCompositionCreateDevice",
+                            DirectComposition::DCompositionCreateDevice(&dxgi_device)
+                        );
+                        let target = call!(
+                            "IDCompositionDevice::CreateTargetForHwnd",
+                            dcomp_device.CreateTargetForHwnd(handle, false)
+                        );
+                        let visual = call!(
+                            "IDCompositionDevice::CreateVisual",
+                            dcomp_device.CreateVisual()
+                        );
+                        call!("IDCompositionTarget::SetRoot", target.SetRoot(&visual));
+
+                        *dcomp_state.write() = Some(DCompState {
+                            visual,
+                            device: dcomp_device,
+                            _target: target,
+                        });
+
+                        profiling::scope!("IDXGIFactory2::CreateSwapChainForComposition");
+                        self.factory.CreateSwapChainForComposition(
+                            &device.present_queue,
+                            &desc,
+                            None,
+                        )
+                    },
                     SurfaceTarget::SurfaceHandle(handle) => {
                         profiling::scope!(
                             "IDXGIFactoryMedia::CreateSwapChainForCompositionSurfaceHandle"
@@ -1184,6 +1252,17 @@ impl crate::Surface for Surface {
 
                 match &self.target {
                     SurfaceTarget::WndHandle(_) | SurfaceTarget::SurfaceHandle(_) => {}
+                    SurfaceTarget::VisualFromWndHandle { dcomp_state, .. } => {
+                        let dcomp_state = dcomp_state.read();
+                        let dcomp_state = dcomp_state
+                            .as_ref()
+                            .expect("dcomp_state was initialized above");
+                        unsafe {
+                            dcomp_state.visual.SetContent(&swap_chain1).map_err(|_| {
+                                crate::SurfaceError::Other("IDCompositionVisual::SetContent")
+                            })?;
+                        }
+                    }
                     SurfaceTarget::Visual(visual) => {
                         if let Err(err) = unsafe { visual.SetContent(&swap_chain1) } {
                             log::error!("Unable to SetContent: {err}");
@@ -1221,6 +1300,7 @@ impl crate::Surface for Surface {
                 .into_device_result("MakeWindowAssociation")?;
             }
             SurfaceTarget::Visual(_)
+            | SurfaceTarget::VisualFromWndHandle { .. }
             | SurfaceTarget::SurfaceHandle(_)
             | SurfaceTarget::SwapChainPanel(_) => {}
         }
@@ -1349,10 +1429,35 @@ impl crate::Queue for Queue {
             m => unreachable!("Cannot make surface with present mode {m:?}"),
         };
 
-        profiling::scope!("IDXGISwapchain3::Present");
-        unsafe { sc.raw.Present(interval, flags) }
-            .ok()
-            .into_device_result("Present")?;
+        unsafe {
+            profiling::scope!("IDXGISwapchain3::Present");
+            sc.raw.Present(interval, flags)
+        }
+        .ok()
+        .into_device_result("Present")?;
+
+        if let SurfaceTarget::VisualFromWndHandle { dcomp_state, .. } = &surface.target {
+            let dcomp_state = dcomp_state.read();
+            let dcomp_state = dcomp_state.as_ref().unwrap();
+            unsafe {
+                if dcomp_state
+                    .device
+                    .CheckDeviceState()
+                    .map_err(|_| {
+                        crate::SurfaceError::Other("IDCompositionDevice::CheckDeviceState")
+                    })?
+                    .into()
+                {
+                    profiling::scope!("IDCompositionDevice::Commit");
+                    dcomp_state
+                        .device
+                        .Commit()
+                        .map_err(|_| crate::SurfaceError::Other("IDCompositionDevice::Commit"))?;
+                } else {
+                    return Err(crate::SurfaceError::Lost);
+                }
+            }
+        }
 
         Ok(())
     }