Skip to main content

naga/back/spv/ray/
mod.rs

1/*!
2Module for code shared between ray queries and ray tracing pipeline code.
3*/
4
5pub mod hit_object;
6pub mod pipeline;
7pub mod query;
8
9use alloc::{vec, vec::Vec};
10
11use super::{Block, Function, FunctionArgument, Instruction, LookupFunctionType, Writer};
12
13struct ExtractedRayDesc {
14    ray_flags_id: spirv::Word,
15    cull_mask_id: spirv::Word,
16    tmin_id: spirv::Word,
17    tmax_id: spirv::Word,
18    ray_origin_id: spirv::Word,
19    ray_dir_id: spirv::Word,
20    valid_id: Option<spirv::Word>,
21}
22
23/// helper function to check if a particular flag is set in a u32.
24fn write_ray_flags_contains_flags(
25    writer: &mut Writer,
26    block: &mut Block,
27    id: spirv::Word,
28    flag: u32,
29) -> spirv::Word {
30    let bit_id = writer.get_constant_scalar(crate::Literal::U32(flag));
31    let zero_id = writer.get_constant_scalar(crate::Literal::U32(0));
32    let u32_type_id = writer.get_u32_type_id();
33    let bool_ty = writer.get_bool_type_id();
34
35    let and_id = writer.id_gen.next();
36    block.body.push(Instruction::binary(
37        spirv::Op::BitwiseAnd,
38        u32_type_id,
39        and_id,
40        id,
41        bit_id,
42    ));
43
44    let eq_id = writer.id_gen.next();
45    block.body.push(Instruction::binary(
46        spirv::Op::INotEqual,
47        bool_ty,
48        eq_id,
49        and_id,
50        zero_id,
51    ));
52
53    eq_id
54}
55
56impl Writer {
57    fn write_extract_ray_desc(
58        &mut self,
59        block: &mut Block,
60        desc_id: spirv::Word,
61        validate: bool,
62    ) -> ExtractedRayDesc {
63        let bool_type_id = self.get_bool_type_id();
64        let bool_vec3_type_id = self.get_vec3_bool_type_id();
65        let f32_type_id = self.get_f32_type_id();
66        let flag_type_id = self.get_numeric_type_id(super::NumericType::Scalar(crate::Scalar::U32));
67
68        //Note: composite extract indices and types must match `generate_ray_desc_type`
69        let ray_flags_id = self.id_gen.next();
70        block.body.push(Instruction::composite_extract(
71            flag_type_id,
72            ray_flags_id,
73            desc_id,
74            &[0],
75        ));
76        let cull_mask_id = self.id_gen.next();
77        block.body.push(Instruction::composite_extract(
78            flag_type_id,
79            cull_mask_id,
80            desc_id,
81            &[1],
82        ));
83
84        let tmin_id = self.id_gen.next();
85        block.body.push(Instruction::composite_extract(
86            f32_type_id,
87            tmin_id,
88            desc_id,
89            &[2],
90        ));
91        let tmax_id = self.id_gen.next();
92        block.body.push(Instruction::composite_extract(
93            f32_type_id,
94            tmax_id,
95            desc_id,
96            &[3],
97        ));
98
99        let vector_type_id = self.get_numeric_type_id(super::NumericType::Vector {
100            size: crate::VectorSize::Tri,
101            scalar: crate::Scalar::F32,
102        });
103        let ray_origin_id = self.id_gen.next();
104        block.body.push(Instruction::composite_extract(
105            vector_type_id,
106            ray_origin_id,
107            desc_id,
108            &[4],
109        ));
110        let ray_dir_id = self.id_gen.next();
111        block.body.push(Instruction::composite_extract(
112            vector_type_id,
113            ray_dir_id,
114            desc_id,
115            &[5],
116        ));
117
118        let valid_id = validate.then(||{
119            let tmin_le_tmax_id = self.id_gen.next();
120            // Check both that tmin is less than or equal to tmax (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06350)
121            // and implicitly that neither tmin or tmax are NaN (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06351)
122            // because this checks if tmin and tmax are ordered too (i.e: not NaN).
123            block.body.push(Instruction::binary(
124                spirv::Op::FOrdLessThanEqual,
125                bool_type_id,
126                tmin_le_tmax_id,
127                tmin_id,
128                tmax_id,
129            ));
130
131            // Check that tmin is greater than or equal to 0 (and
132            // therefore also tmax is too because it is greater than
133            // or equal to tmin) (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06349).
134            let tmin_ge_zero_id = self.id_gen.next();
135            let zero_id = self.get_constant_scalar(crate::Literal::F32(0.0));
136            block.body.push(Instruction::binary(
137                spirv::Op::FOrdGreaterThanEqual,
138                bool_type_id,
139                tmin_ge_zero_id,
140                tmin_id,
141                zero_id,
142            ));
143
144            // Check that ray origin is finite (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06348)
145            let ray_origin_infinite_id = self.id_gen.next();
146            block.body.push(Instruction::unary(
147                spirv::Op::IsInf,
148                bool_vec3_type_id,
149                ray_origin_infinite_id,
150                ray_origin_id,
151            ));
152            let any_ray_origin_infinite_id = self.id_gen.next();
153            block.body.push(Instruction::unary(
154                spirv::Op::Any,
155                bool_type_id,
156                any_ray_origin_infinite_id,
157                ray_origin_infinite_id,
158            ));
159
160            let ray_origin_nan_id = self.id_gen.next();
161            block.body.push(Instruction::unary(
162                spirv::Op::IsNan,
163                bool_vec3_type_id,
164                ray_origin_nan_id,
165                ray_origin_id,
166            ));
167            let any_ray_origin_nan_id = self.id_gen.next();
168            block.body.push(Instruction::unary(
169                spirv::Op::Any,
170                bool_type_id,
171                any_ray_origin_nan_id,
172                ray_origin_nan_id,
173            ));
174
175            let ray_origin_not_finite_id = self.id_gen.next();
176            block.body.push(Instruction::binary(
177                spirv::Op::LogicalOr,
178                bool_type_id,
179                ray_origin_not_finite_id,
180                any_ray_origin_nan_id,
181                any_ray_origin_infinite_id,
182            ));
183
184            let all_ray_origin_finite_id = self.id_gen.next();
185            block.body.push(Instruction::unary(
186                spirv::Op::LogicalNot,
187                bool_type_id,
188                all_ray_origin_finite_id,
189                ray_origin_not_finite_id,
190            ));
191
192            // Check that ray direction is finite (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06348)
193            let ray_dir_infinite_id = self.id_gen.next();
194            block.body.push(Instruction::unary(
195                spirv::Op::IsInf,
196                bool_vec3_type_id,
197                ray_dir_infinite_id,
198                ray_dir_id,
199            ));
200            let any_ray_dir_infinite_id = self.id_gen.next();
201            block.body.push(Instruction::unary(
202                spirv::Op::Any,
203                bool_type_id,
204                any_ray_dir_infinite_id,
205                ray_dir_infinite_id,
206            ));
207
208            let ray_dir_nan_id = self.id_gen.next();
209            block.body.push(Instruction::unary(
210                spirv::Op::IsNan,
211                bool_vec3_type_id,
212                ray_dir_nan_id,
213                ray_dir_id,
214            ));
215            let any_ray_dir_nan_id = self.id_gen.next();
216            block.body.push(Instruction::unary(
217                spirv::Op::Any,
218                bool_type_id,
219                any_ray_dir_nan_id,
220                ray_dir_nan_id,
221            ));
222
223            let ray_dir_not_finite_id = self.id_gen.next();
224            block.body.push(Instruction::binary(
225                spirv::Op::LogicalOr,
226                bool_type_id,
227                ray_dir_not_finite_id,
228                any_ray_dir_nan_id,
229                any_ray_dir_infinite_id,
230            ));
231
232            let all_ray_dir_finite_id = self.id_gen.next();
233            block.body.push(Instruction::unary(
234                spirv::Op::LogicalNot,
235                bool_type_id,
236                all_ray_dir_finite_id,
237                ray_dir_not_finite_id,
238            ));
239
240            /// Writes spirv to check that less than two booleans are true
241            ///
242            /// For each boolean: removes it, `and`s it with all others (i.e for all possible combinations of two booleans in the list checks to see if both are true).
243            /// Then `or`s all of these checks together. This produces whether two or more booleans are true.
244            fn write_less_than_2_true(
245                writer: &mut Writer,
246                block: &mut Block,
247                mut bools: Vec<spirv::Word>,
248            ) -> spirv::Word {
249                assert!(bools.len() > 1, "Must have multiple booleans!");
250                let bool_ty = writer.get_bool_type_id();
251                let mut each_two_true = Vec::new();
252                while let Some(last_bool) = bools.pop() {
253                    for &bool in &bools {
254                        let both_true_id = writer.write_logical_and(
255                            block,
256                            last_bool,
257                            bool,
258                        );
259                        each_two_true.push(both_true_id);
260                    }
261                }
262                let mut all_or_id = each_two_true.pop().expect("since this must have multiple booleans, there must be at least one thing in `each_two_true`");
263                for two_true in each_two_true {
264                    let new_all_or_id = writer.id_gen.next();
265                    block.body.push(Instruction::binary(
266                        spirv::Op::LogicalOr,
267                        bool_ty,
268                        new_all_or_id,
269                        all_or_id,
270                        two_true,
271                    ));
272                    all_or_id = new_all_or_id;
273                }
274
275                let less_than_two_id = writer.id_gen.next();
276                block.body.push(Instruction::unary(
277                    spirv::Op::LogicalNot,
278                    bool_ty,
279                    less_than_two_id,
280                    all_or_id,
281                ));
282                less_than_two_id
283            }
284
285            // Check that at most one of skip triangles and skip AABBs is
286            // present (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06889)
287            let contains_skip_triangles = write_ray_flags_contains_flags(
288                self,
289                block,
290                ray_flags_id,
291                crate::RayFlag::SKIP_TRIANGLES.bits(),
292            );
293            let contains_skip_aabbs = write_ray_flags_contains_flags(
294                self,
295                block,
296                ray_flags_id,
297                crate::RayFlag::SKIP_AABBS.bits(),
298            );
299
300            let not_contain_skip_triangles_aabbs = write_less_than_2_true(
301                self,
302                block,
303                vec![contains_skip_triangles, contains_skip_aabbs],
304            );
305
306            // Check that at most one of skip triangles (taken from above check),
307            // cull back facing, and cull front face is present (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06890)
308            let contains_cull_back = write_ray_flags_contains_flags(
309                self,
310                block,
311                ray_flags_id,
312                crate::RayFlag::CULL_BACK_FACING.bits(),
313            );
314            let contains_cull_front = write_ray_flags_contains_flags(
315                self,
316                block,
317                ray_flags_id,
318                crate::RayFlag::CULL_FRONT_FACING.bits(),
319            );
320
321            let not_contain_skip_triangles_cull = write_less_than_2_true(
322                self,
323                block,
324                vec![
325                    contains_skip_triangles,
326                    contains_cull_back,
327                    contains_cull_front,
328                ],
329            );
330
331            // Check that at most one of force opaque, force not opaque, cull opaque,
332            // and cull not opaque are present (https://docs.vulkan.org/spec/latest/appendices/spirvenv.html#VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06891)
333            let contains_opaque = write_ray_flags_contains_flags(
334                self,
335                block,
336                ray_flags_id,
337                crate::RayFlag::FORCE_OPAQUE.bits(),
338            );
339            let contains_no_opaque = write_ray_flags_contains_flags(
340                self,
341                block,
342                ray_flags_id,
343                crate::RayFlag::FORCE_NO_OPAQUE.bits(),
344            );
345            let contains_cull_opaque = write_ray_flags_contains_flags(
346                self,
347                block,
348                ray_flags_id,
349                crate::RayFlag::CULL_OPAQUE.bits(),
350            );
351            let contains_cull_no_opaque = write_ray_flags_contains_flags(
352                self,
353                block,
354                ray_flags_id,
355                crate::RayFlag::CULL_NO_OPAQUE.bits(),
356            );
357
358            let not_contain_multiple_opaque = write_less_than_2_true(
359                self,
360                block,
361                vec![
362                    contains_opaque,
363                    contains_no_opaque,
364                    contains_cull_opaque,
365                    contains_cull_no_opaque,
366                ],
367            );
368
369            // Combine all checks into a single flag saying whether the call is valid or not.
370            self.write_reduce_and(
371                block,
372                vec![
373                    tmin_le_tmax_id,
374                    tmin_ge_zero_id,
375                    all_ray_origin_finite_id,
376                    all_ray_dir_finite_id,
377                    not_contain_skip_triangles_aabbs,
378                    not_contain_skip_triangles_cull,
379                    not_contain_multiple_opaque,
380                ],
381            )
382        });
383
384        ExtractedRayDesc {
385            ray_flags_id,
386            cull_mask_id,
387            tmin_id,
388            tmax_id,
389            ray_origin_id,
390            ray_dir_id,
391            valid_id,
392        }
393    }
394    /// writes a logical and of two scalar booleans
395    fn write_logical_and(
396        &mut self,
397        block: &mut Block,
398        one: spirv::Word,
399        two: spirv::Word,
400    ) -> spirv::Word {
401        let id = self.id_gen.next();
402        let bool_id = self.get_bool_type_id();
403        block.body.push(Instruction::binary(
404            spirv::Op::LogicalAnd,
405            bool_id,
406            id,
407            one,
408            two,
409        ));
410        id
411    }
412
413    fn write_reduce_and(&mut self, block: &mut Block, mut bools: Vec<spirv::Word>) -> spirv::Word {
414        // The combined `and`ed together of all of the bools up to this point.
415        let mut current_combined = bools.pop().unwrap();
416        for boolean in bools {
417            current_combined = self.write_logical_and(block, current_combined, boolean)
418        }
419        current_combined
420    }
421
422    // returns the id of the function, the function, and ids for its arguments.
423    fn write_function_signature(
424        &mut self,
425        arg_types: &[spirv::Word],
426        return_ty: spirv::Word,
427    ) -> (spirv::Word, Function, Vec<spirv::Word>) {
428        let func_ty = self.get_function_type(LookupFunctionType {
429            parameter_type_ids: Vec::from(arg_types),
430            return_type_id: return_ty,
431        });
432
433        let mut function = Function::default();
434        let func_id = self.id_gen.next();
435        function.signature = Some(Instruction::function(
436            return_ty,
437            func_id,
438            spirv::FunctionControl::empty(),
439            func_ty,
440        ));
441
442        let mut arg_ids = Vec::with_capacity(arg_types.len());
443
444        for (idx, &arg_ty) in arg_types.iter().enumerate() {
445            let id = self.id_gen.next();
446            let instruction = Instruction::function_parameter(arg_ty, id);
447            function.parameters.push(FunctionArgument {
448                instruction,
449                handle_id: idx as u32,
450            });
451            arg_ids.push(id);
452        }
453        (func_id, function, arg_ids)
454    }
455}