Skip to main content

quick_noise/noise/generators/cellular/
batch_3d.rs

1use simply_simd::{Arch, Simd};
2
3use crate::api::batch::interface::BatchGenerator;
4use crate::noise::generators::Cellular;
5use crate::noise::util::constants::{BYTE_SHUFFLE, CELLULAR_EXP_MASK, HASH_MASK, HASH_PRIME};
6
7impl BatchGenerator<3> for Cellular {
8    #[inline(always)]
9    fn sample_batch<A: Arch>(
10        seed: u32,
11        input: [Simd<f32, A>; 3],
12        freq: [Simd<f32, A>; 3],
13    ) -> Simd<f32, A> {
14        // Constants.
15        let three_halves: Simd<f32, A> = Simd::splat(1.5);
16        let one: Simd<f32, A> = Simd::splat(1.0);
17
18        let hash_mask: Simd<u32, A> = Simd::splat(HASH_MASK);
19        let exp_bits: Simd<u32, A> = Simd::splat(CELLULAR_EXP_MASK);
20
21        // Hash constants.
22        let shuffle_indices = Simd::<u8, A>::from_slice(&BYTE_SHUFFLE[..]);
23        let channel_seed = Simd::splat(seed);
24        let prime = Simd::splat(HASH_PRIME);
25
26        // Scale: 3
27        let x_scaled = input[0] * freq[0];
28        let y_scaled = input[1] * freq[1];
29        let z_scaled = input[2] * freq[2];
30
31        // Gridpoints and distances: 12
32        let x_grid_lo = x_scaled.floor();
33        let y_grid_lo = y_scaled.floor();
34        let z_grid_lo = z_scaled.floor();
35
36        let x_dist_lo = x_scaled - x_grid_lo - three_halves;
37        let y_dist_lo = y_scaled - y_grid_lo - three_halves;
38        let z_dist_lo = z_scaled - z_grid_lo - three_halves;
39        let x_dist_hi = one - x_dist_lo;
40        let y_dist_hi = one - y_dist_lo;
41        let z_dist_hi = one - z_dist_lo;
42
43        // Threshold: 8
44        let close_edge_lo = x_dist_lo.min(y_dist_lo).min(z_dist_lo) + Simd::splat(2.0);
45        let close_edge_hi = x_dist_hi.min(y_dist_hi).min(z_dist_hi) - one;
46        let closest_edge_dist = close_edge_lo.min(close_edge_hi);
47        let threshold = closest_edge_dist * closest_edge_dist;
48
49        // Hash: 37
50        let x1: Simd<u32, A> = x_grid_lo.cast_int_trunc().raw_cast() * channel_seed;
51        let y1: Simd<u32, A> = y_grid_lo.cast_int_trunc().raw_cast() * channel_seed;
52        let z1: Simd<u32, A> = z_grid_lo.cast_int_trunc().raw_cast() * channel_seed;
53        let x2 = x1 + channel_seed;
54        let y2 = y1 + channel_seed;
55        let z2 = z1 + channel_seed;
56
57        let x1_shuf = x1.permute_8(shuffle_indices) ^ prime;
58        let y1_shuf = y1.permute_8(shuffle_indices) ^ prime;
59        let z1_shuf = z1.permute_8(shuffle_indices) ^ prime;
60        let x2_shuf = x2.permute_8(shuffle_indices) ^ prime;
61        let y2_shuf = y2.permute_8(shuffle_indices) ^ prime;
62        let z2_shuf = z2.permute_8(shuffle_indices) ^ prime;
63
64        let hash_tlf = x1_shuf * y1_shuf * z1_shuf;
65        let hash_trf = x1_shuf * y1_shuf * z2_shuf;
66        let hash_blf = x1_shuf * y2_shuf * z1_shuf;
67        let hash_brf = x1_shuf * y2_shuf * z2_shuf;
68        let hash_tlb = x2_shuf * y1_shuf * z1_shuf;
69        let hash_trb = x2_shuf * y1_shuf * z2_shuf;
70        let hash_blb = x2_shuf * y2_shuf * z1_shuf;
71        let hash_brb = x2_shuf * y2_shuf * z2_shuf;
72
73        // Distance Calc: 111
74        let x_dist_tlf = ((hash_tlf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
75        let x_dist_trf = ((hash_trf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
76        let x_dist_blf = ((hash_blf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
77        let x_dist_brf = ((hash_brf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
78        let x_dist_tlb = ((hash_tlb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
79        let x_dist_trb = ((hash_trb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
80        let x_dist_blb = ((hash_blb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
81        let x_dist_brb = ((hash_brb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
82
83        let y_dist_tlf = ((hash_tlf >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
84        let y_dist_trf = ((hash_trf >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
85        let y_dist_blf = ((hash_blf >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
86        let y_dist_brf = ((hash_brf >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
87        let y_dist_tlb = ((hash_tlb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
88        let y_dist_trb = ((hash_trb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
89        let y_dist_blb = ((hash_blb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
90        let y_dist_brb = ((hash_brb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
91
92        let z_dist_tlf = (((hash_tlf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
93        let z_dist_trf = (((hash_trf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
94        let z_dist_blf = (((hash_blf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
95        let z_dist_brf = (((hash_brf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
96        let z_dist_tlb = (((hash_tlb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
97        let z_dist_trb = (((hash_trb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
98        let z_dist_blb = (((hash_blb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
99        let z_dist_brb = (((hash_brb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
100
101        let dist_tlf = x_dist_tlf.mul_add(
102            x_dist_tlf,
103            y_dist_tlf.mul_add(y_dist_tlf, z_dist_tlf * z_dist_tlf),
104        );
105        let dist_trf = x_dist_trf.mul_add(
106            x_dist_trf,
107            y_dist_trf.mul_add(y_dist_trf, z_dist_trf * z_dist_trf),
108        );
109        let dist_blf = x_dist_blf.mul_add(
110            x_dist_blf,
111            y_dist_blf.mul_add(y_dist_blf, z_dist_blf * z_dist_blf),
112        );
113        let dist_brf = x_dist_brf.mul_add(
114            x_dist_brf,
115            y_dist_brf.mul_add(y_dist_brf, z_dist_brf * z_dist_brf),
116        );
117        let dist_tlb = x_dist_tlb.mul_add(
118            x_dist_tlb,
119            y_dist_tlb.mul_add(y_dist_tlb, z_dist_tlb * z_dist_tlb),
120        );
121        let dist_trb = x_dist_trb.mul_add(
122            x_dist_trb,
123            y_dist_trb.mul_add(y_dist_trb, z_dist_trb * z_dist_trb),
124        );
125        let dist_blb = x_dist_blb.mul_add(
126            x_dist_blb,
127            y_dist_blb.mul_add(y_dist_blb, z_dist_blb * z_dist_blb),
128        );
129        let dist_brb = x_dist_brb.mul_add(
130            x_dist_brb,
131            y_dist_brb.mul_add(y_dist_brb, z_dist_brb * z_dist_brb),
132        );
133
134        let mut min_dist = dist_tlf
135            .min(dist_trf)
136            .min(dist_blf)
137            .min(dist_brf)
138            .min(dist_tlb)
139            .min(dist_trb)
140            .min(dist_blb)
141            .min(dist_brb);
142
143        // Branch: 2 + Branch prediction.
144        let is_far = min_dist.simd_gt(threshold);
145
146        if !is_far.all_false() {
147            let x0 = x1 - channel_seed;
148            let y0 = y1 - channel_seed;
149            let z0 = z1 - channel_seed;
150            let x3 = x2 + channel_seed;
151            let y3 = y2 + channel_seed;
152            let z3 = z2 + channel_seed;
153
154            let x0_shuf = x0.permute_8(shuffle_indices) ^ prime;
155            let y0_shuf = y0.permute_8(shuffle_indices) ^ prime;
156            let z0_shuf = z0.permute_8(shuffle_indices) ^ prime;
157            let x3_shuf = x3.permute_8(shuffle_indices) ^ prime;
158            let y3_shuf = y3.permute_8(shuffle_indices) ^ prime;
159            let z3_shuf = z3.permute_8(shuffle_indices) ^ prime;
160
161            let hash_tlff = x0_shuf * y1_shuf * z1_shuf;
162            let hash_ttlf = x1_shuf * y0_shuf * z1_shuf;
163            let hash_tllf = x1_shuf * y1_shuf * z0_shuf;
164            let hash_trff = x0_shuf * y1_shuf * z2_shuf;
165            let hash_ttrf = x1_shuf * y0_shuf * z2_shuf;
166            let hash_trrf = x1_shuf * y1_shuf * z3_shuf;
167            let hash_blff = x0_shuf * y2_shuf * z1_shuf;
168            let hash_bblf = x1_shuf * y3_shuf * z1_shuf;
169            let hash_bllf = x1_shuf * y2_shuf * z0_shuf;
170            let hash_brff = x0_shuf * y2_shuf * z2_shuf;
171            let hash_bbrf = x1_shuf * y3_shuf * z2_shuf;
172            let hash_brrf = x1_shuf * y2_shuf * z3_shuf;
173            let hash_tlbb = x3_shuf * y1_shuf * z1_shuf;
174            let hash_ttlb = x2_shuf * y0_shuf * z1_shuf;
175            let hash_tllb = x2_shuf * y1_shuf * z0_shuf;
176            let hash_trbb = x3_shuf * y1_shuf * z2_shuf;
177            let hash_ttrb = x2_shuf * y0_shuf * z2_shuf;
178            let hash_trrb = x2_shuf * y1_shuf * z3_shuf;
179            let hash_blbb = x3_shuf * y2_shuf * z1_shuf;
180            let hash_bblb = x2_shuf * y3_shuf * z1_shuf;
181            let hash_bllb = x2_shuf * y2_shuf * z0_shuf;
182            let hash_brbb = x3_shuf * y2_shuf * z2_shuf;
183            let hash_bbrb = x2_shuf * y3_shuf * z2_shuf;
184            let hash_brrb = x2_shuf * y2_shuf * z3_shuf;
185
186            let x_dist_tlff =
187                ((hash_tlff & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo + one;
188            let x_dist_ttlf = ((hash_ttlf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
189            let x_dist_tllf = ((hash_tllf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
190            let x_dist_trff =
191                ((hash_trff & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo + one;
192            let x_dist_ttrf = ((hash_ttrf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
193            let x_dist_trrf = ((hash_trrf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
194            let x_dist_blff =
195                ((hash_blff & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo + one;
196            let x_dist_bblf = ((hash_bblf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
197            let x_dist_bllf = ((hash_bllf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
198            let x_dist_brff =
199                ((hash_brff & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo + one;
200            let x_dist_bbrf = ((hash_bbrf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
201            let x_dist_brrf = ((hash_brrf & hash_mask) | exp_bits).raw_cast::<f32>() + x_dist_lo;
202            let x_dist_tlbb =
203                ((hash_tlbb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi - one;
204            let x_dist_ttlb = ((hash_ttlb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
205            let x_dist_tllb = ((hash_tllb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
206            let x_dist_trbb =
207                ((hash_trbb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi - one;
208            let x_dist_ttrb = ((hash_ttrb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
209            let x_dist_trrb = ((hash_trrb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
210            let x_dist_blbb =
211                ((hash_blbb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi - one;
212            let x_dist_bblb = ((hash_bblb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
213            let x_dist_bllb = ((hash_bllb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
214            let x_dist_brbb =
215                ((hash_brbb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi - one;
216            let x_dist_bbrb = ((hash_bbrb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
217            let x_dist_brrb = ((hash_brrb & hash_mask) | exp_bits).raw_cast::<f32>() - x_dist_hi;
218
219            let y_dist_tlff = ((hash_tlff >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
220            let y_dist_ttlf = ((hash_ttlf >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo + one;
221            let y_dist_tllf = ((hash_tllf >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
222            let y_dist_trff = ((hash_trff >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
223            let y_dist_ttrf = ((hash_ttrf >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo + one;
224            let y_dist_trrf = ((hash_trrf >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
225            let y_dist_blff = ((hash_blff >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
226            let y_dist_bblf = ((hash_bblf >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi - one;
227            let y_dist_bllf = ((hash_bllf >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
228            let y_dist_brff = ((hash_brff >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
229            let y_dist_bbrf = ((hash_bbrf >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi - one;
230            let y_dist_brrf = ((hash_brrf >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
231            let y_dist_tlbb = ((hash_tlbb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
232            let y_dist_ttlb = ((hash_ttlb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo + one;
233            let y_dist_tllb = ((hash_tllb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
234            let y_dist_trbb = ((hash_trbb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
235            let y_dist_ttrb = ((hash_ttrb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo + one;
236            let y_dist_trrb = ((hash_trrb >> 9) | exp_bits).raw_cast::<f32>() + y_dist_lo;
237            let y_dist_blbb = ((hash_blbb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
238            let y_dist_bblb = ((hash_bblb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi - one;
239            let y_dist_bllb = ((hash_bllb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
240            let y_dist_brbb = ((hash_brbb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
241            let y_dist_bbrb = ((hash_bbrb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi - one;
242            let y_dist_brrb = ((hash_brrb >> 9) | exp_bits).raw_cast::<f32>() - y_dist_hi;
243
244            let z_dist_tlff =
245                (((hash_tlff << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
246            let z_dist_ttlf =
247                (((hash_ttlf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
248            let z_dist_tllf =
249                (((hash_tllf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo + one;
250            let z_dist_trff =
251                (((hash_trff << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
252            let z_dist_ttrf =
253                (((hash_ttrf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
254            let z_dist_trrf =
255                (((hash_trrf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi - one;
256            let z_dist_blff =
257                (((hash_blff << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
258            let z_dist_bblf =
259                (((hash_bblf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
260            let z_dist_bllf =
261                (((hash_bllf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo + one;
262            let z_dist_brff =
263                (((hash_brff << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
264            let z_dist_bbrf =
265                (((hash_bbrf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
266            let z_dist_brrf =
267                (((hash_brrf << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi - one;
268            let z_dist_tlbb =
269                (((hash_tlbb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
270            let z_dist_ttlb =
271                (((hash_ttlb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
272            let z_dist_tllb =
273                (((hash_tllb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo + one;
274            let z_dist_trbb =
275                (((hash_trbb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
276            let z_dist_ttrb =
277                (((hash_ttrb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
278            let z_dist_trrb =
279                (((hash_trrb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi - one;
280            let z_dist_blbb =
281                (((hash_blbb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
282            let z_dist_bblb =
283                (((hash_bblb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo;
284            let z_dist_bllb =
285                (((hash_bllb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() + z_dist_lo + one;
286            let z_dist_brbb =
287                (((hash_brbb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
288            let z_dist_bbrb =
289                (((hash_bbrb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi;
290            let z_dist_brrb =
291                (((hash_brrb << 12) & hash_mask) | exp_bits).raw_cast::<f32>() - z_dist_hi - one;
292
293            let dist_tlff = x_dist_tlff.mul_add(
294                x_dist_tlff,
295                y_dist_tlff.mul_add(y_dist_tlff, z_dist_tlff * z_dist_tlff),
296            );
297            let dist_ttlf = x_dist_ttlf.mul_add(
298                x_dist_ttlf,
299                y_dist_ttlf.mul_add(y_dist_ttlf, z_dist_ttlf * z_dist_ttlf),
300            );
301            let dist_tllf = x_dist_tllf.mul_add(
302                x_dist_tllf,
303                y_dist_tllf.mul_add(y_dist_tllf, z_dist_tllf * z_dist_tllf),
304            );
305            let dist_trff = x_dist_trff.mul_add(
306                x_dist_trff,
307                y_dist_trff.mul_add(y_dist_trff, z_dist_trff * z_dist_trff),
308            );
309            let dist_ttrf = x_dist_ttrf.mul_add(
310                x_dist_ttrf,
311                y_dist_ttrf.mul_add(y_dist_ttrf, z_dist_ttrf * z_dist_ttrf),
312            );
313            let dist_trrf = x_dist_trrf.mul_add(
314                x_dist_trrf,
315                y_dist_trrf.mul_add(y_dist_trrf, z_dist_trrf * z_dist_trrf),
316            );
317            let dist_blff = x_dist_blff.mul_add(
318                x_dist_blff,
319                y_dist_blff.mul_add(y_dist_blff, z_dist_blff * z_dist_blff),
320            );
321            let dist_bblf = x_dist_bblf.mul_add(
322                x_dist_bblf,
323                y_dist_bblf.mul_add(y_dist_bblf, z_dist_bblf * z_dist_bblf),
324            );
325            let dist_bllf = x_dist_bllf.mul_add(
326                x_dist_bllf,
327                y_dist_bllf.mul_add(y_dist_bllf, z_dist_bllf * z_dist_bllf),
328            );
329            let dist_brff = x_dist_brff.mul_add(
330                x_dist_brff,
331                y_dist_brff.mul_add(y_dist_brff, z_dist_brff * z_dist_brff),
332            );
333            let dist_bbrf = x_dist_bbrf.mul_add(
334                x_dist_bbrf,
335                y_dist_bbrf.mul_add(y_dist_bbrf, z_dist_bbrf * z_dist_bbrf),
336            );
337            let dist_brrf = x_dist_brrf.mul_add(
338                x_dist_brrf,
339                y_dist_brrf.mul_add(y_dist_brrf, z_dist_brrf * z_dist_brrf),
340            );
341            let dist_tlbb = x_dist_tlbb.mul_add(
342                x_dist_tlbb,
343                y_dist_tlbb.mul_add(y_dist_tlbb, z_dist_tlbb * z_dist_tlbb),
344            );
345            let dist_ttlb = x_dist_ttlb.mul_add(
346                x_dist_ttlb,
347                y_dist_ttlb.mul_add(y_dist_ttlb, z_dist_ttlb * z_dist_ttlb),
348            );
349            let dist_tllb = x_dist_tllb.mul_add(
350                x_dist_tllb,
351                y_dist_tllb.mul_add(y_dist_tllb, z_dist_tllb * z_dist_tllb),
352            );
353            let dist_trbb = x_dist_trbb.mul_add(
354                x_dist_trbb,
355                y_dist_trbb.mul_add(y_dist_trbb, z_dist_trbb * z_dist_trbb),
356            );
357            let dist_ttrb = x_dist_ttrb.mul_add(
358                x_dist_ttrb,
359                y_dist_ttrb.mul_add(y_dist_ttrb, z_dist_ttrb * z_dist_ttrb),
360            );
361            let dist_trrb = x_dist_trrb.mul_add(
362                x_dist_trrb,
363                y_dist_trrb.mul_add(y_dist_trrb, z_dist_trrb * z_dist_trrb),
364            );
365            let dist_blbb = x_dist_blbb.mul_add(
366                x_dist_blbb,
367                y_dist_blbb.mul_add(y_dist_blbb, z_dist_blbb * z_dist_blbb),
368            );
369            let dist_bblb = x_dist_bblb.mul_add(
370                x_dist_bblb,
371                y_dist_bblb.mul_add(y_dist_bblb, z_dist_bblb * z_dist_bblb),
372            );
373            let dist_bllb = x_dist_bllb.mul_add(
374                x_dist_bllb,
375                y_dist_bllb.mul_add(y_dist_bllb, z_dist_bllb * z_dist_bllb),
376            );
377            let dist_brbb = x_dist_brbb.mul_add(
378                x_dist_brbb,
379                y_dist_brbb.mul_add(y_dist_brbb, z_dist_brbb * z_dist_brbb),
380            );
381            let dist_bbrb = x_dist_bbrb.mul_add(
382                x_dist_bbrb,
383                y_dist_bbrb.mul_add(y_dist_bbrb, z_dist_bbrb * z_dist_bbrb),
384            );
385            let dist_brrb = x_dist_brrb.mul_add(
386                x_dist_brrb,
387                y_dist_brrb.mul_add(y_dist_brrb, z_dist_brrb * z_dist_brrb),
388            );
389
390            let outer_min = dist_tlff
391                .min(dist_ttlf)
392                .min(dist_tllf)
393                .min(dist_trff)
394                .min(dist_ttrf)
395                .min(dist_trrf)
396                .min(dist_blff)
397                .min(dist_bblf)
398                .min(dist_bllf)
399                .min(dist_brff)
400                .min(dist_bbrf)
401                .min(dist_brrf)
402                .min(dist_tlbb)
403                .min(dist_ttlb)
404                .min(dist_tllb)
405                .min(dist_trbb)
406                .min(dist_ttrb)
407                .min(dist_trrb)
408                .min(dist_blbb)
409                .min(dist_bblb)
410                .min(dist_bllb)
411                .min(dist_brbb)
412                .min(dist_bbrb)
413                .min(dist_brrb);
414
415            min_dist = min_dist.min(outer_min);
416        }
417
418        // Sqrt: 1
419        min_dist.sqrt()
420    }
421}