1pub 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
23fn 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 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 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 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 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 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 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 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 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 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 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 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 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 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}