1use super::conv;
2use arrayvec::ArrayVec;
3use ash::vk;
4use core::{mem, ops::Range};
5use hashbrown::hash_map::Entry;
6
7const ALLOCATION_GRANULARITY: u32 = 16;
8const DST_IMAGE_LAYOUT: vk::ImageLayout = vk::ImageLayout::TRANSFER_DST_OPTIMAL;
9
10impl super::Texture {
11 fn map_buffer_copies<T>(&self, regions: T) -> impl Iterator<Item = vk::BufferImageCopy>
12 where
13 T: Iterator<Item = crate::BufferTextureCopy>,
14 {
15 let (block_width, block_height) = self.format.block_dimensions();
16 let format = self.format;
17 let copy_size = self.copy_size;
18 regions.map(move |r| {
19 let extent = r.texture_base.max_copy_size(©_size).min(&r.size);
20 let (image_subresource, image_offset) = conv::map_subresource_layers(&r.texture_base);
21 vk::BufferImageCopy {
22 buffer_offset: r.buffer_layout.offset,
23 buffer_row_length: r.buffer_layout.bytes_per_row.map_or(0, |bpr| {
24 let block_size = format
25 .block_copy_size(Some(r.texture_base.aspect.map()))
26 .unwrap();
27 block_width * (bpr / block_size)
28 }),
29 buffer_image_height: r
30 .buffer_layout
31 .rows_per_image
32 .map_or(0, |rpi| rpi * block_height),
33 image_subresource,
34 image_offset,
35 image_extent: conv::map_copy_extent(&extent),
36 }
37 })
38 }
39}
40
41impl super::CommandEncoder {
42 unsafe fn write_pass_begin_timestamp(&mut self, set: &super::QuerySet, index: u32) {
46 unsafe {
47 self.device.raw.cmd_write_timestamp(
48 self.active,
49 vk::PipelineStageFlags::TOP_OF_PIPE,
50 set.raw,
51 index,
52 );
53 }
54 }
55
56 fn write_pass_end_timestamp_if_requested(&mut self) {
57 if let Some((query_set, index)) = self.end_of_pass_timer_query.take() {
58 unsafe {
59 self.device.raw.cmd_write_timestamp(
60 self.active,
61 vk::PipelineStageFlags::BOTTOM_OF_PIPE,
62 query_set,
63 index,
64 );
65 }
66 }
67 }
68
69 fn make_framebuffer(
70 &mut self,
71 key: super::FramebufferKey,
72 ) -> Result<vk::Framebuffer, crate::DeviceError> {
73 Ok(match self.framebuffers.entry(key) {
74 Entry::Occupied(e) => *e.get(),
75 Entry::Vacant(e) => {
76 let super::FramebufferKey {
77 raw_pass,
78 ref attachment_views,
79 attachment_identities: _,
80 extent,
81 } = *e.key();
82
83 let vk_info = vk::FramebufferCreateInfo::default()
84 .render_pass(raw_pass)
85 .width(extent.width)
86 .height(extent.height)
87 .layers(extent.depth_or_array_layers)
88 .attachments(attachment_views);
89
90 let raw = unsafe { self.device.raw.create_framebuffer(&vk_info, None).unwrap() };
91 *e.insert(raw)
92 }
93 })
94 }
95
96 fn make_temp_texture_view(
97 &mut self,
98 key: super::TempTextureViewKey,
99 ) -> Result<super::IdentifiedTextureView, crate::DeviceError> {
100 Ok(match self.temp_texture_views.entry(key) {
101 Entry::Occupied(e) => *e.get(),
102 Entry::Vacant(e) => {
103 let super::TempTextureViewKey {
104 texture,
105 texture_identity: _,
106 format,
107 mip_level,
108 depth_slice,
109 } = *e.key();
110
111 let vk_info = vk::ImageViewCreateInfo::default()
112 .image(texture)
113 .view_type(vk::ImageViewType::TYPE_2D)
114 .format(format)
115 .subresource_range(vk::ImageSubresourceRange {
116 aspect_mask: vk::ImageAspectFlags::COLOR,
117 base_mip_level: mip_level,
118 level_count: 1,
119 base_array_layer: depth_slice,
120 layer_count: 1,
121 });
122 let raw = unsafe { self.device.raw.create_image_view(&vk_info, None) }
123 .map_err(super::map_host_device_oom_and_ioca_err)?;
124
125 let identity = self.device.texture_view_identity_factory.next();
126
127 *e.insert(super::IdentifiedTextureView { raw, identity })
128 }
129 })
130 }
131}
132
133impl crate::CommandEncoder for super::CommandEncoder {
134 type A = super::Api;
135
136 unsafe fn begin_encoding(&mut self, label: crate::Label) -> Result<(), crate::DeviceError> {
137 if self.free.is_empty() {
138 let vk_info = vk::CommandBufferAllocateInfo::default()
139 .command_pool(self.raw)
140 .command_buffer_count(ALLOCATION_GRANULARITY);
141 let cmd_buf_vec = unsafe {
142 self.device
143 .raw
144 .allocate_command_buffers(&vk_info)
145 .map_err(super::map_host_device_oom_err)?
146 };
147 self.free.extend(cmd_buf_vec);
148 }
149 let raw = self.free.pop().unwrap();
150
151 if !self
152 .device
153 .instance
154 .flags
155 .contains(wgt::InstanceFlags::DISCARD_HAL_LABELS)
156 {
157 unsafe { self.device.set_object_name(raw, label.unwrap_or_default()) };
160 }
161
162 self.rpass_debug_marker_active = false;
164 self.end_of_pass_timer_query = None;
165
166 let vk_info = vk::CommandBufferBeginInfo::default()
167 .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT);
168 unsafe { self.device.raw.begin_command_buffer(raw, &vk_info) }
169 .map_err(super::map_host_device_oom_err)?;
170 self.active = raw;
171
172 Ok(())
173 }
174
175 unsafe fn end_encoding(&mut self) -> Result<super::CommandBuffer, crate::DeviceError> {
176 let raw = self.active;
177 self.active = vk::CommandBuffer::null();
178 unsafe { self.device.raw.end_command_buffer(raw) }.map_err(map_err)?;
179 fn map_err(err: vk::Result) -> crate::DeviceError {
180 super::map_host_device_oom_err(err)
183 }
184 Ok(super::CommandBuffer { raw })
185 }
186
187 unsafe fn discard_encoding(&mut self) {
188 assert_ne!(self.active, vk::CommandBuffer::null());
192
193 self.discarded.push(self.active);
194 self.active = vk::CommandBuffer::null();
195 }
196
197 unsafe fn reset_all<I>(&mut self, cmd_bufs: I)
198 where
199 I: Iterator<Item = super::CommandBuffer>,
200 {
201 self.temp.clear();
202 self.free
203 .extend(cmd_bufs.into_iter().map(|cmd_buf| cmd_buf.raw));
204 self.free.append(&mut self.discarded);
205 for (_, framebuffer) in self.framebuffers.drain() {
207 unsafe { self.device.raw.destroy_framebuffer(framebuffer, None) };
208 }
209 let _ = unsafe {
210 self.device
211 .raw
212 .reset_command_pool(self.raw, vk::CommandPoolResetFlags::default())
213 };
214 }
215
216 unsafe fn transition_buffers<'a, T>(&mut self, barriers: T)
217 where
218 T: Iterator<Item = crate::BufferBarrier<'a, super::Buffer>>,
219 {
220 let mut src_stages = vk::PipelineStageFlags::TOP_OF_PIPE;
222 let mut dst_stages = vk::PipelineStageFlags::BOTTOM_OF_PIPE;
223 let vk_barriers = &mut self.temp.buffer_barriers;
224 vk_barriers.clear();
225
226 for bar in barriers {
227 let (src_stage, src_access) = conv::map_buffer_usage_to_barrier(
228 bar.usage.from,
229 self.device.queue_flags,
230 self.device.features,
231 );
232 src_stages |= src_stage;
233 let (dst_stage, dst_access) = conv::map_buffer_usage_to_barrier(
234 bar.usage.to,
235 self.device.queue_flags,
236 self.device.features,
237 );
238 dst_stages |= dst_stage;
239
240 vk_barriers.push(
241 vk::BufferMemoryBarrier::default()
242 .buffer(bar.buffer.raw)
243 .size(vk::WHOLE_SIZE)
244 .src_access_mask(src_access)
245 .dst_access_mask(dst_access),
246 )
247 }
248
249 if !vk_barriers.is_empty() {
250 unsafe {
251 self.device.raw.cmd_pipeline_barrier(
252 self.active,
253 src_stages,
254 dst_stages,
255 vk::DependencyFlags::empty(),
256 &[],
257 vk_barriers,
258 &[],
259 )
260 };
261 }
262 }
263
264 unsafe fn transition_textures<'a, T>(&mut self, barriers: T)
265 where
266 T: Iterator<Item = crate::TextureBarrier<'a, super::Texture>>,
267 {
268 let mut src_stages = vk::PipelineStageFlags::empty();
269 let mut dst_stages = vk::PipelineStageFlags::empty();
270 let vk_barriers = &mut self.temp.image_barriers;
271 vk_barriers.clear();
272
273 for bar in barriers {
274 let range = conv::map_subresource_range_combined_aspect(
275 &bar.range,
276 bar.texture.format,
277 &self.device.private_caps,
278 );
279 let (src_stage, src_access) = conv::map_texture_usage_to_barrier(
280 bar.usage.from,
281 self.device.queue_flags,
282 self.device.private_caps.store_op_none,
283 self.device.features,
284 );
285 let src_layout = conv::derive_image_layout(bar.usage.from, bar.texture.format);
286 src_stages |= src_stage;
287 let (dst_stage, dst_access) = conv::map_texture_usage_to_barrier(
288 bar.usage.to,
289 self.device.queue_flags,
290 self.device.private_caps.store_op_none,
291 self.device.features,
292 );
293 let dst_layout = conv::derive_image_layout(bar.usage.to, bar.texture.format);
294 dst_stages |= dst_stage;
295
296 let (src_queue_family_index, dst_queue_family_index) =
301 match bar.queue_family_ownership_transfer {
302 Some(transfer) => (
303 conv::map_queue_family(transfer.src),
304 conv::map_queue_family(transfer.dst),
305 ),
306 None => (vk::QUEUE_FAMILY_IGNORED, vk::QUEUE_FAMILY_IGNORED),
307 };
308
309 vk_barriers.push(
310 vk::ImageMemoryBarrier::default()
311 .image(bar.texture.raw)
312 .subresource_range(range)
313 .src_access_mask(src_access)
314 .dst_access_mask(dst_access)
315 .old_layout(src_layout)
316 .new_layout(dst_layout)
317 .src_queue_family_index(src_queue_family_index)
318 .dst_queue_family_index(dst_queue_family_index),
319 );
320 }
321
322 if !vk_barriers.is_empty() {
323 unsafe {
324 self.device.raw.cmd_pipeline_barrier(
325 self.active,
326 src_stages,
327 dst_stages,
328 vk::DependencyFlags::empty(),
329 &[],
330 &[],
331 vk_barriers,
332 )
333 };
334 }
335 }
336
337 unsafe fn clear_buffer(&mut self, buffer: &super::Buffer, range: crate::MemoryRange) {
338 let range_size = range.end - range.start;
339 if self.device.workarounds.contains(
340 super::Workarounds::FORCE_FILL_BUFFER_WITH_SIZE_GREATER_4096_ALIGNED_OFFSET_16,
341 ) && range_size >= 4096
342 && !range.start.is_multiple_of(16)
343 {
344 let rounded_start = wgt::math::align_to(range.start, 16);
345 let prefix_size = rounded_start - range.start;
346
347 unsafe {
348 self.device.raw.cmd_fill_buffer(
349 self.active,
350 buffer.raw,
351 range.start,
352 prefix_size,
353 0,
354 )
355 };
356
357 let suffix_size = range.end - rounded_start;
359
360 unsafe {
361 self.device.raw.cmd_fill_buffer(
362 self.active,
363 buffer.raw,
364 rounded_start,
365 suffix_size,
366 0,
367 )
368 };
369 } else {
370 unsafe {
371 self.device
372 .raw
373 .cmd_fill_buffer(self.active, buffer.raw, range.start, range_size, 0)
374 };
375 }
376 }
377
378 unsafe fn copy_buffer_to_buffer<T>(
379 &mut self,
380 src: &super::Buffer,
381 dst: &super::Buffer,
382 regions: T,
383 ) where
384 T: Iterator<Item = crate::BufferCopy>,
385 {
386 let vk_regions_iter = regions.map(|r| vk::BufferCopy {
387 src_offset: r.src_offset,
388 dst_offset: r.dst_offset,
389 size: r.size.get(),
390 });
391
392 unsafe {
393 self.device.raw.cmd_copy_buffer(
394 self.active,
395 src.raw,
396 dst.raw,
397 &smallvec::SmallVec::<[vk::BufferCopy; 32]>::from_iter(vk_regions_iter),
398 )
399 };
400 }
401
402 unsafe fn copy_texture_to_texture<T>(
403 &mut self,
404 src: &super::Texture,
405 src_usage: wgt::TextureUses,
406 dst: &super::Texture,
407 regions: T,
408 ) where
409 T: Iterator<Item = crate::TextureCopy>,
410 {
411 let src_layout = conv::derive_image_layout(src_usage, src.format);
412
413 let vk_regions_iter = regions.map(|r| {
414 let (src_subresource, src_offset) = conv::map_subresource_layers(&r.src_base);
415 let (dst_subresource, dst_offset) = conv::map_subresource_layers(&r.dst_base);
416 let extent = r
417 .size
418 .min(&r.src_base.max_copy_size(&src.copy_size))
419 .min(&r.dst_base.max_copy_size(&dst.copy_size));
420 vk::ImageCopy {
421 src_subresource,
422 src_offset,
423 dst_subresource,
424 dst_offset,
425 extent: conv::map_copy_extent(&extent),
426 }
427 });
428
429 unsafe {
430 self.device.raw.cmd_copy_image(
431 self.active,
432 src.raw,
433 src_layout,
434 dst.raw,
435 DST_IMAGE_LAYOUT,
436 &smallvec::SmallVec::<[vk::ImageCopy; 32]>::from_iter(vk_regions_iter),
437 )
438 };
439 }
440
441 unsafe fn copy_buffer_to_texture<T>(
442 &mut self,
443 src: &super::Buffer,
444 dst: &super::Texture,
445 regions: T,
446 ) where
447 T: Iterator<Item = crate::BufferTextureCopy>,
448 {
449 let vk_regions_iter = dst.map_buffer_copies(regions);
450
451 unsafe {
452 self.device.raw.cmd_copy_buffer_to_image(
453 self.active,
454 src.raw,
455 dst.raw,
456 DST_IMAGE_LAYOUT,
457 &smallvec::SmallVec::<[vk::BufferImageCopy; 32]>::from_iter(vk_regions_iter),
458 )
459 };
460 }
461
462 unsafe fn copy_texture_to_buffer<T>(
463 &mut self,
464 src: &super::Texture,
465 src_usage: wgt::TextureUses,
466 dst: &super::Buffer,
467 regions: T,
468 ) where
469 T: Iterator<Item = crate::BufferTextureCopy>,
470 {
471 let src_layout = conv::derive_image_layout(src_usage, src.format);
472 let vk_regions_iter = src.map_buffer_copies(regions);
473
474 unsafe {
475 self.device.raw.cmd_copy_image_to_buffer(
476 self.active,
477 src.raw,
478 src_layout,
479 dst.raw,
480 &smallvec::SmallVec::<[vk::BufferImageCopy; 32]>::from_iter(vk_regions_iter),
481 )
482 };
483 }
484
485 unsafe fn begin_query(&mut self, set: &super::QuerySet, index: u32) {
486 unsafe {
487 self.device.raw.cmd_begin_query(
488 self.active,
489 set.raw,
490 index,
491 vk::QueryControlFlags::empty(),
492 )
493 };
494 }
495 unsafe fn end_query(&mut self, set: &super::QuerySet, index: u32) {
496 unsafe { self.device.raw.cmd_end_query(self.active, set.raw, index) };
497 }
498 unsafe fn write_timestamp(&mut self, set: &super::QuerySet, index: u32) {
499 unsafe {
500 self.device.raw.cmd_write_timestamp(
501 self.active,
502 vk::PipelineStageFlags::BOTTOM_OF_PIPE,
503 set.raw,
504 index,
505 )
506 };
507 }
508 unsafe fn read_acceleration_structure_compact_size(
509 &mut self,
510 acceleration_structure: &super::AccelerationStructure,
511 buffer: &super::Buffer,
512 ) {
513 let ray_tracing_functions = self
514 .device
515 .extension_fns
516 .ray_tracing
517 .as_ref()
518 .expect("Feature `RAY_TRACING` not enabled");
519 let query_pool = acceleration_structure
520 .compacted_size_query
521 .as_ref()
522 .unwrap();
523 unsafe {
524 self.device
525 .raw
526 .cmd_reset_query_pool(self.active, *query_pool, 0, 1);
527 ray_tracing_functions
528 .acceleration_structure
529 .cmd_write_acceleration_structures_properties(
530 self.active,
531 &[acceleration_structure.raw],
532 vk::QueryType::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR,
533 *query_pool,
534 0,
535 );
536 self.device.raw.cmd_copy_query_pool_results(
537 self.active,
538 *query_pool,
539 0,
540 1,
541 buffer.raw,
542 0,
543 wgt::QUERY_SIZE as vk::DeviceSize,
544 vk::QueryResultFlags::TYPE_64 | vk::QueryResultFlags::WAIT,
545 )
546 };
547 }
548 unsafe fn reset_queries(&mut self, set: &super::QuerySet, range: Range<u32>) {
549 unsafe {
550 self.device.raw.cmd_reset_query_pool(
551 self.active,
552 set.raw,
553 range.start,
554 range.end - range.start,
555 )
556 };
557 }
558 unsafe fn copy_query_results(
559 &mut self,
560 set: &super::QuerySet,
561 range: Range<u32>,
562 buffer: &super::Buffer,
563 offset: wgt::BufferAddress,
564 stride: wgt::BufferSize,
565 ) {
566 unsafe {
567 self.device.raw.cmd_copy_query_pool_results(
568 self.active,
569 set.raw,
570 range.start,
571 range.end - range.start,
572 buffer.raw,
573 offset,
574 stride.get(),
575 vk::QueryResultFlags::TYPE_64 | vk::QueryResultFlags::WAIT,
576 )
577 };
578 }
579
580 unsafe fn build_acceleration_structures<'a, T>(&mut self, descriptor_count: u32, descriptors: T)
581 where
582 super::Api: 'a,
583 T: IntoIterator<
584 Item = crate::BuildAccelerationStructureDescriptor<
585 'a,
586 super::Buffer,
587 super::AccelerationStructure,
588 >,
589 >,
590 {
591 const CAPACITY_OUTER: usize = 8;
592 const CAPACITY_INNER: usize = 1;
593 let descriptor_count = descriptor_count as usize;
594
595 let ray_tracing_functions = self
596 .device
597 .extension_fns
598 .ray_tracing
599 .as_ref()
600 .expect("Feature `RAY_TRACING` not enabled");
601
602 let get_device_address = |buffer: Option<&super::Buffer>| unsafe {
603 match buffer {
604 Some(buffer) => ray_tracing_functions
605 .buffer_device_address
606 .get_buffer_device_address(
607 &vk::BufferDeviceAddressInfo::default().buffer(buffer.raw),
608 ),
609 None => panic!("Buffers are required to build acceleration structures"),
610 }
611 };
612
613 let mut ranges_storage = smallvec::SmallVec::<
615 [smallvec::SmallVec<[vk::AccelerationStructureBuildRangeInfoKHR; CAPACITY_INNER]>;
616 CAPACITY_OUTER],
617 >::with_capacity(descriptor_count);
618 let mut geometries_storage = smallvec::SmallVec::<
619 [smallvec::SmallVec<[vk::AccelerationStructureGeometryKHR; CAPACITY_INNER]>;
620 CAPACITY_OUTER],
621 >::with_capacity(descriptor_count);
622
623 let mut geometry_infos = smallvec::SmallVec::<
625 [vk::AccelerationStructureBuildGeometryInfoKHR; CAPACITY_OUTER],
626 >::with_capacity(descriptor_count);
627 let mut ranges_ptrs = smallvec::SmallVec::<
628 [&[vk::AccelerationStructureBuildRangeInfoKHR]; CAPACITY_OUTER],
629 >::with_capacity(descriptor_count);
630
631 for desc in descriptors {
632 let (geometries, ranges) = match *desc.entries {
633 crate::AccelerationStructureEntries::Instances(ref instances) => {
634 let instance_data = vk::AccelerationStructureGeometryInstancesDataKHR::default(
635 )
637 .data(vk::DeviceOrHostAddressConstKHR {
638 device_address: get_device_address(instances.buffer),
639 });
640
641 let geometry = vk::AccelerationStructureGeometryKHR::default()
642 .geometry_type(vk::GeometryTypeKHR::INSTANCES)
643 .geometry(vk::AccelerationStructureGeometryDataKHR {
644 instances: instance_data,
645 });
646
647 let range = vk::AccelerationStructureBuildRangeInfoKHR::default()
648 .primitive_count(instances.count)
649 .primitive_offset(instances.offset);
650
651 (smallvec::smallvec![geometry], smallvec::smallvec![range])
652 }
653 crate::AccelerationStructureEntries::Triangles(ref in_geometries) => {
654 let mut ranges = smallvec::SmallVec::<
655 [vk::AccelerationStructureBuildRangeInfoKHR; CAPACITY_INNER],
656 >::with_capacity(in_geometries.len());
657 let mut geometries = smallvec::SmallVec::<
658 [vk::AccelerationStructureGeometryKHR; CAPACITY_INNER],
659 >::with_capacity(in_geometries.len());
660 for triangles in in_geometries {
661 let mut triangle_data =
662 vk::AccelerationStructureGeometryTrianglesDataKHR::default()
663 .index_type(vk::IndexType::NONE_KHR)
666 .vertex_data(vk::DeviceOrHostAddressConstKHR {
667 device_address: get_device_address(triangles.vertex_buffer)
668 + (triangles.first_vertex as u64 * triangles.vertex_stride),
669 })
670 .vertex_format(conv::map_vertex_format(triangles.vertex_format))
671 .max_vertex(triangles.vertex_count)
672 .vertex_stride(triangles.vertex_stride);
673
674 let mut range = vk::AccelerationStructureBuildRangeInfoKHR::default();
675
676 if let Some(ref indices) = triangles.indices {
677 triangle_data = triangle_data
678 .index_data(vk::DeviceOrHostAddressConstKHR {
679 device_address: get_device_address(indices.buffer),
680 })
681 .index_type(conv::map_index_format(indices.format));
682
683 range = range
684 .primitive_count(indices.count / 3)
685 .primitive_offset(indices.offset);
686 } else {
687 range = range.primitive_count(triangles.vertex_count / 3);
688 }
689
690 if let Some(ref transform) = triangles.transform {
691 let transform_device_address = unsafe {
692 ray_tracing_functions
693 .buffer_device_address
694 .get_buffer_device_address(
695 &vk::BufferDeviceAddressInfo::default()
696 .buffer(transform.buffer.raw),
697 )
698 };
699 triangle_data =
700 triangle_data.transform_data(vk::DeviceOrHostAddressConstKHR {
701 device_address: transform_device_address,
702 });
703
704 range = range.transform_offset(transform.offset);
705 }
706
707 let geometry = vk::AccelerationStructureGeometryKHR::default()
708 .geometry_type(vk::GeometryTypeKHR::TRIANGLES)
709 .geometry(vk::AccelerationStructureGeometryDataKHR {
710 triangles: triangle_data,
711 })
712 .flags(conv::map_acceleration_structure_geometry_flags(
713 triangles.flags,
714 ));
715
716 geometries.push(geometry);
717 ranges.push(range);
718 }
719 (geometries, ranges)
720 }
721 crate::AccelerationStructureEntries::AABBs(ref in_geometries) => {
722 let mut ranges = smallvec::SmallVec::<
723 [vk::AccelerationStructureBuildRangeInfoKHR; CAPACITY_INNER],
724 >::with_capacity(in_geometries.len());
725 let mut geometries = smallvec::SmallVec::<
726 [vk::AccelerationStructureGeometryKHR; CAPACITY_INNER],
727 >::with_capacity(in_geometries.len());
728 for aabb in in_geometries {
729 let aabbs_data = vk::AccelerationStructureGeometryAabbsDataKHR::default()
730 .data(vk::DeviceOrHostAddressConstKHR {
731 device_address: get_device_address(aabb.buffer),
732 })
733 .stride(aabb.stride);
734
735 let range = vk::AccelerationStructureBuildRangeInfoKHR::default()
736 .primitive_count(aabb.count)
737 .primitive_offset(aabb.offset);
738
739 let geometry = vk::AccelerationStructureGeometryKHR::default()
740 .geometry_type(vk::GeometryTypeKHR::AABBS)
741 .geometry(vk::AccelerationStructureGeometryDataKHR {
742 aabbs: aabbs_data,
743 })
744 .flags(conv::map_acceleration_structure_geometry_flags(aabb.flags));
745
746 geometries.push(geometry);
747 ranges.push(range);
748 }
749 (geometries, ranges)
750 }
751 };
752
753 ranges_storage.push(ranges);
754 geometries_storage.push(geometries);
755
756 let scratch_device_address = unsafe {
757 ray_tracing_functions
758 .buffer_device_address
759 .get_buffer_device_address(
760 &vk::BufferDeviceAddressInfo::default().buffer(desc.scratch_buffer.raw),
761 )
762 };
763 let ty = match *desc.entries {
764 crate::AccelerationStructureEntries::Instances(_) => {
765 vk::AccelerationStructureTypeKHR::TOP_LEVEL
766 }
767 _ => vk::AccelerationStructureTypeKHR::BOTTOM_LEVEL,
768 };
769 let mut geometry_info = vk::AccelerationStructureBuildGeometryInfoKHR::default()
770 .ty(ty)
771 .mode(conv::map_acceleration_structure_build_mode(desc.mode))
772 .flags(conv::map_acceleration_structure_flags(desc.flags))
773 .dst_acceleration_structure(desc.destination_acceleration_structure.raw)
774 .scratch_data(vk::DeviceOrHostAddressKHR {
775 device_address: scratch_device_address + desc.scratch_buffer_offset,
776 });
777
778 if desc.mode == crate::AccelerationStructureBuildMode::Update {
779 geometry_info.src_acceleration_structure = desc
780 .source_acceleration_structure
781 .unwrap_or(desc.destination_acceleration_structure)
782 .raw;
783 }
784
785 geometry_infos.push(geometry_info);
786 }
787
788 for (i, geometry_info) in geometry_infos.iter_mut().enumerate() {
789 geometry_info.geometry_count = geometries_storage[i].len() as u32;
790 geometry_info.p_geometries = geometries_storage[i].as_ptr();
791 ranges_ptrs.push(&ranges_storage[i]);
792 }
793
794 unsafe {
795 ray_tracing_functions
796 .acceleration_structure
797 .cmd_build_acceleration_structures(self.active, &geometry_infos, &ranges_ptrs);
798 }
799 }
800
801 unsafe fn place_acceleration_structure_barrier(
802 &mut self,
803 barrier: crate::AccelerationStructureBarrier,
804 ) {
805 let (src_stage, src_access) = conv::map_acceleration_structure_usage_to_barrier(
806 barrier.usage.from,
807 self.device.features,
808 self.device.queue_flags,
809 );
810 let (dst_stage, dst_access) = conv::map_acceleration_structure_usage_to_barrier(
811 barrier.usage.to,
812 self.device.features,
813 self.device.queue_flags,
814 );
815
816 unsafe {
817 self.device.raw.cmd_pipeline_barrier(
818 self.active,
819 src_stage | vk::PipelineStageFlags::TOP_OF_PIPE,
820 dst_stage | vk::PipelineStageFlags::BOTTOM_OF_PIPE,
821 vk::DependencyFlags::empty(),
822 &[vk::MemoryBarrier::default()
823 .src_access_mask(src_access)
824 .dst_access_mask(dst_access)],
825 &[],
826 &[],
827 )
828 };
829 }
830
831 unsafe fn set_acceleration_structure_dependencies(
832 _command_buffers: &[&super::CommandBuffer],
833 _dependencies: &[&super::AccelerationStructure],
834 ) {
835 }
836 unsafe fn begin_render_pass(
839 &mut self,
840 desc: &crate::RenderPassDescriptor<super::QuerySet, super::TextureView>,
841 ) -> Result<(), crate::DeviceError> {
842 let mut vk_clear_values =
843 ArrayVec::<vk::ClearValue, { super::MAX_TOTAL_ATTACHMENTS }>::new();
844 let mut rp_key = super::RenderPassKey {
845 colors: ArrayVec::default(),
846 depth_stencil: None,
847 sample_count: desc.sample_count,
848 multiview_mask: desc.multiview_mask,
849 depth_read_only: false,
850 stencil_read_only: false,
851 };
852 let mut fb_key = super::FramebufferKey {
853 raw_pass: vk::RenderPass::null(),
854 attachment_views: ArrayVec::default(),
855 attachment_identities: ArrayVec::default(),
856 extent: desc.extent,
857 };
858
859 for cat in desc.color_attachments {
860 if let Some(cat) = cat.as_ref() {
861 let color_view = if cat.target.view.dimension == wgt::TextureViewDimension::D3 {
862 let key = super::TempTextureViewKey {
863 texture: cat.target.view.raw_texture,
864 texture_identity: cat.target.view.texture_identity,
865 format: cat.target.view.raw_format,
866 mip_level: cat.target.view.base_mip_level,
867 depth_slice: cat.depth_slice.unwrap(),
868 };
869 self.make_temp_texture_view(key)?
870 } else {
871 cat.target.view.identified_raw_view()
872 };
873
874 vk_clear_values.push(vk::ClearValue {
875 color: unsafe { cat.make_vk_clear_color() },
876 });
877 let color = super::ColorAttachmentKey {
878 base: cat.target.make_attachment_key(cat.ops),
879 resolve: cat.resolve_target.as_ref().map(|target| {
880 target.make_attachment_key(
881 crate::AttachmentOps::LOAD_CLEAR | crate::AttachmentOps::STORE,
882 )
883 }),
884 };
885
886 rp_key.colors.push(Some(color));
887 fb_key.push_view(color_view);
888 if let Some(ref at) = cat.resolve_target {
889 vk_clear_values.push(unsafe { mem::zeroed() });
890 fb_key.push_view(at.view.identified_raw_view());
891 }
892 } else {
893 rp_key.colors.push(None);
894 }
895 }
896 if let Some(ref ds) = desc.depth_stencil_attachment {
897 rp_key.depth_read_only = ds.depth_read_only;
898 rp_key.stencil_read_only = ds.stencil_read_only;
899 vk_clear_values.push(vk::ClearValue {
900 depth_stencil: vk::ClearDepthStencilValue {
901 depth: ds.clear_value.0,
902 stencil: ds.clear_value.1,
903 },
904 });
905 rp_key.depth_stencil = Some(super::DepthStencilAttachmentKey {
906 base: ds.target.make_attachment_key(ds.depth_ops),
907 stencil_ops: ds.stencil_ops,
908 });
909 fb_key.push_view(ds.target.view.identified_raw_view());
910 }
911
912 let render_area = vk::Rect2D {
913 offset: vk::Offset2D { x: 0, y: 0 },
914 extent: vk::Extent2D {
915 width: desc.extent.width,
916 height: desc.extent.height,
917 },
918 };
919 let vk_viewports = [vk::Viewport {
920 x: 0.0,
921 y: desc.extent.height as f32,
922 width: desc.extent.width as f32,
923 height: -(desc.extent.height as f32),
924 min_depth: 0.0,
925 max_depth: 1.0,
926 }];
927
928 let raw_pass = self.device.make_render_pass(rp_key).unwrap();
929 fb_key.raw_pass = raw_pass;
930 let raw_framebuffer = self.make_framebuffer(fb_key).unwrap();
931
932 let vk_info = vk::RenderPassBeginInfo::default()
933 .render_pass(raw_pass)
934 .render_area(render_area)
935 .clear_values(&vk_clear_values)
936 .framebuffer(raw_framebuffer);
937
938 if let Some(label) = desc.label {
939 unsafe { self.begin_debug_marker(label) };
940 self.rpass_debug_marker_active = true;
941 }
942
943 if let Some(timestamp_writes) = desc.timestamp_writes.as_ref() {
945 if let Some(index) = timestamp_writes.beginning_of_pass_write_index {
946 unsafe {
947 self.write_pass_begin_timestamp(timestamp_writes.query_set, index);
948 }
949 }
950 self.end_of_pass_timer_query = timestamp_writes
951 .end_of_pass_write_index
952 .map(|index| (timestamp_writes.query_set.raw, index));
953 }
954
955 unsafe {
956 self.device
957 .raw
958 .cmd_set_viewport(self.active, 0, &vk_viewports);
959 self.device
960 .raw
961 .cmd_set_scissor(self.active, 0, &[render_area]);
962 self.device.raw.cmd_begin_render_pass(
963 self.active,
964 &vk_info,
965 vk::SubpassContents::INLINE,
966 );
967 };
968
969 self.bind_point = vk::PipelineBindPoint::GRAPHICS;
970
971 Ok(())
972 }
973 unsafe fn end_render_pass(&mut self) {
974 unsafe {
975 self.device.raw.cmd_end_render_pass(self.active);
976 }
977
978 self.write_pass_end_timestamp_if_requested();
980
981 if self.rpass_debug_marker_active {
982 unsafe {
983 self.end_debug_marker();
984 }
985 self.rpass_debug_marker_active = false;
986 }
987 }
988
989 unsafe fn set_bind_group(
990 &mut self,
991 layout: &super::PipelineLayout,
992 index: u32,
993 group: &super::BindGroup,
994 dynamic_offsets: &[wgt::DynamicOffset],
995 ) {
996 let sets = [group.set.raw()];
997 unsafe {
998 self.device.raw.cmd_bind_descriptor_sets(
999 self.active,
1000 self.bind_point,
1001 layout.raw,
1002 index,
1003 &sets,
1004 dynamic_offsets,
1005 )
1006 };
1007 }
1008 unsafe fn set_immediates(
1009 &mut self,
1010 layout: &super::PipelineLayout,
1011 offset_bytes: u32,
1012 data: &[u32],
1013 ) {
1014 unsafe {
1015 self.device.raw.cmd_push_constants(
1016 self.active,
1017 layout.raw,
1018 vk::ShaderStageFlags::ALL,
1019 offset_bytes,
1020 bytemuck::cast_slice(data),
1021 )
1022 };
1023 }
1024
1025 unsafe fn insert_debug_marker(&mut self, label: &str) {
1026 if let Some(ext) = self.device.extension_fns.debug_utils.as_ref() {
1027 let cstr = self.temp.make_c_str(label);
1028 let vk_label = vk::DebugUtilsLabelEXT::default().label_name(cstr);
1029 unsafe { ext.cmd_insert_debug_utils_label(self.active, &vk_label) };
1030 }
1031 }
1032 unsafe fn begin_debug_marker(&mut self, group_label: &str) {
1033 if let Some(ext) = self.device.extension_fns.debug_utils.as_ref() {
1034 let cstr = self.temp.make_c_str(group_label);
1035 let vk_label = vk::DebugUtilsLabelEXT::default().label_name(cstr);
1036 unsafe { ext.cmd_begin_debug_utils_label(self.active, &vk_label) };
1037 }
1038 }
1039 unsafe fn end_debug_marker(&mut self) {
1040 if let Some(ext) = self.device.extension_fns.debug_utils.as_ref() {
1041 unsafe { ext.cmd_end_debug_utils_label(self.active) };
1042 }
1043 }
1044
1045 unsafe fn set_render_pipeline(&mut self, pipeline: &super::RenderPipeline) {
1046 unsafe {
1047 self.current_pipeline_is_multiview = pipeline.is_multiview;
1048 self.device.raw.cmd_bind_pipeline(
1049 self.active,
1050 vk::PipelineBindPoint::GRAPHICS,
1051 pipeline.raw,
1052 )
1053 };
1054 }
1055
1056 unsafe fn set_index_buffer<'a>(
1057 &mut self,
1058 binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferAddress>,
1059 format: wgt::IndexFormat,
1060 ) {
1061 unsafe {
1062 self.device.raw.cmd_bind_index_buffer(
1063 self.active,
1064 binding.buffer.raw,
1065 binding.offset,
1066 conv::map_index_format(format),
1067 )
1068 };
1069 }
1070 unsafe fn set_vertex_buffer<'a>(
1071 &mut self,
1072 index: u32,
1073 binding: crate::BufferBinding<'a, super::Buffer, wgt::BufferAddress>,
1074 ) {
1075 let vk_buffers = [binding.buffer.raw];
1076 let vk_offsets = [binding.offset];
1077 unsafe {
1078 self.device
1079 .raw
1080 .cmd_bind_vertex_buffers(self.active, index, &vk_buffers, &vk_offsets)
1081 };
1082 }
1083 unsafe fn set_viewport(&mut self, rect: &crate::Rect<f32>, depth_range: Range<f32>) {
1084 let vk_viewports = [vk::Viewport {
1085 x: rect.x,
1086 y: rect.y + rect.h,
1087 width: rect.w,
1088 height: -rect.h, min_depth: depth_range.start,
1090 max_depth: depth_range.end,
1091 }];
1092 unsafe {
1093 self.device
1094 .raw
1095 .cmd_set_viewport(self.active, 0, &vk_viewports)
1096 };
1097 }
1098 unsafe fn set_scissor_rect(&mut self, rect: &crate::Rect<u32>) {
1099 let vk_scissors = [vk::Rect2D {
1100 offset: vk::Offset2D {
1101 x: rect.x as i32,
1102 y: rect.y as i32,
1103 },
1104 extent: vk::Extent2D {
1105 width: rect.w,
1106 height: rect.h,
1107 },
1108 }];
1109 unsafe {
1110 self.device
1111 .raw
1112 .cmd_set_scissor(self.active, 0, &vk_scissors)
1113 };
1114 }
1115 unsafe fn set_stencil_reference(&mut self, value: u32) {
1116 unsafe {
1117 self.device.raw.cmd_set_stencil_reference(
1118 self.active,
1119 vk::StencilFaceFlags::FRONT_AND_BACK,
1120 value,
1121 )
1122 };
1123 }
1124 unsafe fn set_blend_constants(&mut self, color: &[f32; 4]) {
1125 unsafe { self.device.raw.cmd_set_blend_constants(self.active, color) };
1126 }
1127
1128 unsafe fn draw(
1129 &mut self,
1130 first_vertex: u32,
1131 vertex_count: u32,
1132 first_instance: u32,
1133 instance_count: u32,
1134 ) {
1135 if self.current_pipeline_is_multiview
1136 && (first_instance as u64 + instance_count as u64 - 1)
1137 > self.device.private_caps.multiview_instance_index_limit as u64
1138 {
1139 panic!("This vulkan device is affected by [#8333](https://github.com/gfx-rs/wgpu/issues/8333)");
1140 }
1141 unsafe {
1142 self.device.raw.cmd_draw(
1143 self.active,
1144 vertex_count,
1145 instance_count,
1146 first_vertex,
1147 first_instance,
1148 )
1149 };
1150 }
1151 unsafe fn draw_indexed(
1152 &mut self,
1153 first_index: u32,
1154 index_count: u32,
1155 base_vertex: i32,
1156 first_instance: u32,
1157 instance_count: u32,
1158 ) {
1159 if self.current_pipeline_is_multiview
1160 && (first_instance as u64 + instance_count as u64 - 1)
1161 > self.device.private_caps.multiview_instance_index_limit as u64
1162 {
1163 panic!("This vulkan device is affected by [#8333](https://github.com/gfx-rs/wgpu/issues/8333)");
1164 }
1165 unsafe {
1166 self.device.raw.cmd_draw_indexed(
1167 self.active,
1168 index_count,
1169 instance_count,
1170 first_index,
1171 base_vertex,
1172 first_instance,
1173 )
1174 };
1175 }
1176 unsafe fn draw_mesh_tasks(
1177 &mut self,
1178 group_count_x: u32,
1179 group_count_y: u32,
1180 group_count_z: u32,
1181 ) {
1182 if let Some(ref t) = self.device.extension_fns.mesh_shading {
1183 unsafe {
1184 t.cmd_draw_mesh_tasks(self.active, group_count_x, group_count_y, group_count_z);
1185 };
1186 } else {
1187 panic!("Feature `MESH_SHADING` not enabled");
1188 }
1189 }
1190 unsafe fn draw_indirect(
1191 &mut self,
1192 buffer: &super::Buffer,
1193 offset: wgt::BufferAddress,
1194 draw_count: u32,
1195 ) {
1196 if draw_count >= 1
1197 && self.device.private_caps.multi_draw_indirect
1198 && draw_count <= self.device.private_caps.max_draw_indirect_count
1199 {
1200 unsafe {
1201 self.device.raw.cmd_draw_indirect(
1202 self.active,
1203 buffer.raw,
1204 offset,
1205 draw_count,
1206 size_of::<wgt::DrawIndirectArgs>() as u32,
1207 )
1208 };
1209 } else {
1210 for i in 0..draw_count {
1211 let indirect_offset = offset
1212 + i as wgt::BufferAddress
1213 * size_of::<wgt::DrawIndirectArgs>() as wgt::BufferAddress;
1214 unsafe {
1215 self.device.raw.cmd_draw_indirect(
1216 self.active,
1217 buffer.raw,
1218 indirect_offset,
1219 1,
1220 size_of::<wgt::DrawIndirectArgs>() as u32,
1221 )
1222 };
1223 }
1224 }
1225 }
1226 unsafe fn draw_indexed_indirect(
1227 &mut self,
1228 buffer: &super::Buffer,
1229 offset: wgt::BufferAddress,
1230 draw_count: u32,
1231 ) {
1232 if draw_count >= 1
1233 && self.device.private_caps.multi_draw_indirect
1234 && draw_count <= self.device.private_caps.max_draw_indirect_count
1235 {
1236 unsafe {
1237 self.device.raw.cmd_draw_indexed_indirect(
1238 self.active,
1239 buffer.raw,
1240 offset,
1241 draw_count,
1242 size_of::<wgt::DrawIndexedIndirectArgs>() as u32,
1243 )
1244 };
1245 } else {
1246 for i in 0..draw_count {
1247 let indirect_offset = offset
1248 + i as wgt::BufferAddress
1249 * size_of::<wgt::DrawIndexedIndirectArgs>() as wgt::BufferAddress;
1250 unsafe {
1251 self.device.raw.cmd_draw_indexed_indirect(
1252 self.active,
1253 buffer.raw,
1254 indirect_offset,
1255 1,
1256 size_of::<wgt::DrawIndexedIndirectArgs>() as u32,
1257 )
1258 };
1259 }
1260 }
1261 }
1262 unsafe fn draw_mesh_tasks_indirect(
1263 &mut self,
1264 buffer: &<Self::A as crate::Api>::Buffer,
1265 offset: wgt::BufferAddress,
1266 draw_count: u32,
1267 ) {
1268 if let Some(ref t) = self.device.extension_fns.mesh_shading {
1269 unsafe {
1270 t.cmd_draw_mesh_tasks_indirect(
1271 self.active,
1272 buffer.raw,
1273 offset,
1274 draw_count,
1275 size_of::<wgt::DispatchIndirectArgs>() as u32,
1276 );
1277 };
1278 } else {
1279 panic!("Feature `MESH_SHADING` not enabled");
1280 }
1281 }
1282 unsafe fn draw_indirect_count(
1283 &mut self,
1284 buffer: &super::Buffer,
1285 offset: wgt::BufferAddress,
1286 count_buffer: &super::Buffer,
1287 count_offset: wgt::BufferAddress,
1288 max_count: u32,
1289 ) {
1290 let stride = size_of::<wgt::DrawIndirectArgs>() as u32;
1291 match self.device.extension_fns.draw_indirect_count {
1292 Some(ref t) => {
1293 unsafe {
1294 t.cmd_draw_indirect_count(
1295 self.active,
1296 buffer.raw,
1297 offset,
1298 count_buffer.raw,
1299 count_offset,
1300 max_count,
1301 stride,
1302 )
1303 };
1304 }
1305 None => panic!("Feature `DRAW_INDIRECT_COUNT` not enabled"),
1306 }
1307 }
1308 unsafe fn draw_indexed_indirect_count(
1309 &mut self,
1310 buffer: &super::Buffer,
1311 offset: wgt::BufferAddress,
1312 count_buffer: &super::Buffer,
1313 count_offset: wgt::BufferAddress,
1314 max_count: u32,
1315 ) {
1316 let stride = size_of::<wgt::DrawIndexedIndirectArgs>() as u32;
1317 match self.device.extension_fns.draw_indirect_count {
1318 Some(ref t) => {
1319 unsafe {
1320 t.cmd_draw_indexed_indirect_count(
1321 self.active,
1322 buffer.raw,
1323 offset,
1324 count_buffer.raw,
1325 count_offset,
1326 max_count,
1327 stride,
1328 )
1329 };
1330 }
1331 None => panic!("Feature `DRAW_INDIRECT_COUNT` not enabled"),
1332 }
1333 }
1334 unsafe fn draw_mesh_tasks_indirect_count(
1335 &mut self,
1336 buffer: &<Self::A as crate::Api>::Buffer,
1337 offset: wgt::BufferAddress,
1338 count_buffer: &super::Buffer,
1339 count_offset: wgt::BufferAddress,
1340 max_count: u32,
1341 ) {
1342 if self.device.extension_fns.draw_indirect_count.is_none() {
1343 panic!("Feature `DRAW_INDIRECT_COUNT` not enabled");
1344 }
1345 if let Some(ref t) = self.device.extension_fns.mesh_shading {
1346 unsafe {
1347 t.cmd_draw_mesh_tasks_indirect_count(
1348 self.active,
1349 buffer.raw,
1350 offset,
1351 count_buffer.raw,
1352 count_offset,
1353 max_count,
1354 size_of::<wgt::DispatchIndirectArgs>() as u32,
1355 );
1356 };
1357 } else {
1358 panic!("Feature `MESH_SHADING` not enabled");
1359 }
1360 }
1361
1362 unsafe fn begin_compute_pass(
1365 &mut self,
1366 desc: &crate::ComputePassDescriptor<'_, super::QuerySet>,
1367 ) {
1368 self.bind_point = vk::PipelineBindPoint::COMPUTE;
1369 if let Some(label) = desc.label {
1370 unsafe { self.begin_debug_marker(label) };
1371 self.rpass_debug_marker_active = true;
1372 }
1373
1374 if let Some(timestamp_writes) = desc.timestamp_writes.as_ref() {
1375 if let Some(index) = timestamp_writes.beginning_of_pass_write_index {
1376 unsafe {
1377 self.write_pass_begin_timestamp(timestamp_writes.query_set, index);
1378 }
1379 }
1380 self.end_of_pass_timer_query = timestamp_writes
1381 .end_of_pass_write_index
1382 .map(|index| (timestamp_writes.query_set.raw, index));
1383 }
1384 }
1385 unsafe fn end_compute_pass(&mut self) {
1386 self.write_pass_end_timestamp_if_requested();
1387
1388 if self.rpass_debug_marker_active {
1389 unsafe { self.end_debug_marker() };
1390 self.rpass_debug_marker_active = false
1391 }
1392 }
1393
1394 unsafe fn set_compute_pipeline(&mut self, pipeline: &super::ComputePipeline) {
1395 unsafe {
1396 self.device.raw.cmd_bind_pipeline(
1397 self.active,
1398 vk::PipelineBindPoint::COMPUTE,
1399 pipeline.raw,
1400 )
1401 };
1402 }
1403
1404 unsafe fn dispatch_workgroups(&mut self, count: [u32; 3]) {
1405 unsafe {
1406 self.device
1407 .raw
1408 .cmd_dispatch(self.active, count[0], count[1], count[2])
1409 };
1410 }
1411 unsafe fn dispatch_workgroups_indirect(
1412 &mut self,
1413 buffer: &super::Buffer,
1414 offset: wgt::BufferAddress,
1415 ) {
1416 unsafe {
1417 self.device
1418 .raw
1419 .cmd_dispatch_indirect(self.active, buffer.raw, offset)
1420 }
1421 }
1422
1423 unsafe fn begin_ray_tracing_pass(&mut self, desc: &crate::RayTracingPassDescriptor<'_>) {
1426 self.bind_point = vk::PipelineBindPoint::RAY_TRACING_KHR;
1427 if let Some(label) = desc.label {
1428 unsafe { self.begin_debug_marker(label) };
1429 self.rpass_debug_marker_active = true;
1430 }
1431 }
1432 unsafe fn end_ray_tracing_pass(&mut self) {
1433 if self.rpass_debug_marker_active {
1434 unsafe { self.end_debug_marker() };
1435 self.rpass_debug_marker_active = false
1436 }
1437 }
1438
1439 unsafe fn trace_rays(
1440 &mut self,
1441 count: [u32; 3],
1442 ray_generation_group_data: crate::PipelineGroupData<super::Buffer>,
1443 miss_group_data: crate::PipelineGroupData<super::Buffer>,
1444 intersection_group_data: crate::PipelineGroupData<super::Buffer>,
1445 ) {
1446 let ray_tracing_functions = self
1447 .device
1448 .extension_fns
1449 .ray_tracing
1450 .as_ref()
1451 .expect("Feature `EXPERIMENTAL_RAY_TRACING` not enabled");
1452
1453 let ray_tracing_pipeline_functions = self
1454 .device
1455 .extension_fns
1456 .ray_tracing_pipelines
1457 .as_ref()
1458 .expect("Feature `EXPERIMENTAL_RAY_TRACING_PIPELINES` not enabled");
1459
1460 let get_device_address = |buffer: &super::Buffer| unsafe {
1461 ray_tracing_functions
1462 .buffer_device_address
1463 .get_buffer_device_address(
1464 &vk::BufferDeviceAddressInfo::default().buffer(buffer.raw),
1465 )
1466 };
1467
1468 unsafe {
1469 ray_tracing_pipeline_functions.cmd_trace_rays(
1470 self.raw_handle(),
1471 &vk::StridedDeviceAddressRegionKHR {
1472 device_address: get_device_address(ray_generation_group_data.buffer)
1473 + ray_generation_group_data.offset,
1474 stride: ray_generation_group_data.stride,
1475 size: ray_generation_group_data.stride ,
1476 },
1477 &vk::StridedDeviceAddressRegionKHR {
1478 device_address: get_device_address(miss_group_data.buffer)
1479 + miss_group_data.offset,
1480 stride: miss_group_data.stride,
1481 size: miss_group_data.stride * miss_group_data.count,
1482 },
1483 &vk::StridedDeviceAddressRegionKHR {
1484 device_address: get_device_address(intersection_group_data.buffer)
1485 + intersection_group_data.offset,
1486 stride: intersection_group_data.stride,
1487 size: intersection_group_data.stride * intersection_group_data.count,
1488 },
1489 &vk::StridedDeviceAddressRegionKHR {
1490 device_address: 0,
1491 stride: 0,
1492 size: 0,
1493 },
1494 count[0],
1495 count[1],
1496 count[2],
1497 )
1498 };
1499 }
1500
1501 unsafe fn set_ray_tracing_pipeline(&mut self, pipeline: &super::RayTracingPipeline) {
1502 unsafe {
1503 self.device.raw.cmd_bind_pipeline(
1504 self.active,
1505 vk::PipelineBindPoint::RAY_TRACING_KHR,
1506 pipeline.raw,
1507 )
1508 };
1509 }
1510
1511 unsafe fn copy_acceleration_structure_to_acceleration_structure(
1512 &mut self,
1513 src: &super::AccelerationStructure,
1514 dst: &super::AccelerationStructure,
1515 copy: wgt::AccelerationStructureCopy,
1516 ) {
1517 let ray_tracing_functions = self
1518 .device
1519 .extension_fns
1520 .ray_tracing
1521 .as_ref()
1522 .expect("Feature `RAY_TRACING` not enabled");
1523
1524 let mode = match copy {
1525 wgt::AccelerationStructureCopy::Clone => vk::CopyAccelerationStructureModeKHR::CLONE,
1526 wgt::AccelerationStructureCopy::Compact => {
1527 vk::CopyAccelerationStructureModeKHR::COMPACT
1528 }
1529 };
1530
1531 unsafe {
1532 ray_tracing_functions
1533 .acceleration_structure
1534 .cmd_copy_acceleration_structure(
1535 self.active,
1536 &vk::CopyAccelerationStructureInfoKHR {
1537 s_type: vk::StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR,
1538 p_next: core::ptr::null(),
1539 src: src.raw,
1540 dst: dst.raw,
1541 mode,
1542 _marker: Default::default(),
1543 },
1544 );
1545 }
1546 }
1547}
1548
1549#[cfg(test)]
1550mod tests {
1551 use super::*;
1552
1553 #[test]
1554 fn check_dst_image_layout() {
1555 assert_eq!(
1556 conv::derive_image_layout(wgt::TextureUses::COPY_DST, wgt::TextureFormat::Rgba8Unorm),
1557 DST_IMAGE_LAYOUT
1558 );
1559 }
1560}