Load FXC dynamically to remove the dependency on d3dcompiler_47.dll

wgpu-hal/src/dx12/adapter.rs

@@ -57,7 +57,7 @@ impl super::Adapter {
         library: &Arc<D3D12Lib>,
         instance_flags: wgt::InstanceFlags,
         memory_budget_thresholds: wgt::MemoryBudgetThresholds,
-        dxc_container: Option<Arc<shader_compilation::DxcContainer>>,
+        compiler_container: Arc<shader_compilation::CompilerContainer>,
     ) -> Option<crate::ExposedAdapter<super::Api>> {
         // Create the device so that we can get the capabilities.
         let device = {
@@ -224,8 +224,8 @@ impl super::Adapter {
             }
         };
 
-        let shader_model = if let Some(ref dxc_container) = dxc_container {
-            let max_shader_model = match dxc_container.max_shader_model {
+        let shader_model = if let Some(max_shader_model) = compiler_container.max_shader_model() {
+            let max_shader_model = match max_shader_model {
                 wgt::DxcShaderModel::V6_0 => Direct3D12::D3D_SHADER_MODEL_6_0,
                 wgt::DxcShaderModel::V6_1 => Direct3D12::D3D_SHADER_MODEL_6_1,
                 wgt::DxcShaderModel::V6_2 => Direct3D12::D3D_SHADER_MODEL_6_2,
@@ -519,7 +519,7 @@ impl super::Adapter {
                 presentation_timer,
                 workarounds,
                 memory_budget_thresholds,
-                dxc_container,
+                compiler_container,
             },
             info,
             features,
@@ -658,7 +658,7 @@ impl crate::Adapter for super::Adapter {
             self.private_caps,
             &self.library,
             self.memory_budget_thresholds,
-            self.dxc_container.clone(),
+            self.compiler_container.clone(),
         )?;
         Ok(crate::OpenDevice {
             device,

wgpu-hal/src/dx12/device.rs

@@ -46,7 +46,7 @@ impl super::Device {
         private_caps: super::PrivateCapabilities,
         library: &Arc<D3D12Lib>,
         memory_budget_thresholds: wgt::MemoryBudgetThresholds,
-        dxc_container: Option<Arc<shader_compilation::DxcContainer>>,
+        compiler_container: Arc<shader_compilation::CompilerContainer>,
     ) -> Result<Self, crate::DeviceError> {
         if private_caps
             .instance_flags
@@ -202,7 +202,7 @@ impl super::Device {
             render_doc: Default::default(),
             null_rtv_handle,
             mem_allocator,
-            dxc_container,
+            compiler_container,
             counters: Default::default(),
         })
     }
@@ -327,27 +327,14 @@ impl super::Device {
 
         let source_name = stage.module.raw_name.as_deref();
 
-        // Compile with DXC if available, otherwise fall back to FXC
-        let result = if let Some(ref dxc_container) = self.dxc_container {
-            shader_compilation::compile_dxc(
-                self,
-                &source,
-                source_name,
-                raw_ep,
-                stage_bit,
-                &full_stage,
-                dxc_container,
-            )
-        } else {
-            shader_compilation::compile_fxc(
-                self,
-                &source,
-                source_name,
-                raw_ep,
-                stage_bit,
-                &full_stage,
-            )
-        };
+        let result = self.compiler_container.compile(
+            self,
+            &source,
+            source_name,
+            raw_ep,
+            stage_bit,
+            &full_stage,
+        );
 
         let log_level = if result.is_ok() {
             log::Level::Info

wgpu-hal/src/dx12/instance.rs

@@ -10,7 +10,10 @@ use windows::{
 };
 
 use super::SurfaceTarget;
-use crate::{auxil, dx12::D3D12Lib};
+use crate::{
+    auxil,
+    dx12::{shader_compilation::CompilerContainer, D3D12Lib},
+};
 
 impl crate::Instance for super::Instance {
     type A = super::Api;
@@ -66,39 +69,34 @@ impl crate::Instance for super::Instance {
             }
         }
 
-        // Initialize DXC shader compiler
-        let dxc_container = match desc.backend_options.dx12.shader_compiler.clone() {
+        // Initialize the shader compiler
+        let compiler_container = match desc.backend_options.dx12.shader_compiler.clone() {
             wgt::Dx12Compiler::DynamicDxc {
                 dxc_path,
                 max_shader_model,
-            } => {
-                let container = super::shader_compilation::get_dynamic_dxc_container(
-                    dxc_path.into(),
-                    max_shader_model,
-                )
-                .map_err(|e| {
+            } => CompilerContainer::new_dynamic_dxc(dxc_path.into(), max_shader_model).map_err(
+                |e| {
                     crate::InstanceError::with_source(String::from("Failed to load dynamic DXC"), e)
-                })?;
+                },
+            )?,
+            wgt::Dx12Compiler::StaticDxc => CompilerContainer::new_static_dxc().map_err(|e| {
+                crate::InstanceError::with_source(String::from("Failed to load static DXC"), e)
+            })?,
+            wgt::Dx12Compiler::Fxc => CompilerContainer::new_fxc().map_err(|e| {
+                crate::InstanceError::with_source(String::from("Failed to load FXC"), e)
+            })?,
+        };
 
-                Some(Arc::new(container))
+        match compiler_container {
+            CompilerContainer::DynamicDxc(..) => {
+                log::debug!("Using dynamic DXC for shader compilation")
             }
-            wgt::Dx12Compiler::StaticDxc => {
-                let container =
-                    super::shader_compilation::get_static_dxc_container().map_err(|e| {
-                        crate::InstanceError::with_source(
-                            String::from("Failed to load static DXC"),
-                            e,
-                        )
-                    })?;
-
-                Some(Arc::new(container))
+            CompilerContainer::StaticDxc(..) => {
+                log::debug!("Using static DXC for shader compilation")
+            }
+            CompilerContainer::Fxc(..) => {
+                log::debug!("Using FXC for shader compilation")
             }
-            wgt::Dx12Compiler::Fxc => None,
-        };
-
-        match dxc_container {
-            Some(_) => log::debug!("Using DXC for shader compilation"),
-            None => log::debug!("Using FXC for shader compilation"),
         }
 
         Ok(Self {
@@ -110,7 +108,7 @@ impl crate::Instance for super::Instance {
             supports_allow_tearing,
             flags: desc.flags,
             memory_budget_thresholds: desc.memory_budget_thresholds,
-            dxc_container,
+            compiler_container: Arc::new(compiler_container),
         })
     }
 
@@ -148,7 +146,7 @@ impl crate::Instance for super::Instance {
                     &self.library,
                     self.flags,
                     self.memory_budget_thresholds,
-                    self.dxc_container.clone(),
+                    self.compiler_container.clone(),
                 )
             })
             .collect()

wgpu-hal/src/dx12/mod.rs

@@ -460,7 +460,7 @@ pub struct Instance {
     _lib_dxgi: DxgiLib,
     flags: wgt::InstanceFlags,
     memory_budget_thresholds: wgt::MemoryBudgetThresholds,
-    dxc_container: Option<Arc<shader_compilation::DxcContainer>>,
+    compiler_container: Arc<shader_compilation::CompilerContainer>,
 }
 
 impl Instance {
@@ -592,7 +592,7 @@ pub struct Adapter {
     #[allow(unused)]
     workarounds: Workarounds,
     memory_budget_thresholds: wgt::MemoryBudgetThresholds,
-    dxc_container: Option<Arc<shader_compilation::DxcContainer>>,
+    compiler_container: Arc<shader_compilation::CompilerContainer>,
 }
 
 unsafe impl Send for Adapter {}
@@ -655,7 +655,7 @@ pub struct Device {
     render_doc: auxil::renderdoc::RenderDoc,
     null_rtv_handle: descriptor::Handle,
     mem_allocator: Allocator,
-    dxc_container: Option<Arc<shader_compilation::DxcContainer>>,
+    compiler_container: Arc<shader_compilation::CompilerContainer>,
     counters: Arc<wgt::HalCounters>,
 }