ash/extensions/khr/
ray_tracing_pipeline.rs

1use crate::prelude::*;
2use crate::vk;
3use crate::RawPtr;
4use crate::{Device, Instance};
5use std::ffi::CStr;
6use std::mem;
7
8#[derive(Clone)]
9pub struct RayTracingPipeline {
10    handle: vk::Device,
11    fp: vk::KhrRayTracingPipelineFn,
12}
13
14impl RayTracingPipeline {
15    pub fn new(instance: &Instance, device: &Device) -> Self {
16        let handle = device.handle();
17        let fp = vk::KhrRayTracingPipelineFn::load(|name| unsafe {
18            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
19        });
20        Self { handle, fp }
21    }
22
23    pub unsafe fn get_properties(
24        instance: &Instance,
25        pdevice: vk::PhysicalDevice,
26    ) -> vk::PhysicalDeviceRayTracingPipelinePropertiesKHR {
27        let mut props_rt = vk::PhysicalDeviceRayTracingPipelinePropertiesKHR::default();
28        {
29            let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt);
30            instance.get_physical_device_properties2(pdevice, &mut props);
31        }
32        props_rt
33    }
34
35    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysKHR.html>
36    pub unsafe fn cmd_trace_rays(
37        &self,
38        command_buffer: vk::CommandBuffer,
39        raygen_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR,
40        miss_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR,
41        hit_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR,
42        callable_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR,
43        width: u32,
44        height: u32,
45        depth: u32,
46    ) {
47        (self.fp.cmd_trace_rays_khr)(
48            command_buffer,
49            raygen_shader_binding_tables,
50            miss_shader_binding_tables,
51            hit_shader_binding_tables,
52            callable_shader_binding_tables,
53            width,
54            height,
55            depth,
56        );
57    }
58
59    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRayTracingPipelinesKHR.html>
60    pub unsafe fn create_ray_tracing_pipelines(
61        &self,
62        deferred_operation: vk::DeferredOperationKHR,
63        pipeline_cache: vk::PipelineCache,
64        create_info: &[vk::RayTracingPipelineCreateInfoKHR],
65        allocation_callbacks: Option<&vk::AllocationCallbacks>,
66    ) -> VkResult<Vec<vk::Pipeline>> {
67        let mut pipelines = vec![mem::zeroed(); create_info.len()];
68        (self.fp.create_ray_tracing_pipelines_khr)(
69            self.handle,
70            deferred_operation,
71            pipeline_cache,
72            create_info.len() as u32,
73            create_info.as_ptr(),
74            allocation_callbacks.as_raw_ptr(),
75            pipelines.as_mut_ptr(),
76        )
77        .result_with_success(pipelines)
78    }
79
80    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupHandlesKHR.html>
81    pub unsafe fn get_ray_tracing_shader_group_handles(
82        &self,
83        pipeline: vk::Pipeline,
84        first_group: u32,
85        group_count: u32,
86        data_size: usize,
87    ) -> VkResult<Vec<u8>> {
88        let mut data = Vec::<u8>::with_capacity(data_size);
89        let err_code = (self.fp.get_ray_tracing_shader_group_handles_khr)(
90            self.handle,
91            pipeline,
92            first_group,
93            group_count,
94            data_size,
95            data.as_mut_ptr() as *mut std::ffi::c_void,
96        );
97        data.set_len(data_size);
98        err_code.result_with_success(data)
99    }
100
101    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html>
102    pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles(
103        &self,
104        pipeline: vk::Pipeline,
105        first_group: u32,
106        group_count: u32,
107        data_size: usize,
108    ) -> VkResult<Vec<u8>> {
109        let mut data: Vec<u8> = Vec::with_capacity(data_size);
110
111        (self
112            .fp
113            .get_ray_tracing_capture_replay_shader_group_handles_khr)(
114            self.handle,
115            pipeline,
116            first_group,
117            group_count,
118            data_size,
119            data.as_mut_ptr() as *mut _,
120        )
121        .result_with_success(data)
122    }
123
124    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysIndirectKHR.html>
125    pub unsafe fn cmd_trace_rays_indirect(
126        &self,
127        command_buffer: vk::CommandBuffer,
128        raygen_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR],
129        miss_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR],
130        hit_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR],
131        callable_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR],
132        indirect_device_address: vk::DeviceAddress,
133    ) {
134        (self.fp.cmd_trace_rays_indirect_khr)(
135            command_buffer,
136            raygen_shader_binding_table.as_ptr(),
137            miss_shader_binding_table.as_ptr(),
138            hit_shader_binding_table.as_ptr(),
139            callable_shader_binding_table.as_ptr(),
140            indirect_device_address,
141        );
142    }
143
144    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html>
145    pub unsafe fn get_ray_tracing_shader_group_stack_size(
146        &self,
147        pipeline: vk::Pipeline,
148        group: u32,
149        group_shader: vk::ShaderGroupShaderKHR,
150    ) -> vk::DeviceSize {
151        (self.fp.get_ray_tracing_shader_group_stack_size_khr)(
152            self.handle,
153            pipeline,
154            group,
155            group_shader,
156        )
157    }
158
159    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html>
160    pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size(
161        &self,
162        command_buffer: vk::CommandBuffer,
163        pipeline_stack_size: u32,
164    ) {
165        (self.fp.cmd_set_ray_tracing_pipeline_stack_size_khr)(command_buffer, pipeline_stack_size);
166    }
167
168    pub const fn name() -> &'static CStr {
169        vk::KhrRayTracingPipelineFn::name()
170    }
171
172    pub fn fp(&self) -> &vk::KhrRayTracingPipelineFn {
173        &self.fp
174    }
175
176    pub fn device(&self) -> vk::Device {
177        self.handle
178    }
179}