Skip to main content

wgpu_hal/dynamic/
instance.rs

1use alloc::{boxed::Box, vec::Vec};
2
3use crate::{Api, Capabilities, ExposedAdapter, Instance, InstanceError};
4
5use super::{DynAdapter, DynResource, DynResourceExt as _, DynSurface};
6
7#[expect(missing_debug_implementations, reason = "dyn")]
8pub struct DynExposedAdapter {
9    pub adapter: Box<dyn DynAdapter>,
10    pub info: wgt::AdapterInfo,
11    pub features: wgt::Features,
12    pub capabilities: Capabilities,
13}
14
15impl DynExposedAdapter {
16    /// Returns the backend this adapter is using.
17    pub fn backend(&self) -> wgt::Backend {
18        self.info.backend
19    }
20}
21
22impl<A: Api> From<ExposedAdapter<A>> for DynExposedAdapter {
23    fn from(exposed_adapter: ExposedAdapter<A>) -> Self {
24        Self {
25            adapter: Box::new(exposed_adapter.adapter),
26            info: exposed_adapter.info,
27            features: exposed_adapter.features,
28            capabilities: exposed_adapter.capabilities,
29        }
30    }
31}
32
33pub trait DynInstance: DynResource {
34    /// Dynamic version of [Instance::create_surface]
35    unsafe fn create_surface(
36        &self,
37        display_handle: raw_window_handle::RawDisplayHandle,
38        window_handle: raw_window_handle::RawWindowHandle,
39    ) -> Result<Box<dyn DynSurface>, InstanceError>;
40
41    /// Dynamic version of [Instance::enumerate_adapters]
42    unsafe fn enumerate_adapters(
43        &self,
44        surface_hint: Option<&dyn DynSurface>,
45    ) -> Vec<DynExposedAdapter>;
46}
47
48impl<I: Instance + DynResource> DynInstance for I {
49    unsafe fn create_surface(
50        &self,
51        display_handle: raw_window_handle::RawDisplayHandle,
52        window_handle: raw_window_handle::RawWindowHandle,
53    ) -> Result<Box<dyn DynSurface>, InstanceError> {
54        unsafe { I::create_surface(self, display_handle, window_handle) }
55            .map(|surface| -> Box<dyn DynSurface> { Box::new(surface) })
56    }
57
58    unsafe fn enumerate_adapters(
59        &self,
60        surface_hint: Option<&dyn DynSurface>,
61    ) -> Vec<DynExposedAdapter> {
62        let surface_hint = surface_hint.map(|s| s.expect_downcast_ref());
63        unsafe { I::enumerate_adapters(self, surface_hint) }
64            .into_iter()
65            .map(|exposed| DynExposedAdapter {
66                adapter: Box::new(exposed.adapter),
67                info: exposed.info,
68                features: exposed.features,
69                capabilities: exposed.capabilities,
70            })
71            .collect()
72    }
73}