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    unsafe fn submit(
12        &self,
13        command_buffers: &[&dyn DynCommandBuffer],
14        surface_textures: &[&dyn DynSurfaceTexture],
15        signal_fence: (&mut dyn DynFence, FenceValue),
16    ) -> Result<(), DeviceError>;
17    unsafe fn present(
18        &self,
19        surface: &dyn DynSurface,
20        texture: Box<dyn DynSurfaceTexture>,
21    ) -> Result<(), SurfaceError>;
22    unsafe fn get_timestamp_period(&self) -> f32;
23    unsafe fn wait_for_idle(&self) -> Result<(), DeviceError>;
24}
25
26impl<Q: Queue + DynResource> DynQueue for Q {
27    unsafe fn submit(
28        &self,
29        command_buffers: &[&dyn DynCommandBuffer],
30        surface_textures: &[&dyn DynSurfaceTexture],
31        signal_fence: (&mut dyn DynFence, FenceValue),
32    ) -> Result<(), DeviceError> {
33        let command_buffers = command_buffers
34            .iter()
35            .map(|cb| (*cb).expect_downcast_ref())
36            .collect::<Vec<_>>();
37        let surface_textures = surface_textures
38            .iter()
39            .map(|surface| (*surface).expect_downcast_ref())
40            .collect::<Vec<_>>();
41        let signal_fence = (signal_fence.0.expect_downcast_mut(), signal_fence.1);
42        unsafe { Q::submit(self, &command_buffers, &surface_textures, signal_fence) }
43    }
44
45    unsafe fn present(
46        &self,
47        surface: &dyn DynSurface,
48        texture: Box<dyn DynSurfaceTexture>,
49    ) -> Result<(), SurfaceError> {
50        let surface = surface.expect_downcast_ref();
51        unsafe { Q::present(self, surface, texture.unbox()) }
52    }
53
54    unsafe fn get_timestamp_period(&self) -> f32 {
55        unsafe { Q::get_timestamp_period(self) }
56    }
57
58    unsafe fn wait_for_idle(&self) -> Result<(), DeviceError> {
59        unsafe { Q::wait_for_idle(self) }
60    }
61}