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 unsafe fn create_buffer(
23 &self,
24 desc: &BufferDescriptor,
25 ) -> Result<(Box<dyn DynBuffer>, wgt::BufferAddress), DeviceError>;
26
27 unsafe fn destroy_buffer(&self, buffer: Box<dyn DynBuffer>);
29 unsafe fn add_raw_buffer(&self, buffer: &dyn DynBuffer);
31
32 unsafe fn map_buffer(
34 &self,
35 buffer: &dyn DynBuffer,
36 range: MemoryRange,
37 ) -> Result<BufferMapping, DeviceError>;
38
39 unsafe fn unmap_buffer(&self, buffer: &dyn DynBuffer);
41
42 unsafe fn flush_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]);
44 unsafe fn invalidate_mapped_ranges(&self, buffer: &dyn DynBuffer, ranges: &[MemoryRange]);
46
47 unsafe fn create_texture(
49 &self,
50 desc: &TextureDescriptor,
51 ) -> Result<Box<dyn DynTexture>, DeviceError>;
52 unsafe fn destroy_texture(&self, texture: Box<dyn DynTexture>);
54 unsafe fn add_raw_texture(&self, texture: &dyn DynTexture);
56
57 unsafe fn create_texture_view(
59 &self,
60 texture: &dyn DynTexture,
61 desc: &TextureViewDescriptor,
62 ) -> Result<Box<dyn DynTextureView>, DeviceError>;
63 unsafe fn destroy_texture_view(&self, view: Box<dyn DynTextureView>);
65 unsafe fn create_sampler(
67 &self,
68 desc: &SamplerDescriptor,
69 ) -> Result<Box<dyn DynSampler>, DeviceError>;
70 unsafe fn destroy_sampler(&self, sampler: Box<dyn DynSampler>);
72
73 unsafe fn create_command_encoder(
75 &self,
76 desc: &CommandEncoderDescriptor<dyn DynQueue>,
77 ) -> Result<Box<dyn DynCommandEncoder>, DeviceError>;
78
79 unsafe fn create_bind_group_layout(
81 &self,
82 desc: &BindGroupLayoutDescriptor,
83 ) -> Result<Box<dyn DynBindGroupLayout>, DeviceError>;
84 unsafe fn destroy_bind_group_layout(&self, bg_layout: Box<dyn DynBindGroupLayout>);
86
87 unsafe fn create_pipeline_layout(
89 &self,
90 desc: &PipelineLayoutDescriptor<dyn DynBindGroupLayout>,
91 ) -> Result<Box<dyn DynPipelineLayout>, DeviceError>;
92 unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Box<dyn DynPipelineLayout>);
94
95 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 unsafe fn destroy_bind_group(&self, group: Box<dyn DynBindGroup>);
108
109 unsafe fn create_shader_module(
111 &self,
112 desc: &ShaderModuleDescriptor,
113 shader: ShaderInput,
114 ) -> Result<Box<dyn DynShaderModule>, ShaderError>;
115 unsafe fn destroy_shader_module(&self, module: Box<dyn DynShaderModule>);
117
118 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 unsafe fn destroy_render_pipeline(&self, pipeline: Box<dyn DynRenderPipeline>);
129
130 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 unsafe fn destroy_compute_pipeline(&self, pipeline: Box<dyn DynComputePipeline>);
141
142 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 unsafe fn destroy_ray_tracing_pipeline(&self, pipeline: Box<dyn DynRayTracingPipeline>);
153 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 unsafe fn create_pipeline_cache(
162 &self,
163 desc: &PipelineCacheDescriptor<'_>,
164 ) -> Result<Box<dyn DynPipelineCache>, PipelineCacheError>;
165 fn pipeline_cache_validation_key(&self) -> Option<[u8; 16]> {
167 None
168 }
169 unsafe fn destroy_pipeline_cache(&self, cache: Box<dyn DynPipelineCache>);
171
172 unsafe fn create_query_set(
174 &self,
175 desc: &wgt::QuerySetDescriptor<Label>,
176 ) -> Result<Box<dyn DynQuerySet>, DeviceError>;
177 unsafe fn destroy_query_set(&self, set: Box<dyn DynQuerySet>);
179
180 unsafe fn create_fence(&self) -> Result<Box<dyn DynFence>, DeviceError>;
182 unsafe fn destroy_fence(&self, fence: Box<dyn DynFence>);
184 unsafe fn get_fence_value(&self, fence: &dyn DynFence) -> Result<FenceValue, DeviceError>;
186
187 unsafe fn wait(
189 &self,
190 fence: &dyn DynFence,
191 value: FenceValue,
192 timeout: Option<core::time::Duration>,
193 ) -> Result<bool, DeviceError>;
194
195 unsafe fn start_graphics_debugger_capture(&self) -> bool;
197 unsafe fn stop_graphics_debugger_capture(&self);
199
200 unsafe fn pipeline_cache_get_data(&self, cache: &dyn DynPipelineCache) -> Option<Vec<u8>>;
202
203 unsafe fn create_acceleration_structure(
205 &self,
206 desc: &AccelerationStructureDescriptor,
207 ) -> Result<Box<dyn DynAccelerationStructure>, DeviceError>;
208 unsafe fn get_acceleration_structure_build_sizes(
210 &self,
211 desc: &GetAccelerationStructureBuildSizesDescriptor<dyn DynBuffer>,
212 ) -> AccelerationStructureBuildSizes;
213 unsafe fn get_acceleration_structure_device_address(
215 &self,
216 acceleration_structure: &dyn DynAccelerationStructure,
217 ) -> wgt::BufferAddress;
218 unsafe fn destroy_acceleration_structure(
220 &self,
221 acceleration_structure: Box<dyn DynAccelerationStructure>,
222 );
223 fn tlas_instance_to_bytes(&self, instance: TlasInstance, to_extend: &mut Vec<u8>);
225
226 fn get_internal_counters(&self) -> wgt::HalCounters;
228 fn generate_allocator_report(&self) -> Option<wgt::AllocatorReport>;
230
231 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}