Skip to main content

wgpu_hal/vulkan/
command.rs

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(&copy_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    /// Like `write_timestamp`, but at `TOP_OF_PIPE`. Users may write a timestamp once before some
43    /// work and once after to measure time taken for that work. If `TOP_OF_PIPE` is not used the
44    /// driver is free to reorder the first timestamp to be after the work, defeating the point.
45    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            // Set the name even if it is empty, since there might be a
158            // previous name assigned to the command buffer.
159            unsafe { self.device.set_object_name(raw, label.unwrap_or_default()) };
160        }
161
162        // Reset some state in case the last renderpass was never ended.
163        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            // We don't use VK_KHR_video_encode_queue
181            // VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR
182            super::map_host_device_oom_err(err)
183        }
184        Ok(super::CommandBuffer { raw })
185    }
186
187    unsafe fn discard_encoding(&mut self) {
188        // Safe use requires this is not called in the "closed" state, so the buffer
189        // shouldn't be null. Assert this to make sure we're not pushing null
190        // buffers to the discard pile.
191        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        // Delete framebuffers from the framebuffer cache
206        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        //Note: this is done so that we never end up with empty stage flags
221        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            // Insert a queue family ownership transfer if the caller requested
297            // one (used for textures imported from external memory). When no
298            // transfer is requested, both indices are `QUEUE_FAMILY_IGNORED`,
299            // which the spec treats as "no transfer".
300            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            // This will never be zero, as rounding can only add up to 12 bytes, and the total size is 4096.
358            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        // storage to all the data required for cmd_build_acceleration_structures
614        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        // pointers to all the data required for cmd_build_acceleration_structures
624        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                    // TODO: Code is so large that rustfmt refuses to treat this... :(
636                    )
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                                // IndexType::NONE_KHR is not set by default (due to being provided by VK_KHR_acceleration_structure) but unless there is an
664                                // index buffer we need to have IndexType::NONE_KHR as our index type.
665                                .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    // render
837
838    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        // Start timestamp if any (before all other commands but after debug marker)
944        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        // After all other commands but before debug marker, so this is still seen as part of this pass.
979        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, // flip Y
1089            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    // compute
1363
1364    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    // ray tracing
1424
1425    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 /* no need for multiplying by count, vulkan requires the ray gen sbt to be just one group */,
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}