Skip to main content

wgpu_hal/dynamic/
device.rs

1use alloc::{borrow::ToOwned as _, boxed::Box, vec::Vec};
2
3use crate::{
4    AccelerationStructureBuildSizes, AccelerationStructureDescriptor, Api, BindGroupDescriptor,
5    BindGroupLayoutDescriptor, BufferDescriptor, BufferMapping, CommandEncoderDescriptor,
6    ComputePipelineDescriptor, Device, DeviceError, FenceValue,
7    GetAccelerationStructureBuildSizesDescriptor, Label, MemoryRange, PipelineCacheDescriptor,
8    PipelineCacheError, PipelineError, PipelineLayoutDescriptor, RayObjectIntersectionState,
9    RayTracingPipelineDescriptor, RenderPipelineDescriptor, SamplerDescriptor, ShaderError,
10    ShaderInput, ShaderModuleDescriptor, TextureDescriptor, TextureViewDescriptor, TlasInstance,
11};
12
13use super::{
14    DynAccelerationStructure, DynBindGroup, DynBindGroupLayout, DynBuffer, DynCommandEncoder,
15    DynComputePipeline, DynFence, DynPipelineCache, DynPipelineLayout, DynQuerySet, DynQueue,
16    DynRayTracingPipeline, DynRenderPipeline, DynResource, DynResourceExt as _, DynSampler,
17    DynShaderModule, DynTexture, DynTextureView,
18};
19
20pub trait DynDevice: DynResource {
21    /// Dynamic version of [Device::create_buffer]
22    unsafe fn create_buffer(
23        &self,
24        desc: &BufferDescriptor,
25    ) -> Result<(Box<dyn DynBuffer>, wgt::BufferAddress), DeviceError>;
26
27    /// Dynamic version of [Device::destroy_buffer]
28    unsafe fn destroy_buffer(&self, buffer: Box<dyn DynBuffer>);
29    /// Dynamic version of [Device::add_raw_buffer]
30    unsafe fn add_raw_buffer(&self, buffer: &dyn DynBuffer);
31
32    /// Dynamic version of [Device::map_buffer]
33    unsafe fn map_buffer(
34        &self,
35        buffer: &dyn DynBuffer,
36        range: MemoryRange,
37    ) -> Result<BufferMapping, DeviceError>;
38
39    /// Dynamic version of [Device::unmap_buffer]
40    unsafe fn unmap_buffer(&self, buffer: &dyn DynBuffer);
41
42    /// Dynamic version of [Device::flush_mapped_ranges]
43    unsafe fn flush_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]);
44    /// Dynamic version of [Device::invalidate_mapped_ranges]
45    unsafe fn invalidate_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]);
46
47    /// Dynamic version of [Device::create_texture]
48    unsafe fn create_texture(
49        &self,
50        desc: &TextureDescriptor,
51    ) -> Result<Box<dyn DynTexture>, DeviceError>;
52    /// Dynamic version of [Device::destroy_texture]
53    unsafe fn destroy_texture(&self, texture: Box<dyn DynTexture>);
54    /// Dynamic version of [Device::add_raw_texture]
55    unsafe fn add_raw_texture(&self, texture: &dyn DynTexture);
56
57    /// Dynamic version of [Device::create_texture_view]
58    unsafe fn create_texture_view(
59        &self,
60        texture: &dyn DynTexture,
61        desc: &TextureViewDescriptor,
62    ) -> Result<Box<dyn DynTextureView>, DeviceError>;
63    /// Dynamic version of [Device::destroy_texture_view]
64    unsafe fn destroy_texture_view(&self, view: Box<dyn DynTextureView>);
65    /// Dynamic version of [Device::create_sampler]
66    unsafe fn create_sampler(
67        &self,
68        desc: &SamplerDescriptor,
69    ) -> Result<Box<dyn DynSampler>, DeviceError>;
70    /// Dynamic version of [Device::destroy_sampler]
71    unsafe fn destroy_sampler(&self, sampler: Box<dyn DynSampler>);
72
73    /// Dynamic version of [Device::create_command_encoder]
74    unsafe fn create_command_encoder(
75        &self,
76        desc: &CommandEncoderDescriptor<dyn DynQueue>,
77    ) -> Result<Box<dyn DynCommandEncoder>, DeviceError>;
78
79    /// Dynamic version of [Device::create_bind_group_layout]
80    unsafe fn create_bind_group_layout(
81        &self,
82        desc: &BindGroupLayoutDescriptor,
83    ) -> Result<Box<dyn DynBindGroupLayout>, DeviceError>;
84    /// Dynamic version of [Device::destroy_bind_group_layout]
85    unsafe fn destroy_bind_group_layout(&self, bg_layout: Box<dyn DynBindGroupLayout>);
86
87    /// Dynamic version of [Device::create_pipeline_layout]
88    unsafe fn create_pipeline_layout(
89        &self,
90        desc: &PipelineLayoutDescriptor<dyn DynBindGroupLayout>,
91    ) -> Result<Box<dyn DynPipelineLayout>, DeviceError>;
92    /// Dynamic version of [Device::destroy_pipeline_layout]
93    unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Box<dyn DynPipelineLayout>);
94
95    /// Dynamic version of [Device::create_bind_group]
96    unsafe fn create_bind_group(
97        &self,
98        desc: &BindGroupDescriptor<
99            dyn DynBindGroupLayout,
100            dyn DynBuffer,
101            dyn DynSampler,
102            dyn DynTextureView,
103            dyn DynAccelerationStructure,
104        >,
105    ) -> Result<Box<dyn DynBindGroup>, DeviceError>;
106    /// Dynamic version of [Device::destroy_bind_group]
107    unsafe fn destroy_bind_group(&self, group: Box<dyn DynBindGroup>);
108
109    /// Dynamic version of [Device::create_shader_module]
110    unsafe fn create_shader_module(
111        &self,
112        desc: &ShaderModuleDescriptor,
113        shader: ShaderInput,
114    ) -> Result<Box<dyn DynShaderModule>, ShaderError>;
115    /// Dynamic version of [Device::destroy_shader_module]
116    unsafe fn destroy_shader_module(&self, module: Box<dyn DynShaderModule>);
117
118    /// Dynamic version of [Device::create_render_pipeline]
119    unsafe fn create_render_pipeline(
120        &self,
121        desc: &RenderPipelineDescriptor<
122            dyn DynPipelineLayout,
123            dyn DynShaderModule,
124            dyn DynPipelineCache,
125        >,
126    ) -> Result<Box<dyn DynRenderPipeline>, PipelineError>;
127    /// Dynamic version of [Device::destroy_render_pipeline]
128    unsafe fn destroy_render_pipeline(&self, pipeline: Box<dyn DynRenderPipeline>);
129
130    /// Dynamic version of [Device::create_compute_pipeline]
131    unsafe fn create_compute_pipeline(
132        &self,
133        desc: &ComputePipelineDescriptor<
134            dyn DynPipelineLayout,
135            dyn DynShaderModule,
136            dyn DynPipelineCache,
137        >,
138    ) -> Result<Box<dyn DynComputePipeline>, PipelineError>;
139    /// Dynamic version of [Device::destroy_compute_pipeline]
140    unsafe fn destroy_compute_pipeline(&self, pipeline: Box<dyn DynComputePipeline>);
141
142    /// Dynamic version of [Device::create_ray_tracing_pipeline]
143    unsafe fn create_ray_tracing_pipeline(
144        &self,
145        desc: &RayTracingPipelineDescriptor<
146            dyn DynPipelineLayout,
147            dyn DynShaderModule,
148            dyn DynPipelineCache,
149        >,
150    ) -> Result<Box<dyn DynRayTracingPipeline>, PipelineError>;
151    /// Dynamic version of [Device::destroy_ray_tracing_pipeline]
152    unsafe fn destroy_ray_tracing_pipeline(&self, pipeline: Box<dyn DynRayTracingPipeline>);
153    /// Dynamic version of [Device::get_raytracing_pipeline_group_data]
154    unsafe fn get_raytracing_pipeline_group_data(
155        &self,
156        pipeline: &dyn DynRayTracingPipeline,
157        groups: core::ops::Range<u32>,
158    ) -> Result<Vec<u8>, DeviceError>;
159
160    /// Dynamic version of [Device::create_pipeline_cache]
161    unsafe fn create_pipeline_cache(
162        &self,
163        desc: &PipelineCacheDescriptor<'_>,
164    ) -> Result<Box<dyn DynPipelineCache>, PipelineCacheError>;
165    /// Dynamic version of [Device::pipeline_cache_validation_key]
166    fn pipeline_cache_validation_key(&self) -> Option<[u8; 16]> {
167        None
168    }
169    /// Dynamic version of [Device::destroy_pipeline_cache]
170    unsafe fn destroy_pipeline_cache(&self, cache: Box<dyn DynPipelineCache>);
171
172    /// Dynamic version of [Device::create_query_set]
173    unsafe fn create_query_set(
174        &self,
175        desc: &wgt::QuerySetDescriptor<Label>,
176    ) -> Result<Box<dyn DynQuerySet>, DeviceError>;
177    /// Dynamic version of [Device::destroy_query_set]
178    unsafe fn destroy_query_set(&self, set: Box<dyn DynQuerySet>);
179
180    /// Dynamic version of [Device::create_fence]
181    unsafe fn create_fence(&self) -> Result<Box<dyn DynFence>, DeviceError>;
182    /// Dynamic version of [Device::destroy_fence]
183    unsafe fn destroy_fence(&self, fence: Box<dyn DynFence>);
184    /// Dynamic version of [Device::get_fence_value]
185    unsafe fn get_fence_value(&self, fence: &dyn DynFence) -> Result<FenceValue, DeviceError>;
186
187    /// Dynamic version of [Device::wait]
188    unsafe fn wait(
189        &self,
190        fence: &dyn DynFence,
191        value: FenceValue,
192        timeout: Option<core::time::Duration>,
193    ) -> Result<bool, DeviceError>;
194
195    /// Dynamic version of [Device::start_graphics_debugger_capture]
196    unsafe fn start_graphics_debugger_capture(&self) -> bool;
197    /// Dynamic version of [Device::stop_graphics_debugger_capture]
198    unsafe fn stop_graphics_debugger_capture(&self);
199
200    /// Dynamic version of [Device::pipeline_cache_get_data]
201    unsafe fn pipeline_cache_get_data(&self, cache: &dyn DynPipelineCache) -> Option<Vec<u8>>;
202
203    /// Dynamic version of [Device::create_acceleration_structure]
204    unsafe fn create_acceleration_structure(
205        &self,
206        desc: &AccelerationStructureDescriptor,
207    ) -> Result<Box<dyn DynAccelerationStructure>, DeviceError>;
208    /// Dynamic version of [Device::get_acceleration_structure_build_sizes]
209    unsafe fn get_acceleration_structure_build_sizes(
210        &self,
211        desc: &GetAccelerationStructureBuildSizesDescriptor<dyn DynBuffer>,
212    ) -> AccelerationStructureBuildSizes;
213    /// Dynamic version of [Device::get_acceleration_structure_device_address]
214    unsafe fn get_acceleration_structure_device_address(
215        &self,
216        acceleration_structure: &dyn DynAccelerationStructure,
217    ) -> wgt::BufferAddress;
218    /// Dynamic version of [Device::destroy_acceleration_structure]
219    unsafe fn destroy_acceleration_structure(
220        &self,
221        acceleration_structure: Box<dyn DynAccelerationStructure>,
222    );
223    /// Dynamic version of [Device::tlas_instance_to_bytes]
224    fn tlas_instance_to_bytes(&self, instance: TlasInstance, to_extend: &mut Vec<u8>);
225
226    /// Dynamic version of [Device::get_internal_counters]
227    fn get_internal_counters(&self) -> wgt::HalCounters;
228    /// Dynamic version of [Device::generate_allocator_report]
229    fn generate_allocator_report(&self) -> Option<wgt::AllocatorReport>;
230
231    /// Dynamic version of [Device::check_if_oom]
232    fn check_if_oom(&self) -> Result<(), DeviceError>;
233}
234
235impl<D: Device + DynResource> DynDevice for D {
236    unsafe fn create_buffer(
237        &self,
238        desc: &BufferDescriptor,
239    ) -> Result<(Box<dyn DynBuffer>, wgt::BufferAddress), DeviceError> {
240        unsafe { D::create_buffer(self, desc) }
241            .map(|(b, size)| -> (Box<dyn DynBuffer>, _) { (Box::new(b), size) })
242    }
243
244    unsafe fn destroy_buffer(&self, buffer: Box<dyn DynBuffer>) {
245        unsafe { D::destroy_buffer(self, buffer.unbox()) };
246    }
247    unsafe fn add_raw_buffer(&self, buffer: &dyn DynBuffer) {
248        let buffer = buffer.expect_downcast_ref();
249        unsafe { D::add_raw_buffer(self, buffer) };
250    }
251
252    unsafe fn map_buffer(
253        &self,
254        buffer: &dyn DynBuffer,
255        range: MemoryRange,
256    ) -> Result<BufferMapping, DeviceError> {
257        let buffer = buffer.expect_downcast_ref();
258        unsafe { D::map_buffer(self, buffer, range) }
259    }
260
261    unsafe fn unmap_buffer(&self, buffer: &dyn DynBuffer) {
262        let buffer = buffer.expect_downcast_ref();
263        unsafe { D::unmap_buffer(self, buffer) }
264    }
265
266    unsafe fn flush_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]) {
267        let buffer = buffer.expect_downcast_ref();
268        unsafe { D::flush_mapped_ranges(self, buffer, ranges.iter().cloned()) }
269    }
270
271    unsafe fn invalidate_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]) {
272        let buffer = buffer.expect_downcast_ref();
273        unsafe { D::invalidate_mapped_ranges(self, buffer, ranges.iter().cloned()) }
274    }
275
276    unsafe fn create_texture(
277        &self,
278        desc: &TextureDescriptor,
279    ) -> Result<Box<dyn DynTexture>, DeviceError> {
280        unsafe { D::create_texture(self, desc) }.map(|b| {
281            let boxed_texture: Box<<D::A as Api>::Texture> = Box::new(b);
282            let boxed_texture: Box<dyn DynTexture> = boxed_texture;
283            boxed_texture
284        })
285    }
286
287    unsafe fn destroy_texture(&self, texture: Box<dyn DynTexture>) {
288        unsafe { D::destroy_texture(self, texture.unbox()) };
289    }
290
291    unsafe fn add_raw_texture(&self, texture: &dyn DynTexture) {
292        let texture = texture.expect_downcast_ref();
293        unsafe { D::add_raw_texture(self, texture) };
294    }
295
296    unsafe fn create_texture_view(
297        &self,
298        texture: &dyn DynTexture,
299        desc: &TextureViewDescriptor,
300    ) -> Result<Box<dyn DynTextureView>, DeviceError> {
301        let texture = texture.expect_downcast_ref();
302        unsafe { D::create_texture_view(self, texture, desc) }.map(|b| {
303            let boxed_texture_view: Box<<D::A as Api>::TextureView> = Box::new(b);
304            let boxed_texture_view: Box<dyn DynTextureView> = boxed_texture_view;
305            boxed_texture_view
306        })
307    }
308
309    unsafe fn destroy_texture_view(&self, view: Box<dyn DynTextureView>) {
310        unsafe { D::destroy_texture_view(self, view.unbox()) };
311    }
312
313    unsafe fn create_sampler(
314        &self,
315        desc: &SamplerDescriptor,
316    ) -> Result<Box<dyn DynSampler>, DeviceError> {
317        unsafe { D::create_sampler(self, desc) }.map(|b| {
318            let boxed_sampler: Box<<D::A as Api>::Sampler> = Box::new(b);
319            let boxed_sampler: Box<dyn DynSampler> = boxed_sampler;
320            boxed_sampler
321        })
322    }
323
324    unsafe fn destroy_sampler(&self, sampler: Box<dyn DynSampler>) {
325        unsafe { D::destroy_sampler(self, sampler.unbox()) };
326    }
327
328    unsafe fn create_command_encoder(
329        &self,
330        desc: &CommandEncoderDescriptor<'_, dyn DynQueue>,
331    ) -> Result<Box<dyn DynCommandEncoder>, DeviceError> {
332        let desc = CommandEncoderDescriptor {
333            label: desc.label,
334            queue: desc.queue.expect_downcast_ref(),
335        };
336        unsafe { D::create_command_encoder(self, &desc) }
337            .map(|b| -> Box<dyn DynCommandEncoder> { Box::new(b) })
338    }
339
340    unsafe fn create_bind_group_layout(
341        &self,
342        desc: &BindGroupLayoutDescriptor,
343    ) -> Result<Box<dyn DynBindGroupLayout>, DeviceError> {
344        unsafe { D::create_bind_group_layout(self, desc) }
345            .map(|b| -> Box<dyn DynBindGroupLayout> { Box::new(b) })
346    }
347
348    unsafe fn destroy_bind_group_layout(&self, bg_layout: Box<dyn DynBindGroupLayout>) {
349        unsafe { D::destroy_bind_group_layout(self, bg_layout.unbox()) };
350    }
351
352    unsafe fn create_pipeline_layout(
353        &self,
354        desc: &PipelineLayoutDescriptor<dyn DynBindGroupLayout>,
355    ) -> Result<Box<dyn DynPipelineLayout>, DeviceError> {
356        let bind_group_layouts: Vec<_> = desc
357            .bind_group_layouts
358            .iter()
359            .map(|bgl| bgl.map(|bgl| bgl.expect_downcast_ref()))
360            .collect();
361        let desc = PipelineLayoutDescriptor {
362            label: desc.label,
363            bind_group_layouts: &bind_group_layouts,
364            immediate_size: desc.immediate_size,
365            flags: desc.flags,
366        };
367
368        unsafe { D::create_pipeline_layout(self, &desc) }
369            .map(|b| -> Box<dyn DynPipelineLayout> { Box::new(b) })
370    }
371
372    unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Box<dyn DynPipelineLayout>) {
373        unsafe { D::destroy_pipeline_layout(self, pipeline_layout.unbox()) };
374    }
375
376    unsafe fn create_bind_group(
377        &self,
378        desc: &BindGroupDescriptor<
379            dyn DynBindGroupLayout,
380            dyn DynBuffer,
381            dyn DynSampler,
382            dyn DynTextureView,
383            dyn DynAccelerationStructure,
384        >,
385    ) -> Result<Box<dyn DynBindGroup>, DeviceError> {
386        let buffers: Vec<_> = desc
387            .buffers
388            .iter()
389            .map(|b| b.clone().expect_downcast())
390            .collect();
391        let samplers: Vec<_> = desc
392            .samplers
393            .iter()
394            .map(|s| s.expect_downcast_ref())
395            .collect();
396        let textures: Vec<_> = desc
397            .textures
398            .iter()
399            .map(|t| t.clone().expect_downcast())
400            .collect();
401        let acceleration_structures: Vec<_> = desc
402            .acceleration_structures
403            .iter()
404            .map(|a| a.expect_downcast_ref())
405            .collect();
406        let external_textures: Vec<_> = desc
407            .external_textures
408            .iter()
409            .map(|et| et.clone().expect_downcast())
410            .collect();
411
412        let desc = BindGroupDescriptor {
413            label: desc.label.to_owned(),
414            layout: desc.layout.expect_downcast_ref(),
415            buffers: &buffers,
416            samplers: &samplers,
417            textures: &textures,
418            entries: desc.entries,
419            acceleration_structures: &acceleration_structures,
420            external_textures: &external_textures,
421        };
422
423        unsafe { D::create_bind_group(self, &desc) }
424            .map(|b| -> Box<dyn DynBindGroup> { Box::new(b) })
425    }
426
427    unsafe fn destroy_bind_group(&self, group: Box<dyn DynBindGroup>) {
428        unsafe { D::destroy_bind_group(self, group.unbox()) };
429    }
430
431    unsafe fn create_shader_module(
432        &self,
433        desc: &ShaderModuleDescriptor,
434        shader: ShaderInput,
435    ) -> Result<Box<dyn DynShaderModule>, ShaderError> {
436        unsafe { D::create_shader_module(self, desc, shader) }
437            .map(|b| -> Box<dyn DynShaderModule> { Box::new(b) })
438    }
439
440    unsafe fn destroy_shader_module(&self, module: Box<dyn DynShaderModule>) {
441        unsafe { D::destroy_shader_module(self, module.unbox()) };
442    }
443
444    unsafe fn create_render_pipeline(
445        &self,
446        desc: &RenderPipelineDescriptor<
447            dyn DynPipelineLayout,
448            dyn DynShaderModule,
449            dyn DynPipelineCache,
450        >,
451    ) -> Result<Box<dyn DynRenderPipeline>, PipelineError> {
452        let desc = RenderPipelineDescriptor {
453            label: desc.label,
454            layout: desc.layout.expect_downcast_ref(),
455            vertex_processor: match &desc.vertex_processor {
456                crate::VertexProcessor::Standard {
457                    vertex_buffers,
458                    vertex_stage,
459                } => crate::VertexProcessor::Standard {
460                    vertex_buffers,
461                    vertex_stage: vertex_stage.clone().expect_downcast(),
462                },
463                crate::VertexProcessor::Mesh {
464                    task_stage: task,
465                    mesh_stage: mesh,
466                } => crate::VertexProcessor::Mesh {
467                    task_stage: task.as_ref().map(|a| a.clone().expect_downcast()),
468                    mesh_stage: mesh.clone().expect_downcast(),
469                },
470            },
471            primitive: desc.primitive,
472            depth_stencil: desc.depth_stencil.clone(),
473            multisample: desc.multisample,
474            fragment_stage: desc.fragment_stage.clone().map(|f| f.expect_downcast()),
475            color_targets: desc.color_targets,
476            multiview_mask: desc.multiview_mask,
477            cache: desc.cache.map(|c| c.expect_downcast_ref()),
478        };
479
480        unsafe { D::create_render_pipeline(self, &desc) }
481            .map(|b| -> Box<dyn DynRenderPipeline> { Box::new(b) })
482    }
483
484    unsafe fn destroy_render_pipeline(&self, pipeline: Box<dyn DynRenderPipeline>) {
485        unsafe { D::destroy_render_pipeline(self, pipeline.unbox()) };
486    }
487
488    unsafe fn create_compute_pipeline(
489        &self,
490        desc: &ComputePipelineDescriptor<
491            dyn DynPipelineLayout,
492            dyn DynShaderModule,
493            dyn DynPipelineCache,
494        >,
495    ) -> Result<Box<dyn DynComputePipeline>, PipelineError> {
496        let desc = ComputePipelineDescriptor {
497            label: desc.label,
498            layout: desc.layout.expect_downcast_ref(),
499            stage: desc.stage.clone().expect_downcast(),
500            cache: desc.cache.as_ref().map(|c| c.expect_downcast_ref()),
501        };
502
503        unsafe { D::create_compute_pipeline(self, &desc) }
504            .map(|b| -> Box<dyn DynComputePipeline> { Box::new(b) })
505    }
506
507    unsafe fn destroy_compute_pipeline(&self, pipeline: Box<dyn DynComputePipeline>) {
508        unsafe { D::destroy_compute_pipeline(self, pipeline.unbox()) };
509    }
510
511    unsafe fn create_ray_tracing_pipeline(
512        &self,
513        desc: &RayTracingPipelineDescriptor<
514            dyn DynPipelineLayout,
515            dyn DynShaderModule,
516            dyn DynPipelineCache,
517        >,
518    ) -> Result<Box<dyn DynRayTracingPipeline>, PipelineError> {
519        let ray_intersection: Vec<_> = desc
520            .intersection
521            .iter()
522            .map(|stage| RayObjectIntersectionState {
523                closest_hit: stage.closest_hit.clone().expect_downcast(),
524                any_hit: stage
525                    .any_hit
526                    .as_ref()
527                    .map(|stage| stage.clone().expect_downcast()),
528            })
529            .collect();
530
531        let desc = RayTracingPipelineDescriptor {
532            label: desc.label,
533            layout: desc.layout.expect_downcast_ref(),
534            ray_generation: desc.ray_generation.clone().expect_downcast(),
535            miss: desc.miss.clone().expect_downcast(),
536            intersection: &ray_intersection,
537            max_recursion_depth: desc.max_recursion_depth,
538            cache: desc.cache.as_ref().map(|c| c.expect_downcast_ref()),
539        };
540
541        unsafe { D::create_ray_tracing_pipeline(self, &desc) }
542            .map(|b| -> Box<dyn DynRayTracingPipeline> { Box::new(b) })
543    }
544
545    unsafe fn destroy_ray_tracing_pipeline(&self, pipeline: Box<dyn DynRayTracingPipeline>) {
546        unsafe {
547            D::destroy_ray_tracing_pipeline(self, pipeline.unbox());
548        };
549    }
550    unsafe fn get_raytracing_pipeline_group_data(
551        &self,
552        pipeline: &dyn DynRayTracingPipeline,
553        groups: core::ops::Range<u32>,
554    ) -> Result<Vec<u8>, DeviceError> {
555        unsafe {
556            D::get_raytracing_pipeline_group_data(self, pipeline.expect_downcast_ref(), groups)
557        }
558    }
559
560    unsafe fn create_pipeline_cache(
561        &self,
562        desc: &PipelineCacheDescriptor<'_>,
563    ) -> Result<Box<dyn DynPipelineCache>, PipelineCacheError> {
564        unsafe { D::create_pipeline_cache(self, desc) }
565            .map(|b| -> Box<dyn DynPipelineCache> { Box::new(b) })
566    }
567
568    fn pipeline_cache_validation_key(&self) -> Option<[u8; 16]> {
569        D::pipeline_cache_validation_key(self)
570    }
571
572    unsafe fn destroy_pipeline_cache(&self, pipeline_cache: Box<dyn DynPipelineCache>) {
573        unsafe { D::destroy_pipeline_cache(self, pipeline_cache.unbox()) };
574    }
575
576    unsafe fn create_query_set(
577        &self,
578        desc: &wgt::QuerySetDescriptor<Label>,
579    ) -> Result<Box<dyn DynQuerySet>, DeviceError> {
580        unsafe { D::create_query_set(self, desc) }.map(|b| -> Box<dyn DynQuerySet> { Box::new(b) })
581    }
582
583    unsafe fn destroy_query_set(&self, query_set: Box<dyn DynQuerySet>) {
584        unsafe { D::destroy_query_set(self, query_set.unbox()) };
585    }
586
587    unsafe fn create_fence(&self) -> Result<Box<dyn DynFence>, DeviceError> {
588        unsafe { D::create_fence(self) }.map(|b| -> Box<dyn DynFence> { Box::new(b) })
589    }
590
591    unsafe fn destroy_fence(&self, fence: Box<dyn DynFence>) {
592        unsafe { D::destroy_fence(self, fence.unbox()) };
593    }
594
595    unsafe fn get_fence_value(&self, fence: &dyn DynFence) -> Result<FenceValue, DeviceError> {
596        let fence = fence.expect_downcast_ref();
597        unsafe { D::get_fence_value(self, fence) }
598    }
599
600    unsafe fn wait(
601        &self,
602        fence: &dyn DynFence,
603        value: FenceValue,
604        timeout: Option<core::time::Duration>,
605    ) -> Result<bool, DeviceError> {
606        let fence = fence.expect_downcast_ref();
607        unsafe { D::wait(self, fence, value, timeout) }
608    }
609
610    unsafe fn start_graphics_debugger_capture(&self) -> bool {
611        unsafe { D::start_graphics_debugger_capture(self) }
612    }
613
614    unsafe fn stop_graphics_debugger_capture(&self) {
615        unsafe { D::stop_graphics_debugger_capture(self) }
616    }
617
618    unsafe fn pipeline_cache_get_data(&self, cache: &dyn DynPipelineCache) -> Option<Vec<u8>> {
619        let cache = cache.expect_downcast_ref();
620        unsafe { D::pipeline_cache_get_data(self, cache) }
621    }
622
623    unsafe fn create_acceleration_structure(
624        &self,
625        desc: &AccelerationStructureDescriptor,
626    ) -> Result<Box<dyn DynAccelerationStructure>, DeviceError> {
627        unsafe { D::create_acceleration_structure(self, desc) }
628            .map(|b| -> Box<dyn DynAccelerationStructure> { Box::new(b) })
629    }
630
631    unsafe fn get_acceleration_structure_build_sizes(
632        &self,
633        desc: &GetAccelerationStructureBuildSizesDescriptor<dyn DynBuffer>,
634    ) -> AccelerationStructureBuildSizes {
635        let entries = desc.entries.expect_downcast();
636        let desc = GetAccelerationStructureBuildSizesDescriptor {
637            entries: &entries,
638            flags: desc.flags,
639        };
640        unsafe { D::get_acceleration_structure_build_sizes(self, &desc) }
641    }
642
643    unsafe fn get_acceleration_structure_device_address(
644        &self,
645        acceleration_structure: &dyn DynAccelerationStructure,
646    ) -> wgt::BufferAddress {
647        let acceleration_structure = acceleration_structure.expect_downcast_ref();
648        unsafe { D::get_acceleration_structure_device_address(self, acceleration_structure) }
649    }
650
651    unsafe fn destroy_acceleration_structure(
652        &self,
653        acceleration_structure: Box<dyn DynAccelerationStructure>,
654    ) {
655        unsafe { D::destroy_acceleration_structure(self, acceleration_structure.unbox()) }
656    }
657
658    fn tlas_instance_to_bytes(&self, instance: TlasInstance, to_extend: &mut Vec<u8>) {
659        D::tlas_instance_to_bytes(self, instance, to_extend)
660    }
661
662    fn get_internal_counters(&self) -> wgt::HalCounters {
663        D::get_internal_counters(self)
664    }
665
666    fn generate_allocator_report(&self) -> Option<wgt::AllocatorReport> {
667        D::generate_allocator_report(self)
668    }
669
670    fn check_if_oom(&self) -> Result<(), DeviceError> {
671        D::check_if_oom(self)
672    }
673}