Skip to main content

wgpu_hal/dynamic/
queue.rs

1use alloc::{boxed::Box, vec::Vec};
2
3use crate::{
4    DeviceError, DynCommandBuffer, DynFence, DynResource, DynSurface, DynSurfaceTexture,
5    FenceValue, Queue, SurfaceError,
6};
7
8use super::DynResourceExt as _;
9
10pub trait DynQueue: DynResource {
11    /// Dynamic version of [Queue::submit]
12    unsafe fn submit(
13        &self,
14        command_buffers: &[&dyn DynCommandBuffer],
15        surface_textures: &[&dyn DynSurfaceTexture],
16        signal_fence: (&dyn DynFence, FenceValue),
17    ) -> Result<(), DeviceError>;
18    /// Dynamic version of [Queue::present]
19    unsafe fn present(
20        &self,
21        surface: &dyn DynSurface,
22        texture: Box<dyn DynSurfaceTexture>,
23        damage_rects: &[wgt::Rect<u32>],
24    ) -> Result<(), SurfaceError>;
25    /// Dynamic version of [Queue::get_timestamp_period]
26    unsafe fn get_timestamp_period(&self) -> f32;
27    /// Dynamic version of [Queue::wait_for_idle]
28    unsafe fn wait_for_idle(&self) -> Result<(), DeviceError>;
29}
30
31impl<Q: Queue + DynResource> DynQueue for Q {
32    unsafe fn submit(
33        &self,
34        command_buffers: &[&dyn DynCommandBuffer],
35        surface_textures: &[&dyn DynSurfaceTexture],
36        signal_fence: (&dyn DynFence, FenceValue),
37    ) -> Result<(), DeviceError> {
38        let command_buffers = command_buffers
39            .iter()
40            .map(|cb| (*cb).expect_downcast_ref())
41            .collect::<Vec<_>>();
42        let surface_textures = surface_textures
43            .iter()
44            .map(|surface| (*surface).expect_downcast_ref())
45            .collect::<Vec<_>>();
46        let signal_fence = (signal_fence.0.expect_downcast_ref(), signal_fence.1);
47        unsafe { Q::submit(self, &command_buffers, &surface_textures, signal_fence) }
48    }
49
50    unsafe fn present(
51        &self,
52        surface: &dyn DynSurface,
53        texture: Box<dyn DynSurfaceTexture>,
54        damage_rects: &[wgt::Rect<u32>],
55    ) -> Result<(), SurfaceError> {
56        let surface = surface.expect_downcast_ref();
57        unsafe { Q::present(self, surface, texture.unbox(), damage_rects) }
58    }
59
60    unsafe fn get_timestamp_period(&self) -> f32 {
61        unsafe { Q::get_timestamp_period(self) }
62    }
63
64    unsafe fn wait_for_idle(&self) -> Result<(), DeviceError> {
65        unsafe { Q::wait_for_idle(self) }
66    }
67}