diff --git a/Cargo.lock b/Cargo.lock index f00ccd0a..18ccd681 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -18,6 +18,12 @@ version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c71b1793ee61086797f5c80b6efa2b8ffa6d5dd703f118545808a7f2e27f7046" +[[package]] +name = "acorn_prng" +version = "3.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4812dd5f835c603721f95a2c057394fc12a9d53206588664e68247e7cb25549b" + [[package]] name = "adler2" version = "2.0.0" @@ -2777,6 +2783,7 @@ checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832" name = "renderling" version = "0.4.9" dependencies = [ + "acorn_prng", "assert_approx_eq", "async-channel 1.9.0", "bytemuck", diff --git a/Cargo.toml b/Cargo.toml index f090c294..0bb1522d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,6 +16,7 @@ exclude = ["./shaders"] resolver = "2" [workspace.dependencies] +acorn_prng = "3.0" assert_approx_eq = "1.1.0" async-channel = "1.8" bytemuck = { version = "1.13.0", features = ["derive"] } diff --git a/blender/shadow_mapping_point.blend b/blender/shadow_mapping_point.blend new file mode 100644 index 00000000..d049937c Binary files /dev/null and b/blender/shadow_mapping_point.blend differ diff --git a/crates/renderling-build/src/lib.rs b/crates/renderling-build/src/lib.rs index 53de687c..d767ffc9 100644 --- a/crates/renderling-build/src/lib.rs +++ b/crates/renderling-build/src/lib.rs @@ -93,7 +93,12 @@ fn wgsl(spv_filepath: impl AsRef, destination: impl AsRef; var local_3: array; var phi_419_: u32; - var phi_2244_: bool; + var phi_2254_: bool; var phi_426_: u32; var phi_427_: u32; var phi_437_: u32; @@ -74,17 +74,17 @@ fn function() { var phi_607_: type_11; var phi_632_: type_11; var phi_649_: u32; - var phi_2274_: bool; + var phi_2284_: bool; var phi_667_: type_11; - var phi_2300_: u32; - var phi_2319_: bool; + var phi_2310_: u32; + var phi_2329_: bool; var phi_717_: type_23; var phi_727_: u32; - var phi_2341_: bool; + var phi_2351_: bool; var phi_735_: f32; var phi_610_: type_20; var phi_788_: bool; - var phi_2361_: bool; + var phi_2371_: bool; var phi_884_: type_24; var local_4: type_20; var phi_887_: type_11; @@ -93,16 +93,16 @@ fn function() { var phi_913_: type_11; var local_5: type_20; var phi_937_: u32; - var phi_2395_: bool; + var phi_2405_: bool; var phi_946_: u32; - var phi_2419_: bool; + var phi_2429_: bool; var phi_995_: type_17; var phi_1005_: u32; - var phi_2444_: bool; + var phi_2454_: bool; var phi_1078_: type_14; var phi_891_: type_14; var phi_1315_: bool; - var phi_2886_: bool; + var phi_2896_: bool; var local_6: type_14; var local_7: type_14; var local_8: type_14; @@ -145,24 +145,24 @@ fn function() { var phi_1473_: bool; var phi_1474_: bool; var phi_1482_: type_14; - var phi_2579_: bool; - var phi_2644_: vec4; - var phi_2674_: vec4; - var phi_2676_: vec4; - var phi_2685_: type_17; - var phi_2686_: type_17; - var phi_2691_: type_17; - var phi_2692_: type_17; - var phi_2693_: bool; - var phi_2697_: type_17; + var phi_2589_: bool; + var phi_2654_: vec4; + var phi_2684_: vec4; + var phi_2686_: vec4; + var phi_2695_: type_17; + var phi_2696_: type_17; + var phi_2701_: type_17; + var phi_2702_: type_17; + var phi_2703_: bool; + var phi_2707_: type_17; var phi_1484_: type_17; var phi_1486_: type_17; var phi_1487_: bool; - var phi_2791_: bool; + var phi_2801_: bool; var phi_1540_: type_17; var phi_1541_: type_17; var local_22: type_20; - var phi_1644_: u32; + var phi_1654_: u32; var local_23: type_14; switch bitcast(0u) { @@ -193,11 +193,11 @@ fn function() { } let _e119 = phi_419_; if (_e66 >= 1u) { - phi_2244_ = (_e119 <= (_e66 - 1u)); + phi_2254_ = (_e119 <= (_e66 - 1u)); } else { - phi_2244_ = false; + phi_2254_ = false; } - let _e124 = phi_2244_; + let _e124 = phi_2254_; if _e124 { let _e127 = global_3.member[_e119]; phi_426_ = _e127; @@ -337,11 +337,11 @@ fn function() { } let _e321 = phi_649_; if (_e66 >= 2u) { - phi_2274_ = (_e321 <= (_e66 - 2u)); + phi_2284_ = (_e321 <= (_e66 - 2u)); } else { - phi_2274_ = false; + phi_2284_ = false; } - let _e326 = phi_2274_; + let _e326 = phi_2284_; if _e326 { let _e329 = global_3.member[_e321]; let _e333 = global_3.member[(_e321 + 1u)]; @@ -351,17 +351,17 @@ fn function() { } let _e336 = phi_667_; if (_e131 >= _e336.member_1) { - phi_2300_ = 4294967295u; + phi_2310_ = 4294967295u; } else { - phi_2300_ = (_e336.member + (9u * _e131)); + phi_2310_ = (_e336.member + (9u * _e131)); } - let _e343 = phi_2300_; + let _e343 = phi_2310_; if (_e66 >= 9u) { - phi_2319_ = (_e343 <= (_e66 - 9u)); + phi_2329_ = (_e343 <= (_e66 - 9u)); } else { - phi_2319_ = false; + phi_2329_ = false; } - let _e348 = phi_2319_; + let _e348 = phi_2329_; if _e348 { let _e351 = global_3.member[_e343]; let _e356 = global_3.member[(_e343 + 1u)]; @@ -384,11 +384,11 @@ fn function() { } let _e402 = phi_727_; if (_e66 >= 1u) { - phi_2341_ = (_e402 <= (_e66 - 1u)); + phi_2351_ = (_e402 <= (_e66 - 1u)); } else { - phi_2341_ = false; + phi_2351_ = false; } - let _e407 = phi_2341_; + let _e407 = phi_2351_; if _e407 { let _e410 = global_3.member[_e402]; phi_735_ = bitcast(_e410); @@ -422,11 +422,11 @@ fn function() { let _e496 = ((_e94 == 4294967295u) != true); if _e496 { if (_e66 >= 4u) { - phi_2361_ = (_e94 <= (_e66 - 4u)); + phi_2371_ = (_e94 <= (_e66 - 4u)); } else { - phi_2361_ = false; + phi_2371_ = false; } - let _e501 = phi_2361_; + let _e501 = phi_2371_; if _e501 { let _e504 = global_3.member[_e94]; let _e508 = global_3.member[(_e94 + 1u)]; @@ -482,7 +482,7 @@ fn function() { let _e550 = (_e543.member_1 < 4u); if _e550 { } else { - phi_2886_ = true; + phi_2896_ = true; break; } let _e552 = local_1[_e543.member_1]; @@ -493,11 +493,11 @@ fn function() { } let _e560 = phi_937_; if (_e66 >= 1u) { - phi_2395_ = (_e560 <= (_e66 - 1u)); + phi_2405_ = (_e560 <= (_e66 - 1u)); } else { - phi_2395_ = false; + phi_2405_ = false; } - let _e565 = phi_2395_; + let _e565 = phi_2405_; if _e565 { let _e568 = global_3.member[_e560]; phi_946_ = _e568; @@ -506,11 +506,11 @@ fn function() { } let _e570 = phi_946_; if (_e66 >= 10u) { - phi_2419_ = (_e570 <= (_e66 - 10u)); + phi_2429_ = (_e570 <= (_e66 - 10u)); } else { - phi_2419_ = false; + phi_2429_ = false; } - let _e575 = phi_2419_; + let _e575 = phi_2429_; if _e575 { let _e578 = global_3.member[_e570]; let _e583 = global_3.member[(_e570 + 1u)]; @@ -534,11 +534,11 @@ fn function() { } let _e639 = phi_1005_; if (_e66 >= 16u) { - phi_2444_ = (_e639 <= (_e66 - 16u)); + phi_2454_ = (_e639 <= (_e66 - 16u)); } else { - phi_2444_ = false; + phi_2454_ = false; } - let _e644 = phi_2444_; + let _e644 = phi_2454_; if _e644 { let _e647 = global_3.member[_e639]; let _e652 = global_3.member[(_e639 + 1u)]; @@ -573,7 +573,7 @@ fn function() { let _e769 = (vec4(fma(_e630.member_1.x, _e740, _e744), fma(_e630.member_1.y, _e740, -(_e743)), (1f - fma(_e630.member_1.x, _e738, (_e630.member_1.y * _e739))), 0f) * _e630.member_2.z); if _e550 { } else { - phi_2886_ = true; + phi_2896_ = true; break; } let _e874 = local[_e543.member_1]; @@ -593,11 +593,11 @@ fn function() { continuing { phi_887_ = _e541; phi_890_ = _e889; - phi_2886_ = false; + phi_2896_ = false; break if !(_e891); } } - let _e894 = phi_2886_; + let _e894 = phi_2896_; if _e894 { break; } @@ -773,19 +773,19 @@ fn function() { let _e1122 = fma(_e1084.member_2.x, _e1084.member_3.y, -((_e1084.member_2.y * _e1084.member_3.x))); let _e1144 = fma(-(_e1084.member.w), fma(_e1084.member_1.z, _e1122, fma(_e1084.member_1.x, _e1113, -((_e1084.member_1.y * _e1119)))), fma(_e1084.member.z, fma(_e1084.member_1.w, _e1122, fma(_e1084.member_1.x, _e1110, -((_e1084.member_1.y * _e1116)))), fma(_e1084.member.x, fma(_e1084.member_1.w, _e1113, fma(_e1084.member_1.y, _e1107, -((_e1084.member_1.z * _e1110)))), -((_e1084.member.y * fma(_e1084.member_1.w, _e1119, fma(_e1084.member_1.x, _e1107, -((_e1084.member_1.z * _e1116))))))))); if (_e1144 == 0f) { - phi_2691_ = type_17(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); - phi_2692_ = type_17(); - phi_2693_ = true; + phi_2701_ = type_17(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); + phi_2702_ = type_17(); + phi_2703_ = true; } else { let _e1153 = (sqrt(fma(_e1084.member.w, _e1084.member.w, fma(_e1084.member.z, _e1084.member.z, fma(_e1084.member.x, _e1084.member.x, (_e1084.member.y * _e1084.member.y))))) * select(-1f, 1f, (_e1144 >= 0f))); let _e1158 = sqrt(fma(_e1084.member_1.w, _e1084.member_1.w, fma(_e1084.member_1.z, _e1084.member_1.z, fma(_e1084.member_1.x, _e1084.member_1.x, (_e1084.member_1.y * _e1084.member_1.y))))); let _e1163 = sqrt(fma(_e1084.member_2.w, _e1084.member_2.w, fma(_e1084.member_2.z, _e1084.member_2.z, fma(_e1084.member_2.x, _e1084.member_2.x, (_e1084.member_2.y * _e1084.member_2.y))))); if (_e1153 != 0f) { - phi_2579_ = select(true, false, (_e1158 != 0f)); + phi_2589_ = select(true, false, (_e1158 != 0f)); } else { - phi_2579_ = true; + phi_2589_ = true; } - let _e1170 = phi_2579_; + let _e1170 = phi_2589_; let _e1171 = select((_e1163 != 0f), false, _e1170); if _e1171 { let _e1172 = (1f / _e1153); @@ -802,51 +802,51 @@ fn function() { if (_e1214 <= 0f) { let _e1230 = (_e1216 - _e1214); let _e1232 = (0.5f / sqrt(_e1230)); - phi_2674_ = vec4((_e1230 * _e1232), (fma(_e1084.member.y, _e1172, _e1177) * _e1232), (fma(_e1084.member.z, _e1172, _e1178) * _e1232), (fma(_e1084.member_1.z, _e1173, -(_e1179)) * _e1232)); + phi_2684_ = vec4((_e1230 * _e1232), (fma(_e1084.member.y, _e1172, _e1177) * _e1232), (fma(_e1084.member.z, _e1172, _e1178) * _e1232), (fma(_e1084.member_1.z, _e1173, -(_e1179)) * _e1232)); } else { let _e1218 = (_e1216 + _e1214); let _e1220 = (0.5f / sqrt(_e1218)); - phi_2674_ = vec4((fma(_e1084.member.y, _e1172, _e1177) * _e1220), (_e1218 * _e1220), (fma(_e1084.member_1.z, _e1173, _e1179) * _e1220), (fma(_e1084.member_2.x, _e1174, -(_e1176)) * _e1220)); + phi_2684_ = vec4((fma(_e1084.member.y, _e1172, _e1177) * _e1220), (_e1218 * _e1220), (fma(_e1084.member_1.z, _e1173, _e1179) * _e1220), (fma(_e1084.member_2.x, _e1174, -(_e1176)) * _e1220)); } - let _e1243 = phi_2674_; - phi_2676_ = _e1243; + let _e1243 = phi_2684_; + phi_2686_ = _e1243; } else { let _e1182 = fma(_e1084.member_1.y, _e1173, _e1175); let _e1183 = fma(_e1084.member_2.z, _e1174, 1f); if (_e1182 <= 0f) { let _e1199 = (_e1183 - _e1182); let _e1201 = (0.5f / sqrt(_e1199)); - phi_2644_ = vec4((fma(_e1084.member.z, _e1172, _e1178) * _e1201), (fma(_e1084.member_1.z, _e1173, _e1179) * _e1201), (_e1199 * _e1201), (fma(_e1084.member.y, _e1172, -(_e1177)) * _e1201)); + phi_2654_ = vec4((fma(_e1084.member.z, _e1172, _e1178) * _e1201), (fma(_e1084.member_1.z, _e1173, _e1179) * _e1201), (_e1199 * _e1201), (fma(_e1084.member.y, _e1172, -(_e1177)) * _e1201)); } else { let _e1185 = (_e1183 + _e1182); let _e1187 = (0.5f / sqrt(_e1185)); - phi_2644_ = vec4((fma(_e1084.member_1.z, _e1173, -(_e1179)) * _e1187), (fma(_e1084.member_2.x, _e1174, -(_e1176)) * _e1187), (fma(_e1084.member.y, _e1172, -(_e1177)) * _e1187), (_e1185 * _e1187)); + phi_2654_ = vec4((fma(_e1084.member_1.z, _e1173, -(_e1179)) * _e1187), (fma(_e1084.member_2.x, _e1174, -(_e1176)) * _e1187), (fma(_e1084.member.y, _e1172, -(_e1177)) * _e1187), (_e1185 * _e1187)); } - let _e1212 = phi_2644_; - phi_2676_ = _e1212; + let _e1212 = phi_2654_; + phi_2686_ = _e1212; } - let _e1245 = phi_2676_; - phi_2685_ = type_17(vec3(_e1153, _e1158, _e1163), _e1245, vec3(_e1084.member_3.x, _e1084.member_3.y, _e1084.member_3.z)); - phi_2686_ = type_17(); + let _e1245 = phi_2686_; + phi_2695_ = type_17(vec3(_e1153, _e1158, _e1163), _e1245, vec3(_e1084.member_3.x, _e1084.member_3.y, _e1084.member_3.z)); + phi_2696_ = type_17(); } else { - phi_2685_ = type_17(); - phi_2686_ = type_17(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); + phi_2695_ = type_17(); + phi_2696_ = type_17(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); } - let _e1249 = phi_2685_; - let _e1251 = phi_2686_; - phi_2691_ = _e1251; - phi_2692_ = _e1249; - phi_2693_ = select(true, false, _e1171); + let _e1249 = phi_2695_; + let _e1251 = phi_2696_; + phi_2701_ = _e1251; + phi_2702_ = _e1249; + phi_2703_ = select(true, false, _e1171); } - let _e1254 = phi_2691_; - let _e1256 = phi_2692_; - let _e1258 = phi_2693_; + let _e1254 = phi_2701_; + let _e1256 = phi_2702_; + let _e1258 = phi_2703_; if _e1258 { - phi_2697_ = _e1254; + phi_2707_ = _e1254; } else { - phi_2697_ = _e1256; + phi_2707_ = _e1256; } - let _e1260 = phi_2697_; + let _e1260 = phi_2707_; phi_1484_ = type_17(_e1260.member_2, _e1260.member_1, _e1260.member); } else { phi_1484_ = type_17(); @@ -862,11 +862,11 @@ fn function() { let _e1271 = phi_1487_; if _e1271 { if (_e66 >= 10u) { - phi_2791_ = (_e90 <= (_e66 - 10u)); + phi_2801_ = (_e90 <= (_e66 - 10u)); } else { - phi_2791_ = false; + phi_2801_ = false; } - let _e1276 = phi_2791_; + let _e1276 = phi_2801_; if _e1276 { let _e1279 = global_3.member[_e90]; let _e1284 = global_3.member[(_e90 + 1u)]; @@ -907,11 +907,11 @@ fn function() { let _e1411 = global_4.member[_e1405]; let _e1415 = global_4.member[(_e1405 + 1u)]; if (_e1408 >= _e1415) { - phi_1644_ = 4294967295u; + phi_1654_ = 4294967295u; } else { - phi_1644_ = (_e1411 + (16u * _e1408)); + phi_1654_ = (_e1411 + (16u * _e1408)); } - let _e1420 = phi_1644_; + let _e1420 = phi_1654_; let _e1423 = global_4.member[_e1420]; let _e1428 = global_4.member[(_e1420 + 1u)]; let _e1433 = global_4.member[(_e1420 + 2u)]; diff --git a/crates/renderling/shaders/stage-renderlet_fragment.spv b/crates/renderling/shaders/stage-renderlet_fragment.spv index 81a5e7e7..37dba492 100644 Binary files a/crates/renderling/shaders/stage-renderlet_fragment.spv and b/crates/renderling/shaders/stage-renderlet_fragment.spv differ diff --git a/crates/renderling/shaders/stage-renderlet_fragment.wgsl b/crates/renderling/shaders/stage-renderlet_fragment.wgsl index 1f97b72a..1dd89a91 100644 --- a/crates/renderling/shaders/stage-renderlet_fragment.wgsl +++ b/crates/renderling/shaders/stage-renderlet_fragment.wgsl @@ -48,7 +48,7 @@ struct type_31 { member_2: vec3, } -struct type_33 { +struct type_35 { member: vec3, member_1: f32, member_2: vec4, @@ -68,24 +68,24 @@ struct type_33 { member_16: f32, } -struct type_34 { +struct type_36 { member: vec3, member_1: vec4, member_2: f32, } -struct type_35 { +struct type_37 { member: i32, member_1: i32, member_2: bool, } -struct type_36 { +struct type_38 { member: u32, member_1: i32, } -struct type_37 { +struct type_39 { member: vec3, member_1: vec3, member_2: f32, @@ -94,7 +94,7 @@ struct type_37 { member_5: f32, } -struct type_38 { +struct type_40 { member: vec3, member_1: vec3, member_2: vec3, @@ -145,1992 +145,2049 @@ var global_19: texture_2d_array; var global_20: vec4; fn function() { - var local: array, 8>; - var local_1: array, 6>; - var phi_690_: u32; - var phi_5168_: bool; - var phi_818_: type_33; - var phi_822_: type_33; - var phi_5205_: bool; - var phi_862_: u32; - var phi_871_: u32; - var phi_884_: type_15; - var phi_5227_: f32; - var phi_5240_: bool; - var phi_938_: f32; - var phi_933_: f32; - var phi_939_: f32; - var phi_5257_: bool; - var phi_904_: f32; - var phi_941_: f32; - var phi_5275_: f32; - var phi_5288_: bool; - var phi_996_: f32; - var phi_991_: f32; - var phi_997_: f32; - var phi_5305_: bool; - var phi_962_: f32; - var phi_999_: f32; - var phi_5341_: bool; - var phi_1082_: u32; - var phi_1091_: u32; - var phi_1104_: type_15; - var phi_5362_: f32; - var phi_5375_: bool; - var phi_1158_: f32; - var phi_1153_: f32; - var phi_1159_: f32; - var phi_5392_: bool; - var phi_1124_: f32; - var phi_1161_: f32; - var phi_5410_: f32; - var phi_5423_: bool; - var phi_1216_: f32; - var phi_1211_: f32; - var phi_1217_: f32; - var phi_5440_: bool; - var phi_1182_: f32; - var phi_1219_: f32; - var phi_5476_: bool; - var phi_1302_: u32; - var phi_1311_: u32; - var phi_1324_: type_15; - var phi_5497_: f32; - var phi_5510_: bool; - var phi_1378_: f32; - var phi_1373_: f32; - var phi_1379_: f32; - var phi_5527_: bool; - var phi_1344_: f32; - var phi_1381_: f32; - var phi_5545_: f32; - var phi_5558_: bool; - var phi_1436_: f32; - var phi_1431_: f32; - var phi_1437_: f32; - var phi_5575_: bool; - var phi_1402_: f32; - var phi_1439_: f32; - var phi_5611_: bool; - var phi_1522_: u32; - var phi_1531_: u32; - var phi_1544_: type_15; - var phi_5632_: f32; - var phi_5645_: bool; - var phi_1598_: f32; - var phi_1593_: f32; - var phi_1599_: f32; - var phi_5662_: bool; - var phi_1564_: f32; - var phi_1601_: f32; - var phi_5680_: f32; - var phi_5693_: bool; - var phi_1656_: f32; - var phi_1651_: f32; - var phi_1657_: f32; - var phi_5710_: bool; - var phi_1622_: f32; - var phi_1659_: f32; - var phi_5746_: bool; - var phi_1742_: u32; - var phi_1751_: u32; - var phi_1764_: type_15; - var phi_5767_: f32; - var phi_5780_: bool; - var phi_1818_: f32; - var phi_1813_: f32; - var phi_1819_: f32; - var phi_5797_: bool; - var phi_1784_: f32; - var phi_1821_: f32; - var phi_5815_: f32; - var phi_5828_: bool; - var phi_1876_: f32; - var phi_1871_: f32; - var phi_1877_: f32; - var phi_5845_: bool; - var phi_1842_: f32; - var phi_1879_: f32; - var phi_5903_: vec3; - var phi_5938_: vec3; - var phi_5973_: vec3; - var phi_6008_: vec3; - var phi_6043_: vec3; - var phi_1973_: vec3; - var phi_1974_: vec3; + var local: array, 21>; + var local_1: array, 8>; + var local_2: array, 6>; + var phi_722_: u32; + var phi_5803_: bool; + var phi_850_: type_35; + var phi_854_: type_35; + var phi_5840_: bool; + var phi_894_: u32; + var phi_903_: u32; + var phi_916_: type_15; + var phi_5862_: f32; + var phi_5875_: bool; + var phi_970_: f32; + var phi_965_: f32; + var phi_971_: f32; + var phi_5892_: bool; + var phi_936_: f32; + var phi_973_: f32; + var phi_5910_: f32; + var phi_5923_: bool; + var phi_1028_: f32; + var phi_1023_: f32; + var phi_1029_: f32; + var phi_5940_: bool; + var phi_994_: f32; + var phi_1031_: f32; + var phi_5976_: bool; + var phi_1114_: u32; + var phi_1123_: u32; + var phi_1136_: type_15; + var phi_5997_: f32; + var phi_6010_: bool; + var phi_1190_: f32; + var phi_1185_: f32; + var phi_1191_: f32; + var phi_6027_: bool; + var phi_1156_: f32; + var phi_1193_: f32; + var phi_6045_: f32; + var phi_6058_: bool; + var phi_1248_: f32; + var phi_1243_: f32; + var phi_1249_: f32; var phi_6075_: bool; - var phi_2181_: type_14; - var phi_2182_: type_14; - var phi_2205_: type_14; - var phi_2232_: bool; - var phi_2238_: type_14; - var phi_2239_: type_14; - var phi_2262_: type_14; - var phi_2285_: bool; - var phi_2306_: type_25; - var phi_6147_: vec3; - var phi_6206_: vec3; - var phi_6280_: vec3; - var phi_6340_: vec3; - var phi_6389_: vec3; - var phi_6438_: vec3; - var phi_6487_: vec3; - var phi_6536_: vec3; - var phi_6585_: vec3; - var phi_6634_: vec3; - var phi_6673_: vec3; - var phi_6708_: vec3; - var phi_7968_: bool; - var phi_2373_: type_14; - var phi_2376_: vec3; - var phi_2374_: type_14; - var phi_2399_: type_14; - var phi_6734_: u32; - var phi_6753_: bool; - var phi_2416_: u32; - var phi_6777_: bool; - var phi_2428_: u32; - var phi_2442_: type_30; - var phi_6809_: bool; - var phi_2492_: type_31; - var phi_6889_: bool; - var phi_3599_: type_37; - var phi_6939_: vec3; - var phi_6974_: vec3; - var phi_3735_: type_38; - var phi_7009_: vec3; - var phi_3947_: u32; - var phi_3956_: u32; - var phi_7118_: bool; - var phi_7121_: bool; - var phi_7122_: bool; - var phi_7941_: bool; - var phi_4135_: type_35; - var phi_4138_: f32; - var phi_4140_: f32; - var phi_4152_: bool; - var phi_4180_: type_36; - var phi_4192_: type_35; - var phi_4136_: type_35; - var phi_4195_: type_36; - var phi_4206_: type_35; - var phi_4209_: f32; - var phi_4211_: f32; - var phi_4223_: bool; - var phi_4251_: type_36; - var phi_4263_: type_35; - var phi_4207_: type_35; - var phi_4266_: type_36; - var phi_7140_: f32; - var phi_7153_: bool; - var phi_4332_: f32; - var phi_4327_: f32; - var phi_4333_: f32; - var phi_7170_: bool; - var phi_4298_: f32; - var phi_4335_: f32; - var phi_7188_: f32; - var phi_7201_: bool; - var phi_4388_: f32; - var phi_4383_: f32; - var phi_4389_: f32; - var phi_7218_: bool; - var phi_4354_: f32; - var phi_4391_: f32; - var phi_4210_: f32; - var phi_4212_: f32; - var phi_4453_: bool; - var phi_7925_: bool; - var phi_8022_: bool; - var phi_4139_: f32; - var phi_4141_: f32; - var phi_4454_: bool; - var phi_8021_: bool; - var local_2: f32; + var phi_1214_: f32; + var phi_1251_: f32; + var phi_6111_: bool; + var phi_1334_: u32; + var phi_1343_: u32; + var phi_1356_: type_15; + var phi_6132_: f32; + var phi_6145_: bool; + var phi_1410_: f32; + var phi_1405_: f32; + var phi_1411_: f32; + var phi_6162_: bool; + var phi_1376_: f32; + var phi_1413_: f32; + var phi_6180_: f32; + var phi_6193_: bool; + var phi_1468_: f32; + var phi_1463_: f32; + var phi_1469_: f32; + var phi_6210_: bool; + var phi_1434_: f32; + var phi_1471_: f32; + var phi_6246_: bool; + var phi_1554_: u32; + var phi_1563_: u32; + var phi_1576_: type_15; + var phi_6267_: f32; + var phi_6280_: bool; + var phi_1630_: f32; + var phi_1625_: f32; + var phi_1631_: f32; + var phi_6297_: bool; + var phi_1596_: f32; + var phi_1633_: f32; + var phi_6315_: f32; + var phi_6328_: bool; + var phi_1688_: f32; + var phi_1683_: f32; + var phi_1689_: f32; + var phi_6345_: bool; + var phi_1654_: f32; + var phi_1691_: f32; + var phi_6381_: bool; + var phi_1774_: u32; + var phi_1783_: u32; + var phi_1796_: type_15; + var phi_6402_: f32; + var phi_6415_: bool; + var phi_1850_: f32; + var phi_1845_: f32; + var phi_1851_: f32; + var phi_6432_: bool; + var phi_1816_: f32; + var phi_1853_: f32; + var phi_6450_: f32; + var phi_6463_: bool; + var phi_1908_: f32; + var phi_1903_: f32; + var phi_1909_: f32; + var phi_6480_: bool; + var phi_1874_: f32; + var phi_1911_: f32; + var phi_6538_: vec3; + var phi_6573_: vec3; + var phi_6608_: vec3; + var phi_6643_: vec3; + var phi_6678_: vec3; + var phi_2005_: vec3; + var phi_2006_: vec3; + var phi_6710_: bool; + var phi_2213_: type_14; + var phi_2214_: type_14; + var phi_2237_: type_14; + var phi_2264_: bool; + var phi_2270_: type_14; + var phi_2271_: type_14; + var phi_2294_: type_14; + var phi_2317_: bool; + var phi_2338_: type_25; + var phi_6782_: vec3; + var phi_6841_: vec3; + var phi_6915_: vec3; + var phi_6975_: vec3; + var phi_7024_: vec3; + var phi_7073_: vec3; + var phi_7122_: vec3; + var phi_7171_: vec3; + var phi_7220_: vec3; + var phi_7269_: vec3; + var phi_7308_: vec3; + var phi_7343_: vec3; + var phi_8882_: bool; + var phi_2405_: type_14; + var phi_2408_: vec3; + var phi_2406_: type_14; + var phi_2431_: type_14; + var phi_7369_: u32; + var phi_7388_: bool; + var phi_2448_: u32; + var phi_7412_: bool; + var phi_2460_: u32; + var phi_2474_: type_30; + var phi_7444_: bool; + var phi_2524_: type_31; + var phi_7524_: bool; + var phi_4104_: type_39; + var phi_7574_: vec3; + var phi_7609_: vec3; + var phi_4240_: type_40; + var phi_7644_: vec3; + var phi_7749_: bool; + var phi_7752_: bool; + var phi_7753_: bool; + var phi_4612_: u32; + var phi_4621_: u32; + var phi_8855_: bool; + var phi_4649_: type_37; + var phi_4652_: f32; + var phi_4654_: f32; + var phi_4666_: bool; + var phi_4694_: type_38; + var phi_4706_: type_37; + var phi_4650_: type_37; + var phi_4709_: type_38; + var phi_4720_: type_37; + var phi_4723_: f32; + var phi_4725_: f32; + var phi_4737_: bool; + var phi_4765_: type_38; + var phi_4777_: type_37; + var phi_4721_: type_37; + var phi_4780_: type_38; + var phi_7775_: f32; + var phi_7788_: bool; + var phi_4846_: f32; + var phi_4841_: f32; + var phi_4847_: f32; + var phi_7805_: bool; + var phi_4812_: f32; + var phi_4849_: f32; + var phi_7823_: f32; + var phi_7836_: bool; + var phi_4902_: f32; + var phi_4897_: f32; + var phi_4903_: f32; + var phi_7853_: bool; + var phi_4868_: f32; + var phi_4905_: f32; + var phi_4964_: f32; + var phi_4724_: f32; + var phi_4726_: f32; + var phi_4966_: bool; + var phi_8839_: bool; + var phi_8936_: bool; + var phi_4653_: f32; + var phi_4655_: f32; + var phi_4967_: bool; + var phi_8935_: bool; var local_3: f32; - var phi_8093_: bool; - var phi_4457_: f32; - var phi_8092_: bool; - var phi_4458_: f32; - var phi_8091_: bool; - var phi_4472_: vec3; - var phi_7255_: bool; - var phi_3346_: type_34; - var phi_7302_: vec3; - var phi_7337_: vec3; - var phi_3536_: vec3; - var phi_7429_: bool; - var phi_2540_: type_34; - var phi_7476_: vec3; - var phi_7511_: vec3; - var phi_2781_: u32; - var phi_2790_: u32; - var phi_7620_: bool; - var phi_7623_: bool; - var phi_7624_: bool; - var phi_8039_: bool; - var phi_2969_: type_35; - var phi_2972_: f32; - var phi_2974_: f32; - var phi_2986_: bool; - var phi_3014_: type_36; - var phi_3026_: type_35; - var phi_2970_: type_35; - var phi_3029_: type_36; - var phi_3040_: type_35; - var phi_3043_: f32; - var phi_3045_: f32; - var phi_3057_: bool; - var phi_3085_: type_36; - var phi_3097_: type_35; - var phi_3041_: type_35; - var phi_3100_: type_36; - var phi_7642_: f32; - var phi_7655_: bool; - var phi_3166_: f32; - var phi_3161_: f32; - var phi_3167_: f32; - var phi_7672_: bool; - var phi_3132_: f32; - var phi_3169_: f32; - var phi_7690_: f32; - var phi_7703_: bool; - var phi_3222_: f32; - var phi_3217_: f32; - var phi_3223_: f32; - var phi_7720_: bool; - var phi_3188_: f32; - var phi_3225_: f32; - var phi_3044_: f32; - var phi_3046_: f32; - var phi_3287_: bool; - var phi_8023_: bool; - var phi_8085_: bool; - var phi_2973_: f32; - var phi_2975_: f32; - var phi_3288_: bool; - var phi_8084_: bool; var local_4: f32; + var phi_9063_: bool; + var phi_4970_: f32; + var phi_9062_: bool; + var phi_4971_: f32; + var phi_9061_: bool; + var phi_4972_: f32; + var phi_4973_: vec3; + var phi_7890_: bool; + var phi_3373_: type_36; + var phi_7937_: vec3; + var phi_7972_: vec3; + var phi_3652_: type_14; + var phi_3655_: f32; + var phi_3653_: type_14; + var phi_3678_: type_14; + var phi_8093_: vec3; + var phi_8127_: vec2; + var phi_8130_: vec2; + var phi_8131_: u32; + var phi_8134_: vec2; + var phi_8135_: u32; + var phi_8136_: bool; + var phi_8161_: vec2; + var phi_8164_: vec2; + var phi_8165_: u32; + var phi_8168_: vec2; + var phi_8169_: u32; + var phi_8170_: bool; + var phi_8191_: vec2; + var phi_8194_: vec2; + var phi_8195_: u32; + var phi_8197_: vec2; + var phi_8198_: u32; + var phi_3715_: u32; + var phi_3816_: u32; + var phi_3847_: u32; + var phi_3856_: u32; + var phi_8228_: f32; + var phi_8241_: bool; + var phi_3916_: f32; + var phi_3911_: f32; + var phi_3917_: f32; + var phi_8258_: bool; + var phi_3882_: f32; + var phi_3919_: f32; + var phi_8276_: f32; + var phi_8289_: bool; + var phi_3974_: f32; + var phi_3969_: f32; + var phi_3975_: f32; + var phi_8306_: bool; + var phi_3940_: f32; + var phi_3977_: f32; + var phi_4036_: f32; + var phi_3656_: f32; + var phi_4037_: bool; + var phi_8937_: bool; var local_5: f32; - var phi_8103_: bool; - var phi_3291_: f32; - var phi_8102_: bool; - var phi_3292_: f32; - var phi_8090_: bool; - var phi_4474_: vec3; - var phi_4475_: bool; - var phi_8087_: bool; - var phi_2377_: vec3; - var phi_4484_: bool; - var phi_8086_: bool; - var local_6: vec3; - var local_7: vec3; + var phi_9065_: bool; + var phi_4039_: f32; + var phi_9064_: bool; + var phi_4040_: f32; + var phi_4041_: vec3; + var phi_8343_: bool; + var phi_2572_: type_36; + var phi_8390_: vec3; + var phi_8425_: vec3; + var phi_8530_: bool; + var phi_8533_: bool; + var phi_8534_: bool; + var phi_2973_: u32; + var phi_2982_: u32; + var phi_9009_: bool; + var phi_3010_: type_37; + var phi_3013_: f32; + var phi_3015_: f32; + var phi_3027_: bool; + var phi_3055_: type_38; + var phi_3067_: type_37; + var phi_3011_: type_37; + var phi_3070_: type_38; + var phi_3081_: type_37; + var phi_3084_: f32; + var phi_3086_: f32; + var phi_3098_: bool; + var phi_3126_: type_38; + var phi_3138_: type_37; + var phi_3082_: type_37; + var phi_3141_: type_38; + var phi_8556_: f32; + var phi_8569_: bool; + var phi_3207_: f32; + var phi_3202_: f32; + var phi_3208_: f32; + var phi_8586_: bool; + var phi_3173_: f32; + var phi_3210_: f32; + var phi_8604_: f32; + var phi_8617_: bool; + var phi_3263_: f32; + var phi_3258_: f32; + var phi_3264_: f32; + var phi_8634_: bool; + var phi_3229_: f32; + var phi_3266_: f32; + var phi_3325_: f32; + var phi_3085_: f32; + var phi_3087_: f32; + var phi_3327_: bool; + var phi_8993_: bool; + var phi_9055_: bool; + var phi_3014_: f32; + var phi_3016_: f32; + var phi_3328_: bool; + var phi_9054_: bool; + var local_6: f32; + var local_7: f32; + var phi_9067_: bool; + var phi_3331_: f32; + var phi_9066_: bool; + var phi_3332_: f32; + var phi_9060_: bool; + var phi_4975_: f32; + var phi_4976_: vec3; + var phi_4977_: bool; + var phi_4997_: vec3; + var phi_9057_: bool; + var phi_2409_: vec3; + var phi_5003_: bool; + var phi_9056_: bool; var local_8: vec3; - var phi_8112_: bool; - var phi_4601_: vec4; - var phi_8104_: bool; - var local_9: f32; - var local_10: f32; + var local_9: vec3; + var local_10: vec3; + var phi_9076_: bool; + var phi_5120_: vec4; + var phi_9068_: bool; var local_11: f32; var local_12: f32; + var local_13: f32; + var local_14: f32; switch bitcast(0u) { default: { - let _e122 = arrayLength((&global.member)); - let _e124 = arrayLength((&global_1.member)); - let _e125 = global_2; - let _e126 = global_3; - let _e127 = global_4; - let _e128 = global_5; - let _e129 = global_6; - let _e130 = global_7; - let _e131 = global_8; - let _e132 = global_9; - let _e136 = global.member[(_e125 + 9u)]; - let _e140 = global.member[(_e125 + 11u)]; - let _e144 = global.member[(_e125 + 17u)]; - let _e147 = global.member[_e144]; - let _e151 = global.member[(_e144 + 1u)]; - let _e155 = global.member[(_e144 + 4u)]; - switch bitcast(_e155) { + let _e146 = arrayLength((&global.member)); + let _e148 = arrayLength((&global_1.member)); + let _e149 = global_2; + let _e150 = global_3; + let _e151 = global_4; + let _e152 = global_5; + let _e153 = global_6; + let _e154 = global_7; + let _e155 = global_8; + let _e156 = global_9; + let _e160 = global.member[(_e149 + 9u)]; + let _e164 = global.member[(_e149 + 11u)]; + let _e168 = global.member[(_e149 + 17u)]; + let _e171 = global.member[_e168]; + let _e175 = global.member[(_e168 + 1u)]; + let _e179 = global.member[(_e168 + 4u)]; + switch bitcast(_e179) { case 0: { - phi_690_ = 0u; + phi_722_ = 0u; break; } case 1: { - phi_690_ = 1u; + phi_722_ = 1u; break; } case 2: { - phi_690_ = 2u; + phi_722_ = 2u; break; } case 3: { - phi_690_ = 3u; + phi_722_ = 3u; break; } case 4: { - phi_690_ = 4u; + phi_722_ = 4u; break; } case 5: { - phi_690_ = 5u; + phi_722_ = 5u; break; } case 6: { - phi_690_ = 6u; + phi_722_ = 6u; break; } case 7: { - phi_690_ = 7u; + phi_722_ = 7u; break; } case 8: { - phi_690_ = 8u; + phi_722_ = 8u; break; } case 9: { - phi_690_ = 9u; + phi_722_ = 9u; break; } case 10: { - phi_690_ = 10u; + phi_722_ = 10u; break; } case 11: { - phi_690_ = 11u; + phi_722_ = 11u; break; } case 12: { - phi_690_ = 12u; + phi_722_ = 12u; break; } case 13: { - phi_690_ = 13u; + phi_722_ = 13u; break; } case 14: { - phi_690_ = 14u; + phi_722_ = 14u; break; } case 15: { - phi_690_ = 15u; + phi_722_ = 15u; break; } case 16: { - phi_690_ = 16u; + phi_722_ = 16u; break; } case 17: { - phi_690_ = 17u; + phi_722_ = 17u; break; } case 18: { - phi_690_ = 18u; + phi_722_ = 18u; break; } case 19: { - phi_690_ = 19u; + phi_722_ = 19u; break; } default: { - phi_690_ = 0u; + phi_722_ = 0u; break; } } - let _e158 = phi_690_; - let _e162 = global.member[(_e144 + 5u)]; - if (_e140 == 4294967295u) { - phi_822_ = type_33(vec3(0f, 0f, 0f), 1f, vec4(1f, 1f, 1f, 1f), 1f, 1f, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 0u, 0u, 0u, 0u, 0u, false, 0f); + let _e182 = phi_722_; + let _e186 = global.member[(_e168 + 5u)]; + if (_e164 == 4294967295u) { + phi_854_ = type_35(vec3(0f, 0f, 0f), 1f, vec4(1f, 1f, 1f, 1f), 1f, 1f, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 0u, 0u, 0u, 0u, 0u, false, 0f); } else { - if (_e122 >= 22u) { - phi_5168_ = (_e140 <= (_e122 - 22u)); + if (_e146 >= 22u) { + phi_5803_ = (_e164 <= (_e146 - 22u)); } else { - phi_5168_ = false; - } - let _e169 = phi_5168_; - if _e169 { - let _e172 = global.member[_e140]; - let _e177 = global.member[(_e140 + 1u)]; - let _e182 = global.member[(_e140 + 2u)]; - let _e188 = global.member[(_e140 + 3u)]; - let _e193 = global.member[(_e140 + 4u)]; - let _e198 = global.member[(_e140 + 5u)]; - let _e203 = global.member[(_e140 + 6u)]; - let _e208 = global.member[(_e140 + 7u)]; - let _e214 = global.member[(_e140 + 8u)]; - let _e219 = global.member[(_e140 + 9u)]; - let _e224 = global.member[(_e140 + 10u)]; - let _e228 = global.member[(_e140 + 11u)]; - let _e232 = global.member[(_e140 + 12u)]; - let _e236 = global.member[(_e140 + 13u)]; - let _e240 = global.member[(_e140 + 14u)]; - let _e244 = global.member[(_e140 + 15u)]; - let _e248 = global.member[(_e140 + 16u)]; - let _e252 = global.member[(_e140 + 17u)]; - let _e256 = global.member[(_e140 + 18u)]; - let _e260 = global.member[(_e140 + 19u)]; - let _e264 = global.member[(_e140 + 20u)]; - let _e269 = global.member[(_e140 + 21u)]; - phi_818_ = type_33(vec3(bitcast(_e172), bitcast(_e177), bitcast(_e182)), bitcast(_e188), vec4(bitcast(_e193), bitcast(_e198), bitcast(_e203), bitcast(_e208)), bitcast(_e214), bitcast(_e219), _e224, _e228, _e232, _e236, _e240, _e244, _e248, _e252, _e256, _e260, (_e264 == 1u), bitcast(_e269)); + phi_5803_ = false; + } + let _e193 = phi_5803_; + if _e193 { + let _e196 = global.member[_e164]; + let _e201 = global.member[(_e164 + 1u)]; + let _e206 = global.member[(_e164 + 2u)]; + let _e212 = global.member[(_e164 + 3u)]; + let _e217 = global.member[(_e164 + 4u)]; + let _e222 = global.member[(_e164 + 5u)]; + let _e227 = global.member[(_e164 + 6u)]; + let _e232 = global.member[(_e164 + 7u)]; + let _e238 = global.member[(_e164 + 8u)]; + let _e243 = global.member[(_e164 + 9u)]; + let _e248 = global.member[(_e164 + 10u)]; + let _e252 = global.member[(_e164 + 11u)]; + let _e256 = global.member[(_e164 + 12u)]; + let _e260 = global.member[(_e164 + 13u)]; + let _e264 = global.member[(_e164 + 14u)]; + let _e268 = global.member[(_e164 + 15u)]; + let _e272 = global.member[(_e164 + 16u)]; + let _e276 = global.member[(_e164 + 17u)]; + let _e280 = global.member[(_e164 + 18u)]; + let _e284 = global.member[(_e164 + 19u)]; + let _e288 = global.member[(_e164 + 20u)]; + let _e293 = global.member[(_e164 + 21u)]; + phi_850_ = type_35(vec3(bitcast(_e196), bitcast(_e201), bitcast(_e206)), bitcast(_e212), vec4(bitcast(_e217), bitcast(_e222), bitcast(_e227), bitcast(_e232)), bitcast(_e238), bitcast(_e243), _e248, _e252, _e256, _e260, _e264, _e268, _e272, _e276, _e280, _e284, (_e288 == 1u), bitcast(_e293)); } else { - phi_818_ = type_33(vec3(0f, 0f, 0f), 1f, vec4(1f, 1f, 1f, 1f), 1f, 1f, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 0u, 0u, 0u, 0u, 0u, true, 0f); + phi_850_ = type_35(vec3(0f, 0f, 0f), 1f, vec4(1f, 1f, 1f, 1f), 1f, 1f, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 4294967295u, 0u, 0u, 0u, 0u, 0u, true, 0f); } - let _e273 = phi_818_; - phi_822_ = type_33(_e273.member, _e273.member_1, _e273.member_2, _e273.member_3, _e273.member_4, _e273.member_5, _e273.member_6, _e273.member_7, _e273.member_8, _e273.member_9, _e273.member_10, _e273.member_11, _e273.member_12, _e273.member_13, _e273.member_14, (_e273.member_15 && (_e162 == 1u)), _e273.member_16); + let _e297 = phi_850_; + phi_854_ = type_35(_e297.member, _e297.member_1, _e297.member_2, _e297.member_3, _e297.member_4, _e297.member_5, _e297.member_6, _e297.member_7, _e297.member_8, _e297.member_9, _e297.member_10, _e297.member_11, _e297.member_12, _e297.member_13, _e297.member_14, (_e297.member_15 && (_e186 == 1u)), _e297.member_16); } - let _e295 = phi_822_; - let _e299 = select(_e128, _e127, vec2((_e295.member_10 == 0u))); - let _e301 = (_e122 >= 8u); - if _e301 { - phi_5205_ = (_e295.member_5 <= (_e122 - 8u)); + let _e319 = phi_854_; + let _e323 = select(_e152, _e151, vec2((_e319.member_10 == 0u))); + let _e325 = (_e146 >= 8u); + if _e325 { + phi_5840_ = (_e319.member_5 <= (_e146 - 8u)); } else { - phi_5205_ = false; + phi_5840_ = false; } - let _e305 = phi_5205_; - if _e305 { - let _e308 = global.member[_e295.member_5]; - let _e312 = global.member[(_e295.member_5 + 1u)]; - let _e317 = global.member[(_e295.member_5 + 2u)]; - let _e321 = global.member[(_e295.member_5 + 3u)]; - let _e326 = global.member[(_e295.member_5 + 4u)]; - let _e330 = global.member[(_e295.member_5 + 5u)]; - let _e334 = global.member[(_e295.member_5 + 6u)]; - switch bitcast(_e334) { + let _e329 = phi_5840_; + if _e329 { + let _e332 = global.member[_e319.member_5]; + let _e336 = global.member[(_e319.member_5 + 1u)]; + let _e341 = global.member[(_e319.member_5 + 2u)]; + let _e345 = global.member[(_e319.member_5 + 3u)]; + let _e350 = global.member[(_e319.member_5 + 4u)]; + let _e354 = global.member[(_e319.member_5 + 5u)]; + let _e358 = global.member[(_e319.member_5 + 6u)]; + switch bitcast(_e358) { case 0: { - phi_862_ = 0u; + phi_894_ = 0u; break; } case 1: { - phi_862_ = 1u; + phi_894_ = 1u; break; } case 2: { - phi_862_ = 2u; + phi_894_ = 2u; break; } default: { - phi_862_ = 0u; + phi_894_ = 0u; break; } } - let _e337 = phi_862_; - let _e341 = global.member[(_e295.member_5 + 7u)]; - switch bitcast(_e341) { + let _e361 = phi_894_; + let _e365 = global.member[(_e319.member_5 + 7u)]; + switch bitcast(_e365) { case 0: { - phi_871_ = 0u; + phi_903_ = 0u; break; } case 1: { - phi_871_ = 1u; + phi_903_ = 1u; break; } case 2: { - phi_871_ = 2u; + phi_903_ = 2u; break; } default: { - phi_871_ = 0u; + phi_903_ = 0u; break; } } - let _e344 = phi_871_; - phi_884_ = type_15(type_14(_e337, _e344), vec2(_e308, _e312), vec2(_e317, _e321), _e326, _e330); + let _e368 = phi_903_; + phi_916_ = type_15(type_14(_e361, _e368), vec2(_e332, _e336), vec2(_e341, _e345), _e350, _e354); } else { - phi_884_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + phi_916_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); } - let _e348 = phi_884_; - switch bitcast(_e348.member.member) { + let _e372 = phi_916_; + switch bitcast(_e372.member.member) { case 1: { - let _e386 = abs(_e299.x); - let _e388 = (_e386 % 1f); - if (_e386 >= 1f) { - phi_5257_ = select(true, false, (_e388 == 0f)); + let _e410 = abs(_e323.x); + let _e412 = (_e410 % 1f); + if (_e410 >= 1f) { + phi_5892_ = select(true, false, (_e412 == 0f)); } else { - phi_5257_ = true; + phi_5892_ = true; } - let _e392 = phi_5257_; - let _e393 = select(1f, _e388, _e392); - if (select(-1f, 1f, (_e299.x >= 0f)) > 0f) { - phi_904_ = _e393; + let _e416 = phi_5892_; + let _e417 = select(1f, _e412, _e416); + if (select(-1f, 1f, (_e323.x >= 0f)) > 0f) { + phi_936_ = _e417; } else { - phi_904_ = (1f - _e393); + phi_936_ = (1f - _e417); } - let _e397 = phi_904_; - phi_941_ = _e397; + let _e421 = phi_936_; + phi_973_ = _e421; break; } case 2: { - let _e360 = abs(_e299.x); - let _e367 = ((select(select(u32(_e360), 0u, (_e360 < 0f)), 4294967295u, (_e360 > 4294967000f)) % 2u) == 0u); - let _e369 = (_e360 % 1f); - if (_e360 >= 1f) { - phi_5240_ = select(true, false, (_e369 == 0f)); + let _e384 = abs(_e323.x); + let _e391 = ((select(select(u32(_e384), 0u, (_e384 < 0f)), 4294967295u, (_e384 > 4294967000f)) % 2u) == 0u); + let _e393 = (_e384 % 1f); + if (_e384 >= 1f) { + phi_5875_ = select(true, false, (_e393 == 0f)); } else { - phi_5240_ = true; + phi_5875_ = true; } - let _e373 = phi_5240_; - let _e374 = select(1f, _e369, _e373); - if (select(-1f, 1f, (_e299.x >= 0f)) > 0f) { - if _e367 { - phi_933_ = _e374; + let _e397 = phi_5875_; + let _e398 = select(1f, _e393, _e397); + if (select(-1f, 1f, (_e323.x >= 0f)) > 0f) { + if _e391 { + phi_965_ = _e398; } else { - phi_933_ = (1f - _e374); + phi_965_ = (1f - _e398); } - let _e381 = phi_933_; - phi_939_ = _e381; + let _e405 = phi_965_; + phi_971_ = _e405; } else { - if _e367 { - phi_938_ = (1f - _e374); + if _e391 { + phi_970_ = (1f - _e398); } else { - phi_938_ = _e374; + phi_970_ = _e398; } - let _e378 = phi_938_; - phi_939_ = _e378; + let _e402 = phi_970_; + phi_971_ = _e402; } - let _e383 = phi_939_; - phi_941_ = _e383; + let _e407 = phi_971_; + phi_973_ = _e407; break; } case 0: { - if (_e299.x > 1f) { - phi_5227_ = 0.9999999f; + if (_e323.x > 1f) { + phi_5862_ = 0.9999999f; } else { - phi_5227_ = select(_e299.x, 0.00000011920929f, (_e299.x < 0f)); + phi_5862_ = select(_e323.x, 0.00000011920929f, (_e323.x < 0f)); } - let _e357 = phi_5227_; - phi_941_ = _e357; + let _e381 = phi_5862_; + phi_973_ = _e381; break; } default: { - phi_941_ = f32(); + phi_973_ = f32(); break; } } - let _e399 = phi_941_; - switch bitcast(_e348.member.member_1) { + let _e423 = phi_973_; + switch bitcast(_e372.member.member_1) { case 1: { - let _e437 = abs(_e299.y); - let _e439 = (_e437 % 1f); - if (_e437 >= 1f) { - phi_5305_ = select(true, false, (_e439 == 0f)); + let _e461 = abs(_e323.y); + let _e463 = (_e461 % 1f); + if (_e461 >= 1f) { + phi_5940_ = select(true, false, (_e463 == 0f)); } else { - phi_5305_ = true; + phi_5940_ = true; } - let _e443 = phi_5305_; - let _e444 = select(1f, _e439, _e443); - if (select(-1f, 1f, (_e299.y >= 0f)) > 0f) { - phi_962_ = _e444; + let _e467 = phi_5940_; + let _e468 = select(1f, _e463, _e467); + if (select(-1f, 1f, (_e323.y >= 0f)) > 0f) { + phi_994_ = _e468; } else { - phi_962_ = (1f - _e444); + phi_994_ = (1f - _e468); } - let _e448 = phi_962_; - phi_999_ = _e448; + let _e472 = phi_994_; + phi_1031_ = _e472; break; } case 2: { - let _e411 = abs(_e299.y); - let _e418 = ((select(select(u32(_e411), 0u, (_e411 < 0f)), 4294967295u, (_e411 > 4294967000f)) % 2u) == 0u); - let _e420 = (_e411 % 1f); - if (_e411 >= 1f) { - phi_5288_ = select(true, false, (_e420 == 0f)); + let _e435 = abs(_e323.y); + let _e442 = ((select(select(u32(_e435), 0u, (_e435 < 0f)), 4294967295u, (_e435 > 4294967000f)) % 2u) == 0u); + let _e444 = (_e435 % 1f); + if (_e435 >= 1f) { + phi_5923_ = select(true, false, (_e444 == 0f)); } else { - phi_5288_ = true; + phi_5923_ = true; } - let _e424 = phi_5288_; - let _e425 = select(1f, _e420, _e424); - if (select(-1f, 1f, (_e299.y >= 0f)) > 0f) { - if _e418 { - phi_991_ = _e425; + let _e448 = phi_5923_; + let _e449 = select(1f, _e444, _e448); + if (select(-1f, 1f, (_e323.y >= 0f)) > 0f) { + if _e442 { + phi_1023_ = _e449; } else { - phi_991_ = (1f - _e425); + phi_1023_ = (1f - _e449); } - let _e432 = phi_991_; - phi_997_ = _e432; + let _e456 = phi_1023_; + phi_1029_ = _e456; } else { - if _e418 { - phi_996_ = (1f - _e425); + if _e442 { + phi_1028_ = (1f - _e449); } else { - phi_996_ = _e425; + phi_1028_ = _e449; } - let _e429 = phi_996_; - phi_997_ = _e429; + let _e453 = phi_1028_; + phi_1029_ = _e453; } - let _e434 = phi_997_; - phi_999_ = _e434; + let _e458 = phi_1029_; + phi_1031_ = _e458; break; } case 0: { - if (_e299.y > 1f) { - phi_5275_ = 0.9999999f; + if (_e323.y > 1f) { + phi_5910_ = 0.9999999f; } else { - phi_5275_ = select(_e299.y, 0.00000011920929f, (_e299.y < 0f)); + phi_5910_ = select(_e323.y, 0.00000011920929f, (_e323.y < 0f)); } - let _e408 = phi_5275_; - phi_999_ = _e408; + let _e432 = phi_5910_; + phi_1031_ = _e432; break; } default: { - phi_999_ = f32(); + phi_1031_ = f32(); break; } } - let _e450 = phi_999_; - let _e454 = (_e399 * f32(_e348.member_2.x)); - let _e463 = (_e450 * f32(_e348.member_2.y)); - let _e475 = f32(_e147); - let _e476 = f32(_e151); - let _e483 = vec3((f32((select(select(u32(_e454), 0u, (_e454 < 0f)), 4294967295u, (_e454 > 4294967000f)) + _e348.member_1.x)) / _e475), (f32((select(select(u32(_e463), 0u, (_e463 < 0f)), 4294967295u, (_e463 > 4294967000f)) + _e348.member_1.y)) / _e476), f32(_e348.member_3)); - let _e489 = textureSampleLevel(global_11, global_10, vec2(_e483.x, _e483.y), i32(_e483.z), 0f); - let _e492 = select(_e489, vec4(1f, 1f, 1f, 1f), vec4((_e295.member_5 == 4294967295u))); - let _e496 = select(_e128, _e127, vec2((_e295.member_11 == 0u))); - if _e301 { - phi_5341_ = (_e295.member_6 <= (_e122 - 8u)); + let _e474 = phi_1031_; + let _e478 = (_e423 * f32(_e372.member_2.x)); + let _e487 = (_e474 * f32(_e372.member_2.y)); + let _e499 = f32(_e171); + let _e500 = f32(_e175); + let _e507 = vec3((f32((select(select(u32(_e478), 0u, (_e478 < 0f)), 4294967295u, (_e478 > 4294967000f)) + _e372.member_1.x)) / _e499), (f32((select(select(u32(_e487), 0u, (_e487 < 0f)), 4294967295u, (_e487 > 4294967000f)) + _e372.member_1.y)) / _e500), f32(_e372.member_3)); + let _e513 = textureSampleLevel(global_11, global_10, vec2(_e507.x, _e507.y), i32(_e507.z), 0f); + let _e516 = select(_e513, vec4(1f, 1f, 1f, 1f), vec4((_e319.member_5 == 4294967295u))); + let _e520 = select(_e152, _e151, vec2((_e319.member_11 == 0u))); + if _e325 { + phi_5976_ = (_e319.member_6 <= (_e146 - 8u)); } else { - phi_5341_ = false; + phi_5976_ = false; } - let _e501 = phi_5341_; - if _e501 { - let _e504 = global.member[_e295.member_6]; - let _e508 = global.member[(_e295.member_6 + 1u)]; - let _e513 = global.member[(_e295.member_6 + 2u)]; - let _e517 = global.member[(_e295.member_6 + 3u)]; - let _e522 = global.member[(_e295.member_6 + 4u)]; - let _e526 = global.member[(_e295.member_6 + 5u)]; - let _e530 = global.member[(_e295.member_6 + 6u)]; - switch bitcast(_e530) { + let _e525 = phi_5976_; + if _e525 { + let _e528 = global.member[_e319.member_6]; + let _e532 = global.member[(_e319.member_6 + 1u)]; + let _e537 = global.member[(_e319.member_6 + 2u)]; + let _e541 = global.member[(_e319.member_6 + 3u)]; + let _e546 = global.member[(_e319.member_6 + 4u)]; + let _e550 = global.member[(_e319.member_6 + 5u)]; + let _e554 = global.member[(_e319.member_6 + 6u)]; + switch bitcast(_e554) { case 0: { - phi_1082_ = 0u; + phi_1114_ = 0u; break; } case 1: { - phi_1082_ = 1u; + phi_1114_ = 1u; break; } case 2: { - phi_1082_ = 2u; + phi_1114_ = 2u; break; } default: { - phi_1082_ = 0u; + phi_1114_ = 0u; break; } } - let _e533 = phi_1082_; - let _e537 = global.member[(_e295.member_6 + 7u)]; - switch bitcast(_e537) { + let _e557 = phi_1114_; + let _e561 = global.member[(_e319.member_6 + 7u)]; + switch bitcast(_e561) { case 0: { - phi_1091_ = 0u; + phi_1123_ = 0u; break; } case 1: { - phi_1091_ = 1u; + phi_1123_ = 1u; break; } case 2: { - phi_1091_ = 2u; + phi_1123_ = 2u; break; } default: { - phi_1091_ = 0u; + phi_1123_ = 0u; break; } } - let _e540 = phi_1091_; - phi_1104_ = type_15(type_14(_e533, _e540), vec2(_e504, _e508), vec2(_e513, _e517), _e522, _e526); + let _e564 = phi_1123_; + phi_1136_ = type_15(type_14(_e557, _e564), vec2(_e528, _e532), vec2(_e537, _e541), _e546, _e550); } else { - phi_1104_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + phi_1136_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); } - let _e544 = phi_1104_; - switch bitcast(_e544.member.member) { + let _e568 = phi_1136_; + switch bitcast(_e568.member.member) { case 1: { - let _e582 = abs(_e496.x); - let _e584 = (_e582 % 1f); - if (_e582 >= 1f) { - phi_5392_ = select(true, false, (_e584 == 0f)); + let _e606 = abs(_e520.x); + let _e608 = (_e606 % 1f); + if (_e606 >= 1f) { + phi_6027_ = select(true, false, (_e608 == 0f)); } else { - phi_5392_ = true; + phi_6027_ = true; } - let _e588 = phi_5392_; - let _e589 = select(1f, _e584, _e588); - if (select(-1f, 1f, (_e496.x >= 0f)) > 0f) { - phi_1124_ = _e589; + let _e612 = phi_6027_; + let _e613 = select(1f, _e608, _e612); + if (select(-1f, 1f, (_e520.x >= 0f)) > 0f) { + phi_1156_ = _e613; } else { - phi_1124_ = (1f - _e589); + phi_1156_ = (1f - _e613); } - let _e593 = phi_1124_; - phi_1161_ = _e593; + let _e617 = phi_1156_; + phi_1193_ = _e617; break; } case 2: { - let _e556 = abs(_e496.x); - let _e563 = ((select(select(u32(_e556), 0u, (_e556 < 0f)), 4294967295u, (_e556 > 4294967000f)) % 2u) == 0u); - let _e565 = (_e556 % 1f); - if (_e556 >= 1f) { - phi_5375_ = select(true, false, (_e565 == 0f)); + let _e580 = abs(_e520.x); + let _e587 = ((select(select(u32(_e580), 0u, (_e580 < 0f)), 4294967295u, (_e580 > 4294967000f)) % 2u) == 0u); + let _e589 = (_e580 % 1f); + if (_e580 >= 1f) { + phi_6010_ = select(true, false, (_e589 == 0f)); } else { - phi_5375_ = true; + phi_6010_ = true; } - let _e569 = phi_5375_; - let _e570 = select(1f, _e565, _e569); - if (select(-1f, 1f, (_e496.x >= 0f)) > 0f) { - if _e563 { - phi_1153_ = _e570; + let _e593 = phi_6010_; + let _e594 = select(1f, _e589, _e593); + if (select(-1f, 1f, (_e520.x >= 0f)) > 0f) { + if _e587 { + phi_1185_ = _e594; } else { - phi_1153_ = (1f - _e570); + phi_1185_ = (1f - _e594); } - let _e577 = phi_1153_; - phi_1159_ = _e577; + let _e601 = phi_1185_; + phi_1191_ = _e601; } else { - if _e563 { - phi_1158_ = (1f - _e570); + if _e587 { + phi_1190_ = (1f - _e594); } else { - phi_1158_ = _e570; + phi_1190_ = _e594; } - let _e574 = phi_1158_; - phi_1159_ = _e574; + let _e598 = phi_1190_; + phi_1191_ = _e598; } - let _e579 = phi_1159_; - phi_1161_ = _e579; + let _e603 = phi_1191_; + phi_1193_ = _e603; break; } case 0: { - if (_e496.x > 1f) { - phi_5362_ = 0.9999999f; + if (_e520.x > 1f) { + phi_5997_ = 0.9999999f; } else { - phi_5362_ = select(_e496.x, 0.00000011920929f, (_e496.x < 0f)); + phi_5997_ = select(_e520.x, 0.00000011920929f, (_e520.x < 0f)); } - let _e553 = phi_5362_; - phi_1161_ = _e553; + let _e577 = phi_5997_; + phi_1193_ = _e577; break; } default: { - phi_1161_ = f32(); + phi_1193_ = f32(); break; } } - let _e595 = phi_1161_; - switch bitcast(_e544.member.member_1) { + let _e619 = phi_1193_; + switch bitcast(_e568.member.member_1) { case 1: { - let _e633 = abs(_e496.y); - let _e635 = (_e633 % 1f); - if (_e633 >= 1f) { - phi_5440_ = select(true, false, (_e635 == 0f)); + let _e657 = abs(_e520.y); + let _e659 = (_e657 % 1f); + if (_e657 >= 1f) { + phi_6075_ = select(true, false, (_e659 == 0f)); } else { - phi_5440_ = true; + phi_6075_ = true; } - let _e639 = phi_5440_; - let _e640 = select(1f, _e635, _e639); - if (select(-1f, 1f, (_e496.y >= 0f)) > 0f) { - phi_1182_ = _e640; + let _e663 = phi_6075_; + let _e664 = select(1f, _e659, _e663); + if (select(-1f, 1f, (_e520.y >= 0f)) > 0f) { + phi_1214_ = _e664; } else { - phi_1182_ = (1f - _e640); + phi_1214_ = (1f - _e664); } - let _e644 = phi_1182_; - phi_1219_ = _e644; + let _e668 = phi_1214_; + phi_1251_ = _e668; break; } case 2: { - let _e607 = abs(_e496.y); - let _e614 = ((select(select(u32(_e607), 0u, (_e607 < 0f)), 4294967295u, (_e607 > 4294967000f)) % 2u) == 0u); - let _e616 = (_e607 % 1f); - if (_e607 >= 1f) { - phi_5423_ = select(true, false, (_e616 == 0f)); + let _e631 = abs(_e520.y); + let _e638 = ((select(select(u32(_e631), 0u, (_e631 < 0f)), 4294967295u, (_e631 > 4294967000f)) % 2u) == 0u); + let _e640 = (_e631 % 1f); + if (_e631 >= 1f) { + phi_6058_ = select(true, false, (_e640 == 0f)); } else { - phi_5423_ = true; + phi_6058_ = true; } - let _e620 = phi_5423_; - let _e621 = select(1f, _e616, _e620); - if (select(-1f, 1f, (_e496.y >= 0f)) > 0f) { - if _e614 { - phi_1211_ = _e621; + let _e644 = phi_6058_; + let _e645 = select(1f, _e640, _e644); + if (select(-1f, 1f, (_e520.y >= 0f)) > 0f) { + if _e638 { + phi_1243_ = _e645; } else { - phi_1211_ = (1f - _e621); + phi_1243_ = (1f - _e645); } - let _e628 = phi_1211_; - phi_1217_ = _e628; + let _e652 = phi_1243_; + phi_1249_ = _e652; } else { - if _e614 { - phi_1216_ = (1f - _e621); + if _e638 { + phi_1248_ = (1f - _e645); } else { - phi_1216_ = _e621; + phi_1248_ = _e645; } - let _e625 = phi_1216_; - phi_1217_ = _e625; + let _e649 = phi_1248_; + phi_1249_ = _e649; } - let _e630 = phi_1217_; - phi_1219_ = _e630; + let _e654 = phi_1249_; + phi_1251_ = _e654; break; } case 0: { - if (_e496.y > 1f) { - phi_5410_ = 0.9999999f; + if (_e520.y > 1f) { + phi_6045_ = 0.9999999f; } else { - phi_5410_ = select(_e496.y, 0.00000011920929f, (_e496.y < 0f)); + phi_6045_ = select(_e520.y, 0.00000011920929f, (_e520.y < 0f)); } - let _e604 = phi_5410_; - phi_1219_ = _e604; + let _e628 = phi_6045_; + phi_1251_ = _e628; break; } default: { - phi_1219_ = f32(); + phi_1251_ = f32(); break; } } - let _e646 = phi_1219_; - let _e650 = (_e595 * f32(_e544.member_2.x)); - let _e659 = (_e646 * f32(_e544.member_2.y)); - let _e677 = vec3((f32((select(select(u32(_e650), 0u, (_e650 < 0f)), 4294967295u, (_e650 > 4294967000f)) + _e544.member_1.x)) / _e475), (f32((select(select(u32(_e659), 0u, (_e659 < 0f)), 4294967295u, (_e659 > 4294967000f)) + _e544.member_1.y)) / _e476), f32(_e544.member_3)); - let _e683 = textureSampleLevel(global_11, global_10, vec2(_e677.x, _e677.y), i32(_e677.z), 0f); - let _e686 = select(_e683, vec4(1f, 1f, 1f, 1f), vec4((_e295.member_6 == 4294967295u))); - let _e690 = select(_e128, _e127, vec2((_e295.member_12 == 0u))); - if _e301 { - phi_5476_ = (_e295.member_7 <= (_e122 - 8u)); + let _e670 = phi_1251_; + let _e674 = (_e619 * f32(_e568.member_2.x)); + let _e683 = (_e670 * f32(_e568.member_2.y)); + let _e701 = vec3((f32((select(select(u32(_e674), 0u, (_e674 < 0f)), 4294967295u, (_e674 > 4294967000f)) + _e568.member_1.x)) / _e499), (f32((select(select(u32(_e683), 0u, (_e683 < 0f)), 4294967295u, (_e683 > 4294967000f)) + _e568.member_1.y)) / _e500), f32(_e568.member_3)); + let _e707 = textureSampleLevel(global_11, global_10, vec2(_e701.x, _e701.y), i32(_e701.z), 0f); + let _e710 = select(_e707, vec4(1f, 1f, 1f, 1f), vec4((_e319.member_6 == 4294967295u))); + let _e714 = select(_e152, _e151, vec2((_e319.member_12 == 0u))); + if _e325 { + phi_6111_ = (_e319.member_7 <= (_e146 - 8u)); } else { - phi_5476_ = false; + phi_6111_ = false; } - let _e695 = phi_5476_; - if _e695 { - let _e698 = global.member[_e295.member_7]; - let _e702 = global.member[(_e295.member_7 + 1u)]; - let _e707 = global.member[(_e295.member_7 + 2u)]; - let _e711 = global.member[(_e295.member_7 + 3u)]; - let _e716 = global.member[(_e295.member_7 + 4u)]; - let _e720 = global.member[(_e295.member_7 + 5u)]; - let _e724 = global.member[(_e295.member_7 + 6u)]; - switch bitcast(_e724) { + let _e719 = phi_6111_; + if _e719 { + let _e722 = global.member[_e319.member_7]; + let _e726 = global.member[(_e319.member_7 + 1u)]; + let _e731 = global.member[(_e319.member_7 + 2u)]; + let _e735 = global.member[(_e319.member_7 + 3u)]; + let _e740 = global.member[(_e319.member_7 + 4u)]; + let _e744 = global.member[(_e319.member_7 + 5u)]; + let _e748 = global.member[(_e319.member_7 + 6u)]; + switch bitcast(_e748) { case 0: { - phi_1302_ = 0u; + phi_1334_ = 0u; break; } case 1: { - phi_1302_ = 1u; + phi_1334_ = 1u; break; } case 2: { - phi_1302_ = 2u; + phi_1334_ = 2u; break; } default: { - phi_1302_ = 0u; + phi_1334_ = 0u; break; } } - let _e727 = phi_1302_; - let _e731 = global.member[(_e295.member_7 + 7u)]; - switch bitcast(_e731) { + let _e751 = phi_1334_; + let _e755 = global.member[(_e319.member_7 + 7u)]; + switch bitcast(_e755) { case 0: { - phi_1311_ = 0u; + phi_1343_ = 0u; break; } case 1: { - phi_1311_ = 1u; + phi_1343_ = 1u; break; } case 2: { - phi_1311_ = 2u; + phi_1343_ = 2u; break; } default: { - phi_1311_ = 0u; + phi_1343_ = 0u; break; } } - let _e734 = phi_1311_; - phi_1324_ = type_15(type_14(_e727, _e734), vec2(_e698, _e702), vec2(_e707, _e711), _e716, _e720); + let _e758 = phi_1343_; + phi_1356_ = type_15(type_14(_e751, _e758), vec2(_e722, _e726), vec2(_e731, _e735), _e740, _e744); } else { - phi_1324_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + phi_1356_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); } - let _e738 = phi_1324_; - switch bitcast(_e738.member.member) { + let _e762 = phi_1356_; + switch bitcast(_e762.member.member) { case 1: { - let _e776 = abs(_e690.x); - let _e778 = (_e776 % 1f); - if (_e776 >= 1f) { - phi_5527_ = select(true, false, (_e778 == 0f)); + let _e800 = abs(_e714.x); + let _e802 = (_e800 % 1f); + if (_e800 >= 1f) { + phi_6162_ = select(true, false, (_e802 == 0f)); } else { - phi_5527_ = true; + phi_6162_ = true; } - let _e782 = phi_5527_; - let _e783 = select(1f, _e778, _e782); - if (select(-1f, 1f, (_e690.x >= 0f)) > 0f) { - phi_1344_ = _e783; + let _e806 = phi_6162_; + let _e807 = select(1f, _e802, _e806); + if (select(-1f, 1f, (_e714.x >= 0f)) > 0f) { + phi_1376_ = _e807; } else { - phi_1344_ = (1f - _e783); + phi_1376_ = (1f - _e807); } - let _e787 = phi_1344_; - phi_1381_ = _e787; + let _e811 = phi_1376_; + phi_1413_ = _e811; break; } case 2: { - let _e750 = abs(_e690.x); - let _e757 = ((select(select(u32(_e750), 0u, (_e750 < 0f)), 4294967295u, (_e750 > 4294967000f)) % 2u) == 0u); - let _e759 = (_e750 % 1f); - if (_e750 >= 1f) { - phi_5510_ = select(true, false, (_e759 == 0f)); + let _e774 = abs(_e714.x); + let _e781 = ((select(select(u32(_e774), 0u, (_e774 < 0f)), 4294967295u, (_e774 > 4294967000f)) % 2u) == 0u); + let _e783 = (_e774 % 1f); + if (_e774 >= 1f) { + phi_6145_ = select(true, false, (_e783 == 0f)); } else { - phi_5510_ = true; + phi_6145_ = true; } - let _e763 = phi_5510_; - let _e764 = select(1f, _e759, _e763); - if (select(-1f, 1f, (_e690.x >= 0f)) > 0f) { - if _e757 { - phi_1373_ = _e764; + let _e787 = phi_6145_; + let _e788 = select(1f, _e783, _e787); + if (select(-1f, 1f, (_e714.x >= 0f)) > 0f) { + if _e781 { + phi_1405_ = _e788; } else { - phi_1373_ = (1f - _e764); + phi_1405_ = (1f - _e788); } - let _e771 = phi_1373_; - phi_1379_ = _e771; + let _e795 = phi_1405_; + phi_1411_ = _e795; } else { - if _e757 { - phi_1378_ = (1f - _e764); + if _e781 { + phi_1410_ = (1f - _e788); } else { - phi_1378_ = _e764; + phi_1410_ = _e788; } - let _e768 = phi_1378_; - phi_1379_ = _e768; + let _e792 = phi_1410_; + phi_1411_ = _e792; } - let _e773 = phi_1379_; - phi_1381_ = _e773; + let _e797 = phi_1411_; + phi_1413_ = _e797; break; } case 0: { - if (_e690.x > 1f) { - phi_5497_ = 0.9999999f; + if (_e714.x > 1f) { + phi_6132_ = 0.9999999f; } else { - phi_5497_ = select(_e690.x, 0.00000011920929f, (_e690.x < 0f)); + phi_6132_ = select(_e714.x, 0.00000011920929f, (_e714.x < 0f)); } - let _e747 = phi_5497_; - phi_1381_ = _e747; + let _e771 = phi_6132_; + phi_1413_ = _e771; break; } default: { - phi_1381_ = f32(); + phi_1413_ = f32(); break; } } - let _e789 = phi_1381_; - switch bitcast(_e738.member.member_1) { + let _e813 = phi_1413_; + switch bitcast(_e762.member.member_1) { case 1: { - let _e827 = abs(_e690.y); - let _e829 = (_e827 % 1f); - if (_e827 >= 1f) { - phi_5575_ = select(true, false, (_e829 == 0f)); + let _e851 = abs(_e714.y); + let _e853 = (_e851 % 1f); + if (_e851 >= 1f) { + phi_6210_ = select(true, false, (_e853 == 0f)); } else { - phi_5575_ = true; + phi_6210_ = true; } - let _e833 = phi_5575_; - let _e834 = select(1f, _e829, _e833); - if (select(-1f, 1f, (_e690.y >= 0f)) > 0f) { - phi_1402_ = _e834; + let _e857 = phi_6210_; + let _e858 = select(1f, _e853, _e857); + if (select(-1f, 1f, (_e714.y >= 0f)) > 0f) { + phi_1434_ = _e858; } else { - phi_1402_ = (1f - _e834); + phi_1434_ = (1f - _e858); } - let _e838 = phi_1402_; - phi_1439_ = _e838; + let _e862 = phi_1434_; + phi_1471_ = _e862; break; } case 2: { - let _e801 = abs(_e690.y); - let _e808 = ((select(select(u32(_e801), 0u, (_e801 < 0f)), 4294967295u, (_e801 > 4294967000f)) % 2u) == 0u); - let _e810 = (_e801 % 1f); - if (_e801 >= 1f) { - phi_5558_ = select(true, false, (_e810 == 0f)); + let _e825 = abs(_e714.y); + let _e832 = ((select(select(u32(_e825), 0u, (_e825 < 0f)), 4294967295u, (_e825 > 4294967000f)) % 2u) == 0u); + let _e834 = (_e825 % 1f); + if (_e825 >= 1f) { + phi_6193_ = select(true, false, (_e834 == 0f)); } else { - phi_5558_ = true; + phi_6193_ = true; } - let _e814 = phi_5558_; - let _e815 = select(1f, _e810, _e814); - if (select(-1f, 1f, (_e690.y >= 0f)) > 0f) { - if _e808 { - phi_1431_ = _e815; + let _e838 = phi_6193_; + let _e839 = select(1f, _e834, _e838); + if (select(-1f, 1f, (_e714.y >= 0f)) > 0f) { + if _e832 { + phi_1463_ = _e839; } else { - phi_1431_ = (1f - _e815); + phi_1463_ = (1f - _e839); } - let _e822 = phi_1431_; - phi_1437_ = _e822; + let _e846 = phi_1463_; + phi_1469_ = _e846; } else { - if _e808 { - phi_1436_ = (1f - _e815); + if _e832 { + phi_1468_ = (1f - _e839); } else { - phi_1436_ = _e815; + phi_1468_ = _e839; } - let _e819 = phi_1436_; - phi_1437_ = _e819; + let _e843 = phi_1468_; + phi_1469_ = _e843; } - let _e824 = phi_1437_; - phi_1439_ = _e824; + let _e848 = phi_1469_; + phi_1471_ = _e848; break; } case 0: { - if (_e690.y > 1f) { - phi_5545_ = 0.9999999f; + if (_e714.y > 1f) { + phi_6180_ = 0.9999999f; } else { - phi_5545_ = select(_e690.y, 0.00000011920929f, (_e690.y < 0f)); + phi_6180_ = select(_e714.y, 0.00000011920929f, (_e714.y < 0f)); } - let _e798 = phi_5545_; - phi_1439_ = _e798; + let _e822 = phi_6180_; + phi_1471_ = _e822; break; } default: { - phi_1439_ = f32(); + phi_1471_ = f32(); break; } } - let _e840 = phi_1439_; - let _e844 = (_e789 * f32(_e738.member_2.x)); - let _e853 = (_e840 * f32(_e738.member_2.y)); - let _e871 = vec3((f32((select(select(u32(_e844), 0u, (_e844 < 0f)), 4294967295u, (_e844 > 4294967000f)) + _e738.member_1.x)) / _e475), (f32((select(select(u32(_e853), 0u, (_e853 < 0f)), 4294967295u, (_e853 > 4294967000f)) + _e738.member_1.y)) / _e476), f32(_e738.member_3)); - let _e877 = textureSampleLevel(global_11, global_10, vec2(_e871.x, _e871.y), i32(_e871.z), 0f); - let _e878 = (_e295.member_7 == 4294967295u); - let _e880 = select(_e877, vec4(1f, 1f, 1f, 1f), vec4(_e878)); - let _e884 = select(_e128, _e127, vec2((_e295.member_13 == 0u))); - if _e301 { - phi_5611_ = (_e295.member_8 <= (_e122 - 8u)); + let _e864 = phi_1471_; + let _e868 = (_e813 * f32(_e762.member_2.x)); + let _e877 = (_e864 * f32(_e762.member_2.y)); + let _e895 = vec3((f32((select(select(u32(_e868), 0u, (_e868 < 0f)), 4294967295u, (_e868 > 4294967000f)) + _e762.member_1.x)) / _e499), (f32((select(select(u32(_e877), 0u, (_e877 < 0f)), 4294967295u, (_e877 > 4294967000f)) + _e762.member_1.y)) / _e500), f32(_e762.member_3)); + let _e901 = textureSampleLevel(global_11, global_10, vec2(_e895.x, _e895.y), i32(_e895.z), 0f); + let _e902 = (_e319.member_7 == 4294967295u); + let _e904 = select(_e901, vec4(1f, 1f, 1f, 1f), vec4(_e902)); + let _e908 = select(_e152, _e151, vec2((_e319.member_13 == 0u))); + if _e325 { + phi_6246_ = (_e319.member_8 <= (_e146 - 8u)); } else { - phi_5611_ = false; + phi_6246_ = false; } - let _e889 = phi_5611_; - if _e889 { - let _e892 = global.member[_e295.member_8]; - let _e896 = global.member[(_e295.member_8 + 1u)]; - let _e901 = global.member[(_e295.member_8 + 2u)]; - let _e905 = global.member[(_e295.member_8 + 3u)]; - let _e910 = global.member[(_e295.member_8 + 4u)]; - let _e914 = global.member[(_e295.member_8 + 5u)]; - let _e918 = global.member[(_e295.member_8 + 6u)]; - switch bitcast(_e918) { + let _e913 = phi_6246_; + if _e913 { + let _e916 = global.member[_e319.member_8]; + let _e920 = global.member[(_e319.member_8 + 1u)]; + let _e925 = global.member[(_e319.member_8 + 2u)]; + let _e929 = global.member[(_e319.member_8 + 3u)]; + let _e934 = global.member[(_e319.member_8 + 4u)]; + let _e938 = global.member[(_e319.member_8 + 5u)]; + let _e942 = global.member[(_e319.member_8 + 6u)]; + switch bitcast(_e942) { case 0: { - phi_1522_ = 0u; + phi_1554_ = 0u; break; } case 1: { - phi_1522_ = 1u; + phi_1554_ = 1u; break; } case 2: { - phi_1522_ = 2u; + phi_1554_ = 2u; break; } default: { - phi_1522_ = 0u; + phi_1554_ = 0u; break; } } - let _e921 = phi_1522_; - let _e925 = global.member[(_e295.member_8 + 7u)]; - switch bitcast(_e925) { + let _e945 = phi_1554_; + let _e949 = global.member[(_e319.member_8 + 7u)]; + switch bitcast(_e949) { case 0: { - phi_1531_ = 0u; + phi_1563_ = 0u; break; } case 1: { - phi_1531_ = 1u; + phi_1563_ = 1u; break; } case 2: { - phi_1531_ = 2u; + phi_1563_ = 2u; break; } default: { - phi_1531_ = 0u; + phi_1563_ = 0u; break; } } - let _e928 = phi_1531_; - phi_1544_ = type_15(type_14(_e921, _e928), vec2(_e892, _e896), vec2(_e901, _e905), _e910, _e914); + let _e952 = phi_1563_; + phi_1576_ = type_15(type_14(_e945, _e952), vec2(_e916, _e920), vec2(_e925, _e929), _e934, _e938); } else { - phi_1544_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + phi_1576_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); } - let _e932 = phi_1544_; - switch bitcast(_e932.member.member) { + let _e956 = phi_1576_; + switch bitcast(_e956.member.member) { case 1: { - let _e970 = abs(_e884.x); - let _e972 = (_e970 % 1f); - if (_e970 >= 1f) { - phi_5662_ = select(true, false, (_e972 == 0f)); + let _e994 = abs(_e908.x); + let _e996 = (_e994 % 1f); + if (_e994 >= 1f) { + phi_6297_ = select(true, false, (_e996 == 0f)); } else { - phi_5662_ = true; + phi_6297_ = true; } - let _e976 = phi_5662_; - let _e977 = select(1f, _e972, _e976); - if (select(-1f, 1f, (_e884.x >= 0f)) > 0f) { - phi_1564_ = _e977; + let _e1000 = phi_6297_; + let _e1001 = select(1f, _e996, _e1000); + if (select(-1f, 1f, (_e908.x >= 0f)) > 0f) { + phi_1596_ = _e1001; } else { - phi_1564_ = (1f - _e977); + phi_1596_ = (1f - _e1001); } - let _e981 = phi_1564_; - phi_1601_ = _e981; + let _e1005 = phi_1596_; + phi_1633_ = _e1005; break; } case 2: { - let _e944 = abs(_e884.x); - let _e951 = ((select(select(u32(_e944), 0u, (_e944 < 0f)), 4294967295u, (_e944 > 4294967000f)) % 2u) == 0u); - let _e953 = (_e944 % 1f); - if (_e944 >= 1f) { - phi_5645_ = select(true, false, (_e953 == 0f)); + let _e968 = abs(_e908.x); + let _e975 = ((select(select(u32(_e968), 0u, (_e968 < 0f)), 4294967295u, (_e968 > 4294967000f)) % 2u) == 0u); + let _e977 = (_e968 % 1f); + if (_e968 >= 1f) { + phi_6280_ = select(true, false, (_e977 == 0f)); } else { - phi_5645_ = true; + phi_6280_ = true; } - let _e957 = phi_5645_; - let _e958 = select(1f, _e953, _e957); - if (select(-1f, 1f, (_e884.x >= 0f)) > 0f) { - if _e951 { - phi_1593_ = _e958; + let _e981 = phi_6280_; + let _e982 = select(1f, _e977, _e981); + if (select(-1f, 1f, (_e908.x >= 0f)) > 0f) { + if _e975 { + phi_1625_ = _e982; } else { - phi_1593_ = (1f - _e958); + phi_1625_ = (1f - _e982); } - let _e965 = phi_1593_; - phi_1599_ = _e965; + let _e989 = phi_1625_; + phi_1631_ = _e989; } else { - if _e951 { - phi_1598_ = (1f - _e958); + if _e975 { + phi_1630_ = (1f - _e982); } else { - phi_1598_ = _e958; + phi_1630_ = _e982; } - let _e962 = phi_1598_; - phi_1599_ = _e962; + let _e986 = phi_1630_; + phi_1631_ = _e986; } - let _e967 = phi_1599_; - phi_1601_ = _e967; + let _e991 = phi_1631_; + phi_1633_ = _e991; break; } case 0: { - if (_e884.x > 1f) { - phi_5632_ = 0.9999999f; + if (_e908.x > 1f) { + phi_6267_ = 0.9999999f; } else { - phi_5632_ = select(_e884.x, 0.00000011920929f, (_e884.x < 0f)); + phi_6267_ = select(_e908.x, 0.00000011920929f, (_e908.x < 0f)); } - let _e941 = phi_5632_; - phi_1601_ = _e941; + let _e965 = phi_6267_; + phi_1633_ = _e965; break; } default: { - phi_1601_ = f32(); + phi_1633_ = f32(); break; } } - let _e983 = phi_1601_; - switch bitcast(_e932.member.member_1) { + let _e1007 = phi_1633_; + switch bitcast(_e956.member.member_1) { case 1: { - let _e1021 = abs(_e884.y); - let _e1023 = (_e1021 % 1f); - if (_e1021 >= 1f) { - phi_5710_ = select(true, false, (_e1023 == 0f)); + let _e1045 = abs(_e908.y); + let _e1047 = (_e1045 % 1f); + if (_e1045 >= 1f) { + phi_6345_ = select(true, false, (_e1047 == 0f)); } else { - phi_5710_ = true; + phi_6345_ = true; } - let _e1027 = phi_5710_; - let _e1028 = select(1f, _e1023, _e1027); - if (select(-1f, 1f, (_e884.y >= 0f)) > 0f) { - phi_1622_ = _e1028; + let _e1051 = phi_6345_; + let _e1052 = select(1f, _e1047, _e1051); + if (select(-1f, 1f, (_e908.y >= 0f)) > 0f) { + phi_1654_ = _e1052; } else { - phi_1622_ = (1f - _e1028); + phi_1654_ = (1f - _e1052); } - let _e1032 = phi_1622_; - phi_1659_ = _e1032; + let _e1056 = phi_1654_; + phi_1691_ = _e1056; break; } case 2: { - let _e995 = abs(_e884.y); - let _e1002 = ((select(select(u32(_e995), 0u, (_e995 < 0f)), 4294967295u, (_e995 > 4294967000f)) % 2u) == 0u); - let _e1004 = (_e995 % 1f); - if (_e995 >= 1f) { - phi_5693_ = select(true, false, (_e1004 == 0f)); + let _e1019 = abs(_e908.y); + let _e1026 = ((select(select(u32(_e1019), 0u, (_e1019 < 0f)), 4294967295u, (_e1019 > 4294967000f)) % 2u) == 0u); + let _e1028 = (_e1019 % 1f); + if (_e1019 >= 1f) { + phi_6328_ = select(true, false, (_e1028 == 0f)); } else { - phi_5693_ = true; + phi_6328_ = true; } - let _e1008 = phi_5693_; - let _e1009 = select(1f, _e1004, _e1008); - if (select(-1f, 1f, (_e884.y >= 0f)) > 0f) { - if _e1002 { - phi_1651_ = _e1009; + let _e1032 = phi_6328_; + let _e1033 = select(1f, _e1028, _e1032); + if (select(-1f, 1f, (_e908.y >= 0f)) > 0f) { + if _e1026 { + phi_1683_ = _e1033; } else { - phi_1651_ = (1f - _e1009); + phi_1683_ = (1f - _e1033); } - let _e1016 = phi_1651_; - phi_1657_ = _e1016; + let _e1040 = phi_1683_; + phi_1689_ = _e1040; } else { - if _e1002 { - phi_1656_ = (1f - _e1009); + if _e1026 { + phi_1688_ = (1f - _e1033); } else { - phi_1656_ = _e1009; + phi_1688_ = _e1033; } - let _e1013 = phi_1656_; - phi_1657_ = _e1013; + let _e1037 = phi_1688_; + phi_1689_ = _e1037; } - let _e1018 = phi_1657_; - phi_1659_ = _e1018; + let _e1042 = phi_1689_; + phi_1691_ = _e1042; break; } case 0: { - if (_e884.y > 1f) { - phi_5680_ = 0.9999999f; + if (_e908.y > 1f) { + phi_6315_ = 0.9999999f; } else { - phi_5680_ = select(_e884.y, 0.00000011920929f, (_e884.y < 0f)); + phi_6315_ = select(_e908.y, 0.00000011920929f, (_e908.y < 0f)); } - let _e992 = phi_5680_; - phi_1659_ = _e992; + let _e1016 = phi_6315_; + phi_1691_ = _e1016; break; } default: { - phi_1659_ = f32(); + phi_1691_ = f32(); break; } } - let _e1034 = phi_1659_; - let _e1038 = (_e983 * f32(_e932.member_2.x)); - let _e1047 = (_e1034 * f32(_e932.member_2.y)); - let _e1065 = vec3((f32((select(select(u32(_e1038), 0u, (_e1038 < 0f)), 4294967295u, (_e1038 > 4294967000f)) + _e932.member_1.x)) / _e475), (f32((select(select(u32(_e1047), 0u, (_e1047 < 0f)), 4294967295u, (_e1047 > 4294967000f)) + _e932.member_1.y)) / _e476), f32(_e932.member_3)); - let _e1071 = textureSampleLevel(global_11, global_10, vec2(_e1065.x, _e1065.y), i32(_e1065.z), 0f); - let _e1078 = select(_e128, _e127, vec2((_e295.member_14 == 0u))); - if _e301 { - phi_5746_ = (_e295.member_9 <= (_e122 - 8u)); + let _e1058 = phi_1691_; + let _e1062 = (_e1007 * f32(_e956.member_2.x)); + let _e1071 = (_e1058 * f32(_e956.member_2.y)); + let _e1089 = vec3((f32((select(select(u32(_e1062), 0u, (_e1062 < 0f)), 4294967295u, (_e1062 > 4294967000f)) + _e956.member_1.x)) / _e499), (f32((select(select(u32(_e1071), 0u, (_e1071 < 0f)), 4294967295u, (_e1071 > 4294967000f)) + _e956.member_1.y)) / _e500), f32(_e956.member_3)); + let _e1095 = textureSampleLevel(global_11, global_10, vec2(_e1089.x, _e1089.y), i32(_e1089.z), 0f); + let _e1102 = select(_e152, _e151, vec2((_e319.member_14 == 0u))); + if _e325 { + phi_6381_ = (_e319.member_9 <= (_e146 - 8u)); } else { - phi_5746_ = false; + phi_6381_ = false; } - let _e1083 = phi_5746_; - if _e1083 { - let _e1086 = global.member[_e295.member_9]; - let _e1090 = global.member[(_e295.member_9 + 1u)]; - let _e1095 = global.member[(_e295.member_9 + 2u)]; - let _e1099 = global.member[(_e295.member_9 + 3u)]; - let _e1104 = global.member[(_e295.member_9 + 4u)]; - let _e1108 = global.member[(_e295.member_9 + 5u)]; - let _e1112 = global.member[(_e295.member_9 + 6u)]; - switch bitcast(_e1112) { + let _e1107 = phi_6381_; + if _e1107 { + let _e1110 = global.member[_e319.member_9]; + let _e1114 = global.member[(_e319.member_9 + 1u)]; + let _e1119 = global.member[(_e319.member_9 + 2u)]; + let _e1123 = global.member[(_e319.member_9 + 3u)]; + let _e1128 = global.member[(_e319.member_9 + 4u)]; + let _e1132 = global.member[(_e319.member_9 + 5u)]; + let _e1136 = global.member[(_e319.member_9 + 6u)]; + switch bitcast(_e1136) { case 0: { - phi_1742_ = 0u; + phi_1774_ = 0u; break; } case 1: { - phi_1742_ = 1u; + phi_1774_ = 1u; break; } case 2: { - phi_1742_ = 2u; + phi_1774_ = 2u; break; } default: { - phi_1742_ = 0u; + phi_1774_ = 0u; break; } } - let _e1115 = phi_1742_; - let _e1119 = global.member[(_e295.member_9 + 7u)]; - switch bitcast(_e1119) { + let _e1139 = phi_1774_; + let _e1143 = global.member[(_e319.member_9 + 7u)]; + switch bitcast(_e1143) { case 0: { - phi_1751_ = 0u; + phi_1783_ = 0u; break; } case 1: { - phi_1751_ = 1u; + phi_1783_ = 1u; break; } case 2: { - phi_1751_ = 2u; + phi_1783_ = 2u; break; } default: { - phi_1751_ = 0u; + phi_1783_ = 0u; break; } } - let _e1122 = phi_1751_; - phi_1764_ = type_15(type_14(_e1115, _e1122), vec2(_e1086, _e1090), vec2(_e1095, _e1099), _e1104, _e1108); + let _e1146 = phi_1783_; + phi_1796_ = type_15(type_14(_e1139, _e1146), vec2(_e1110, _e1114), vec2(_e1119, _e1123), _e1128, _e1132); } else { - phi_1764_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + phi_1796_ = type_15(type_14(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); } - let _e1126 = phi_1764_; - switch bitcast(_e1126.member.member) { + let _e1150 = phi_1796_; + switch bitcast(_e1150.member.member) { case 1: { - let _e1164 = abs(_e1078.x); - let _e1166 = (_e1164 % 1f); - if (_e1164 >= 1f) { - phi_5797_ = select(true, false, (_e1166 == 0f)); + let _e1188 = abs(_e1102.x); + let _e1190 = (_e1188 % 1f); + if (_e1188 >= 1f) { + phi_6432_ = select(true, false, (_e1190 == 0f)); } else { - phi_5797_ = true; + phi_6432_ = true; } - let _e1170 = phi_5797_; - let _e1171 = select(1f, _e1166, _e1170); - if (select(-1f, 1f, (_e1078.x >= 0f)) > 0f) { - phi_1784_ = _e1171; + let _e1194 = phi_6432_; + let _e1195 = select(1f, _e1190, _e1194); + if (select(-1f, 1f, (_e1102.x >= 0f)) > 0f) { + phi_1816_ = _e1195; } else { - phi_1784_ = (1f - _e1171); + phi_1816_ = (1f - _e1195); } - let _e1175 = phi_1784_; - phi_1821_ = _e1175; + let _e1199 = phi_1816_; + phi_1853_ = _e1199; break; } case 2: { - let _e1138 = abs(_e1078.x); - let _e1145 = ((select(select(u32(_e1138), 0u, (_e1138 < 0f)), 4294967295u, (_e1138 > 4294967000f)) % 2u) == 0u); - let _e1147 = (_e1138 % 1f); - if (_e1138 >= 1f) { - phi_5780_ = select(true, false, (_e1147 == 0f)); + let _e1162 = abs(_e1102.x); + let _e1169 = ((select(select(u32(_e1162), 0u, (_e1162 < 0f)), 4294967295u, (_e1162 > 4294967000f)) % 2u) == 0u); + let _e1171 = (_e1162 % 1f); + if (_e1162 >= 1f) { + phi_6415_ = select(true, false, (_e1171 == 0f)); } else { - phi_5780_ = true; + phi_6415_ = true; } - let _e1151 = phi_5780_; - let _e1152 = select(1f, _e1147, _e1151); - if (select(-1f, 1f, (_e1078.x >= 0f)) > 0f) { - if _e1145 { - phi_1813_ = _e1152; + let _e1175 = phi_6415_; + let _e1176 = select(1f, _e1171, _e1175); + if (select(-1f, 1f, (_e1102.x >= 0f)) > 0f) { + if _e1169 { + phi_1845_ = _e1176; } else { - phi_1813_ = (1f - _e1152); + phi_1845_ = (1f - _e1176); } - let _e1159 = phi_1813_; - phi_1819_ = _e1159; + let _e1183 = phi_1845_; + phi_1851_ = _e1183; } else { - if _e1145 { - phi_1818_ = (1f - _e1152); + if _e1169 { + phi_1850_ = (1f - _e1176); } else { - phi_1818_ = _e1152; + phi_1850_ = _e1176; } - let _e1156 = phi_1818_; - phi_1819_ = _e1156; + let _e1180 = phi_1850_; + phi_1851_ = _e1180; } - let _e1161 = phi_1819_; - phi_1821_ = _e1161; + let _e1185 = phi_1851_; + phi_1853_ = _e1185; break; } case 0: { - if (_e1078.x > 1f) { - phi_5767_ = 0.9999999f; + if (_e1102.x > 1f) { + phi_6402_ = 0.9999999f; } else { - phi_5767_ = select(_e1078.x, 0.00000011920929f, (_e1078.x < 0f)); + phi_6402_ = select(_e1102.x, 0.00000011920929f, (_e1102.x < 0f)); } - let _e1135 = phi_5767_; - phi_1821_ = _e1135; + let _e1159 = phi_6402_; + phi_1853_ = _e1159; break; } default: { - phi_1821_ = f32(); + phi_1853_ = f32(); break; } } - let _e1177 = phi_1821_; - switch bitcast(_e1126.member.member_1) { + let _e1201 = phi_1853_; + switch bitcast(_e1150.member.member_1) { case 1: { - let _e1215 = abs(_e1078.y); - let _e1217 = (_e1215 % 1f); - if (_e1215 >= 1f) { - phi_5845_ = select(true, false, (_e1217 == 0f)); + let _e1239 = abs(_e1102.y); + let _e1241 = (_e1239 % 1f); + if (_e1239 >= 1f) { + phi_6480_ = select(true, false, (_e1241 == 0f)); } else { - phi_5845_ = true; + phi_6480_ = true; } - let _e1221 = phi_5845_; - let _e1222 = select(1f, _e1217, _e1221); - if (select(-1f, 1f, (_e1078.y >= 0f)) > 0f) { - phi_1842_ = _e1222; + let _e1245 = phi_6480_; + let _e1246 = select(1f, _e1241, _e1245); + if (select(-1f, 1f, (_e1102.y >= 0f)) > 0f) { + phi_1874_ = _e1246; } else { - phi_1842_ = (1f - _e1222); + phi_1874_ = (1f - _e1246); } - let _e1226 = phi_1842_; - phi_1879_ = _e1226; + let _e1250 = phi_1874_; + phi_1911_ = _e1250; break; } case 2: { - let _e1189 = abs(_e1078.y); - let _e1196 = ((select(select(u32(_e1189), 0u, (_e1189 < 0f)), 4294967295u, (_e1189 > 4294967000f)) % 2u) == 0u); - let _e1198 = (_e1189 % 1f); - if (_e1189 >= 1f) { - phi_5828_ = select(true, false, (_e1198 == 0f)); + let _e1213 = abs(_e1102.y); + let _e1220 = ((select(select(u32(_e1213), 0u, (_e1213 < 0f)), 4294967295u, (_e1213 > 4294967000f)) % 2u) == 0u); + let _e1222 = (_e1213 % 1f); + if (_e1213 >= 1f) { + phi_6463_ = select(true, false, (_e1222 == 0f)); } else { - phi_5828_ = true; + phi_6463_ = true; } - let _e1202 = phi_5828_; - let _e1203 = select(1f, _e1198, _e1202); - if (select(-1f, 1f, (_e1078.y >= 0f)) > 0f) { - if _e1196 { - phi_1871_ = _e1203; + let _e1226 = phi_6463_; + let _e1227 = select(1f, _e1222, _e1226); + if (select(-1f, 1f, (_e1102.y >= 0f)) > 0f) { + if _e1220 { + phi_1903_ = _e1227; } else { - phi_1871_ = (1f - _e1203); + phi_1903_ = (1f - _e1227); } - let _e1210 = phi_1871_; - phi_1877_ = _e1210; + let _e1234 = phi_1903_; + phi_1909_ = _e1234; } else { - if _e1196 { - phi_1876_ = (1f - _e1203); + if _e1220 { + phi_1908_ = (1f - _e1227); } else { - phi_1876_ = _e1203; + phi_1908_ = _e1227; } - let _e1207 = phi_1876_; - phi_1877_ = _e1207; + let _e1231 = phi_1908_; + phi_1909_ = _e1231; } - let _e1212 = phi_1877_; - phi_1879_ = _e1212; + let _e1236 = phi_1909_; + phi_1911_ = _e1236; break; } case 0: { - if (_e1078.y > 1f) { - phi_5815_ = 0.9999999f; + if (_e1102.y > 1f) { + phi_6450_ = 0.9999999f; } else { - phi_5815_ = select(_e1078.y, 0.00000011920929f, (_e1078.y < 0f)); + phi_6450_ = select(_e1102.y, 0.00000011920929f, (_e1102.y < 0f)); } - let _e1186 = phi_5815_; - phi_1879_ = _e1186; + let _e1210 = phi_6450_; + phi_1911_ = _e1210; break; } default: { - phi_1879_ = f32(); + phi_1911_ = f32(); break; } } - let _e1228 = phi_1879_; - let _e1232 = (_e1177 * f32(_e1126.member_2.x)); - let _e1241 = (_e1228 * f32(_e1126.member_2.y)); - let _e1259 = vec3((f32((select(select(u32(_e1232), 0u, (_e1232 < 0f)), 4294967295u, (_e1232 > 4294967000f)) + _e1126.member_1.x)) / _e475), (f32((select(select(u32(_e1241), 0u, (_e1241 < 0f)), 4294967295u, (_e1241 > 4294967000f)) + _e1126.member_1.y)) / _e476), f32(_e1126.member_3)); - let _e1265 = textureSampleLevel(global_11, global_10, vec2(_e1259.x, _e1259.y), i32(_e1259.z), 0f); - let _e1268 = select(_e1265, vec4(1f, 1f, 1f, 1f), vec4((_e295.member_9 == 4294967295u))); - if _e878 { - phi_1973_ = vec3(0f, 0f, 0f); - phi_1974_ = _e129; + let _e1252 = phi_1911_; + let _e1256 = (_e1201 * f32(_e1150.member_2.x)); + let _e1265 = (_e1252 * f32(_e1150.member_2.y)); + let _e1283 = vec3((f32((select(select(u32(_e1256), 0u, (_e1256 < 0f)), 4294967295u, (_e1256 > 4294967000f)) + _e1150.member_1.x)) / _e499), (f32((select(select(u32(_e1265), 0u, (_e1265 < 0f)), 4294967295u, (_e1265 > 4294967000f)) + _e1150.member_1.y)) / _e500), f32(_e1150.member_3)); + let _e1289 = textureSampleLevel(global_11, global_10, vec2(_e1283.x, _e1283.y), i32(_e1283.z), 0f); + let _e1292 = select(_e1289, vec4(1f, 1f, 1f, 1f), vec4((_e319.member_9 == 4294967295u))); + if _e902 { + phi_2005_ = vec3(0f, 0f, 0f); + phi_2006_ = _e153; } else { - let _e1272 = fma(_e880.x, 2f, -1f); - let _e1273 = fma(_e880.y, 2f, -1f); - let _e1274 = fma(_e880.z, 2f, -1f); - let _e1279 = sqrt(fma(_e1274, _e1274, fma(_e1272, _e1272, (_e1273 * _e1273)))); - if (_e1279 == 0f) { - phi_5903_ = vec3(0f, 0f, 0f); + let _e1296 = fma(_e904.x, 2f, -1f); + let _e1297 = fma(_e904.y, 2f, -1f); + let _e1298 = fma(_e904.z, 2f, -1f); + let _e1303 = sqrt(fma(_e1298, _e1298, fma(_e1296, _e1296, (_e1297 * _e1297)))); + if (_e1303 == 0f) { + phi_6538_ = vec3(0f, 0f, 0f); } else { - phi_5903_ = (vec3(_e1272, _e1273, _e1274) * (1f / _e1279)); + phi_6538_ = (vec3(_e1296, _e1297, _e1298) * (1f / _e1303)); } - let _e1284 = phi_5903_; - let _e1291 = sqrt(fma(_e130.z, _e130.z, fma(_e130.x, _e130.x, (_e130.y * _e130.y)))); - if (_e1291 == 0f) { - phi_5938_ = vec3(0f, 0f, 0f); + let _e1308 = phi_6538_; + let _e1315 = sqrt(fma(_e154.z, _e154.z, fma(_e154.x, _e154.x, (_e154.y * _e154.y)))); + if (_e1315 == 0f) { + phi_6573_ = vec3(0f, 0f, 0f); } else { - phi_5938_ = (_e130 * (1f / _e1291)); + phi_6573_ = (_e154 * (1f / _e1315)); } - let _e1296 = phi_5938_; - let _e1303 = sqrt(fma(_e131.z, _e131.z, fma(_e131.x, _e131.x, (_e131.y * _e131.y)))); - if (_e1303 == 0f) { - phi_5973_ = vec3(0f, 0f, 0f); + let _e1320 = phi_6573_; + let _e1327 = sqrt(fma(_e155.z, _e155.z, fma(_e155.x, _e155.x, (_e155.y * _e155.y)))); + if (_e1327 == 0f) { + phi_6608_ = vec3(0f, 0f, 0f); } else { - phi_5973_ = (_e131 * (1f / _e1303)); + phi_6608_ = (_e155 * (1f / _e1327)); } - let _e1308 = phi_5973_; - let _e1315 = sqrt(fma(_e129.z, _e129.z, fma(_e129.x, _e129.x, (_e129.y * _e129.y)))); - if (_e1315 == 0f) { - phi_6008_ = vec3(0f, 0f, 0f); + let _e1332 = phi_6608_; + let _e1339 = sqrt(fma(_e153.z, _e153.z, fma(_e153.x, _e153.x, (_e153.y * _e153.y)))); + if (_e1339 == 0f) { + phi_6643_ = vec3(0f, 0f, 0f); } else { - phi_6008_ = (_e129 * (1f / _e1315)); - } - let _e1320 = phi_6008_; - let _e1339 = fma(_e1320.x, _e1284.z, fma(_e1296.x, _e1284.x, (_e1308.x * _e1284.y))); - let _e1340 = fma(_e1320.y, _e1284.z, fma(_e1296.y, _e1284.x, (_e1308.y * _e1284.y))); - let _e1341 = fma(_e1320.z, _e1284.z, fma(_e1296.z, _e1284.x, (_e1308.z * _e1284.y))); - let _e1346 = sqrt(fma(_e1341, _e1341, fma(_e1339, _e1339, (_e1340 * _e1340)))); - if (_e1346 == 0f) { - phi_6043_ = vec3(0f, 0f, 0f); + phi_6643_ = (_e153 * (1f / _e1339)); + } + let _e1344 = phi_6643_; + let _e1363 = fma(_e1344.x, _e1308.z, fma(_e1320.x, _e1308.x, (_e1332.x * _e1308.y))); + let _e1364 = fma(_e1344.y, _e1308.z, fma(_e1320.y, _e1308.x, (_e1332.y * _e1308.y))); + let _e1365 = fma(_e1344.z, _e1308.z, fma(_e1320.z, _e1308.x, (_e1332.z * _e1308.y))); + let _e1370 = sqrt(fma(_e1365, _e1365, fma(_e1363, _e1363, (_e1364 * _e1364)))); + if (_e1370 == 0f) { + phi_6678_ = vec3(0f, 0f, 0f); } else { - phi_6043_ = (vec3(_e1339, _e1340, _e1341) * (1f / _e1346)); + phi_6678_ = (vec3(_e1363, _e1364, _e1365) * (1f / _e1370)); } - let _e1351 = phi_6043_; - phi_1973_ = _e1284; - phi_1974_ = _e1351; + let _e1375 = phi_6678_; + phi_2005_ = _e1308; + phi_2006_ = _e1375; } - let _e1353 = phi_1973_; - let _e1355 = phi_1974_; - let _e1359 = (_e492.x * _e295.member_2.x); - let _e1362 = (_e492.y * _e295.member_2.y); - let _e1365 = (_e492.z * _e295.member_2.z); - let _e1370 = (_e1359 * _e126.x); - let _e1372 = (_e1362 * _e126.y); - let _e1374 = (_e1365 * _e126.z); - let _e1379 = (_e686.y * _e295.member_4); - let _e1382 = (_e686.z * _e295.member_3); - let _e1386 = fma(_e295.member_16, (select(_e1071, vec4(1f, 1f, 1f, 1f), vec4((_e295.member_8 == 4294967295u))).x - 1f), 1f); - let _e1392 = (_e1268.x * _e295.member.x); - let _e1394 = (_e1268.y * _e295.member.y); - let _e1396 = (_e1268.z * _e295.member.z); - let _e1401 = textureSampleLevel(global_12, global_13, _e1355, 0f); - if (_e122 >= 86u) { - phi_6075_ = (_e136 <= (_e122 - 86u)); + let _e1377 = phi_2005_; + let _e1379 = phi_2006_; + let _e1383 = (_e516.x * _e319.member_2.x); + let _e1386 = (_e516.y * _e319.member_2.y); + let _e1389 = (_e516.z * _e319.member_2.z); + let _e1394 = (_e1383 * _e150.x); + let _e1396 = (_e1386 * _e150.y); + let _e1398 = (_e1389 * _e150.z); + let _e1403 = (_e710.y * _e319.member_4); + let _e1406 = (_e710.z * _e319.member_3); + let _e1410 = fma(_e319.member_16, (select(_e1095, vec4(1f, 1f, 1f, 1f), vec4((_e319.member_8 == 4294967295u))).x - 1f), 1f); + let _e1416 = (_e1292.x * _e319.member.x); + let _e1418 = (_e1292.y * _e319.member.y); + let _e1420 = (_e1292.z * _e319.member.z); + let _e1425 = textureSampleLevel(global_12, global_13, _e1379, 0f); + if (_e146 >= 86u) { + phi_6710_ = (_e160 <= (_e146 - 86u)); } else { - phi_6075_ = false; + phi_6710_ = false; } - let _e1409 = phi_6075_; - if _e1409 { - let _e1412 = global.member[_e136]; - let _e1417 = global.member[(_e136 + 1u)]; - let _e1422 = global.member[(_e136 + 2u)]; - let _e1427 = global.member[(_e136 + 3u)]; - let _e1433 = global.member[(_e136 + 4u)]; - let _e1438 = global.member[(_e136 + 5u)]; - let _e1443 = global.member[(_e136 + 6u)]; - let _e1448 = global.member[(_e136 + 7u)]; - let _e1454 = global.member[(_e136 + 8u)]; - let _e1459 = global.member[(_e136 + 9u)]; - let _e1464 = global.member[(_e136 + 10u)]; - let _e1469 = global.member[(_e136 + 11u)]; - let _e1475 = global.member[(_e136 + 12u)]; - let _e1480 = global.member[(_e136 + 13u)]; - let _e1485 = global.member[(_e136 + 14u)]; - let _e1490 = global.member[(_e136 + 15u)]; - let _e1497 = global.member[(_e136 + 16u)]; - let _e1502 = global.member[(_e136 + 17u)]; - let _e1507 = global.member[(_e136 + 18u)]; - let _e1512 = global.member[(_e136 + 19u)]; - let _e1518 = global.member[(_e136 + 20u)]; - let _e1523 = global.member[(_e136 + 21u)]; - let _e1528 = global.member[(_e136 + 22u)]; - let _e1533 = global.member[(_e136 + 23u)]; - let _e1539 = global.member[(_e136 + 24u)]; - let _e1544 = global.member[(_e136 + 25u)]; - let _e1549 = global.member[(_e136 + 26u)]; - let _e1554 = global.member[(_e136 + 27u)]; - let _e1560 = global.member[(_e136 + 28u)]; - let _e1565 = global.member[(_e136 + 29u)]; - let _e1570 = global.member[(_e136 + 30u)]; - let _e1575 = global.member[(_e136 + 31u)]; - let _e1582 = global.member[(_e136 + 32u)]; - let _e1587 = global.member[(_e136 + 33u)]; - let _e1592 = global.member[(_e136 + 34u)]; - local_1 = array, 6>(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)); - phi_2181_ = type_14(0u, 6u); + let _e1433 = phi_6710_; + if _e1433 { + let _e1436 = global.member[_e160]; + let _e1441 = global.member[(_e160 + 1u)]; + let _e1446 = global.member[(_e160 + 2u)]; + let _e1451 = global.member[(_e160 + 3u)]; + let _e1457 = global.member[(_e160 + 4u)]; + let _e1462 = global.member[(_e160 + 5u)]; + let _e1467 = global.member[(_e160 + 6u)]; + let _e1472 = global.member[(_e160 + 7u)]; + let _e1478 = global.member[(_e160 + 8u)]; + let _e1483 = global.member[(_e160 + 9u)]; + let _e1488 = global.member[(_e160 + 10u)]; + let _e1493 = global.member[(_e160 + 11u)]; + let _e1499 = global.member[(_e160 + 12u)]; + let _e1504 = global.member[(_e160 + 13u)]; + let _e1509 = global.member[(_e160 + 14u)]; + let _e1514 = global.member[(_e160 + 15u)]; + let _e1521 = global.member[(_e160 + 16u)]; + let _e1526 = global.member[(_e160 + 17u)]; + let _e1531 = global.member[(_e160 + 18u)]; + let _e1536 = global.member[(_e160 + 19u)]; + let _e1542 = global.member[(_e160 + 20u)]; + let _e1547 = global.member[(_e160 + 21u)]; + let _e1552 = global.member[(_e160 + 22u)]; + let _e1557 = global.member[(_e160 + 23u)]; + let _e1563 = global.member[(_e160 + 24u)]; + let _e1568 = global.member[(_e160 + 25u)]; + let _e1573 = global.member[(_e160 + 26u)]; + let _e1578 = global.member[(_e160 + 27u)]; + let _e1584 = global.member[(_e160 + 28u)]; + let _e1589 = global.member[(_e160 + 29u)]; + let _e1594 = global.member[(_e160 + 30u)]; + let _e1599 = global.member[(_e160 + 31u)]; + let _e1606 = global.member[(_e160 + 32u)]; + let _e1611 = global.member[(_e160 + 33u)]; + let _e1616 = global.member[(_e160 + 34u)]; + local_2 = array, 6>(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)); + phi_2213_ = type_14(0u, 6u); loop { - let _e1597 = phi_2181_; - if (_e1597.member < _e1597.member_1) { - phi_2182_ = type_14((_e1597.member + 1u), _e1597.member_1); - phi_2205_ = type_14(1u, _e1597.member); + let _e1621 = phi_2213_; + if (_e1621.member < _e1621.member_1) { + phi_2214_ = type_14((_e1621.member + 1u), _e1621.member_1); + phi_2237_ = type_14(1u, _e1621.member); } else { - phi_2182_ = _e1597; - phi_2205_ = type_14(0u, type_14().member_1); + phi_2214_ = _e1621; + phi_2237_ = type_14(0u, type_14().member_1); } - let _e1610 = phi_2182_; - let _e1612 = phi_2205_; - switch bitcast(_e1612.member) { + let _e1634 = phi_2214_; + let _e1636 = phi_2237_; + switch bitcast(_e1636.member) { case 0: { - phi_2232_ = false; + phi_2264_ = false; break; } case 1: { - let _e1617 = ((_e136 + 35u) + (_e1612.member_1 * 4u)); - let _e1620 = global.member[_e1617]; - let _e1625 = global.member[(_e1617 + 1u)]; - let _e1630 = global.member[(_e1617 + 2u)]; - let _e1635 = global.member[(_e1617 + 3u)]; - local_1[_e1612.member_1] = vec4(bitcast(_e1620), bitcast(_e1625), bitcast(_e1630), bitcast(_e1635)); - phi_2232_ = true; + let _e1641 = ((_e160 + 35u) + (_e1636.member_1 * 4u)); + let _e1644 = global.member[_e1641]; + let _e1649 = global.member[(_e1641 + 1u)]; + let _e1654 = global.member[(_e1641 + 2u)]; + let _e1659 = global.member[(_e1641 + 3u)]; + local_2[_e1636.member_1] = vec4(bitcast(_e1644), bitcast(_e1649), bitcast(_e1654), bitcast(_e1659)); + phi_2264_ = true; break; } default: { - phi_2232_ = bool(); + phi_2264_ = bool(); break; } } - let _e1640 = phi_2232_; + let _e1664 = phi_2264_; continue; continuing { - phi_2181_ = _e1610; - break if !(_e1640); + phi_2213_ = _e1634; + break if !(_e1664); } } - let _e1642 = local_1; - local = array, 8>(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f)); - phi_2238_ = type_14(0u, 8u); + let _e1666 = local_2; + local_1 = array, 8>(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f)); + phi_2270_ = type_14(0u, 8u); loop { - let _e1645 = phi_2238_; - if (_e1645.member < _e1645.member_1) { - phi_2239_ = type_14((_e1645.member + 1u), _e1645.member_1); - phi_2262_ = type_14(1u, _e1645.member); + let _e1669 = phi_2270_; + if (_e1669.member < _e1669.member_1) { + phi_2271_ = type_14((_e1669.member + 1u), _e1669.member_1); + phi_2294_ = type_14(1u, _e1669.member); } else { - phi_2239_ = _e1645; - phi_2262_ = type_14(0u, type_14().member_1); + phi_2271_ = _e1669; + phi_2294_ = type_14(0u, type_14().member_1); } - let _e1658 = phi_2239_; - let _e1660 = phi_2262_; - switch bitcast(_e1660.member) { + let _e1682 = phi_2271_; + let _e1684 = phi_2294_; + switch bitcast(_e1684.member) { case 0: { - phi_2285_ = false; + phi_2317_ = false; break; } case 1: { - let _e1665 = ((_e136 + 59u) + (_e1660.member_1 * 3u)); - let _e1668 = global.member[_e1665]; - let _e1673 = global.member[(_e1665 + 1u)]; - let _e1678 = global.member[(_e1665 + 2u)]; - local[_e1660.member_1] = vec3(bitcast(_e1668), bitcast(_e1673), bitcast(_e1678)); - phi_2285_ = true; + let _e1689 = ((_e160 + 59u) + (_e1684.member_1 * 3u)); + let _e1692 = global.member[_e1689]; + let _e1697 = global.member[(_e1689 + 1u)]; + let _e1702 = global.member[(_e1689 + 2u)]; + local_1[_e1684.member_1] = vec3(bitcast(_e1692), bitcast(_e1697), bitcast(_e1702)); + phi_2317_ = true; break; } default: { - phi_2285_ = bool(); + phi_2317_ = bool(); break; } } - let _e1683 = phi_2285_; + let _e1707 = phi_2317_; continue; continuing { - phi_2238_ = _e1658; - break if !(_e1683); + phi_2270_ = _e1682; + break if !(_e1707); } } - let _e1685 = local; - let _e1689 = global.member[(_e136 + 83u)]; - let _e1694 = global.member[(_e136 + 84u)]; - let _e1699 = global.member[(_e136 + 85u)]; - phi_2306_ = type_25(type_23(vec4(bitcast(_e1412), bitcast(_e1417), bitcast(_e1422), bitcast(_e1427)), vec4(bitcast(_e1433), bitcast(_e1438), bitcast(_e1443), bitcast(_e1448)), vec4(bitcast(_e1454), bitcast(_e1459), bitcast(_e1464), bitcast(_e1469)), vec4(bitcast(_e1475), bitcast(_e1480), bitcast(_e1485), bitcast(_e1490))), type_23(vec4(bitcast(_e1497), bitcast(_e1502), bitcast(_e1507), bitcast(_e1512)), vec4(bitcast(_e1518), bitcast(_e1523), bitcast(_e1528), bitcast(_e1533)), vec4(bitcast(_e1539), bitcast(_e1544), bitcast(_e1549), bitcast(_e1554)), vec4(bitcast(_e1560), bitcast(_e1565), bitcast(_e1570), bitcast(_e1575))), vec3(bitcast(_e1582), bitcast(_e1587), bitcast(_e1592)), type_24(_e1685, _e1642, vec3(bitcast(_e1689), bitcast(_e1694), bitcast(_e1699)))); + let _e1709 = local_1; + let _e1713 = global.member[(_e160 + 83u)]; + let _e1718 = global.member[(_e160 + 84u)]; + let _e1723 = global.member[(_e160 + 85u)]; + phi_2338_ = type_25(type_23(vec4(bitcast(_e1436), bitcast(_e1441), bitcast(_e1446), bitcast(_e1451)), vec4(bitcast(_e1457), bitcast(_e1462), bitcast(_e1467), bitcast(_e1472)), vec4(bitcast(_e1478), bitcast(_e1483), bitcast(_e1488), bitcast(_e1493)), vec4(bitcast(_e1499), bitcast(_e1504), bitcast(_e1509), bitcast(_e1514))), type_23(vec4(bitcast(_e1521), bitcast(_e1526), bitcast(_e1531), bitcast(_e1536)), vec4(bitcast(_e1542), bitcast(_e1547), bitcast(_e1552), bitcast(_e1557)), vec4(bitcast(_e1563), bitcast(_e1568), bitcast(_e1573), bitcast(_e1578)), vec4(bitcast(_e1584), bitcast(_e1589), bitcast(_e1594), bitcast(_e1599))), vec3(bitcast(_e1606), bitcast(_e1611), bitcast(_e1616)), type_24(_e1709, _e1666, vec3(bitcast(_e1713), bitcast(_e1718), bitcast(_e1723)))); } else { - phi_2306_ = type_25(type_23(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_23(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), vec3(0f, 0f, 0f), type_24(array, 8>(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f)), array, 6>(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)), vec3(0f, 0f, 0f))); + phi_2338_ = type_25(type_23(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_23(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), vec3(0f, 0f, 0f), type_24(array, 8>(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f)), array, 6>(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)), vec3(0f, 0f, 0f))); } - let _e1705 = phi_2306_; - let _e1707 = (_e1705.member_2 - _e132); - let _e1714 = sqrt(fma(_e1707.z, _e1707.z, fma(_e1707.x, _e1707.x, (_e1707.y * _e1707.y)))); - let _e1715 = (_e1714 == 0f); - if _e1715 { - phi_6147_ = vec3(0f, 0f, 0f); + let _e1729 = phi_2338_; + let _e1731 = (_e1729.member_2 - _e156); + let _e1738 = sqrt(fma(_e1731.z, _e1731.z, fma(_e1731.x, _e1731.x, (_e1731.y * _e1731.y)))); + let _e1739 = (_e1738 == 0f); + if _e1739 { + phi_6782_ = vec3(0f, 0f, 0f); } else { - phi_6147_ = (_e1707 * (1f / _e1714)); + phi_6782_ = (_e1731 * (1f / _e1738)); } - let _e1719 = phi_6147_; - let _e1720 = -(_e1719); - let _e1727 = sqrt(fma(_e1355.z, _e1355.z, fma(_e1355.x, _e1355.x, (_e1355.y * _e1355.y)))); - let _e1728 = (_e1727 == 0f); - if _e1728 { - phi_6206_ = vec3(0f, 0f, 0f); + let _e1743 = phi_6782_; + let _e1744 = -(_e1743); + let _e1751 = sqrt(fma(_e1379.z, _e1379.z, fma(_e1379.x, _e1379.x, (_e1379.y * _e1379.y)))); + let _e1752 = (_e1751 == 0f); + if _e1752 { + phi_6841_ = vec3(0f, 0f, 0f); } else { - phi_6206_ = (_e1355 * (1f / _e1727)); + phi_6841_ = (_e1379 * (1f / _e1751)); } - let _e1732 = phi_6206_; - let _e1742 = (2f * fma(_e1732.z, _e1720.z, fma(_e1732.x, _e1720.x, (_e1732.y * _e1720.y)))); - let _e1749 = textureSampleLevel(global_14, global_15, (_e1720 - vec3((_e1742 * _e1732.x), (_e1742 * _e1732.y), (_e1742 * _e1732.z))), (_e1379 * 4f)); - if _e1715 { - phi_6280_ = vec3(0f, 0f, 0f); + let _e1756 = phi_6841_; + let _e1766 = (2f * fma(_e1756.z, _e1744.z, fma(_e1756.x, _e1744.x, (_e1756.y * _e1744.y)))); + let _e1773 = textureSampleLevel(global_14, global_15, (_e1744 - vec3((_e1766 * _e1756.x), (_e1766 * _e1756.y), (_e1766 * _e1756.z))), (_e1403 * 4f)); + if _e1739 { + phi_6915_ = vec3(0f, 0f, 0f); } else { - phi_6280_ = (_e1707 * (1f / _e1714)); + phi_6915_ = (_e1731 * (1f / _e1738)); } - let _e1756 = phi_6280_; - let _e1765 = textureSampleLevel(global_16, global_17, vec2(max(fma(_e1355.z, _e1756.z, fma(_e1355.x, _e1756.x, (_e1355.y * _e1756.y))), 0f), _e1379), 0f); - switch bitcast(_e158) { + let _e1780 = phi_6915_; + let _e1789 = textureSampleLevel(global_16, global_17, vec2(max(fma(_e1379.z, _e1780.z, fma(_e1379.x, _e1780.x, (_e1379.y * _e1780.y))), 0f), _e1403), 0f); + switch bitcast(_e182) { case 0: { - if _e295.member_15 { - if _e1728 { - phi_6673_ = vec3(0f, 0f, 0f); + if _e319.member_15 { + if _e1752 { + phi_7308_ = vec3(0f, 0f, 0f); } else { - phi_6673_ = (_e1355 * (1f / _e1727)); + phi_7308_ = (_e1379 * (1f / _e1751)); } - let _e1934 = phi_6673_; - if _e1715 { - phi_6708_ = vec3(0f, 0f, 0f); + let _e1958 = phi_7308_; + if _e1739 { + phi_7343_ = vec3(0f, 0f, 0f); } else { - phi_6708_ = (_e1707 * (1f / _e1714)); + phi_7343_ = (_e1731 * (1f / _e1738)); } - let _e1938 = phi_6708_; - let _e1941 = global_1.member[0u]; - let _e1944 = global_1.member[1u]; - let _e1947 = global_1.member[2u]; - phi_7968_ = false; - phi_2373_ = type_14(0u, _e1944); - phi_2376_ = vec3(0f, 0f, 0f); + let _e1962 = phi_7343_; + let _e1965 = global_1.member[0u]; + let _e1968 = global_1.member[1u]; + let _e1971 = global_1.member[2u]; + phi_8882_ = false; + phi_2405_ = type_14(0u, _e1968); + phi_2408_ = vec3(0f, 0f, 0f); loop { - let _e1950 = phi_7968_; - let _e1952 = phi_2373_; - let _e1954 = phi_2376_; - local_6 = _e1954; - local_7 = _e1954; - local_8 = _e1954; - if (_e1952.member < _e1952.member_1) { - phi_2374_ = type_14((_e1952.member + 1u), _e1952.member_1); - phi_2399_ = type_14(1u, _e1952.member); + let _e1974 = phi_8882_; + let _e1976 = phi_2405_; + let _e1978 = phi_2408_; + local_8 = _e1978; + local_9 = _e1978; + local_10 = _e1978; + if (_e1976.member < _e1976.member_1) { + phi_2406_ = type_14((_e1976.member + 1u), _e1976.member_1); + phi_2431_ = type_14(1u, _e1976.member); } else { - phi_2374_ = _e1952; - phi_2399_ = type_14(0u, type_14().member_1); + phi_2406_ = _e1976; + phi_2431_ = type_14(0u, type_14().member_1); } - let _e1967 = phi_2374_; - let _e1969 = phi_2399_; - switch bitcast(_e1969.member) { + let _e1991 = phi_2406_; + let _e1993 = phi_2431_; + switch bitcast(_e1993.member) { case 0: { - phi_8087_ = _e1950; - phi_2377_ = vec3(); - phi_4484_ = false; + phi_9057_ = _e1974; + phi_2409_ = vec3(); + phi_5003_ = false; break; } case 1: { - if (_e1969.member_1 >= _e1944) { - phi_6734_ = 4294967295u; + if (_e1993.member_1 >= _e1968) { + phi_7369_ = 4294967295u; } else { - phi_6734_ = (_e1941 + _e1969.member_1); + phi_7369_ = (_e1965 + _e1993.member_1); } - let _e1976 = phi_6734_; - if (_e124 >= 1u) { - phi_6753_ = (_e1976 <= (_e124 - 1u)); + let _e2000 = phi_7369_; + if (_e148 >= 1u) { + phi_7388_ = (_e2000 <= (_e148 - 1u)); } else { - phi_6753_ = false; + phi_7388_ = false; } - let _e1981 = phi_6753_; - if _e1981 { - let _e1984 = global_1.member[_e1976]; - phi_2416_ = _e1984; + let _e2005 = phi_7388_; + if _e2005 { + let _e2008 = global_1.member[_e2000]; + phi_2448_ = _e2008; } else { - phi_2416_ = 4294967295u; + phi_2448_ = 4294967295u; } - let _e1986 = phi_2416_; - if (_e124 >= 4u) { - phi_6777_ = (_e1986 <= (_e124 - 4u)); + let _e2010 = phi_2448_; + if (_e148 >= 4u) { + phi_7412_ = (_e2010 <= (_e148 - 4u)); } else { - phi_6777_ = false; + phi_7412_ = false; } - let _e1991 = phi_6777_; - if _e1991 { - let _e1994 = global_1.member[_e1986]; - switch bitcast(_e1994) { + let _e2015 = phi_7412_; + if _e2015 { + let _e2018 = global_1.member[_e2010]; + switch bitcast(_e2018) { case 0: { - phi_2428_ = 0u; + phi_2460_ = 0u; break; } case 1: { - phi_2428_ = 1u; + phi_2460_ = 1u; break; } case 2: { - phi_2428_ = 2u; + phi_2460_ = 2u; break; } default: { - phi_2428_ = 0u; + phi_2460_ = 0u; break; } } - let _e1997 = phi_2428_; - let _e2001 = global_1.member[(_e1986 + 1u)]; - let _e2005 = global_1.member[(_e1986 + 2u)]; - let _e2009 = global_1.member[(_e1986 + 3u)]; - phi_2442_ = type_30(_e1997, _e2001, _e2005, _e2009); + let _e2021 = phi_2460_; + let _e2025 = global_1.member[(_e2010 + 1u)]; + let _e2029 = global_1.member[(_e2010 + 2u)]; + let _e2033 = global_1.member[(_e2010 + 3u)]; + phi_2474_ = type_30(_e2021, _e2025, _e2029, _e2033); } else { - phi_2442_ = type_30(0u, 4294967295u, 4294967295u, 4294967295u); + phi_2474_ = type_30(0u, 4294967295u, 4294967295u, 4294967295u); } - let _e2012 = phi_2442_; - if (_e124 >= 10u) { - phi_6809_ = (_e2012.member_2 <= (_e124 - 10u)); + let _e2036 = phi_2474_; + if (_e148 >= 10u) { + phi_7444_ = (_e2036.member_2 <= (_e148 - 10u)); } else { - phi_6809_ = false; + phi_7444_ = false; } - let _e2018 = phi_6809_; - if _e2018 { - let _e2021 = global_1.member[_e2012.member_2]; - let _e2026 = global_1.member[(_e2012.member_2 + 1u)]; - let _e2031 = global_1.member[(_e2012.member_2 + 2u)]; - let _e2037 = global_1.member[(_e2012.member_2 + 3u)]; - let _e2042 = global_1.member[(_e2012.member_2 + 4u)]; - let _e2047 = global_1.member[(_e2012.member_2 + 5u)]; - let _e2052 = global_1.member[(_e2012.member_2 + 6u)]; - let _e2058 = global_1.member[(_e2012.member_2 + 7u)]; - let _e2063 = global_1.member[(_e2012.member_2 + 8u)]; - let _e2068 = global_1.member[(_e2012.member_2 + 9u)]; - phi_2492_ = type_31(vec3(bitcast(_e2021), bitcast(_e2026), bitcast(_e2031)), vec4(bitcast(_e2037), bitcast(_e2042), bitcast(_e2047), bitcast(_e2052)), vec3(bitcast(_e2058), bitcast(_e2063), bitcast(_e2068))); + let _e2042 = phi_7444_; + if _e2042 { + let _e2045 = global_1.member[_e2036.member_2]; + let _e2050 = global_1.member[(_e2036.member_2 + 1u)]; + let _e2055 = global_1.member[(_e2036.member_2 + 2u)]; + let _e2061 = global_1.member[(_e2036.member_2 + 3u)]; + let _e2066 = global_1.member[(_e2036.member_2 + 4u)]; + let _e2071 = global_1.member[(_e2036.member_2 + 5u)]; + let _e2076 = global_1.member[(_e2036.member_2 + 6u)]; + let _e2082 = global_1.member[(_e2036.member_2 + 7u)]; + let _e2087 = global_1.member[(_e2036.member_2 + 8u)]; + let _e2092 = global_1.member[(_e2036.member_2 + 9u)]; + phi_2524_ = type_31(vec3(bitcast(_e2045), bitcast(_e2050), bitcast(_e2055)), vec4(bitcast(_e2061), bitcast(_e2066), bitcast(_e2071), bitcast(_e2076)), vec3(bitcast(_e2082), bitcast(_e2087), bitcast(_e2092))); } else { - phi_2492_ = type_31(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + phi_2524_ = type_31(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); } - let _e2073 = phi_2492_; - let _e2081 = (_e2073.member_1.x + _e2073.member_1.x); - let _e2082 = (_e2073.member_1.y + _e2073.member_1.y); - let _e2083 = (_e2073.member_1.z + _e2073.member_1.z); - let _e2085 = (_e2073.member_1.z * _e2083); - let _e2086 = (_e2073.member_1.w * _e2081); - let _e2087 = (_e2073.member_1.w * _e2082); - let _e2088 = (_e2073.member_1.w * _e2083); - let _e2108 = (vec4((1f - fma(_e2073.member_1.y, _e2082, _e2085)), fma(_e2073.member_1.x, _e2082, _e2088), fma(_e2073.member_1.x, _e2083, -(_e2087)), 0f) * _e2073.member_2.x); - let _e2110 = (vec4(fma(_e2073.member_1.x, _e2082, -(_e2088)), (1f - fma(_e2073.member_1.x, _e2081, _e2085)), fma(_e2073.member_1.y, _e2083, _e2086), 0f) * _e2073.member_2.y); - let _e2112 = (vec4(fma(_e2073.member_1.x, _e2083, _e2087), fma(_e2073.member_1.y, _e2083, -(_e2086)), (1f - fma(_e2073.member_1.x, _e2081, (_e2073.member_1.y * _e2082))), 0f) * _e2073.member_2.z); - switch bitcast(_e2012.member) { + let _e2097 = phi_2524_; + let _e2105 = (_e2097.member_1.x + _e2097.member_1.x); + let _e2106 = (_e2097.member_1.y + _e2097.member_1.y); + let _e2107 = (_e2097.member_1.z + _e2097.member_1.z); + let _e2109 = (_e2097.member_1.z * _e2107); + let _e2110 = (_e2097.member_1.w * _e2105); + let _e2111 = (_e2097.member_1.w * _e2106); + let _e2112 = (_e2097.member_1.w * _e2107); + let _e2132 = (vec4((1f - fma(_e2097.member_1.y, _e2106, _e2109)), fma(_e2097.member_1.x, _e2106, _e2112), fma(_e2097.member_1.x, _e2107, -(_e2111)), 0f) * _e2097.member_2.x); + let _e2134 = (vec4(fma(_e2097.member_1.x, _e2106, -(_e2112)), (1f - fma(_e2097.member_1.x, _e2105, _e2109)), fma(_e2097.member_1.y, _e2107, _e2110), 0f) * _e2097.member_2.y); + let _e2136 = (vec4(fma(_e2097.member_1.x, _e2107, _e2111), fma(_e2097.member_1.y, _e2107, -(_e2110)), (1f - fma(_e2097.member_1.x, _e2105, (_e2097.member_1.y * _e2106))), 0f) * _e2097.member_2.z); + switch bitcast(_e2036.member) { case 0: { - if (_e124 >= 8u) { - phi_7429_ = (_e2012.member_1 <= (_e124 - 8u)); + if (_e148 >= 8u) { + phi_8343_ = (_e2036.member_1 <= (_e148 - 8u)); } else { - phi_7429_ = false; + phi_8343_ = false; } - let _e3114 = phi_7429_; - if _e3114 { - let _e3117 = global_1.member[_e2012.member_1]; - let _e3122 = global_1.member[(_e2012.member_1 + 1u)]; - let _e3127 = global_1.member[(_e2012.member_1 + 2u)]; - let _e3133 = global_1.member[(_e2012.member_1 + 3u)]; - let _e3138 = global_1.member[(_e2012.member_1 + 4u)]; - let _e3143 = global_1.member[(_e2012.member_1 + 5u)]; - let _e3148 = global_1.member[(_e2012.member_1 + 6u)]; - let _e3154 = global_1.member[(_e2012.member_1 + 7u)]; - phi_2540_ = type_34(vec3(bitcast(_e3117), bitcast(_e3122), bitcast(_e3127)), vec4(bitcast(_e3133), bitcast(_e3138), bitcast(_e3143), bitcast(_e3148)), bitcast(_e3154)); + let _e3568 = phi_8343_; + if _e3568 { + let _e3571 = global_1.member[_e2036.member_1]; + let _e3576 = global_1.member[(_e2036.member_1 + 1u)]; + let _e3581 = global_1.member[(_e2036.member_1 + 2u)]; + let _e3587 = global_1.member[(_e2036.member_1 + 3u)]; + let _e3592 = global_1.member[(_e2036.member_1 + 4u)]; + let _e3597 = global_1.member[(_e2036.member_1 + 5u)]; + let _e3602 = global_1.member[(_e2036.member_1 + 6u)]; + let _e3608 = global_1.member[(_e2036.member_1 + 7u)]; + phi_2572_ = type_36(vec3(bitcast(_e3571), bitcast(_e3576), bitcast(_e3581)), vec4(bitcast(_e3587), bitcast(_e3592), bitcast(_e3597), bitcast(_e3602)), bitcast(_e3608)); } else { - phi_2540_ = type_34(vec3(0f, -1f, 0f), vec4(1f, 1f, 1f, 1f), 1f); + phi_2572_ = type_36(vec3(0f, -1f, 0f), vec4(1f, 1f, 1f, 1f), 1f); } - let _e3158 = phi_2540_; - let _e3180 = fma(_e2112.x, _e3158.member.z, fma(_e2110.x, _e3158.member.y, (_e2108.x * _e3158.member.x))); - let _e3181 = fma(_e2112.y, _e3158.member.z, fma(_e2110.y, _e3158.member.y, (_e2108.y * _e3158.member.x))); - let _e3182 = fma(_e2112.z, _e3158.member.z, fma(_e2110.z, _e3158.member.y, (_e2108.z * _e3158.member.x))); - let _e3187 = sqrt(fma(_e3182, _e3182, fma(_e3180, _e3180, (_e3181 * _e3181)))); - if (_e3187 == 0f) { - phi_7476_ = vec3(0f, 0f, 0f); + let _e3612 = phi_2572_; + let _e3634 = fma(_e2136.x, _e3612.member.z, fma(_e2134.x, _e3612.member.y, (_e2132.x * _e3612.member.x))); + let _e3635 = fma(_e2136.y, _e3612.member.z, fma(_e2134.y, _e3612.member.y, (_e2132.y * _e3612.member.x))); + let _e3636 = fma(_e2136.z, _e3612.member.z, fma(_e2134.z, _e3612.member.y, (_e2132.z * _e3612.member.x))); + let _e3641 = sqrt(fma(_e3636, _e3636, fma(_e3634, _e3634, (_e3635 * _e3635)))); + if (_e3641 == 0f) { + phi_8390_ = vec3(0f, 0f, 0f); } else { - phi_7476_ = (vec3(_e3180, _e3181, _e3182) * (1f / _e3187)); + phi_8390_ = (vec3(_e3634, _e3635, _e3636) * (1f / _e3641)); } - let _e3192 = phi_7476_; - let _e3194 = -(_e3192.x); - let _e3196 = -(_e3192.y); - let _e3198 = -(_e3192.z); - let _e3199 = -(_e3192); - let _e3201 = fma(-(_e686.z), _e295.member_3, 1f); - let _e3205 = fma(0.4f, _e3201, (_e1370 * _e1382)); - let _e3206 = fma(0.4f, _e3201, (_e1372 * _e1382)); - let _e3207 = fma(0.4f, _e3201, (_e1374 * _e1382)); - let _e3215 = (_e1938 + vec3(_e3194, _e3196, _e3198)); - let _e3222 = sqrt(fma(_e3215.z, _e3215.z, fma(_e3215.x, _e3215.x, (_e3215.y * _e3215.y)))); - if (_e3222 == 0f) { - phi_7511_ = vec3(0f, 0f, 0f); + let _e3646 = phi_8390_; + let _e3648 = -(_e3646.x); + let _e3650 = -(_e3646.y); + let _e3652 = -(_e3646.z); + let _e3653 = -(_e3646); + let _e3655 = fma(-(_e710.z), _e319.member_3, 1f); + let _e3659 = fma(0.4f, _e3655, (_e1394 * _e1406)); + let _e3660 = fma(0.4f, _e3655, (_e1396 * _e1406)); + let _e3661 = fma(0.4f, _e3655, (_e1398 * _e1406)); + let _e3669 = (_e1962 + vec3(_e3648, _e3650, _e3652)); + let _e3676 = sqrt(fma(_e3669.z, _e3669.z, fma(_e3669.x, _e3669.x, (_e3669.y * _e3669.y)))); + if (_e3676 == 0f) { + phi_8425_ = vec3(0f, 0f, 0f); } else { - phi_7511_ = (_e3215 * (1f / _e3222)); + phi_8425_ = (_e3669 * (1f / _e3676)); } - let _e3227 = phi_7511_; - let _e3228 = (_e1379 * _e1379); - let _e3239 = max(fma(_e1934.z, _e3227.z, fma(_e1934.x, _e3227.x, (_e1934.y * _e3227.y))), 0f); - let _e3252 = max(fma(_e1934.z, _e1938.z, fma(_e1934.x, _e1938.x, (_e1934.y * _e1938.y))), 0f); - let _e3258 = fma(_e1934.z, _e3199.z, fma(_e1934.x, _e3199.x, (_e1934.y * _e3199.y))); - let _e3259 = max(_e3258, 0f); - let _e3260 = fma(_e686.y, _e295.member_4, 1f); - let _e3261 = (_e3260 * _e3260); - let _e3262 = (_e3261 * 0.125f); - let _e3264 = fma(-(_e3261), 0.125f, 1f); - let _e3277 = (1f - max(fma(_e3227.z, _e1938.z, fma(_e3227.x, _e1938.x, (_e3227.y * _e1938.y))), 0f)); - let _e3279 = select(_e3277, 0f, (_e3277 < 0f)); - let _e3282 = pow(select(_e3279, 1f, (_e3279 > 1f)), 5f); - let _e3283 = fma((1f - _e3205), _e3282, _e3205); - let _e3284 = fma((1f - _e3206), _e3282, _e3206); - let _e3285 = fma((1f - _e3207), _e3282, _e3207); - let _e3292 = (((_e3228 * _e3228) / (pow(fma((_e3239 * _e3239), fma(_e3228, _e3228, -1f), 1f), 2f) * 3.1415927f)) * ((_e3252 / fma(_e3252, _e3264, _e3262)) * (_e3259 / fma(_e3259, _e3264, _e3262)))); - let _e3299 = max(fma(_e1934.z, _e3198, fma(_e1934.x, _e3194, (_e1934.y * _e3196))), 0f); - let _e3301 = fma((4f * _e3252), _e3299, 0.0001f); - if ((_e2012.member_3 == 4294967295u) != true) { - let _e3322 = global_1.member[_e2012.member_3]; - let _e3326 = global_1.member[(_e2012.member_3 + 1u)]; - let _e3330 = global_1.member[(_e2012.member_3 + 2u)]; - let _e3334 = global_1.member[(_e2012.member_3 + 3u)]; - let _e3338 = global_1.member[(_e2012.member_3 + 4u)]; - let _e3343 = global_1.member[(_e2012.member_3 + 5u)]; - let _e3348 = global_1.member[(_e2012.member_3 + 6u)]; - let _e3353 = global_1.member[select(_e3330, 4294967295u, (0u >= _e3334))]; - let _e3356 = global_1.member[_e3353]; - let _e3360 = global_1.member[(_e3353 + 1u)]; - let _e3364 = global_1.member[(_e3353 + 2u)]; - let _e3368 = global_1.member[(_e3353 + 3u)]; - let _e3372 = global_1.member[(_e3353 + 4u)]; - let _e3376 = global_1.member[(_e3353 + 6u)]; - switch bitcast(_e3376) { - case 0: { - phi_2781_ = 0u; - break; - } - case 1: { - phi_2781_ = 1u; - break; - } - case 2: { - phi_2781_ = 2u; - break; - } - default: { - phi_2781_ = 0u; - break; - } - } - let _e3379 = phi_2781_; - let _e3383 = global_1.member[(_e3353 + 7u)]; - switch bitcast(_e3383) { - case 0: { - phi_2790_ = 0u; - break; - } - case 1: { - phi_2790_ = 1u; - break; - } - case 2: { - phi_2790_ = 2u; - break; - } - default: { - phi_2790_ = 0u; - break; - } - } - let _e3386 = phi_2790_; - let _e3389 = global_1.member[_e1947]; - let _e3393 = global_1.member[(_e1947 + 1u)]; - let _e3395 = select(_e3322, 4294967295u, (0u >= _e3326)); - let _e3398 = global_1.member[_e3395]; - let _e3403 = global_1.member[(_e3395 + 1u)]; - let _e3408 = global_1.member[(_e3395 + 2u)]; - let _e3413 = global_1.member[(_e3395 + 3u)]; - let _e3418 = global_1.member[(_e3395 + 4u)]; - let _e3423 = global_1.member[(_e3395 + 5u)]; - let _e3428 = global_1.member[(_e3395 + 6u)]; - let _e3433 = global_1.member[(_e3395 + 7u)]; - let _e3438 = global_1.member[(_e3395 + 8u)]; - let _e3443 = global_1.member[(_e3395 + 9u)]; - let _e3448 = global_1.member[(_e3395 + 10u)]; - let _e3453 = global_1.member[(_e3395 + 11u)]; - let _e3458 = global_1.member[(_e3395 + 12u)]; - let _e3463 = global_1.member[(_e3395 + 13u)]; - let _e3468 = global_1.member[(_e3395 + 14u)]; - let _e3473 = global_1.member[(_e3395 + 15u)]; - let _e3493 = (bitcast(_e3473) + fma(bitcast(_e3453), _e132.z, fma(bitcast(_e3433), _e132.y, (bitcast(_e3413) * _e132.x)))); - let _e3494 = ((bitcast(_e3458) + fma(bitcast(_e3438), _e132.z, fma(bitcast(_e3418), _e132.y, (bitcast(_e3398) * _e132.x)))) / _e3493); - let _e3495 = ((bitcast(_e3463) + fma(bitcast(_e3443), _e132.z, fma(bitcast(_e3423), _e132.y, (bitcast(_e3403) * _e132.x)))) / _e3493); - let _e3496 = ((bitcast(_e3468) + fma(bitcast(_e3448), _e132.z, fma(bitcast(_e3428), _e132.y, (bitcast(_e3408) * _e132.x)))) / _e3493); - if (abs(_e3494) <= 1f) { - let _e3500 = (abs(_e3495) <= 1f); - if _e3500 { - phi_7620_ = (abs(_e3496) <= 1f); + let _e3681 = phi_8425_; + let _e3682 = (_e1403 * _e1403); + let _e3693 = max(fma(_e1958.z, _e3681.z, fma(_e1958.x, _e3681.x, (_e1958.y * _e3681.y))), 0f); + let _e3706 = max(fma(_e1958.z, _e1962.z, fma(_e1958.x, _e1962.x, (_e1958.y * _e1962.y))), 0f); + let _e3712 = fma(_e1958.z, _e3653.z, fma(_e1958.x, _e3653.x, (_e1958.y * _e3653.y))); + let _e3713 = max(_e3712, 0f); + let _e3714 = fma(_e710.y, _e319.member_4, 1f); + let _e3715 = (_e3714 * _e3714); + let _e3716 = (_e3715 * 0.125f); + let _e3718 = fma(-(_e3715), 0.125f, 1f); + let _e3731 = (1f - max(fma(_e3681.z, _e1962.z, fma(_e3681.x, _e1962.x, (_e3681.y * _e1962.y))), 0f)); + let _e3733 = select(_e3731, 0f, (_e3731 < 0f)); + let _e3736 = pow(select(_e3733, 1f, (_e3733 > 1f)), 5f); + let _e3737 = fma((1f - _e3659), _e3736, _e3659); + let _e3738 = fma((1f - _e3660), _e3736, _e3660); + let _e3739 = fma((1f - _e3661), _e3736, _e3661); + let _e3746 = (((_e3682 * _e3682) / (pow(fma((_e3693 * _e3693), fma(_e3682, _e3682, -1f), 1f), 2f) * 3.1415927f)) * ((_e3706 / fma(_e3706, _e3718, _e3716)) * (_e3713 / fma(_e3713, _e3718, _e3716)))); + let _e3753 = max(fma(_e1958.z, _e3652, fma(_e1958.x, _e3648, (_e1958.y * _e3650))), 0f); + let _e3755 = fma((4f * _e3706), _e3753, 0.0001f); + if ((_e2036.member_3 == 4294967295u) != true) { + let _e3777 = global_1.member[_e2036.member_3]; + let _e3781 = global_1.member[(_e2036.member_3 + 1u)]; + let _e3785 = global_1.member[(_e2036.member_3 + 4u)]; + let _e3789 = global_1.member[(_e2036.member_3 + 5u)]; + let _e3793 = global_1.member[(_e2036.member_3 + 6u)]; + let _e3798 = global_1.member[(_e2036.member_3 + 7u)]; + let _e3803 = global_1.member[(_e2036.member_3 + 8u)]; + let _e3806 = global_1.member[_e1971]; + let _e3810 = global_1.member[(_e1971 + 1u)]; + let _e3812 = select(_e3777, 4294967295u, (0u >= _e3781)); + let _e3815 = global_1.member[_e3812]; + let _e3820 = global_1.member[(_e3812 + 1u)]; + let _e3825 = global_1.member[(_e3812 + 2u)]; + let _e3830 = global_1.member[(_e3812 + 3u)]; + let _e3835 = global_1.member[(_e3812 + 4u)]; + let _e3840 = global_1.member[(_e3812 + 5u)]; + let _e3845 = global_1.member[(_e3812 + 6u)]; + let _e3850 = global_1.member[(_e3812 + 7u)]; + let _e3855 = global_1.member[(_e3812 + 8u)]; + let _e3860 = global_1.member[(_e3812 + 9u)]; + let _e3865 = global_1.member[(_e3812 + 10u)]; + let _e3870 = global_1.member[(_e3812 + 11u)]; + let _e3875 = global_1.member[(_e3812 + 12u)]; + let _e3880 = global_1.member[(_e3812 + 13u)]; + let _e3885 = global_1.member[(_e3812 + 14u)]; + let _e3890 = global_1.member[(_e3812 + 15u)]; + let _e3910 = (bitcast(_e3890) + fma(bitcast(_e3870), _e156.z, fma(bitcast(_e3850), _e156.y, (bitcast(_e3830) * _e156.x)))); + let _e3911 = ((bitcast(_e3875) + fma(bitcast(_e3855), _e156.z, fma(bitcast(_e3835), _e156.y, (bitcast(_e3815) * _e156.x)))) / _e3910); + let _e3912 = ((bitcast(_e3880) + fma(bitcast(_e3860), _e156.z, fma(bitcast(_e3840), _e156.y, (bitcast(_e3820) * _e156.x)))) / _e3910); + let _e3913 = ((bitcast(_e3885) + fma(bitcast(_e3865), _e156.z, fma(bitcast(_e3845), _e156.y, (bitcast(_e3825) * _e156.x)))) / _e3910); + if (abs(_e3911) <= 1f) { + let _e3917 = (abs(_e3912) <= 1f); + if _e3917 { + phi_8530_ = (abs(_e3913) <= 1f); } else { - phi_7620_ = bool(); + phi_8530_ = bool(); } - let _e3504 = phi_7620_; - phi_7623_ = _e3504; - phi_7624_ = select(true, false, _e3500); + let _e3921 = phi_8530_; + phi_8533_ = _e3921; + phi_8534_ = select(true, false, _e3917); } else { - phi_7623_ = bool(); - phi_7624_ = true; + phi_8533_ = bool(); + phi_8534_ = true; } - let _e3507 = phi_7623_; - let _e3509 = phi_7624_; - if select(_e3507, false, _e3509) { - let _e3513 = bitcast(_e3348); - let _e3515 = f32(_e3364); - let _e3516 = f32(_e3368); - let _e3520 = type_35((_e3513 / -2i), (_e3513 / 2i), false); - phi_8039_ = _e1950; - phi_2969_ = _e3520; - phi_2972_ = 0f; - phi_2974_ = 0f; + let _e3924 = phi_8533_; + let _e3926 = phi_8534_; + if select(_e3924, false, _e3926) { + let _e3934 = global_1.member[select(_e3785, 4294967295u, (0u >= _e3789))]; + let _e3937 = global_1.member[_e3934]; + let _e3941 = global_1.member[(_e3934 + 1u)]; + let _e3945 = global_1.member[(_e3934 + 2u)]; + let _e3949 = global_1.member[(_e3934 + 3u)]; + let _e3953 = global_1.member[(_e3934 + 4u)]; + let _e3957 = global_1.member[(_e3934 + 6u)]; + switch bitcast(_e3957) { + case 0: { + phi_2973_ = 0u; + break; + } + case 1: { + phi_2973_ = 1u; + break; + } + case 2: { + phi_2973_ = 2u; + break; + } + default: { + phi_2973_ = 0u; + break; + } + } + let _e3960 = phi_2973_; + let _e3964 = global_1.member[(_e3934 + 7u)]; + switch bitcast(_e3964) { + case 0: { + phi_2982_ = 0u; + break; + } + case 1: { + phi_2982_ = 1u; + break; + } + case 2: { + phi_2982_ = 2u; + break; + } + default: { + phi_2982_ = 0u; + break; + } + } + let _e3967 = phi_2982_; + let _e3968 = bitcast(_e3803); + let _e3970 = f32(_e3945); + let _e3971 = f32(_e3949); + let _e3975 = type_37((_e3968 / -2i), (_e3968 / 2i), false); + phi_9009_ = _e1974; + phi_3010_ = _e3975; + phi_3013_ = 0f; + phi_3015_ = 0f; loop { - let _e3522 = phi_8039_; - let _e3524 = phi_2969_; - let _e3526 = phi_2972_; - let _e3528 = phi_2974_; - local_4 = _e3526; - local_5 = _e3528; - if _e3524.member_2 { - phi_2986_ = true; + let _e3977 = phi_9009_; + let _e3979 = phi_3010_; + let _e3981 = phi_3013_; + let _e3983 = phi_3015_; + local_6 = _e3981; + local_7 = _e3983; + if _e3979.member_2 { + phi_3027_ = true; } else { - phi_2986_ = ((_e3524.member <= _e3524.member_1) != true); + phi_3027_ = ((_e3979.member <= _e3979.member_1) != true); } - let _e3535 = phi_2986_; - if _e3535 { - phi_2970_ = _e3524; - phi_3029_ = type_36(0u, type_36().member_1); + let _e3990 = phi_3027_; + if _e3990 { + phi_3011_ = _e3979; + phi_3070_ = type_38(0u, type_38().member_1); } else { - if (_e3524.member < _e3524.member_1) { - let _e3543 = (_e3524.member + 1i); - if select(false, true, ((false == (_e3543 > _e3524.member)) != false)) { - phi_3014_ = type_36(0u, type_36().member_1); + if (_e3979.member < _e3979.member_1) { + let _e3998 = (_e3979.member + 1i); + if select(false, true, ((false == (_e3998 > _e3979.member)) != false)) { + phi_3055_ = type_38(0u, type_38().member_1); } else { - phi_3014_ = type_36(1u, _e3543); + phi_3055_ = type_38(1u, _e3998); } - let _e3553 = phi_3014_; - switch bitcast(_e3553.member) { + let _e4008 = phi_3055_; + switch bitcast(_e4008.member) { case 0: { - phi_8084_ = true; + phi_9054_ = true; break; } case 1: { @@ -2140,55 +2197,55 @@ fn function() { break; } } - phi_3026_ = type_35(_e3553.member_1, _e3524.member_1, _e3524.member_2); + phi_3067_ = type_37(_e4008.member_1, _e3979.member_1, _e3979.member_2); } else { - phi_3026_ = type_35(_e3524.member, _e3524.member_1, true); + phi_3067_ = type_37(_e3979.member, _e3979.member_1, true); } - let _e3562 = phi_3026_; - phi_2970_ = _e3562; - phi_3029_ = type_36(1u, _e3524.member); + let _e4017 = phi_3067_; + phi_3011_ = _e4017; + phi_3070_ = type_38(1u, _e3979.member); } - let _e3568 = phi_2970_; - let _e3570 = phi_3029_; - switch bitcast(_e3570.member) { + let _e4023 = phi_3011_; + let _e4025 = phi_3070_; + switch bitcast(_e4025.member) { case 0: { - phi_8085_ = _e3522; - phi_2973_ = f32(); - phi_2975_ = f32(); - phi_3288_ = false; + phi_9055_ = _e3977; + phi_3014_ = f32(); + phi_3016_ = f32(); + phi_3328_ = false; break; } case 1: { - phi_3040_ = _e3520; - phi_3043_ = _e3526; - phi_3045_ = _e3528; + phi_3081_ = _e3975; + phi_3084_ = _e3981; + phi_3086_ = _e3983; loop { - let _e3575 = phi_3040_; - let _e3577 = phi_3043_; - let _e3579 = phi_3045_; - local_11 = _e3577; - local_12 = _e3579; - if _e3575.member_2 { - phi_3057_ = true; + let _e4030 = phi_3081_; + let _e4032 = phi_3084_; + let _e4034 = phi_3086_; + local_13 = _e4032; + local_14 = _e4034; + if _e4030.member_2 { + phi_3098_ = true; } else { - phi_3057_ = ((_e3575.member <= _e3575.member_1) != true); + phi_3098_ = ((_e4030.member <= _e4030.member_1) != true); } - let _e3586 = phi_3057_; - if _e3586 { - phi_3041_ = _e3575; - phi_3100_ = type_36(0u, type_36().member_1); + let _e4041 = phi_3098_; + if _e4041 { + phi_3082_ = _e4030; + phi_3141_ = type_38(0u, type_38().member_1); } else { - if (_e3575.member < _e3575.member_1) { - let _e3594 = (_e3575.member + 1i); - if select(false, true, ((false == (_e3594 > _e3575.member)) != false)) { - phi_3085_ = type_36(0u, type_36().member_1); + if (_e4030.member < _e4030.member_1) { + let _e4049 = (_e4030.member + 1i); + if select(false, true, ((false == (_e4049 > _e4030.member)) != false)) { + phi_3126_ = type_38(0u, type_38().member_1); } else { - phi_3085_ = type_36(1u, _e3594); + phi_3126_ = type_38(1u, _e4049); } - let _e3604 = phi_3085_; - switch bitcast(_e3604.member) { + let _e4059 = phi_3126_; + switch bitcast(_e4059.member) { case 0: { - phi_8023_ = true; + phi_8993_ = true; break; } case 1: { @@ -2198,547 +2255,954 @@ fn function() { break; } } - phi_3097_ = type_35(_e3604.member_1, _e3575.member_1, _e3575.member_2); + phi_3138_ = type_37(_e4059.member_1, _e4030.member_1, _e4030.member_2); } else { - phi_3097_ = type_35(_e3575.member, _e3575.member_1, true); + phi_3138_ = type_37(_e4030.member, _e4030.member_1, true); } - let _e3613 = phi_3097_; - phi_3041_ = _e3613; - phi_3100_ = type_36(1u, _e3575.member); + let _e4068 = phi_3138_; + phi_3082_ = _e4068; + phi_3141_ = type_38(1u, _e4030.member); } - let _e3619 = phi_3041_; - let _e3621 = phi_3100_; - switch bitcast(_e3621.member) { + let _e4074 = phi_3082_; + let _e4076 = phi_3141_; + switch bitcast(_e4076.member) { case 0: { - phi_3044_ = f32(); - phi_3046_ = f32(); - phi_3287_ = false; + phi_3085_ = f32(); + phi_3087_ = f32(); + phi_3327_ = false; break; } case 1: { - let _e3629 = fma((_e3494 + 1f), 0.5f, (f32(_e3570.member_1) * (1f / _e3515))); - let _e3630 = fma(fma(_e3495, -1f, 1f), 0.5f, (f32(_e3621.member_1) * (1f / _e3516))); - switch bitcast(_e3379) { + let _e4084 = fma((_e3911 + 1f), 0.5f, (f32(_e4025.member_1) * (1f / _e3970))); + let _e4085 = fma(fma(_e3912, -1f, 1f), 0.5f, (f32(_e4076.member_1) * (1f / _e3971))); + switch bitcast(_e3960) { case 1: { - let _e3665 = abs(_e3629); - let _e3667 = (_e3665 % 1f); - if (_e3665 >= 1f) { - phi_7672_ = select(true, false, (_e3667 == 0f)); + let _e4120 = abs(_e4084); + let _e4122 = (_e4120 % 1f); + if (_e4120 >= 1f) { + phi_8586_ = select(true, false, (_e4122 == 0f)); } else { - phi_7672_ = true; + phi_8586_ = true; } - let _e3671 = phi_7672_; - let _e3672 = select(1f, _e3667, _e3671); - if (select(-1f, 1f, (_e3629 >= 0f)) > 0f) { - phi_3132_ = _e3672; + let _e4126 = phi_8586_; + let _e4127 = select(1f, _e4122, _e4126); + if (select(-1f, 1f, (_e4084 >= 0f)) > 0f) { + phi_3173_ = _e4127; } else { - phi_3132_ = (1f - _e3672); + phi_3173_ = (1f - _e4127); } - let _e3676 = phi_3132_; - phi_3169_ = _e3676; + let _e4131 = phi_3173_; + phi_3210_ = _e4131; break; } case 2: { - let _e3639 = abs(_e3629); - let _e3646 = ((select(select(u32(_e3639), 0u, (_e3639 < 0f)), 4294967295u, (_e3639 > 4294967000f)) % 2u) == 0u); - let _e3648 = (_e3639 % 1f); - if (_e3639 >= 1f) { - phi_7655_ = select(true, false, (_e3648 == 0f)); + let _e4094 = abs(_e4084); + let _e4101 = ((select(select(u32(_e4094), 0u, (_e4094 < 0f)), 4294967295u, (_e4094 > 4294967000f)) % 2u) == 0u); + let _e4103 = (_e4094 % 1f); + if (_e4094 >= 1f) { + phi_8569_ = select(true, false, (_e4103 == 0f)); } else { - phi_7655_ = true; + phi_8569_ = true; } - let _e3652 = phi_7655_; - let _e3653 = select(1f, _e3648, _e3652); - if (select(-1f, 1f, (_e3629 >= 0f)) > 0f) { - if _e3646 { - phi_3161_ = _e3653; + let _e4107 = phi_8569_; + let _e4108 = select(1f, _e4103, _e4107); + if (select(-1f, 1f, (_e4084 >= 0f)) > 0f) { + if _e4101 { + phi_3202_ = _e4108; } else { - phi_3161_ = (1f - _e3653); + phi_3202_ = (1f - _e4108); } - let _e3660 = phi_3161_; - phi_3167_ = _e3660; + let _e4115 = phi_3202_; + phi_3208_ = _e4115; } else { - if _e3646 { - phi_3166_ = (1f - _e3653); + if _e4101 { + phi_3207_ = (1f - _e4108); } else { - phi_3166_ = _e3653; + phi_3207_ = _e4108; } - let _e3657 = phi_3166_; - phi_3167_ = _e3657; + let _e4112 = phi_3207_; + phi_3208_ = _e4112; } - let _e3662 = phi_3167_; - phi_3169_ = _e3662; + let _e4117 = phi_3208_; + phi_3210_ = _e4117; break; } case 0: { - if (_e3629 > 1f) { - phi_7642_ = 0.9999999f; + if (_e4084 > 1f) { + phi_8556_ = 0.9999999f; } else { - phi_7642_ = select(_e3629, 0.00000011920929f, (_e3629 < 0f)); + phi_8556_ = select(_e4084, 0.00000011920929f, (_e4084 < 0f)); } - let _e3636 = phi_7642_; - phi_3169_ = _e3636; + let _e4091 = phi_8556_; + phi_3210_ = _e4091; break; } default: { - phi_3169_ = f32(); + phi_3210_ = f32(); break; } } - let _e3678 = phi_3169_; - switch bitcast(_e3386) { + let _e4133 = phi_3210_; + switch bitcast(_e3967) { case 1: { - let _e3713 = abs(_e3630); - let _e3715 = (_e3713 % 1f); - if (_e3713 >= 1f) { - phi_7720_ = select(true, false, (_e3715 == 0f)); + let _e4168 = abs(_e4085); + let _e4170 = (_e4168 % 1f); + if (_e4168 >= 1f) { + phi_8634_ = select(true, false, (_e4170 == 0f)); } else { - phi_7720_ = true; + phi_8634_ = true; } - let _e3719 = phi_7720_; - let _e3720 = select(1f, _e3715, _e3719); - if (select(-1f, 1f, (_e3630 >= 0f)) > 0f) { - phi_3188_ = _e3720; + let _e4174 = phi_8634_; + let _e4175 = select(1f, _e4170, _e4174); + if (select(-1f, 1f, (_e4085 >= 0f)) > 0f) { + phi_3229_ = _e4175; } else { - phi_3188_ = (1f - _e3720); + phi_3229_ = (1f - _e4175); } - let _e3724 = phi_3188_; - phi_3225_ = _e3724; + let _e4179 = phi_3229_; + phi_3266_ = _e4179; break; } case 2: { - let _e3687 = abs(_e3630); - let _e3694 = ((select(select(u32(_e3687), 0u, (_e3687 < 0f)), 4294967295u, (_e3687 > 4294967000f)) % 2u) == 0u); - let _e3696 = (_e3687 % 1f); - if (_e3687 >= 1f) { - phi_7703_ = select(true, false, (_e3696 == 0f)); + let _e4142 = abs(_e4085); + let _e4149 = ((select(select(u32(_e4142), 0u, (_e4142 < 0f)), 4294967295u, (_e4142 > 4294967000f)) % 2u) == 0u); + let _e4151 = (_e4142 % 1f); + if (_e4142 >= 1f) { + phi_8617_ = select(true, false, (_e4151 == 0f)); } else { - phi_7703_ = true; + phi_8617_ = true; } - let _e3700 = phi_7703_; - let _e3701 = select(1f, _e3696, _e3700); - if (select(-1f, 1f, (_e3630 >= 0f)) > 0f) { - if _e3694 { - phi_3217_ = _e3701; + let _e4155 = phi_8617_; + let _e4156 = select(1f, _e4151, _e4155); + if (select(-1f, 1f, (_e4085 >= 0f)) > 0f) { + if _e4149 { + phi_3258_ = _e4156; } else { - phi_3217_ = (1f - _e3701); + phi_3258_ = (1f - _e4156); } - let _e3708 = phi_3217_; - phi_3223_ = _e3708; + let _e4163 = phi_3258_; + phi_3264_ = _e4163; } else { - if _e3694 { - phi_3222_ = (1f - _e3701); + if _e4149 { + phi_3263_ = (1f - _e4156); } else { - phi_3222_ = _e3701; + phi_3263_ = _e4156; } - let _e3705 = phi_3222_; - phi_3223_ = _e3705; + let _e4160 = phi_3263_; + phi_3264_ = _e4160; } - let _e3710 = phi_3223_; - phi_3225_ = _e3710; + let _e4165 = phi_3264_; + phi_3266_ = _e4165; break; } case 0: { - if (_e3630 > 1f) { - phi_7690_ = 0.9999999f; + if (_e4085 > 1f) { + phi_8604_ = 0.9999999f; } else { - phi_7690_ = select(_e3630, 0.00000011920929f, (_e3630 < 0f)); + phi_8604_ = select(_e4085, 0.00000011920929f, (_e4085 < 0f)); } - let _e3684 = phi_7690_; - phi_3225_ = _e3684; + let _e4139 = phi_8604_; + phi_3266_ = _e4139; break; } default: { - phi_3225_ = f32(); + phi_3266_ = f32(); break; } } - let _e3726 = phi_3225_; - let _e3727 = (_e3678 * _e3515); - let _e3733 = (_e3726 * _e3516); - let _e3748 = vec3((f32((select(select(u32(_e3727), 0u, (_e3727 < 0f)), 4294967295u, (_e3727 > 4294967000f)) + _e3356)) / f32(_e3389)), (f32((select(select(u32(_e3733), 0u, (_e3733 < 0f)), 4294967295u, (_e3733 > 4294967000f)) + _e3360)) / f32(_e3393)), f32(_e3372)); - let _e3754 = textureSampleLevel(global_19, global_18, vec2(_e3748.x, _e3748.y), i32(_e3748.z), 0f); - phi_3044_ = (_e3577 + 1f); - phi_3046_ = (_e3579 + select(0f, 1f, ((_e3496 - max((bitcast(_e3343) * (1f - _e3258)), bitcast(_e3338))) > _e3754.x))); - phi_3287_ = true; + let _e4181 = phi_3266_; + let _e4182 = (_e4133 * _e3970); + let _e4188 = (_e4181 * _e3971); + let _e4203 = vec3((f32((select(select(u32(_e4182), 0u, (_e4182 < 0f)), 4294967295u, (_e4182 > 4294967000f)) + _e3937)) / f32(_e3806)), (f32((select(select(u32(_e4188), 0u, (_e4188 < 0f)), 4294967295u, (_e4188 > 4294967000f)) + _e3941)) / f32(_e3810)), f32(_e3953)); + let _e4209 = textureSampleLevel(global_19, global_18, vec2(_e4203.x, _e4203.y), i32(_e4203.z), 0f); + if ((_e3913 - max((bitcast(_e3798) * (1f - _e3712)), bitcast(_e3793))) > _e4209.x) { + phi_3325_ = (_e4034 + 1f); + } else { + phi_3325_ = _e4034; + } + let _e4218 = phi_3325_; + phi_3085_ = (_e4032 + 1f); + phi_3087_ = _e4218; + phi_3327_ = true; break; } default: { - phi_3044_ = f32(); - phi_3046_ = f32(); - phi_3287_ = bool(); + phi_3085_ = f32(); + phi_3087_ = f32(); + phi_3327_ = bool(); break; } } - let _e3765 = phi_3044_; - let _e3767 = phi_3046_; - let _e3769 = phi_3287_; + let _e4221 = phi_3085_; + let _e4223 = phi_3087_; + let _e4225 = phi_3327_; continue; continuing { - phi_3040_ = _e3619; - phi_3043_ = _e3765; - phi_3045_ = _e3767; - phi_8023_ = _e3522; - break if !(_e3769); + phi_3081_ = _e4074; + phi_3084_ = _e4221; + phi_3086_ = _e4223; + phi_8993_ = _e3977; + break if !(_e4225); } } - let _e3772 = phi_8023_; - phi_8084_ = _e3772; - if _e3772 { + let _e4228 = phi_8993_; + phi_9054_ = _e4228; + if _e4228 { break; } - phi_8085_ = _e3772; - let _e4164 = local_11; - phi_2973_ = _e4164; - let _e4167 = local_12; - phi_2975_ = _e4167; - phi_3288_ = true; + phi_9055_ = _e4228; + let _e4681 = local_13; + phi_3014_ = _e4681; + let _e4684 = local_14; + phi_3016_ = _e4684; + phi_3328_ = true; break; } default: { - phi_8085_ = _e3522; - phi_2973_ = f32(); - phi_2975_ = f32(); - phi_3288_ = bool(); + phi_9055_ = _e3977; + phi_3014_ = f32(); + phi_3016_ = f32(); + phi_3328_ = bool(); break; } } - let _e3774 = phi_8085_; - let _e3776 = phi_2973_; - let _e3778 = phi_2975_; - let _e3780 = phi_3288_; + let _e4230 = phi_9055_; + let _e4232 = phi_3014_; + let _e4234 = phi_3016_; + let _e4236 = phi_3328_; continue; continuing { - phi_8039_ = _e3774; - phi_2969_ = _e3568; - phi_2972_ = _e3776; - phi_2974_ = _e3778; - phi_8084_ = _e3774; - break if !(_e3780); + phi_9009_ = _e4230; + phi_3010_ = _e4023; + phi_3013_ = _e4232; + phi_3015_ = _e4234; + phi_9054_ = _e4230; + break if !(_e4236); } } - let _e3783 = phi_8084_; - phi_8086_ = _e3783; - if _e3783 { + let _e4239 = phi_9054_; + phi_9056_ = _e4239; + if _e4239 { break; } - let _e3785 = local_4; - let _e3788 = local_5; - phi_8103_ = _e3783; - phi_3291_ = (_e3788 / max(_e3785, 1f)); + let _e4241 = local_6; + let _e4244 = local_7; + phi_9067_ = _e4239; + phi_3331_ = (_e4244 / max(_e4241, 1f)); } else { - phi_8103_ = _e1950; - phi_3291_ = 0f; + phi_9067_ = _e1974; + phi_3331_ = 0f; } - let _e3791 = phi_8103_; - let _e3793 = phi_3291_; - phi_8102_ = _e3791; - phi_3292_ = _e3793; + let _e4247 = phi_9067_; + let _e4249 = phi_3331_; + phi_9066_ = _e4247; + phi_3332_ = _e4249; } else { - phi_8102_ = _e1950; - phi_3292_ = 0f; + phi_9066_ = _e1974; + phi_3332_ = 0f; } - let _e3795 = phi_8102_; - let _e3797 = phi_3292_; - let _e3798 = (1f - _e3797); - phi_8090_ = _e3795; - phi_4474_ = vec3(fma(((fma((((1f - _e3283) * _e3201) * _e1370), 0.31830987f, ((_e3292 * _e3283) / _e3301)) * (_e3158.member_1.x * _e3158.member_2)) * _e3299), _e3798, _e1954.x), fma(((fma((((1f - _e3284) * _e3201) * _e1372), 0.31830987f, ((_e3292 * _e3284) / _e3301)) * (_e3158.member_1.y * _e3158.member_2)) * _e3299), _e3798, _e1954.y), fma(((fma((((1f - _e3285) * _e3201) * _e1374), 0.31830987f, ((_e3292 * _e3285) / _e3301)) * (_e3158.member_1.z * _e3158.member_2)) * _e3299), _e3798, _e1954.z)); - phi_4475_ = true; + let _e4251 = phi_9066_; + let _e4253 = phi_3332_; + phi_9060_ = _e4251; + phi_4975_ = _e4253; + phi_4976_ = vec3(((fma((((1f - _e3737) * _e3655) * _e1394), 0.31830987f, ((_e3746 * _e3737) / _e3755)) * (_e3612.member_1.x * _e3612.member_2)) * _e3753), ((fma((((1f - _e3738) * _e3655) * _e1396), 0.31830987f, ((_e3746 * _e3738) / _e3755)) * (_e3612.member_1.y * _e3612.member_2)) * _e3753), ((fma((((1f - _e3739) * _e3655) * _e1398), 0.31830987f, ((_e3746 * _e3739) / _e3755)) * (_e3612.member_1.z * _e3612.member_2)) * _e3753)); + phi_4977_ = true; break; } case 1: { - if (_e124 >= 8u) { - phi_7255_ = (_e2012.member_1 <= (_e124 - 8u)); + if (_e148 >= 8u) { + phi_7890_ = (_e2036.member_1 <= (_e148 - 8u)); } else { - phi_7255_ = false; + phi_7890_ = false; } - let _e2902 = phi_7255_; - if _e2902 { - let _e2905 = global_1.member[_e2012.member_1]; - let _e2910 = global_1.member[(_e2012.member_1 + 1u)]; - let _e2915 = global_1.member[(_e2012.member_1 + 2u)]; - let _e2921 = global_1.member[(_e2012.member_1 + 3u)]; - let _e2926 = global_1.member[(_e2012.member_1 + 4u)]; - let _e2931 = global_1.member[(_e2012.member_1 + 5u)]; - let _e2936 = global_1.member[(_e2012.member_1 + 6u)]; - let _e2942 = global_1.member[(_e2012.member_1 + 7u)]; - phi_3346_ = type_34(vec3(bitcast(_e2905), bitcast(_e2910), bitcast(_e2915)), vec4(bitcast(_e2921), bitcast(_e2926), bitcast(_e2931), bitcast(_e2936)), bitcast(_e2942)); + let _e2922 = phi_7890_; + if _e2922 { + let _e2925 = global_1.member[_e2036.member_1]; + let _e2930 = global_1.member[(_e2036.member_1 + 1u)]; + let _e2935 = global_1.member[(_e2036.member_1 + 2u)]; + let _e2941 = global_1.member[(_e2036.member_1 + 3u)]; + let _e2946 = global_1.member[(_e2036.member_1 + 4u)]; + let _e2951 = global_1.member[(_e2036.member_1 + 5u)]; + let _e2956 = global_1.member[(_e2036.member_1 + 6u)]; + let _e2962 = global_1.member[(_e2036.member_1 + 7u)]; + phi_3373_ = type_36(vec3(bitcast(_e2925), bitcast(_e2930), bitcast(_e2935)), vec4(bitcast(_e2941), bitcast(_e2946), bitcast(_e2951), bitcast(_e2956)), bitcast(_e2962)); } else { - phi_3346_ = type_34(vec3(0f, 0f, 0f), vec4(1f, 1f, 1f, 1f), 1f); + phi_3373_ = type_36(vec3(0f, 0f, 0f), vec4(1f, 1f, 1f, 1f), 1f); } - let _e2946 = phi_3346_; - let _e2975 = (vec3((_e2073.member.x + fma(_e2112.x, _e2946.member.z, fma(_e2110.x, _e2946.member.y, (_e2108.x * _e2946.member.x)))), (_e2073.member.y + fma(_e2112.y, _e2946.member.z, fma(_e2110.y, _e2946.member.y, (_e2108.y * _e2946.member.x)))), (_e2073.member.z + fma(_e2112.z, _e2946.member.z, fma(_e2110.z, _e2946.member.y, (_e2108.z * _e2946.member.x))))) - _e132); - let _e2982 = sqrt(fma(_e2975.z, _e2975.z, fma(_e2975.x, _e2975.x, (_e2975.y * _e2975.y)))); - let _e2983 = (_e2982 == 0f); - if _e2983 { - phi_3536_ = vec3(); + let _e2966 = phi_3373_; + let _e2991 = (_e2097.member.x + fma(_e2136.x, _e2966.member.z, fma(_e2134.x, _e2966.member.y, (_e2132.x * _e2966.member.x)))); + let _e2992 = (_e2097.member.y + fma(_e2136.y, _e2966.member.z, fma(_e2134.y, _e2966.member.y, (_e2132.y * _e2966.member.x)))); + let _e2993 = (_e2097.member.z + fma(_e2136.z, _e2966.member.z, fma(_e2134.z, _e2966.member.y, (_e2132.z * _e2966.member.x)))); + let _e2995 = (vec3(_e2991, _e2992, _e2993) - _e156); + let _e3002 = sqrt(fma(_e2995.z, _e2995.z, fma(_e2995.x, _e2995.x, (_e2995.y * _e2995.y)))); + let _e3003 = (_e3002 == 0f); + if _e3003 { + phi_9064_ = _e1974; + phi_4040_ = f32(); + phi_4041_ = vec3(); } else { - if _e2983 { - phi_7302_ = vec3(0f, 0f, 0f); + if _e3003 { + phi_7937_ = vec3(0f, 0f, 0f); + } else { + phi_7937_ = (_e2995 * (1f / _e3002)); + } + let _e3007 = phi_7937_; + let _e3009 = (_e2966.member_2 / (_e3002 * _e3002)); + let _e3011 = fma(-(_e710.z), _e319.member_3, 1f); + let _e3015 = fma(0.4f, _e3011, (_e1394 * _e1406)); + let _e3016 = fma(0.4f, _e3011, (_e1396 * _e1406)); + let _e3017 = fma(0.4f, _e3011, (_e1398 * _e1406)); + let _e3024 = (_e1962 + _e3007); + let _e3031 = sqrt(fma(_e3024.z, _e3024.z, fma(_e3024.x, _e3024.x, (_e3024.y * _e3024.y)))); + if (_e3031 == 0f) { + phi_7972_ = vec3(0f, 0f, 0f); } else { - phi_7302_ = (_e2975 * (1f / _e2982)); + phi_7972_ = (_e3024 * (1f / _e3031)); } - let _e2987 = phi_7302_; - let _e2989 = (_e2946.member_2 / (_e2982 * _e2982)); - let _e2991 = fma(-(_e686.z), _e295.member_3, 1f); - let _e2995 = fma(0.4f, _e2991, (_e1370 * _e1382)); - let _e2996 = fma(0.4f, _e2991, (_e1372 * _e1382)); - let _e2997 = fma(0.4f, _e2991, (_e1374 * _e1382)); - let _e3004 = (_e1938 + _e2987); - let _e3011 = sqrt(fma(_e3004.z, _e3004.z, fma(_e3004.x, _e3004.x, (_e3004.y * _e3004.y)))); - if (_e3011 == 0f) { - phi_7337_ = vec3(0f, 0f, 0f); + let _e3036 = phi_7972_; + let _e3037 = (_e1403 * _e1403); + let _e3048 = max(fma(_e1958.z, _e3036.z, fma(_e1958.x, _e3036.x, (_e1958.y * _e3036.y))), 0f); + let _e3061 = max(fma(_e1958.z, _e1962.z, fma(_e1958.x, _e1962.x, (_e1958.y * _e1962.y))), 0f); + let _e3067 = fma(_e1958.z, _e3007.z, fma(_e1958.x, _e3007.x, (_e1958.y * _e3007.y))); + let _e3068 = max(_e3067, 0f); + let _e3069 = fma(_e710.y, _e319.member_4, 1f); + let _e3070 = (_e3069 * _e3069); + let _e3071 = (_e3070 * 0.125f); + let _e3073 = fma(-(_e3070), 0.125f, 1f); + let _e3086 = (1f - max(fma(_e3036.z, _e1962.z, fma(_e3036.x, _e1962.x, (_e3036.y * _e1962.y))), 0f)); + let _e3088 = select(_e3086, 0f, (_e3086 < 0f)); + let _e3091 = pow(select(_e3088, 1f, (_e3088 > 1f)), 5f); + let _e3092 = fma((1f - _e3015), _e3091, _e3015); + let _e3093 = fma((1f - _e3016), _e3091, _e3016); + let _e3094 = fma((1f - _e3017), _e3091, _e3017); + let _e3101 = (((_e3037 * _e3037) / (pow(fma((_e3048 * _e3048), fma(_e3037, _e3037, -1f), 1f), 2f) * 3.1415927f)) * ((_e3061 / fma(_e3061, _e3073, _e3071)) * (_e3068 / fma(_e3068, _e3073, _e3071)))); + let _e3106 = fma((4f * _e3061), _e3068, 0.0001f); + if ((_e2036.member_3 == 4294967295u) != true) { + let _e3128 = global_1.member[_e2036.member_3]; + let _e3132 = global_1.member[(_e2036.member_3 + 1u)]; + let _e3136 = global_1.member[(_e2036.member_3 + 3u)]; + let _e3141 = global_1.member[(_e2036.member_3 + 4u)]; + let _e3145 = global_1.member[(_e2036.member_3 + 5u)]; + let _e3149 = global_1.member[(_e2036.member_3 + 6u)]; + let _e3154 = global_1.member[(_e2036.member_3 + 7u)]; + let _e3159 = global_1.member[(_e2036.member_3 + 8u)]; + let _e3162 = global_1.member[_e1971]; + let _e3166 = global_1.member[(_e1971 + 1u)]; + let _e3168 = (_e156.x - _e2991); + let _e3170 = (_e156.y - _e2992); + let _e3172 = (_e156.z - _e2993); + let _e3175 = min(max(f32(_e3159), 1f), 21f); + let _e3187 = ((1f + (sqrt(fma(_e3172, _e3172, fma(_e3168, _e3168, (_e3170 * _e3170)))) / bitcast(_e3136))) * 0.04f); + phi_3652_ = type_14(0u, select(select(u32(_e3175), 0u, (_e3175 < 0f)), 4294967295u, (_e3175 > 4294967000f))); + phi_3655_ = 0f; + loop { + let _e3190 = phi_3652_; + let _e3192 = phi_3655_; + local_5 = _e3192; + if (_e3190.member < _e3190.member_1) { + phi_3653_ = type_14((_e3190.member + 1u), _e3190.member_1); + phi_3678_ = type_14(1u, _e3190.member); + } else { + phi_3653_ = _e3190; + phi_3678_ = type_14(0u, type_14().member_1); + } + let _e3205 = phi_3653_; + let _e3207 = phi_3678_; + switch bitcast(_e3207.member) { + case 0: { + phi_3656_ = f32(); + phi_4037_ = false; + break; + } + case 1: { + local = array, 21>(vec3(0f, 0f, 0f), vec3(1f, 1f, 1f), vec3(1f, -1f, 1f), vec3(-1f, -1f, 1f), vec3(-1f, 1f, 1f), vec3(1f, 1f, -1f), vec3(1f, -1f, -1f), vec3(-1f, -1f, -1f), vec3(-1f, 1f, -1f), vec3(1f, 1f, 0f), vec3(1f, -1f, 0f), vec3(-1f, -1f, 0f), vec3(-1f, 1f, 0f), vec3(1f, 0f, 1f), vec3(-1f, 0f, 1f), vec3(1f, 0f, -1f), vec3(-1f, 0f, -1f), vec3(0f, 1f, 1f), vec3(0f, -1f, 1f), vec3(0f, -1f, -1f), vec3(0f, 1f, -1f)); + if (_e3207.member_1 < 21u) { + } else { + phi_8937_ = true; + break; + } + let _e3213 = local[_e3207.member_1]; + let _e3217 = fma(_e3213.x, _e3187, _e3168); + let _e3218 = fma(_e3213.y, _e3187, _e3170); + let _e3219 = fma(_e3213.z, _e3187, _e3172); + let _e3224 = sqrt(fma(_e3219, _e3219, fma(_e3217, _e3217, (_e3218 * _e3218)))); + if (_e3224 == 0f) { + phi_8093_ = vec3(0f, 0f, 0f); + } else { + phi_8093_ = (vec3(_e3217, _e3218, _e3219) * (1f / _e3224)); + } + let _e3229 = phi_8093_; + let _e3231 = abs(_e3229.x); + let _e3233 = abs(_e3229.y); + let _e3235 = abs(_e3229.z); + if (_e3231 >= _e3233) { + let _e3237 = (_e3231 >= _e3235); + if _e3237 { + let _e3238 = (_e3229.x > 0f); + if _e3238 { + phi_8127_ = vec2((-(_e3229.z) / _e3231), (-(_e3229.y) / _e3231)); + } else { + phi_8127_ = vec2((_e3229.z / _e3231), (-(_e3229.y) / _e3231)); + } + let _e3249 = phi_8127_; + phi_8130_ = _e3249; + phi_8131_ = select(1u, 0u, _e3238); + } else { + phi_8130_ = vec2(); + phi_8131_ = u32(); + } + let _e3252 = phi_8130_; + let _e3254 = phi_8131_; + phi_8134_ = _e3252; + phi_8135_ = _e3254; + phi_8136_ = select(true, false, _e3237); + } else { + phi_8134_ = vec2(); + phi_8135_ = u32(); + phi_8136_ = true; + } + let _e3257 = phi_8134_; + let _e3259 = phi_8135_; + let _e3261 = phi_8136_; + if _e3261 { + if (_e3233 >= _e3231) { + let _e3263 = (_e3233 >= _e3235); + if _e3263 { + let _e3264 = (_e3229.y > 0f); + if _e3264 { + phi_8161_ = vec2((_e3229.x / _e3233), (_e3229.z / _e3233)); + } else { + phi_8161_ = vec2((_e3229.x / _e3233), (-(_e3229.z) / _e3233)); + } + let _e3273 = phi_8161_; + phi_8164_ = _e3273; + phi_8165_ = select(3u, 2u, _e3264); + } else { + phi_8164_ = vec2(); + phi_8165_ = u32(); + } + let _e3276 = phi_8164_; + let _e3278 = phi_8165_; + phi_8168_ = _e3276; + phi_8169_ = _e3278; + phi_8170_ = select(true, false, _e3263); + } else { + phi_8168_ = vec2(); + phi_8169_ = u32(); + phi_8170_ = true; + } + let _e3281 = phi_8168_; + let _e3283 = phi_8169_; + let _e3285 = phi_8170_; + if _e3285 { + let _e3286 = (_e3229.z > 0f); + if _e3286 { + phi_8191_ = vec2((_e3229.x / _e3235), (-(_e3229.y) / _e3235)); + } else { + phi_8191_ = vec2((-(_e3229.x) / _e3235), (-(_e3229.y) / _e3235)); + } + let _e3297 = phi_8191_; + phi_8194_ = _e3297; + phi_8195_ = select(5u, 4u, _e3286); + } else { + phi_8194_ = _e3281; + phi_8195_ = _e3283; + } + let _e3300 = phi_8194_; + let _e3302 = phi_8195_; + phi_8197_ = _e3300; + phi_8198_ = _e3302; + } else { + phi_8197_ = _e3257; + phi_8198_ = _e3259; + } + let _e3304 = phi_8197_; + let _e3306 = phi_8198_; + let _e3311 = ((_e3304.x + 1f) * 0.5f); + let _e3312 = ((_e3304.y + 1f) * 0.5f); + if (_e3306 >= _e3132) { + phi_3715_ = 4294967295u; + } else { + phi_3715_ = (_e3128 + (16u * _e3306)); + } + let _e3317 = phi_3715_; + let _e3321 = global_1.member[(_e3317 + 2u)]; + let _e3326 = global_1.member[(_e3317 + 3u)]; + let _e3331 = global_1.member[(_e3317 + 6u)]; + let _e3336 = global_1.member[(_e3317 + 7u)]; + let _e3341 = global_1.member[(_e3317 + 10u)]; + let _e3346 = global_1.member[(_e3317 + 11u)]; + let _e3351 = global_1.member[(_e3317 + 14u)]; + let _e3356 = global_1.member[(_e3317 + 15u)]; + if (_e3306 >= _e3145) { + phi_3816_ = 4294967295u; + } else { + phi_3816_ = (_e3141 + _e3306); + } + let _e3370 = phi_3816_; + let _e3373 = global_1.member[_e3370]; + let _e3376 = global_1.member[_e3373]; + let _e3380 = global_1.member[(_e3373 + 1u)]; + let _e3384 = global_1.member[(_e3373 + 2u)]; + let _e3388 = global_1.member[(_e3373 + 3u)]; + let _e3392 = global_1.member[(_e3373 + 4u)]; + let _e3396 = global_1.member[(_e3373 + 6u)]; + switch bitcast(_e3396) { + case 0: { + phi_3847_ = 0u; + break; + } + case 1: { + phi_3847_ = 1u; + break; + } + case 2: { + phi_3847_ = 2u; + break; + } + default: { + phi_3847_ = 0u; + break; + } + } + let _e3399 = phi_3847_; + let _e3403 = global_1.member[(_e3373 + 7u)]; + switch bitcast(_e3403) { + case 0: { + phi_3856_ = 0u; + break; + } + case 1: { + phi_3856_ = 1u; + break; + } + case 2: { + phi_3856_ = 2u; + break; + } + default: { + phi_3856_ = 0u; + break; + } + } + let _e3406 = phi_3856_; + switch bitcast(_e3399) { + case 1: { + let _e3441 = abs(_e3311); + let _e3443 = (_e3441 % 1f); + if (_e3441 >= 1f) { + phi_8258_ = select(true, false, (_e3443 == 0f)); + } else { + phi_8258_ = true; + } + let _e3447 = phi_8258_; + let _e3448 = select(1f, _e3443, _e3447); + if (select(-1f, 1f, (_e3311 >= 0f)) > 0f) { + phi_3882_ = _e3448; + } else { + phi_3882_ = (1f - _e3448); + } + let _e3452 = phi_3882_; + phi_3919_ = _e3452; + break; + } + case 2: { + let _e3415 = abs(_e3311); + let _e3422 = ((select(select(u32(_e3415), 0u, (_e3415 < 0f)), 4294967295u, (_e3415 > 4294967000f)) % 2u) == 0u); + let _e3424 = (_e3415 % 1f); + if (_e3415 >= 1f) { + phi_8241_ = select(true, false, (_e3424 == 0f)); + } else { + phi_8241_ = true; + } + let _e3428 = phi_8241_; + let _e3429 = select(1f, _e3424, _e3428); + if (select(-1f, 1f, (_e3311 >= 0f)) > 0f) { + if _e3422 { + phi_3911_ = _e3429; + } else { + phi_3911_ = (1f - _e3429); + } + let _e3436 = phi_3911_; + phi_3917_ = _e3436; + } else { + if _e3422 { + phi_3916_ = (1f - _e3429); + } else { + phi_3916_ = _e3429; + } + let _e3433 = phi_3916_; + phi_3917_ = _e3433; + } + let _e3438 = phi_3917_; + phi_3919_ = _e3438; + break; + } + case 0: { + if (_e3311 > 1f) { + phi_8228_ = 0.9999999f; + } else { + phi_8228_ = select(_e3311, 0.00000011920929f, (_e3311 < 0f)); + } + let _e3412 = phi_8228_; + phi_3919_ = _e3412; + break; + } + default: { + phi_3919_ = f32(); + break; + } + } + let _e3454 = phi_3919_; + switch bitcast(_e3406) { + case 1: { + let _e3489 = abs(_e3312); + let _e3491 = (_e3489 % 1f); + if (_e3489 >= 1f) { + phi_8306_ = select(true, false, (_e3491 == 0f)); + } else { + phi_8306_ = true; + } + let _e3495 = phi_8306_; + let _e3496 = select(1f, _e3491, _e3495); + if (select(-1f, 1f, (_e3312 >= 0f)) > 0f) { + phi_3940_ = _e3496; + } else { + phi_3940_ = (1f - _e3496); + } + let _e3500 = phi_3940_; + phi_3977_ = _e3500; + break; + } + case 2: { + let _e3463 = abs(_e3312); + let _e3470 = ((select(select(u32(_e3463), 0u, (_e3463 < 0f)), 4294967295u, (_e3463 > 4294967000f)) % 2u) == 0u); + let _e3472 = (_e3463 % 1f); + if (_e3463 >= 1f) { + phi_8289_ = select(true, false, (_e3472 == 0f)); + } else { + phi_8289_ = true; + } + let _e3476 = phi_8289_; + let _e3477 = select(1f, _e3472, _e3476); + if (select(-1f, 1f, (_e3312 >= 0f)) > 0f) { + if _e3470 { + phi_3969_ = _e3477; + } else { + phi_3969_ = (1f - _e3477); + } + let _e3484 = phi_3969_; + phi_3975_ = _e3484; + } else { + if _e3470 { + phi_3974_ = (1f - _e3477); + } else { + phi_3974_ = _e3477; + } + let _e3481 = phi_3974_; + phi_3975_ = _e3481; + } + let _e3486 = phi_3975_; + phi_3977_ = _e3486; + break; + } + case 0: { + if (_e3312 > 1f) { + phi_8276_ = 0.9999999f; + } else { + phi_8276_ = select(_e3312, 0.00000011920929f, (_e3312 < 0f)); + } + let _e3460 = phi_8276_; + phi_3977_ = _e3460; + break; + } + default: { + phi_3977_ = f32(); + break; + } + } + let _e3502 = phi_3977_; + let _e3504 = (_e3454 * f32(_e3384)); + let _e3511 = (_e3502 * f32(_e3388)); + let _e3526 = vec3((f32((select(select(u32(_e3504), 0u, (_e3504 < 0f)), 4294967295u, (_e3504 > 4294967000f)) + _e3376)) / f32(_e3162)), (f32((select(select(u32(_e3511), 0u, (_e3511 < 0f)), 4294967295u, (_e3511 > 4294967000f)) + _e3380)) / f32(_e3166)), f32(_e3392)); + let _e3532 = textureSampleLevel(global_19, global_18, vec2(_e3526.x, _e3526.y), i32(_e3526.z), 0f); + if ((((bitcast(_e3351) + fma(bitcast(_e3341), _e156.z, fma(bitcast(_e3331), _e156.y, (bitcast(_e3321) * _e156.x)))) / (bitcast(_e3356) + fma(bitcast(_e3346), _e156.z, fma(bitcast(_e3336), _e156.y, (bitcast(_e3326) * _e156.x))))) - max((bitcast(_e3154) * (1f - _e3067)), bitcast(_e3149))) > _e3532.x) { + phi_4036_ = (_e3192 + 1f); + } else { + phi_4036_ = _e3192; + } + let _e3541 = phi_4036_; + phi_3656_ = _e3541; + phi_4037_ = true; + break; + } + default: { + phi_3656_ = f32(); + phi_4037_ = bool(); + break; + } + } + let _e3543 = phi_3656_; + let _e3545 = phi_4037_; + continue; + continuing { + phi_3652_ = _e3205; + phi_3655_ = _e3543; + phi_8937_ = _e1974; + break if !(_e3545); + } + } + let _e3548 = phi_8937_; + phi_9056_ = _e3548; + if _e3548 { + break; + } + let _e3550 = local_5; + phi_9065_ = _e3548; + phi_4039_ = (_e3550 / _e3175); } else { - phi_7337_ = (_e3004 * (1f / _e3011)); + phi_9065_ = _e1974; + phi_4039_ = 0f; } - let _e3016 = phi_7337_; - let _e3017 = (_e1379 * _e1379); - let _e3028 = max(fma(_e1934.z, _e3016.z, fma(_e1934.x, _e3016.x, (_e1934.y * _e3016.y))), 0f); - let _e3041 = max(fma(_e1934.z, _e1938.z, fma(_e1934.x, _e1938.x, (_e1934.y * _e1938.y))), 0f); - let _e3048 = max(fma(_e1934.z, _e2987.z, fma(_e1934.x, _e2987.x, (_e1934.y * _e2987.y))), 0f); - let _e3049 = fma(_e686.y, _e295.member_4, 1f); - let _e3050 = (_e3049 * _e3049); - let _e3051 = (_e3050 * 0.125f); - let _e3053 = fma(-(_e3050), 0.125f, 1f); - let _e3066 = (1f - max(fma(_e3016.z, _e1938.z, fma(_e3016.x, _e1938.x, (_e3016.y * _e1938.y))), 0f)); - let _e3068 = select(_e3066, 0f, (_e3066 < 0f)); - let _e3071 = pow(select(_e3068, 1f, (_e3068 > 1f)), 5f); - let _e3072 = fma((1f - _e2995), _e3071, _e2995); - let _e3073 = fma((1f - _e2996), _e3071, _e2996); - let _e3074 = fma((1f - _e2997), _e3071, _e2997); - let _e3081 = (((_e3017 * _e3017) / (pow(fma((_e3028 * _e3028), fma(_e3017, _e3017, -1f), 1f), 2f) * 3.1415927f)) * ((_e3041 / fma(_e3041, _e3053, _e3051)) * (_e3048 / fma(_e3048, _e3053, _e3051)))); - let _e3086 = fma((4f * _e3041), _e3048, 0.0001f); - phi_3536_ = vec3(fma((fma((((1f - _e3072) * _e2991) * _e1370), 0.31830987f, ((_e3081 * _e3072) / _e3086)) * (_e2946.member_1.x * _e2989)), _e3048, _e1954.x), fma((fma((((1f - _e3073) * _e2991) * _e1372), 0.31830987f, ((_e3081 * _e3073) / _e3086)) * (_e2946.member_1.y * _e2989)), _e3048, _e1954.y), fma((fma((((1f - _e3074) * _e2991) * _e1374), 0.31830987f, ((_e3081 * _e3074) / _e3086)) * (_e2946.member_1.z * _e2989)), _e3048, _e1954.z)); + let _e3553 = phi_9065_; + let _e3555 = phi_4039_; + phi_9064_ = _e3553; + phi_4040_ = _e3555; + phi_4041_ = vec3(((fma((((1f - _e3092) * _e3011) * _e1394), 0.31830987f, ((_e3101 * _e3092) / _e3106)) * (_e2966.member_1.x * _e3009)) * _e3068), ((fma((((1f - _e3093) * _e3011) * _e1396), 0.31830987f, ((_e3101 * _e3093) / _e3106)) * (_e2966.member_1.y * _e3009)) * _e3068), ((fma((((1f - _e3094) * _e3011) * _e1398), 0.31830987f, ((_e3101 * _e3094) / _e3106)) * (_e2966.member_1.z * _e3009)) * _e3068)); } - let _e3107 = phi_3536_; - phi_8090_ = _e1950; - phi_4474_ = _e3107; - phi_4475_ = select(true, false, _e2983); + let _e3557 = phi_9064_; + let _e3559 = phi_4040_; + let _e3561 = phi_4041_; + phi_9060_ = _e3557; + phi_4975_ = _e3559; + phi_4976_ = _e3561; + phi_4977_ = select(true, false, _e3003); break; } case 2: { - if (_e124 >= 13u) { - phi_6889_ = (_e2012.member_1 <= (_e124 - 13u)); + if (_e148 >= 13u) { + phi_7524_ = (_e2036.member_1 <= (_e148 - 13u)); } else { - phi_6889_ = false; + phi_7524_ = false; } - let _e2123 = phi_6889_; - if _e2123 { - let _e2126 = global_1.member[_e2012.member_1]; - let _e2131 = global_1.member[(_e2012.member_1 + 1u)]; - let _e2136 = global_1.member[(_e2012.member_1 + 2u)]; - let _e2142 = global_1.member[(_e2012.member_1 + 3u)]; - let _e2147 = global_1.member[(_e2012.member_1 + 4u)]; - let _e2152 = global_1.member[(_e2012.member_1 + 5u)]; - let _e2158 = global_1.member[(_e2012.member_1 + 6u)]; - let _e2163 = global_1.member[(_e2012.member_1 + 7u)]; - let _e2168 = global_1.member[(_e2012.member_1 + 8u)]; - let _e2173 = global_1.member[(_e2012.member_1 + 9u)]; - let _e2178 = global_1.member[(_e2012.member_1 + 10u)]; - let _e2183 = global_1.member[(_e2012.member_1 + 11u)]; - let _e2189 = global_1.member[(_e2012.member_1 + 12u)]; - phi_3599_ = type_37(vec3(bitcast(_e2126), bitcast(_e2131), bitcast(_e2136)), vec3(bitcast(_e2142), bitcast(_e2147), bitcast(_e2152)), bitcast(_e2158), bitcast(_e2163), vec4(bitcast(_e2168), bitcast(_e2173), bitcast(_e2178), bitcast(_e2183)), bitcast(_e2189)); + let _e2147 = phi_7524_; + if _e2147 { + let _e2150 = global_1.member[_e2036.member_1]; + let _e2155 = global_1.member[(_e2036.member_1 + 1u)]; + let _e2160 = global_1.member[(_e2036.member_1 + 2u)]; + let _e2166 = global_1.member[(_e2036.member_1 + 3u)]; + let _e2171 = global_1.member[(_e2036.member_1 + 4u)]; + let _e2176 = global_1.member[(_e2036.member_1 + 5u)]; + let _e2182 = global_1.member[(_e2036.member_1 + 6u)]; + let _e2187 = global_1.member[(_e2036.member_1 + 7u)]; + let _e2192 = global_1.member[(_e2036.member_1 + 8u)]; + let _e2197 = global_1.member[(_e2036.member_1 + 9u)]; + let _e2202 = global_1.member[(_e2036.member_1 + 10u)]; + let _e2207 = global_1.member[(_e2036.member_1 + 11u)]; + let _e2213 = global_1.member[(_e2036.member_1 + 12u)]; + phi_4104_ = type_39(vec3(bitcast(_e2150), bitcast(_e2155), bitcast(_e2160)), vec3(bitcast(_e2166), bitcast(_e2171), bitcast(_e2176)), bitcast(_e2182), bitcast(_e2187), vec4(bitcast(_e2192), bitcast(_e2197), bitcast(_e2202), bitcast(_e2207)), bitcast(_e2213)); } else { - phi_3599_ = type_37(vec3(0f, 0f, 0f), vec3(0f, -1f, 0f), 1.0471976f, 1.5707964f, vec4(1f, 1f, 1f, 1f), 1f); + phi_4104_ = type_39(vec3(0f, 0f, 0f), vec3(0f, -1f, 0f), 1.0471976f, 1.5707964f, vec4(1f, 1f, 1f, 1f), 1f); } - let _e2193 = phi_3599_; - let _e2219 = vec3((_e2073.member.x + fma(_e2112.x, _e2193.member.z, fma(_e2110.x, _e2193.member.y, (_e2108.x * _e2193.member.x)))), (_e2073.member.y + fma(_e2112.y, _e2193.member.z, fma(_e2110.y, _e2193.member.y, (_e2108.y * _e2193.member.x)))), (_e2073.member.z + fma(_e2112.z, _e2193.member.z, fma(_e2110.z, _e2193.member.y, (_e2108.z * _e2193.member.x))))); - let _e2220 = (_e2219 - _e132); - let _e2227 = sqrt(fma(_e2220.z, _e2220.z, fma(_e2220.x, _e2220.x, (_e2220.y * _e2220.y)))); - let _e2228 = (_e2227 == 0f); - if _e2228 { - phi_3735_ = type_38(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), 0f, 0f, 0f, 0f, 0f, 0f, 0f, false, false); + let _e2217 = phi_4104_; + let _e2243 = vec3((_e2097.member.x + fma(_e2136.x, _e2217.member.z, fma(_e2134.x, _e2217.member.y, (_e2132.x * _e2217.member.x)))), (_e2097.member.y + fma(_e2136.y, _e2217.member.z, fma(_e2134.y, _e2217.member.y, (_e2132.y * _e2217.member.x)))), (_e2097.member.z + fma(_e2136.z, _e2217.member.z, fma(_e2134.z, _e2217.member.y, (_e2132.z * _e2217.member.x))))); + let _e2244 = (_e2243 - _e156); + let _e2251 = sqrt(fma(_e2244.z, _e2244.z, fma(_e2244.x, _e2244.x, (_e2244.y * _e2244.y)))); + let _e2252 = (_e2251 == 0f); + if _e2252 { + phi_4240_ = type_40(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), 0f, 0f, 0f, 0f, 0f, 0f, 0f, false, false); } else { - if _e2228 { - phi_6939_ = vec3(0f, 0f, 0f); + if _e2252 { + phi_7574_ = vec3(0f, 0f, 0f); } else { - phi_6939_ = (_e2220 * (1f / _e2227)); + phi_7574_ = (_e2244 * (1f / _e2251)); } - let _e2232 = phi_6939_; - let _e2243 = fma(_e2112.x, _e2193.member_1.z, fma(_e2110.x, _e2193.member_1.y, (_e2108.x * _e2193.member_1.x))); - let _e2244 = fma(_e2112.y, _e2193.member_1.z, fma(_e2110.y, _e2193.member_1.y, (_e2108.y * _e2193.member_1.x))); - let _e2245 = fma(_e2112.z, _e2193.member_1.z, fma(_e2110.z, _e2193.member_1.y, (_e2108.z * _e2193.member_1.x))); - let _e2250 = sqrt(fma(_e2245, _e2245, fma(_e2243, _e2243, (_e2244 * _e2244)))); - if (_e2250 == 0f) { - phi_6974_ = vec3(0f, 0f, 0f); + let _e2256 = phi_7574_; + let _e2267 = fma(_e2136.x, _e2217.member_1.z, fma(_e2134.x, _e2217.member_1.y, (_e2132.x * _e2217.member_1.x))); + let _e2268 = fma(_e2136.y, _e2217.member_1.z, fma(_e2134.y, _e2217.member_1.y, (_e2132.y * _e2217.member_1.x))); + let _e2269 = fma(_e2136.z, _e2217.member_1.z, fma(_e2134.z, _e2217.member_1.y, (_e2132.z * _e2217.member_1.x))); + let _e2274 = sqrt(fma(_e2269, _e2269, fma(_e2267, _e2267, (_e2268 * _e2268)))); + if (_e2274 == 0f) { + phi_7609_ = vec3(0f, 0f, 0f); } else { - phi_6974_ = (vec3(_e2243, _e2244, _e2245) * (1f / _e2250)); + phi_7609_ = (vec3(_e2267, _e2268, _e2269) * (1f / _e2274)); } - let _e2255 = phi_6974_; - let _e2257 = cos(_e2193.member_2); - let _e2259 = cos(_e2193.member_3); - let _e2260 = (_e2257 - _e2259); - let _e2272 = fma(_e2232.z, -(_e2255.z), fma(_e2232.x, -(_e2255.x), (_e2232.y * -(_e2255.y)))); - let _e2276 = ((_e2272 - _e2259) / _e2260); - let _e2278 = select(_e2276, 0f, (_e2276 < 0f)); - phi_3735_ = type_38(_e2219, _e132, _e2232, _e2255, _e2227, _e2257, _e2259, _e2260, _e2272, _e2276, select(_e2278, 1f, (_e2278 > 1f)), (_e2272 > _e2257), (_e2272 > _e2259)); + let _e2279 = phi_7609_; + let _e2281 = cos(_e2217.member_2); + let _e2283 = cos(_e2217.member_3); + let _e2284 = (_e2281 - _e2283); + let _e2296 = fma(_e2256.z, -(_e2279.z), fma(_e2256.x, -(_e2279.x), (_e2256.y * -(_e2279.y)))); + let _e2300 = ((_e2296 - _e2283) / _e2284); + let _e2302 = select(_e2300, 0f, (_e2300 < 0f)); + phi_4240_ = type_40(_e2243, _e156, _e2256, _e2279, _e2251, _e2281, _e2283, _e2284, _e2296, _e2300, select(_e2302, 1f, (_e2302 > 1f)), (_e2296 > _e2281), (_e2296 > _e2283)); } - let _e2283 = phi_3735_; - let _e2285 = (_e2283.member_4 == 0f); - if _e2285 { - phi_8091_ = _e1950; - phi_4472_ = vec3(); + let _e2307 = phi_4240_; + let _e2309 = (_e2307.member_4 == 0f); + if _e2309 { + phi_9061_ = _e1974; + phi_4972_ = f32(); + phi_4973_ = vec3(); } else { - let _e2288 = (_e2193.member_5 * _e2283.member_10); - let _e2292 = fma(-(_e686.z), _e295.member_3, 1f); - let _e2296 = fma(0.4f, _e2292, (_e1370 * _e1382)); - let _e2297 = fma(0.4f, _e2292, (_e1372 * _e1382)); - let _e2298 = fma(0.4f, _e2292, (_e1374 * _e1382)); - let _e2305 = (_e1938 + _e2283.member_2); - let _e2312 = sqrt(fma(_e2305.z, _e2305.z, fma(_e2305.x, _e2305.x, (_e2305.y * _e2305.y)))); - if (_e2312 == 0f) { - phi_7009_ = vec3(0f, 0f, 0f); + let _e2312 = (_e2217.member_5 * _e2307.member_10); + let _e2316 = fma(-(_e710.z), _e319.member_3, 1f); + let _e2320 = fma(0.4f, _e2316, (_e1394 * _e1406)); + let _e2321 = fma(0.4f, _e2316, (_e1396 * _e1406)); + let _e2322 = fma(0.4f, _e2316, (_e1398 * _e1406)); + let _e2329 = (_e1962 + _e2307.member_2); + let _e2336 = sqrt(fma(_e2329.z, _e2329.z, fma(_e2329.x, _e2329.x, (_e2329.y * _e2329.y)))); + if (_e2336 == 0f) { + phi_7644_ = vec3(0f, 0f, 0f); } else { - phi_7009_ = (_e2305 * (1f / _e2312)); + phi_7644_ = (_e2329 * (1f / _e2336)); } - let _e2317 = phi_7009_; - let _e2318 = (_e1379 * _e1379); - let _e2329 = max(fma(_e1934.z, _e2317.z, fma(_e1934.x, _e2317.x, (_e1934.y * _e2317.y))), 0f); - let _e2342 = max(fma(_e1934.z, _e1938.z, fma(_e1934.x, _e1938.x, (_e1934.y * _e1938.y))), 0f); - let _e2348 = fma(_e1934.z, _e2283.member_2.z, fma(_e1934.x, _e2283.member_2.x, (_e1934.y * _e2283.member_2.y))); - let _e2349 = max(_e2348, 0f); - let _e2350 = fma(_e686.y, _e295.member_4, 1f); - let _e2351 = (_e2350 * _e2350); - let _e2352 = (_e2351 * 0.125f); - let _e2354 = fma(-(_e2351), 0.125f, 1f); - let _e2367 = (1f - max(fma(_e2317.z, _e1938.z, fma(_e2317.x, _e1938.x, (_e2317.y * _e1938.y))), 0f)); - let _e2369 = select(_e2367, 0f, (_e2367 < 0f)); - let _e2372 = pow(select(_e2369, 1f, (_e2369 > 1f)), 5f); - let _e2373 = fma((1f - _e2296), _e2372, _e2296); - let _e2374 = fma((1f - _e2297), _e2372, _e2297); - let _e2375 = fma((1f - _e2298), _e2372, _e2298); - let _e2382 = (((_e2318 * _e2318) / (pow(fma((_e2329 * _e2329), fma(_e2318, _e2318, -1f), 1f), 2f) * 3.1415927f)) * ((_e2342 / fma(_e2342, _e2354, _e2352)) * (_e2349 / fma(_e2349, _e2354, _e2352)))); - let _e2387 = fma((4f * _e2342), _e2349, 0.0001f); - if ((_e2012.member_3 == 4294967295u) != true) { - let _e2408 = global_1.member[_e2012.member_3]; - let _e2412 = global_1.member[(_e2012.member_3 + 1u)]; - let _e2416 = global_1.member[(_e2012.member_3 + 2u)]; - let _e2420 = global_1.member[(_e2012.member_3 + 3u)]; - let _e2424 = global_1.member[(_e2012.member_3 + 4u)]; - let _e2429 = global_1.member[(_e2012.member_3 + 5u)]; - let _e2434 = global_1.member[(_e2012.member_3 + 6u)]; - let _e2439 = global_1.member[select(_e2416, 4294967295u, (0u >= _e2420))]; - let _e2442 = global_1.member[_e2439]; - let _e2446 = global_1.member[(_e2439 + 1u)]; - let _e2450 = global_1.member[(_e2439 + 2u)]; - let _e2454 = global_1.member[(_e2439 + 3u)]; - let _e2458 = global_1.member[(_e2439 + 4u)]; - let _e2462 = global_1.member[(_e2439 + 6u)]; - switch bitcast(_e2462) { - case 0: { - phi_3947_ = 0u; - break; - } - case 1: { - phi_3947_ = 1u; - break; - } - case 2: { - phi_3947_ = 2u; - break; - } - default: { - phi_3947_ = 0u; - break; - } - } - let _e2465 = phi_3947_; - let _e2469 = global_1.member[(_e2439 + 7u)]; - switch bitcast(_e2469) { - case 0: { - phi_3956_ = 0u; - break; - } - case 1: { - phi_3956_ = 1u; - break; - } - case 2: { - phi_3956_ = 2u; - break; - } - default: { - phi_3956_ = 0u; - break; - } - } - let _e2472 = phi_3956_; - let _e2475 = global_1.member[_e1947]; - let _e2479 = global_1.member[(_e1947 + 1u)]; - let _e2481 = select(_e2408, 4294967295u, (0u >= _e2412)); - let _e2484 = global_1.member[_e2481]; - let _e2489 = global_1.member[(_e2481 + 1u)]; - let _e2494 = global_1.member[(_e2481 + 2u)]; - let _e2499 = global_1.member[(_e2481 + 3u)]; - let _e2504 = global_1.member[(_e2481 + 4u)]; - let _e2509 = global_1.member[(_e2481 + 5u)]; - let _e2514 = global_1.member[(_e2481 + 6u)]; - let _e2519 = global_1.member[(_e2481 + 7u)]; - let _e2524 = global_1.member[(_e2481 + 8u)]; - let _e2529 = global_1.member[(_e2481 + 9u)]; - let _e2534 = global_1.member[(_e2481 + 10u)]; - let _e2539 = global_1.member[(_e2481 + 11u)]; - let _e2544 = global_1.member[(_e2481 + 12u)]; - let _e2549 = global_1.member[(_e2481 + 13u)]; - let _e2554 = global_1.member[(_e2481 + 14u)]; - let _e2559 = global_1.member[(_e2481 + 15u)]; - let _e2579 = (bitcast(_e2559) + fma(bitcast(_e2539), _e132.z, fma(bitcast(_e2519), _e132.y, (bitcast(_e2499) * _e132.x)))); - let _e2580 = ((bitcast(_e2544) + fma(bitcast(_e2524), _e132.z, fma(bitcast(_e2504), _e132.y, (bitcast(_e2484) * _e132.x)))) / _e2579); - let _e2581 = ((bitcast(_e2549) + fma(bitcast(_e2529), _e132.z, fma(bitcast(_e2509), _e132.y, (bitcast(_e2489) * _e132.x)))) / _e2579); - let _e2582 = ((bitcast(_e2554) + fma(bitcast(_e2534), _e132.z, fma(bitcast(_e2514), _e132.y, (bitcast(_e2494) * _e132.x)))) / _e2579); - if (abs(_e2580) <= 1f) { - let _e2586 = (abs(_e2581) <= 1f); - if _e2586 { - phi_7118_ = (abs(_e2582) <= 1f); + let _e2341 = phi_7644_; + let _e2342 = (_e1403 * _e1403); + let _e2353 = max(fma(_e1958.z, _e2341.z, fma(_e1958.x, _e2341.x, (_e1958.y * _e2341.y))), 0f); + let _e2366 = max(fma(_e1958.z, _e1962.z, fma(_e1958.x, _e1962.x, (_e1958.y * _e1962.y))), 0f); + let _e2372 = fma(_e1958.z, _e2307.member_2.z, fma(_e1958.x, _e2307.member_2.x, (_e1958.y * _e2307.member_2.y))); + let _e2373 = max(_e2372, 0f); + let _e2374 = fma(_e710.y, _e319.member_4, 1f); + let _e2375 = (_e2374 * _e2374); + let _e2376 = (_e2375 * 0.125f); + let _e2378 = fma(-(_e2375), 0.125f, 1f); + let _e2391 = (1f - max(fma(_e2341.z, _e1962.z, fma(_e2341.x, _e1962.x, (_e2341.y * _e1962.y))), 0f)); + let _e2393 = select(_e2391, 0f, (_e2391 < 0f)); + let _e2396 = pow(select(_e2393, 1f, (_e2393 > 1f)), 5f); + let _e2397 = fma((1f - _e2320), _e2396, _e2320); + let _e2398 = fma((1f - _e2321), _e2396, _e2321); + let _e2399 = fma((1f - _e2322), _e2396, _e2322); + let _e2406 = (((_e2342 * _e2342) / (pow(fma((_e2353 * _e2353), fma(_e2342, _e2342, -1f), 1f), 2f) * 3.1415927f)) * ((_e2366 / fma(_e2366, _e2378, _e2376)) * (_e2373 / fma(_e2373, _e2378, _e2376)))); + let _e2411 = fma((4f * _e2366), _e2373, 0.0001f); + if ((_e2036.member_3 == 4294967295u) != true) { + let _e2433 = global_1.member[_e2036.member_3]; + let _e2437 = global_1.member[(_e2036.member_3 + 1u)]; + let _e2441 = global_1.member[(_e2036.member_3 + 4u)]; + let _e2445 = global_1.member[(_e2036.member_3 + 5u)]; + let _e2449 = global_1.member[(_e2036.member_3 + 6u)]; + let _e2454 = global_1.member[(_e2036.member_3 + 7u)]; + let _e2459 = global_1.member[(_e2036.member_3 + 8u)]; + let _e2462 = global_1.member[_e1971]; + let _e2466 = global_1.member[(_e1971 + 1u)]; + let _e2468 = select(_e2433, 4294967295u, (0u >= _e2437)); + let _e2471 = global_1.member[_e2468]; + let _e2476 = global_1.member[(_e2468 + 1u)]; + let _e2481 = global_1.member[(_e2468 + 2u)]; + let _e2486 = global_1.member[(_e2468 + 3u)]; + let _e2491 = global_1.member[(_e2468 + 4u)]; + let _e2496 = global_1.member[(_e2468 + 5u)]; + let _e2501 = global_1.member[(_e2468 + 6u)]; + let _e2506 = global_1.member[(_e2468 + 7u)]; + let _e2511 = global_1.member[(_e2468 + 8u)]; + let _e2516 = global_1.member[(_e2468 + 9u)]; + let _e2521 = global_1.member[(_e2468 + 10u)]; + let _e2526 = global_1.member[(_e2468 + 11u)]; + let _e2531 = global_1.member[(_e2468 + 12u)]; + let _e2536 = global_1.member[(_e2468 + 13u)]; + let _e2541 = global_1.member[(_e2468 + 14u)]; + let _e2546 = global_1.member[(_e2468 + 15u)]; + let _e2566 = (bitcast(_e2546) + fma(bitcast(_e2526), _e156.z, fma(bitcast(_e2506), _e156.y, (bitcast(_e2486) * _e156.x)))); + let _e2567 = ((bitcast(_e2531) + fma(bitcast(_e2511), _e156.z, fma(bitcast(_e2491), _e156.y, (bitcast(_e2471) * _e156.x)))) / _e2566); + let _e2568 = ((bitcast(_e2536) + fma(bitcast(_e2516), _e156.z, fma(bitcast(_e2496), _e156.y, (bitcast(_e2476) * _e156.x)))) / _e2566); + let _e2569 = ((bitcast(_e2541) + fma(bitcast(_e2521), _e156.z, fma(bitcast(_e2501), _e156.y, (bitcast(_e2481) * _e156.x)))) / _e2566); + if (abs(_e2567) <= 1f) { + let _e2573 = (abs(_e2568) <= 1f); + if _e2573 { + phi_7749_ = (abs(_e2569) <= 1f); } else { - phi_7118_ = bool(); + phi_7749_ = bool(); } - let _e2590 = phi_7118_; - phi_7121_ = _e2590; - phi_7122_ = select(true, false, _e2586); + let _e2577 = phi_7749_; + phi_7752_ = _e2577; + phi_7753_ = select(true, false, _e2573); } else { - phi_7121_ = bool(); - phi_7122_ = true; + phi_7752_ = bool(); + phi_7753_ = true; } - let _e2593 = phi_7121_; - let _e2595 = phi_7122_; - if select(_e2593, false, _e2595) { - let _e2599 = bitcast(_e2434); - let _e2601 = f32(_e2450); - let _e2602 = f32(_e2454); - let _e2606 = type_35((_e2599 / -2i), (_e2599 / 2i), false); - phi_7941_ = _e1950; - phi_4135_ = _e2606; - phi_4138_ = 0f; - phi_4140_ = 0f; + let _e2580 = phi_7752_; + let _e2582 = phi_7753_; + if select(_e2580, false, _e2582) { + let _e2590 = global_1.member[select(_e2441, 4294967295u, (0u >= _e2445))]; + let _e2593 = global_1.member[_e2590]; + let _e2597 = global_1.member[(_e2590 + 1u)]; + let _e2601 = global_1.member[(_e2590 + 2u)]; + let _e2605 = global_1.member[(_e2590 + 3u)]; + let _e2609 = global_1.member[(_e2590 + 4u)]; + let _e2613 = global_1.member[(_e2590 + 6u)]; + switch bitcast(_e2613) { + case 0: { + phi_4612_ = 0u; + break; + } + case 1: { + phi_4612_ = 1u; + break; + } + case 2: { + phi_4612_ = 2u; + break; + } + default: { + phi_4612_ = 0u; + break; + } + } + let _e2616 = phi_4612_; + let _e2620 = global_1.member[(_e2590 + 7u)]; + switch bitcast(_e2620) { + case 0: { + phi_4621_ = 0u; + break; + } + case 1: { + phi_4621_ = 1u; + break; + } + case 2: { + phi_4621_ = 2u; + break; + } + default: { + phi_4621_ = 0u; + break; + } + } + let _e2623 = phi_4621_; + let _e2624 = bitcast(_e2459); + let _e2626 = f32(_e2601); + let _e2627 = f32(_e2605); + let _e2631 = type_37((_e2624 / -2i), (_e2624 / 2i), false); + phi_8855_ = _e1974; + phi_4649_ = _e2631; + phi_4652_ = 0f; + phi_4654_ = 0f; loop { - let _e2608 = phi_7941_; - let _e2610 = phi_4135_; - let _e2612 = phi_4138_; - let _e2614 = phi_4140_; - local_2 = _e2612; - local_3 = _e2614; - if _e2610.member_2 { - phi_4152_ = true; + let _e2633 = phi_8855_; + let _e2635 = phi_4649_; + let _e2637 = phi_4652_; + let _e2639 = phi_4654_; + local_3 = _e2637; + local_4 = _e2639; + if _e2635.member_2 { + phi_4666_ = true; } else { - phi_4152_ = ((_e2610.member <= _e2610.member_1) != true); + phi_4666_ = ((_e2635.member <= _e2635.member_1) != true); } - let _e2621 = phi_4152_; - if _e2621 { - phi_4136_ = _e2610; - phi_4195_ = type_36(0u, type_36().member_1); + let _e2646 = phi_4666_; + if _e2646 { + phi_4650_ = _e2635; + phi_4709_ = type_38(0u, type_38().member_1); } else { - if (_e2610.member < _e2610.member_1) { - let _e2629 = (_e2610.member + 1i); - if select(false, true, ((false == (_e2629 > _e2610.member)) != false)) { - phi_4180_ = type_36(0u, type_36().member_1); + if (_e2635.member < _e2635.member_1) { + let _e2654 = (_e2635.member + 1i); + if select(false, true, ((false == (_e2654 > _e2635.member)) != false)) { + phi_4694_ = type_38(0u, type_38().member_1); } else { - phi_4180_ = type_36(1u, _e2629); + phi_4694_ = type_38(1u, _e2654); } - let _e2639 = phi_4180_; - switch bitcast(_e2639.member) { + let _e2664 = phi_4694_; + switch bitcast(_e2664.member) { case 0: { - phi_8021_ = true; + phi_8935_ = true; break; } case 1: { @@ -2748,55 +3212,55 @@ fn function() { break; } } - phi_4192_ = type_35(_e2639.member_1, _e2610.member_1, _e2610.member_2); + phi_4706_ = type_37(_e2664.member_1, _e2635.member_1, _e2635.member_2); } else { - phi_4192_ = type_35(_e2610.member, _e2610.member_1, true); + phi_4706_ = type_37(_e2635.member, _e2635.member_1, true); } - let _e2648 = phi_4192_; - phi_4136_ = _e2648; - phi_4195_ = type_36(1u, _e2610.member); + let _e2673 = phi_4706_; + phi_4650_ = _e2673; + phi_4709_ = type_38(1u, _e2635.member); } - let _e2654 = phi_4136_; - let _e2656 = phi_4195_; - switch bitcast(_e2656.member) { + let _e2679 = phi_4650_; + let _e2681 = phi_4709_; + switch bitcast(_e2681.member) { case 0: { - phi_8022_ = _e2608; - phi_4139_ = f32(); - phi_4141_ = f32(); - phi_4454_ = false; + phi_8936_ = _e2633; + phi_4653_ = f32(); + phi_4655_ = f32(); + phi_4967_ = false; break; } case 1: { - phi_4206_ = _e2606; - phi_4209_ = _e2612; - phi_4211_ = _e2614; + phi_4720_ = _e2631; + phi_4723_ = _e2637; + phi_4725_ = _e2639; loop { - let _e2661 = phi_4206_; - let _e2663 = phi_4209_; - let _e2665 = phi_4211_; - local_9 = _e2663; - local_10 = _e2665; - if _e2661.member_2 { - phi_4223_ = true; + let _e2686 = phi_4720_; + let _e2688 = phi_4723_; + let _e2690 = phi_4725_; + local_11 = _e2688; + local_12 = _e2690; + if _e2686.member_2 { + phi_4737_ = true; } else { - phi_4223_ = ((_e2661.member <= _e2661.member_1) != true); + phi_4737_ = ((_e2686.member <= _e2686.member_1) != true); } - let _e2672 = phi_4223_; - if _e2672 { - phi_4207_ = _e2661; - phi_4266_ = type_36(0u, type_36().member_1); + let _e2697 = phi_4737_; + if _e2697 { + phi_4721_ = _e2686; + phi_4780_ = type_38(0u, type_38().member_1); } else { - if (_e2661.member < _e2661.member_1) { - let _e2680 = (_e2661.member + 1i); - if select(false, true, ((false == (_e2680 > _e2661.member)) != false)) { - phi_4251_ = type_36(0u, type_36().member_1); + if (_e2686.member < _e2686.member_1) { + let _e2705 = (_e2686.member + 1i); + if select(false, true, ((false == (_e2705 > _e2686.member)) != false)) { + phi_4765_ = type_38(0u, type_38().member_1); } else { - phi_4251_ = type_36(1u, _e2680); + phi_4765_ = type_38(1u, _e2705); } - let _e2690 = phi_4251_; - switch bitcast(_e2690.member) { + let _e2715 = phi_4765_; + switch bitcast(_e2715.member) { case 0: { - phi_7925_ = true; + phi_8839_ = true; break; } case 1: { @@ -2806,474 +3270,491 @@ fn function() { break; } } - phi_4263_ = type_35(_e2690.member_1, _e2661.member_1, _e2661.member_2); + phi_4777_ = type_37(_e2715.member_1, _e2686.member_1, _e2686.member_2); } else { - phi_4263_ = type_35(_e2661.member, _e2661.member_1, true); + phi_4777_ = type_37(_e2686.member, _e2686.member_1, true); } - let _e2699 = phi_4263_; - phi_4207_ = _e2699; - phi_4266_ = type_36(1u, _e2661.member); + let _e2724 = phi_4777_; + phi_4721_ = _e2724; + phi_4780_ = type_38(1u, _e2686.member); } - let _e2705 = phi_4207_; - let _e2707 = phi_4266_; - switch bitcast(_e2707.member) { + let _e2730 = phi_4721_; + let _e2732 = phi_4780_; + switch bitcast(_e2732.member) { case 0: { - phi_4210_ = f32(); - phi_4212_ = f32(); - phi_4453_ = false; + phi_4724_ = f32(); + phi_4726_ = f32(); + phi_4966_ = false; break; } case 1: { - let _e2715 = fma((_e2580 + 1f), 0.5f, (f32(_e2656.member_1) * (1f / _e2601))); - let _e2716 = fma(fma(_e2581, -1f, 1f), 0.5f, (f32(_e2707.member_1) * (1f / _e2602))); - switch bitcast(_e2465) { + let _e2740 = fma((_e2567 + 1f), 0.5f, (f32(_e2681.member_1) * (1f / _e2626))); + let _e2741 = fma(fma(_e2568, -1f, 1f), 0.5f, (f32(_e2732.member_1) * (1f / _e2627))); + switch bitcast(_e2616) { case 1: { - let _e2751 = abs(_e2715); - let _e2753 = (_e2751 % 1f); - if (_e2751 >= 1f) { - phi_7170_ = select(true, false, (_e2753 == 0f)); + let _e2776 = abs(_e2740); + let _e2778 = (_e2776 % 1f); + if (_e2776 >= 1f) { + phi_7805_ = select(true, false, (_e2778 == 0f)); } else { - phi_7170_ = true; + phi_7805_ = true; } - let _e2757 = phi_7170_; - let _e2758 = select(1f, _e2753, _e2757); - if (select(-1f, 1f, (_e2715 >= 0f)) > 0f) { - phi_4298_ = _e2758; + let _e2782 = phi_7805_; + let _e2783 = select(1f, _e2778, _e2782); + if (select(-1f, 1f, (_e2740 >= 0f)) > 0f) { + phi_4812_ = _e2783; } else { - phi_4298_ = (1f - _e2758); + phi_4812_ = (1f - _e2783); } - let _e2762 = phi_4298_; - phi_4335_ = _e2762; + let _e2787 = phi_4812_; + phi_4849_ = _e2787; break; } case 2: { - let _e2725 = abs(_e2715); - let _e2732 = ((select(select(u32(_e2725), 0u, (_e2725 < 0f)), 4294967295u, (_e2725 > 4294967000f)) % 2u) == 0u); - let _e2734 = (_e2725 % 1f); - if (_e2725 >= 1f) { - phi_7153_ = select(true, false, (_e2734 == 0f)); + let _e2750 = abs(_e2740); + let _e2757 = ((select(select(u32(_e2750), 0u, (_e2750 < 0f)), 4294967295u, (_e2750 > 4294967000f)) % 2u) == 0u); + let _e2759 = (_e2750 % 1f); + if (_e2750 >= 1f) { + phi_7788_ = select(true, false, (_e2759 == 0f)); } else { - phi_7153_ = true; + phi_7788_ = true; } - let _e2738 = phi_7153_; - let _e2739 = select(1f, _e2734, _e2738); - if (select(-1f, 1f, (_e2715 >= 0f)) > 0f) { - if _e2732 { - phi_4327_ = _e2739; + let _e2763 = phi_7788_; + let _e2764 = select(1f, _e2759, _e2763); + if (select(-1f, 1f, (_e2740 >= 0f)) > 0f) { + if _e2757 { + phi_4841_ = _e2764; } else { - phi_4327_ = (1f - _e2739); + phi_4841_ = (1f - _e2764); } - let _e2746 = phi_4327_; - phi_4333_ = _e2746; + let _e2771 = phi_4841_; + phi_4847_ = _e2771; } else { - if _e2732 { - phi_4332_ = (1f - _e2739); + if _e2757 { + phi_4846_ = (1f - _e2764); } else { - phi_4332_ = _e2739; + phi_4846_ = _e2764; } - let _e2743 = phi_4332_; - phi_4333_ = _e2743; + let _e2768 = phi_4846_; + phi_4847_ = _e2768; } - let _e2748 = phi_4333_; - phi_4335_ = _e2748; + let _e2773 = phi_4847_; + phi_4849_ = _e2773; break; } case 0: { - if (_e2715 > 1f) { - phi_7140_ = 0.9999999f; + if (_e2740 > 1f) { + phi_7775_ = 0.9999999f; } else { - phi_7140_ = select(_e2715, 0.00000011920929f, (_e2715 < 0f)); + phi_7775_ = select(_e2740, 0.00000011920929f, (_e2740 < 0f)); } - let _e2722 = phi_7140_; - phi_4335_ = _e2722; + let _e2747 = phi_7775_; + phi_4849_ = _e2747; break; } default: { - phi_4335_ = f32(); + phi_4849_ = f32(); break; } } - let _e2764 = phi_4335_; - switch bitcast(_e2472) { + let _e2789 = phi_4849_; + switch bitcast(_e2623) { case 1: { - let _e2799 = abs(_e2716); - let _e2801 = (_e2799 % 1f); - if (_e2799 >= 1f) { - phi_7218_ = select(true, false, (_e2801 == 0f)); + let _e2824 = abs(_e2741); + let _e2826 = (_e2824 % 1f); + if (_e2824 >= 1f) { + phi_7853_ = select(true, false, (_e2826 == 0f)); } else { - phi_7218_ = true; + phi_7853_ = true; } - let _e2805 = phi_7218_; - let _e2806 = select(1f, _e2801, _e2805); - if (select(-1f, 1f, (_e2716 >= 0f)) > 0f) { - phi_4354_ = _e2806; + let _e2830 = phi_7853_; + let _e2831 = select(1f, _e2826, _e2830); + if (select(-1f, 1f, (_e2741 >= 0f)) > 0f) { + phi_4868_ = _e2831; } else { - phi_4354_ = (1f - _e2806); + phi_4868_ = (1f - _e2831); } - let _e2810 = phi_4354_; - phi_4391_ = _e2810; + let _e2835 = phi_4868_; + phi_4905_ = _e2835; break; } case 2: { - let _e2773 = abs(_e2716); - let _e2780 = ((select(select(u32(_e2773), 0u, (_e2773 < 0f)), 4294967295u, (_e2773 > 4294967000f)) % 2u) == 0u); - let _e2782 = (_e2773 % 1f); - if (_e2773 >= 1f) { - phi_7201_ = select(true, false, (_e2782 == 0f)); + let _e2798 = abs(_e2741); + let _e2805 = ((select(select(u32(_e2798), 0u, (_e2798 < 0f)), 4294967295u, (_e2798 > 4294967000f)) % 2u) == 0u); + let _e2807 = (_e2798 % 1f); + if (_e2798 >= 1f) { + phi_7836_ = select(true, false, (_e2807 == 0f)); } else { - phi_7201_ = true; + phi_7836_ = true; } - let _e2786 = phi_7201_; - let _e2787 = select(1f, _e2782, _e2786); - if (select(-1f, 1f, (_e2716 >= 0f)) > 0f) { - if _e2780 { - phi_4383_ = _e2787; + let _e2811 = phi_7836_; + let _e2812 = select(1f, _e2807, _e2811); + if (select(-1f, 1f, (_e2741 >= 0f)) > 0f) { + if _e2805 { + phi_4897_ = _e2812; } else { - phi_4383_ = (1f - _e2787); + phi_4897_ = (1f - _e2812); } - let _e2794 = phi_4383_; - phi_4389_ = _e2794; + let _e2819 = phi_4897_; + phi_4903_ = _e2819; } else { - if _e2780 { - phi_4388_ = (1f - _e2787); + if _e2805 { + phi_4902_ = (1f - _e2812); } else { - phi_4388_ = _e2787; + phi_4902_ = _e2812; } - let _e2791 = phi_4388_; - phi_4389_ = _e2791; + let _e2816 = phi_4902_; + phi_4903_ = _e2816; } - let _e2796 = phi_4389_; - phi_4391_ = _e2796; + let _e2821 = phi_4903_; + phi_4905_ = _e2821; break; } case 0: { - if (_e2716 > 1f) { - phi_7188_ = 0.9999999f; + if (_e2741 > 1f) { + phi_7823_ = 0.9999999f; } else { - phi_7188_ = select(_e2716, 0.00000011920929f, (_e2716 < 0f)); + phi_7823_ = select(_e2741, 0.00000011920929f, (_e2741 < 0f)); } - let _e2770 = phi_7188_; - phi_4391_ = _e2770; + let _e2795 = phi_7823_; + phi_4905_ = _e2795; break; } default: { - phi_4391_ = f32(); + phi_4905_ = f32(); break; } } - let _e2812 = phi_4391_; - let _e2813 = (_e2764 * _e2601); - let _e2819 = (_e2812 * _e2602); - let _e2834 = vec3((f32((select(select(u32(_e2813), 0u, (_e2813 < 0f)), 4294967295u, (_e2813 > 4294967000f)) + _e2442)) / f32(_e2475)), (f32((select(select(u32(_e2819), 0u, (_e2819 < 0f)), 4294967295u, (_e2819 > 4294967000f)) + _e2446)) / f32(_e2479)), f32(_e2458)); - let _e2840 = textureSampleLevel(global_19, global_18, vec2(_e2834.x, _e2834.y), i32(_e2834.z), 0f); - phi_4210_ = (_e2663 + 1f); - phi_4212_ = (_e2665 + select(0f, 1f, ((_e2582 - max((bitcast(_e2429) * (1f - _e2348)), bitcast(_e2424))) > _e2840.x))); - phi_4453_ = true; + let _e2837 = phi_4905_; + let _e2838 = (_e2789 * _e2626); + let _e2844 = (_e2837 * _e2627); + let _e2859 = vec3((f32((select(select(u32(_e2838), 0u, (_e2838 < 0f)), 4294967295u, (_e2838 > 4294967000f)) + _e2593)) / f32(_e2462)), (f32((select(select(u32(_e2844), 0u, (_e2844 < 0f)), 4294967295u, (_e2844 > 4294967000f)) + _e2597)) / f32(_e2466)), f32(_e2609)); + let _e2865 = textureSampleLevel(global_19, global_18, vec2(_e2859.x, _e2859.y), i32(_e2859.z), 0f); + if ((_e2569 - max((bitcast(_e2454) * (1f - _e2372)), bitcast(_e2449))) > _e2865.x) { + phi_4964_ = (_e2690 + 1f); + } else { + phi_4964_ = _e2690; + } + let _e2874 = phi_4964_; + phi_4724_ = (_e2688 + 1f); + phi_4726_ = _e2874; + phi_4966_ = true; break; } default: { - phi_4210_ = f32(); - phi_4212_ = f32(); - phi_4453_ = bool(); + phi_4724_ = f32(); + phi_4726_ = f32(); + phi_4966_ = bool(); break; } } - let _e2851 = phi_4210_; - let _e2853 = phi_4212_; - let _e2855 = phi_4453_; + let _e2877 = phi_4724_; + let _e2879 = phi_4726_; + let _e2881 = phi_4966_; continue; continuing { - phi_4206_ = _e2705; - phi_4209_ = _e2851; - phi_4211_ = _e2853; - phi_7925_ = _e2608; - break if !(_e2855); + phi_4720_ = _e2730; + phi_4723_ = _e2877; + phi_4725_ = _e2879; + phi_8839_ = _e2633; + break if !(_e2881); } } - let _e2858 = phi_7925_; - phi_8021_ = _e2858; - if _e2858 { + let _e2884 = phi_8839_; + phi_8935_ = _e2884; + if _e2884 { break; } - phi_8022_ = _e2858; - let _e4096 = local_9; - phi_4139_ = _e4096; - let _e4099 = local_10; - phi_4141_ = _e4099; - phi_4454_ = true; + phi_8936_ = _e2884; + let _e4560 = local_11; + phi_4653_ = _e4560; + let _e4563 = local_12; + phi_4655_ = _e4563; + phi_4967_ = true; break; } default: { - phi_8022_ = _e2608; - phi_4139_ = f32(); - phi_4141_ = f32(); - phi_4454_ = bool(); + phi_8936_ = _e2633; + phi_4653_ = f32(); + phi_4655_ = f32(); + phi_4967_ = bool(); break; } } - let _e2860 = phi_8022_; - let _e2862 = phi_4139_; - let _e2864 = phi_4141_; - let _e2866 = phi_4454_; + let _e2886 = phi_8936_; + let _e2888 = phi_4653_; + let _e2890 = phi_4655_; + let _e2892 = phi_4967_; continue; continuing { - phi_7941_ = _e2860; - phi_4135_ = _e2654; - phi_4138_ = _e2862; - phi_4140_ = _e2864; - phi_8021_ = _e2860; - break if !(_e2866); + phi_8855_ = _e2886; + phi_4649_ = _e2679; + phi_4652_ = _e2888; + phi_4654_ = _e2890; + phi_8935_ = _e2886; + break if !(_e2892); } } - let _e2869 = phi_8021_; - phi_8086_ = _e2869; - if _e2869 { + let _e2895 = phi_8935_; + phi_9056_ = _e2895; + if _e2895 { break; } - let _e2871 = local_2; - let _e2874 = local_3; - phi_8093_ = _e2869; - phi_4457_ = (_e2874 / max(_e2871, 1f)); + let _e2897 = local_3; + let _e2900 = local_4; + phi_9063_ = _e2895; + phi_4970_ = (_e2900 / max(_e2897, 1f)); } else { - phi_8093_ = _e1950; - phi_4457_ = 0f; + phi_9063_ = _e1974; + phi_4970_ = 0f; } - let _e2877 = phi_8093_; - let _e2879 = phi_4457_; - phi_8092_ = _e2877; - phi_4458_ = _e2879; + let _e2903 = phi_9063_; + let _e2905 = phi_4970_; + phi_9062_ = _e2903; + phi_4971_ = _e2905; } else { - phi_8092_ = _e1950; - phi_4458_ = 0f; + phi_9062_ = _e1974; + phi_4971_ = 0f; } - let _e2881 = phi_8092_; - let _e2883 = phi_4458_; - let _e2884 = (1f - _e2883); - phi_8091_ = _e2881; - phi_4472_ = vec3(fma(((fma((((1f - _e2373) * _e2292) * _e1370), 0.31830987f, ((_e2382 * _e2373) / _e2387)) * (_e2193.member_4.x * _e2288)) * _e2349), _e2884, _e1954.x), fma(((fma((((1f - _e2374) * _e2292) * _e1372), 0.31830987f, ((_e2382 * _e2374) / _e2387)) * (_e2193.member_4.y * _e2288)) * _e2349), _e2884, _e1954.y), fma(((fma((((1f - _e2375) * _e2292) * _e1374), 0.31830987f, ((_e2382 * _e2375) / _e2387)) * (_e2193.member_4.z * _e2288)) * _e2349), _e2884, _e1954.z)); + let _e2907 = phi_9062_; + let _e2909 = phi_4971_; + phi_9061_ = _e2907; + phi_4972_ = _e2909; + phi_4973_ = vec3(((fma((((1f - _e2397) * _e2316) * _e1394), 0.31830987f, ((_e2406 * _e2397) / _e2411)) * (_e2217.member_4.x * _e2312)) * _e2373), ((fma((((1f - _e2398) * _e2316) * _e1396), 0.31830987f, ((_e2406 * _e2398) / _e2411)) * (_e2217.member_4.y * _e2312)) * _e2373), ((fma((((1f - _e2399) * _e2316) * _e1398), 0.31830987f, ((_e2406 * _e2399) / _e2411)) * (_e2217.member_4.z * _e2312)) * _e2373)); } - let _e2893 = phi_8091_; - let _e2895 = phi_4472_; - phi_8090_ = _e2893; - phi_4474_ = _e2895; - phi_4475_ = select(true, false, _e2285); + let _e2911 = phi_9061_; + let _e2913 = phi_4972_; + let _e2915 = phi_4973_; + phi_9060_ = _e2911; + phi_4975_ = _e2913; + phi_4976_ = _e2915; + phi_4977_ = select(true, false, _e2309); break; } default: { - phi_8090_ = _e1950; - phi_4474_ = vec3(); - phi_4475_ = bool(); + phi_9060_ = _e1974; + phi_4975_ = f32(); + phi_4976_ = vec3(); + phi_4977_ = bool(); break; } } - let _e3807 = phi_8090_; - let _e3809 = phi_4474_; - let _e3811 = phi_4475_; - phi_8087_ = _e3807; - phi_2377_ = select(_e3809, _e1954, vec3(select(true, false, _e3811))); - phi_4484_ = true; + let _e4255 = phi_9060_; + let _e4257 = phi_4975_; + let _e4259 = phi_4976_; + let _e4261 = phi_4977_; + if _e4261 { + let _e4262 = (1f - _e4257); + phi_4997_ = vec3(fma(_e4259.x, _e4262, _e1978.x), fma(_e4259.y, _e4262, _e1978.y), fma(_e4259.z, _e4262, _e1978.z)); + } else { + phi_4997_ = vec3(); + } + let _e4274 = phi_4997_; + phi_9057_ = _e4255; + phi_2409_ = select(_e4274, _e1978, vec3(select(true, false, _e4261))); + phi_5003_ = true; break; } default: { - phi_8087_ = _e1950; - phi_2377_ = vec3(); - phi_4484_ = bool(); + phi_9057_ = _e1974; + phi_2409_ = vec3(); + phi_5003_ = bool(); break; } } - let _e3816 = phi_8087_; - let _e3818 = phi_2377_; - let _e3820 = phi_4484_; + let _e4279 = phi_9057_; + let _e4281 = phi_2409_; + let _e4283 = phi_5003_; continue; continuing { - phi_7968_ = _e3816; - phi_2373_ = _e1967; - phi_2376_ = _e3818; - phi_8086_ = _e3816; - break if !(_e3820); + phi_8882_ = _e4279; + phi_2405_ = _e1991; + phi_2408_ = _e4281; + phi_9056_ = _e4279; + break if !(_e4283); } } - let _e3823 = phi_8086_; - phi_8104_ = _e3823; - if _e3823 { + let _e4286 = phi_9056_; + phi_9068_ = _e4286; + if _e4286 { break; } - let _e3825 = fma(-(_e686.z), _e295.member_3, 1f); - let _e3829 = fma(0.04f, _e3825, (_e1370 * _e1382)); - let _e3830 = fma(0.04f, _e3825, (_e1372 * _e1382)); - let _e3831 = fma(0.04f, _e3825, (_e1374 * _e1382)); - let _e3843 = fma(-(_e686.y), _e295.member_4, 1f); - let _e3850 = (1f - max(fma(_e1934.z, _e1938.z, fma(_e1934.x, _e1938.x, (_e1934.y * _e1938.y))), 0f)); - let _e3852 = select(_e3850, 0f, (_e3850 < 0f)); - let _e3855 = pow(select(_e3852, 1f, (_e3852 > 1f)), 5f); - let _e3856 = fma((max(_e3843, _e3829) - _e3829), _e3855, _e3829); - let _e3857 = fma((max(_e3843, _e3830) - _e3830), _e3855, _e3830); - let _e3858 = fma((max(_e3843, _e3831) - _e3831), _e3855, _e3831); - let _e3878 = local_6; - let _e3882 = local_7; - let _e3886 = local_8; - phi_8112_ = _e3823; - phi_4601_ = vec4(fma(_e1392, _e295.member_1, fma(fma(((1f - _e3856) * _e3825), (_e1401.x * _e1370), (_e1749.x * fma(_e3856, _e1765.x, _e1765.y))), _e1386, _e3878.x)), fma(_e1394, _e295.member_1, fma(fma(((1f - _e3857) * _e3825), (_e1401.y * _e1372), (_e1749.y * fma(_e3857, _e1765.x, _e1765.y))), _e1386, _e3882.y)), fma(_e1396, _e295.member_1, fma(fma(((1f - _e3858) * _e3825), (_e1401.z * _e1374), (_e1749.z * fma(_e3858, _e1765.x, _e1765.y))), _e1386, _e3886.z)), 1f); + let _e4288 = fma(-(_e710.z), _e319.member_3, 1f); + let _e4292 = fma(0.04f, _e4288, (_e1394 * _e1406)); + let _e4293 = fma(0.04f, _e4288, (_e1396 * _e1406)); + let _e4294 = fma(0.04f, _e4288, (_e1398 * _e1406)); + let _e4306 = fma(-(_e710.y), _e319.member_4, 1f); + let _e4313 = (1f - max(fma(_e1958.z, _e1962.z, fma(_e1958.x, _e1962.x, (_e1958.y * _e1962.y))), 0f)); + let _e4315 = select(_e4313, 0f, (_e4313 < 0f)); + let _e4318 = pow(select(_e4315, 1f, (_e4315 > 1f)), 5f); + let _e4319 = fma((max(_e4306, _e4292) - _e4292), _e4318, _e4292); + let _e4320 = fma((max(_e4306, _e4293) - _e4293), _e4318, _e4293); + let _e4321 = fma((max(_e4306, _e4294) - _e4294), _e4318, _e4294); + let _e4341 = local_8; + let _e4345 = local_9; + let _e4349 = local_10; + phi_9076_ = _e4286; + phi_5120_ = vec4(fma(_e1416, _e319.member_1, fma(fma(((1f - _e4319) * _e4288), (_e1425.x * _e1394), (_e1773.x * fma(_e4319, _e1789.x, _e1789.y))), _e1410, _e4341.x)), fma(_e1418, _e319.member_1, fma(fma(((1f - _e4320) * _e4288), (_e1425.y * _e1396), (_e1773.y * fma(_e4320, _e1789.x, _e1789.y))), _e1410, _e4345.y)), fma(_e1420, _e319.member_1, fma(fma(((1f - _e4321) * _e4288), (_e1425.z * _e1398), (_e1773.z * fma(_e4321, _e1789.x, _e1789.y))), _e1410, _e4349.z)), 1f); } else { - phi_8112_ = false; - phi_4601_ = (vec4((_e126.x * _e492.x), (_e126.y * _e492.y), (_e126.z * _e492.z), (_e126.w * _e492.w)) * _e295.member_2); + phi_9076_ = false; + phi_5120_ = (vec4((_e150.x * _e516.x), (_e150.y * _e516.y), (_e150.z * _e516.z), (_e150.w * _e516.w)) * _e319.member_2); } - let _e3894 = phi_8112_; - let _e3896 = phi_4601_; - global_20 = _e3896; - phi_8104_ = _e3894; + let _e4357 = phi_9076_; + let _e4359 = phi_5120_; + global_20 = _e4359; + phi_9068_ = _e4357; break; } case 1: { - let _e1907 = sqrt(fma(_e127.x, _e127.x, (_e127.y * _e127.y))); - if (_e1907 == 0f) { - phi_6634_ = vec3(0f, 0f, 0f); + let _e1931 = sqrt(fma(_e151.x, _e151.x, (_e151.y * _e151.y))); + if (_e1931 == 0f) { + phi_7269_ = vec3(0f, 0f, 0f); } else { - phi_6634_ = (vec3(_e127.x, _e127.y, 0f) * (1f / _e1907)); + phi_7269_ = (vec3(_e151.x, _e151.y, 0f) * (1f / _e1931)); } - let _e1912 = phi_6634_; - global_20 = vec4(((_e1912.x + 1f) * 0.5f), ((_e1912.y + 1f) * 0.5f), ((_e1912.z + 1f) * 0.5f), 1f); - phi_8104_ = false; + let _e1936 = phi_7269_; + global_20 = vec4(((_e1936.x + 1f) * 0.5f), ((_e1936.y + 1f) * 0.5f), ((_e1936.z + 1f) * 0.5f), 1f); + phi_9068_ = false; break; } case 2: { - let _e1886 = sqrt(fma(_e128.x, _e128.x, (_e128.y * _e128.y))); - if (_e1886 == 0f) { - phi_6585_ = vec3(0f, 0f, 0f); + let _e1910 = sqrt(fma(_e152.x, _e152.x, (_e152.y * _e152.y))); + if (_e1910 == 0f) { + phi_7220_ = vec3(0f, 0f, 0f); } else { - phi_6585_ = (vec3(_e128.x, _e128.y, 0f) * (1f / _e1886)); + phi_7220_ = (vec3(_e152.x, _e152.y, 0f) * (1f / _e1910)); } - let _e1891 = phi_6585_; - global_20 = vec4(((_e1891.x + 1f) * 0.5f), ((_e1891.y + 1f) * 0.5f), ((_e1891.z + 1f) * 0.5f), 1f); - phi_8104_ = false; + let _e1915 = phi_7220_; + global_20 = vec4(((_e1915.x + 1f) * 0.5f), ((_e1915.y + 1f) * 0.5f), ((_e1915.z + 1f) * 0.5f), 1f); + phi_9068_ = false; break; } case 3: { - if _e1728 { - phi_6536_ = vec3(0f, 0f, 0f); + if _e1752 { + phi_7171_ = vec3(0f, 0f, 0f); } else { - phi_6536_ = (_e1355 * (1f / _e1727)); + phi_7171_ = (_e1379 * (1f / _e1751)); } - let _e1870 = phi_6536_; - global_20 = vec4(((_e1870.x + 1f) * 0.5f), ((_e1870.y + 1f) * 0.5f), ((_e1870.z + 1f) * 0.5f), 1f); - phi_8104_ = false; + let _e1894 = phi_7171_; + global_20 = vec4(((_e1894.x + 1f) * 0.5f), ((_e1894.y + 1f) * 0.5f), ((_e1894.z + 1f) * 0.5f), 1f); + phi_9068_ = false; break; } case 4: { - global_20 = _e126; - phi_8104_ = false; + global_20 = _e150; + phi_9068_ = false; break; } case 5: { - let _e1851 = sqrt(fma(_e129.z, _e129.z, fma(_e129.x, _e129.x, (_e129.y * _e129.y)))); - if (_e1851 == 0f) { - phi_6487_ = vec3(0f, 0f, 0f); + let _e1875 = sqrt(fma(_e153.z, _e153.z, fma(_e153.x, _e153.x, (_e153.y * _e153.y)))); + if (_e1875 == 0f) { + phi_7122_ = vec3(0f, 0f, 0f); } else { - phi_6487_ = (_e129 * (1f / _e1851)); + phi_7122_ = (_e153 * (1f / _e1875)); } - let _e1856 = phi_6487_; - global_20 = vec4(((_e1856.x + 1f) * 0.5f), ((_e1856.y + 1f) * 0.5f), ((_e1856.z + 1f) * 0.5f), 1f); - phi_8104_ = false; + let _e1880 = phi_7122_; + global_20 = vec4(((_e1880.x + 1f) * 0.5f), ((_e1880.y + 1f) * 0.5f), ((_e1880.z + 1f) * 0.5f), 1f); + phi_9068_ = false; break; } case 6: { - let _e1829 = sqrt(fma(_e1353.z, _e1353.z, fma(_e1353.x, _e1353.x, (_e1353.y * _e1353.y)))); - if (_e1829 == 0f) { - phi_6438_ = vec3(0f, 0f, 0f); + let _e1853 = sqrt(fma(_e1377.z, _e1377.z, fma(_e1377.x, _e1377.x, (_e1377.y * _e1377.y)))); + if (_e1853 == 0f) { + phi_7073_ = vec3(0f, 0f, 0f); } else { - phi_6438_ = (_e1353 * (1f / _e1829)); + phi_7073_ = (_e1377 * (1f / _e1853)); } - let _e1834 = phi_6438_; - global_20 = vec4(((_e1834.x + 1f) * 0.5f), ((_e1834.y + 1f) * 0.5f), ((_e1834.z + 1f) * 0.5f), 1f); - phi_8104_ = false; + let _e1858 = phi_7073_; + global_20 = vec4(((_e1858.x + 1f) * 0.5f), ((_e1858.y + 1f) * 0.5f), ((_e1858.z + 1f) * 0.5f), 1f); + phi_9068_ = false; break; } case 7: { - let _e1807 = sqrt(fma(_e130.z, _e130.z, fma(_e130.x, _e130.x, (_e130.y * _e130.y)))); - if (_e1807 == 0f) { - phi_6389_ = vec3(0f, 0f, 0f); + let _e1831 = sqrt(fma(_e154.z, _e154.z, fma(_e154.x, _e154.x, (_e154.y * _e154.y)))); + if (_e1831 == 0f) { + phi_7024_ = vec3(0f, 0f, 0f); } else { - phi_6389_ = (_e130 * (1f / _e1807)); + phi_7024_ = (_e154 * (1f / _e1831)); } - let _e1812 = phi_6389_; - global_20 = vec4(((_e1812.x + 1f) * 0.5f), ((_e1812.y + 1f) * 0.5f), ((_e1812.z + 1f) * 0.5f), 1f); - phi_8104_ = false; + let _e1836 = phi_7024_; + global_20 = vec4(((_e1836.x + 1f) * 0.5f), ((_e1836.y + 1f) * 0.5f), ((_e1836.z + 1f) * 0.5f), 1f); + phi_9068_ = false; break; } case 8: { - let _e1785 = sqrt(fma(_e131.z, _e131.z, fma(_e131.x, _e131.x, (_e131.y * _e131.y)))); - if (_e1785 == 0f) { - phi_6340_ = vec3(0f, 0f, 0f); + let _e1809 = sqrt(fma(_e155.z, _e155.z, fma(_e155.x, _e155.x, (_e155.y * _e155.y)))); + if (_e1809 == 0f) { + phi_6975_ = vec3(0f, 0f, 0f); } else { - phi_6340_ = (_e131 * (1f / _e1785)); + phi_6975_ = (_e155 * (1f / _e1809)); } - let _e1790 = phi_6340_; - global_20 = vec4(((_e1790.x + 1f) * 0.5f), ((_e1790.y + 1f) * 0.5f), ((_e1790.z + 1f) * 0.5f), 1f); - phi_8104_ = false; + let _e1814 = phi_6975_; + global_20 = vec4(((_e1814.x + 1f) * 0.5f), ((_e1814.y + 1f) * 0.5f), ((_e1814.z + 1f) * 0.5f), 1f); + phi_9068_ = false; break; } case 9: { - global_20 = vec4(_e1401.x, _e1401.y, _e1401.z, 1f); - phi_8104_ = false; + global_20 = vec4(_e1425.x, _e1425.y, _e1425.z, 1f); + phi_9068_ = false; break; } case 10: { - global_20 = vec4(_e1749.x, _e1749.y, _e1749.z, 1f); - phi_8104_ = false; + global_20 = vec4(_e1773.x, _e1773.y, _e1773.z, 1f); + phi_9068_ = false; break; } case 11: { - global_20 = vec4(_e1765.x, _e1765.y, 1f, 1f); - phi_8104_ = false; + global_20 = vec4(_e1789.x, _e1789.y, 1f, 1f); + phi_9068_ = false; break; } case 12: { - global_20 = (vec4(_e1359, _e1362, _e1365, (_e492.w * _e295.member_2.w)) * _e126); - phi_8104_ = false; + global_20 = (vec4(_e1383, _e1386, _e1389, (_e516.w * _e319.member_2.w)) * _e150); + phi_9068_ = false; break; } case 13: { - global_20 = vec4(_e1379, _e1379, _e1379, 1f); - phi_8104_ = false; + global_20 = vec4(_e1403, _e1403, _e1403, 1f); + phi_9068_ = false; break; } case 14: { - global_20 = vec4(_e1382, _e1382, _e1382, 1f); - phi_8104_ = false; + global_20 = vec4(_e1406, _e1406, _e1406, 1f); + phi_9068_ = false; break; } case 15: { - global_20 = vec4(_e1386, _e1386, _e1386, 1f); - phi_8104_ = false; + global_20 = vec4(_e1410, _e1410, _e1410, 1f); + phi_9068_ = false; break; } case 16: { - global_20 = vec4((_e1392 * _e295.member_1), (_e1394 * _e295.member_1), (_e1396 * _e295.member_1), 1f); - phi_8104_ = false; + global_20 = vec4((_e1416 * _e319.member_1), (_e1418 * _e319.member_1), (_e1420 * _e319.member_1), 1f); + phi_9068_ = false; break; } case 17: { - global_20 = vec4(_e1268.x, _e1268.y, _e1268.z, 1f); - phi_8104_ = false; + global_20 = vec4(_e1292.x, _e1292.y, _e1292.z, 1f); + phi_9068_ = false; break; } case 18: { - global_20 = vec4(_e295.member.x, _e295.member.y, _e295.member.z, 1f); - phi_8104_ = false; + global_20 = vec4(_e319.member.x, _e319.member.y, _e319.member.z, 1f); + phi_9068_ = false; break; } case 19: { - global_20 = vec4(_e295.member_1, _e295.member_1, _e295.member_1, 1f); - phi_8104_ = false; + global_20 = vec4(_e319.member_1, _e319.member_1, _e319.member_1, 1f); + phi_9068_ = false; break; } default: { - phi_8104_ = false; + phi_9068_ = false; break; } } - let _e3898 = phi_8104_; - if _e3898 { + let _e4361 = phi_9068_; + if _e4361 { break; } break; diff --git a/crates/renderling/src/atlas/cpu.rs b/crates/renderling/src/atlas/cpu.rs index 32666560..49dbcfb7 100644 --- a/crates/renderling/src/atlas/cpu.rs +++ b/crates/renderling/src/atlas/cpu.rs @@ -435,6 +435,14 @@ impl Atlas { let buffer = self.atlas_img_buffer(runtime, layer); buffer.into_linear_rgba(&runtime.device).unwrap() } + + pub fn read_images(&self, runtime: impl AsRef) -> Vec { + let mut images = vec![]; + for i in 0..self.layers.read().unwrap().len() { + images.push(self.atlas_img(runtime.as_ref(), i as u32)); + } + images + } } fn pack_images<'a>( diff --git a/crates/renderling/src/cubemap.rs b/crates/renderling/src/cubemap.rs index f1076ddc..c986fda3 100644 --- a/crates/renderling/src/cubemap.rs +++ b/crates/renderling/src/cubemap.rs @@ -1,8 +1,11 @@ //! Cubemap utilities. //! //! Shaders, render pipelines and layouts for creating and sampling cubemaps. +//! +//! For more info see: +//! * use crabslab::{Array, Id, Slab}; -use glam::{Vec2, Vec3, Vec3Swizzles, Vec4}; +use glam::{Mat4, Vec2, Vec3, Vec3Swizzles, Vec4}; use spirv_std::{num_traits::Zero, spirv}; #[cfg(cpu)] @@ -39,6 +42,73 @@ pub fn cubemap_sampling_test_fragment( *frag_color = cubemap.sample(*sampler, in_uv); } +/// Represents one side of a cubemap. +/// +/// Assumes the camera is at the origin, inside the cube, with +/// a left-handed coordinate system (+Z going into the screen). +#[derive(Clone, Copy)] +pub struct CubemapFaceDirection { + /// Where is the camera + pub eye: Vec3, + /// Where is the camera looking + pub dir: Vec3, + /// Which direction is up + pub up: Vec3, +} + +impl CubemapFaceDirection { + pub const X: Self = Self { + eye: Vec3::ZERO, + dir: Vec3::X, + up: Vec3::Y, + }; + pub const NEG_X: Self = Self { + eye: Vec3::ZERO, + dir: Vec3::NEG_X, + up: Vec3::Y, + }; + + pub const Y: Self = Self { + eye: Vec3::ZERO, + dir: Vec3::Y, + up: Vec3::NEG_Z, + }; + pub const NEG_Y: Self = Self { + eye: Vec3::ZERO, + dir: Vec3::NEG_Y, + up: Vec3::Z, + }; + + pub const Z: Self = Self { + eye: Vec3::ZERO, + dir: Vec3::Z, + up: Vec3::Y, + }; + pub const NEG_Z: Self = Self { + eye: Vec3::ZERO, + dir: Vec3::NEG_Z, + up: Vec3::Y, + }; + + pub const FACES: [Self; 6] = [ + CubemapFaceDirection::X, + CubemapFaceDirection::NEG_X, + CubemapFaceDirection::Y, + CubemapFaceDirection::NEG_Y, + CubemapFaceDirection::Z, + CubemapFaceDirection::NEG_Z, + ]; + + pub fn right(&self) -> Vec3 { + -self.dir.cross(self.up) + } + + /// The view from _inside_ the cube. + pub fn view(&self) -> Mat4 { + Mat4::look_at_lh(self.eye, self.eye + self.dir, self.up) + } +} + pub struct CubemapDescriptor { atlas_descriptor_id: Id, faces: Array, @@ -47,62 +117,30 @@ pub struct CubemapDescriptor { impl CubemapDescriptor { /// Return the face index and UV coordinates that can be used to sample /// a cubemap from the given directional coordinate. - /// - /// `coord` must be normalized, and must **not be zero**. pub fn get_face_index_and_uv(coord: Vec3) -> (usize, Vec2) { - // Unpack coordinate components - let x = coord.x; - let y = coord.y; - let z = coord.z; - - // Determine the major direction - let abs_x = x.abs(); - let abs_y = y.abs(); - let abs_z = z.abs(); - - // Initialize face index and UV coordinates - let (face_index, u, v); - - if abs_x >= abs_y && abs_x >= abs_z { - // X-major direction - if x > 0.0 { - face_index = 0; // +X - u = -z / x; - v = -y / x; + let abs_x = coord.x.abs(); + let abs_y = coord.y.abs(); + let abs_z = coord.z.abs(); + + let (face_index, uv) = if abs_x >= abs_y && abs_x >= abs_z { + if coord.x > 0.0 { + (0, Vec2::new(-coord.z, -coord.y) / abs_x) } else { - face_index = 1; // -X - u = -z / x; - v = y / x; + (1, Vec2::new(coord.z, -coord.y) / abs_x) } } else if abs_y >= abs_x && abs_y >= abs_z { - // Y-major direction - if y > 0.0 { - face_index = 2; // +Y - u = x / y; - v = z / y; + if coord.y > 0.0 { + (2, Vec2::new(coord.x, coord.z) / abs_y) } else { - face_index = 3; // -Y - u = x / y; - v = -z / y; + (3, Vec2::new(coord.x, -coord.z) / abs_y) } + } else if coord.z > 0.0 { + (4, Vec2::new(coord.x, -coord.y) / abs_z) } else { - // Z-major direction - if z > 0.0 { - face_index = 4; // +Z - u = x / z; - v = -y / z; - } else { - face_index = 5; // -Z - u = -x / z; - v = -y / z; - } - } - - // Convert from range [-1, 1] to [0, 1] - let u = (u + 1.0) / 2.0; - let v = (v + 1.0) / 2.0; + (5, Vec2::new(-coord.x, -coord.y) / abs_z) + }; - (face_index, Vec2::new(u, v)) + (face_index, (uv + Vec2::ONE) / 2.0) } /// Sample the cubemap with a directional coordinate. @@ -123,3 +161,42 @@ impl CubemapDescriptor { atlas.sample_by_lod(*sampler, uv, 0.0) } } + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn cubemap_right() { + assert_eq!(Vec3::NEG_Z, CubemapFaceDirection::X.right()); + assert_eq!(Vec3::Z, CubemapFaceDirection::NEG_X.right()); + assert_eq!(Vec3::X, CubemapFaceDirection::Y.right()); + assert_eq!(Vec3::X, CubemapFaceDirection::NEG_Y.right()); + assert_eq!(Vec3::X, CubemapFaceDirection::Z.right()); + assert_eq!(Vec3::NEG_X, CubemapFaceDirection::NEG_Z.right()); + + assert_eq!( + (1, Vec2::new(0.0, 1.0)), + CubemapDescriptor::get_face_index_and_uv(Vec3::NEG_ONE) + ); + } + + #[test] + fn cubemap_face_index() { + let center = Vec2::splat(0.5); + let data = [ + (Vec3::X, 0, center), + (Vec3::NEG_X, 1, center), + (Vec3::Y, 2, center), + (Vec3::NEG_Y, 3, center), + (Vec3::Z, 4, center), + (Vec3::NEG_Z, 5, center), + ]; + for (coord, expected_face_index, expected_uv) in data { + let (seen_face_index, seen_uv) = CubemapDescriptor::get_face_index_and_uv(coord); + dbg!((coord, seen_face_index, seen_uv)); + assert_eq!(expected_face_index, seen_face_index); + assert_eq!(expected_uv, seen_uv); + } + } +} diff --git a/crates/renderling/src/cubemap/cpu.rs b/crates/renderling/src/cubemap/cpu.rs index 12870d11..7fe78fca 100644 --- a/crates/renderling/src/cubemap/cpu.rs +++ b/crates/renderling/src/cubemap/cpu.rs @@ -10,7 +10,7 @@ use crate::{ texture::Texture, }; -use super::CubemapDescriptor; +use super::{CubemapDescriptor, CubemapFaceDirection}; pub fn cpu_sample_cubemap(cubemap: &[image::DynamicImage; 6], coord: Vec3) -> Vec4 { let coord = coord.normalize_or(Vec3::X); @@ -36,76 +36,6 @@ pub fn cpu_sample_cubemap(cubemap: &[image::DynamicImage; 6], coord: Vec3) -> Ve ) } -/// Represents one side of a cubemap. -/// -/// Assumes the camera is at the origin. -pub struct CubemapFaceDirection { - /// Where is the camera - pub dir: Vec3, - /// Which direction is up - pub up: Vec3, - /// Which direct is right - pub right: Vec3, -} - -impl CubemapFaceDirection { - pub const X: Self = Self { - dir: Vec3::X, - up: Vec3::NEG_Y, - right: Vec3::NEG_Z, - }; - pub const NEG_X: Self = Self { - dir: Vec3::NEG_X, - up: Vec3::NEG_Y, - right: Vec3::Z, - }; - pub const NEG_Y: Self = Self { - dir: Vec3::NEG_Y, - up: Vec3::NEG_Z, - right: Vec3::X, - }; - pub const Y: Self = Self { - dir: Vec3::Y, - up: Vec3::Z, - right: Vec3::X, - }; - pub const Z: Self = Self { - dir: Vec3::Z, - up: Vec3::NEG_Y, - right: Vec3::X, - }; - pub const NEG_Z: Self = Self { - dir: Vec3::NEG_Z, - up: Vec3::NEG_Y, - right: Vec3::NEG_X, - }; - pub const FACES: [Self; 6] = [ - CubemapFaceDirection::X, - CubemapFaceDirection::NEG_X, - CubemapFaceDirection::NEG_Y, - CubemapFaceDirection::Y, - CubemapFaceDirection::Z, - CubemapFaceDirection::NEG_Z, - ]; - - pub fn view(&self) -> Mat4 { - Mat4::look_at_rh(Vec3::ZERO, self.dir, self.up) - } - - pub fn to_corners_tr_tl_br_bl(self) -> [Vec3; 4] { - let tr = self.dir + self.up + self.right; - let tl = self.dir + self.up - self.right; - let br = self.dir - self.up + self.right; - let bl = self.dir - self.up - self.right; - [tr, tl, br, bl] - } - - pub fn to_tri_list(self) -> [Vec3; 6] { - let [tr, tl, br, bl] = self.to_corners_tr_tl_br_bl(); - [tr, tl, bl, tr, bl, br] - } -} - /// A cubemap that acts as a render target for an entire scene. /// /// Use this to create and update a skybox with scene geometry. @@ -175,7 +105,7 @@ impl SceneCubemap { // faces align correctly to each other at the edges. let fovy = std::f32::consts::FRAC_PI_2; let aspect = self.cubemap_texture.width() as f32 / self.cubemap_texture.height() as f32; - let projection = Mat4::perspective_rh(fovy, aspect, 1.0, 25.0); + let projection = Mat4::perspective_lh(fovy, aspect, 1.0, 25.0); // Render each face by rendering the scene from each camera angle into the cubemap for (i, face) in CubemapFaceDirection::FACES.iter().enumerate() { // Update the camera angle, no need to sync as calling `Stage::render` does this @@ -339,63 +269,17 @@ impl EquirectangularImageToCubemapBlitter { #[cfg(test)] mod test { - use core::fmt::Debug; - - use assert_approx_eq::assert_approx_eq; use craballoc::slab::SlabAllocator; - use glam::{Quat, Vec2, Vec4}; + use glam::Vec4; use image::GenericImageView; use crate::{ - atlas::{Atlas, AtlasImage}, math::{UNIT_INDICES, UNIT_POINTS}, stage::{Renderlet, Vertex}, }; use super::*; - #[test] - fn cubemap_face_views() { - // This tests that the cubemap faces `views` make a valid cubemap. - - // We got this array from the original skybox code, which we know makes - // valid cubemaps. - let skybox_views = [ - Mat4::look_at_rh( - Vec3::new(0.0, 0.0, 0.0), - Vec3::new(1.0, 0.0, 0.0), - Vec3::new(0.0, -1.0, 0.0), - ), - Mat4::look_at_rh( - Vec3::new(0.0, 0.0, 0.0), - Vec3::new(-1.0, 0.0, 0.0), - Vec3::new(0.0, -1.0, 0.0), - ), - Mat4::look_at_rh( - Vec3::new(0.0, 0.0, 0.0), - Vec3::new(0.0, -1.0, 0.0), - Vec3::new(0.0, 0.0, -1.0), - ), - Mat4::look_at_rh( - Vec3::new(0.0, 0.0, 0.0), - Vec3::new(0.0, 1.0, 0.0), - Vec3::new(0.0, 0.0, 1.0), - ), - Mat4::look_at_rh( - Vec3::new(0.0, 0.0, 0.0), - Vec3::new(0.0, 0.0, 1.0), - Vec3::new(0.0, -1.0, 0.0), - ), - Mat4::look_at_rh( - Vec3::new(0.0, 0.0, 0.0), - Vec3::new(0.0, 0.0, -1.0), - Vec3::new(0.0, -1.0, 0.0), - ), - ]; - let views = CubemapFaceDirection::FACES.map(|f| f.view()); - assert_eq!(skybox_views, views); - } - #[test] fn hand_rolled_cubemap_sampling() { let width = 256; @@ -417,8 +301,7 @@ mod test { // multiply by 2.0 because the unit cube's AABB bounds are at 0.5, and we want 1.0 .with_position(unit_cube_point * 2.0) // "normalize" (really "shift") the space coord from [-0.5, 0.5] to [0.0, 1.0] - // ...but flip y - .with_color((unit_cube_point * Vec3::new(1.0, -1.0, 1.0) + 0.5).extend(1.0)) + .with_color((unit_cube_point + 0.5).extend(1.0)) })); let indices = stage.new_array(UNIT_INDICES.map(|u| u as u32)); let renderlet = stage.new_value(Renderlet { @@ -439,13 +322,9 @@ mod test { scene_cubemap.run(&stage); let frame = ctx.get_next_frame().unwrap(); - crate::test::capture_gpu_frame( - &ctx, - "cubemap/hand_rolled_cubemap_sampling/frame.gputrace", - || stage.render(&frame.view()), - ); + stage.render(&frame.view()); let img = frame.read_image().unwrap(); - img_diff::save("cubemap/hand_rolled_cubemap_sampling/cube.png", img); + img_diff::assert_img_eq("cubemap/hand_rolled_cubemap_sampling/cube.png", img); frame.present(); let slab = SlabAllocator::new(&ctx, wgpu::BufferUsages::empty()); @@ -652,7 +531,7 @@ mod test { .into_image::>(ctx.get_device()) .unwrap(); - img_diff::save( + img_diff::assert_img_eq( &format!( "cubemap/hand_rolled_cubemap_sampling/face_{}.png", index_to_face_string(i as usize) @@ -709,21 +588,40 @@ mod test { } } + // add in some deterministic pseudo-randomn points + { + let order = acorn_prng::Order::new(666); + let seed = acorn_prng::Seed::new(1_000_000); + let mut prng = acorn_prng::Acorn::new(order, seed); + let mut rf32 = move || { + let u = prng.generate_u32_between_range(0..=u32::MAX); + f32::from_bits(u) + }; + let mut rxvec3 = { || Vec3::new(f32::MAX, rf32(), rf32()).normalize_or(Vec3::X) }; + // let mut rvec3 = || Vec3::new(rf32(), rf32(), rf32()); + uvs.extend((0..20).map(|_| rxvec3())); + } + // add zero uvs.push(Vec3::ZERO); const THRESHOLD: f32 = 0.005; for uv in uvs.into_iter() { + let nuv = uv.normalize_or(Vec3::X); let color = sample(uv); let (face_index, uv2d) = CubemapDescriptor::get_face_index_and_uv(uv.normalize_or(Vec3::X)); + let px = (uv2d.x * (width as f32 - 1.0)).round() as u32; + let py = (uv2d.y * (height as f32 - 1.0)).round() as u32; + let puv = UVec2::new(px, py); let cpu_color = cpu_sample_cubemap(&cpu_cubemap, uv); let dir_string = index_to_face_string(face_index); println!( "__uv: {uv},\n\ + _nuv: {nuv},\n\ _gpu: {color}\n\ _cpu: {cpu_color}\n\ - from: {dir_string}({face_index}) {uv2d}\n" + from: {dir_string}({face_index}) {uv2d} {puv}\n" ); let cmp = pretty_assertions::Comparison::new(&color, &cpu_color); let distance = color.distance(cpu_color); diff --git a/crates/renderling/src/light.rs b/crates/renderling/src/light.rs index c559ccf0..c543a573 100644 --- a/crates/renderling/src/light.rs +++ b/crates/renderling/src/light.rs @@ -9,6 +9,7 @@ use spirv_std::spirv; use crate::{ atlas::{AtlasDescriptor, AtlasTexture}, + cubemap::{CubemapDescriptor, CubemapFaceDirection}, math::{IsSampler, IsVector, Sample2dArray}, stage::Renderlet, transform::Transform, @@ -44,6 +45,10 @@ pub struct LightingDescriptor { #[derive(Clone, Copy, Default, SlabItem, core::fmt::Debug)] pub struct ShadowMapDescriptor { pub light_space_transforms_array: Array, + /// Near plane of the projection matrix + pub z_near: f32, + /// Far plane of the projection matrix + pub z_far: f32, /// Pointers to the atlas textures where the shadow map depth /// data is stored. /// @@ -352,24 +357,35 @@ impl Default for PointLightDescriptor { } impl PointLightDescriptor { + pub fn shadow_mapping_view_matrix( + &self, + face_index: usize, + parent_light_transform: &Mat4, + ) -> Mat4 { + let eye = parent_light_transform.transform_point3(self.position); + let mut face = CubemapFaceDirection::FACES[face_index]; + face.eye = eye; + face.view() + } + + pub fn shadow_mapping_projection_matrix(z_near: f32, z_far: f32) -> Mat4 { + Mat4::perspective_lh(core::f32::consts::FRAC_PI_2, 1.0, z_near, z_far) + } + pub fn shadow_mapping_projection_and_view_matrices( &self, parent_light_transform: &Mat4, z_near: f32, z_far: f32, ) -> (Mat4, [Mat4; 6]) { - let p = Mat4::perspective_rh(core::f32::consts::FRAC_PI_2, 1.0, z_near, z_far); + let p = Self::shadow_mapping_projection_matrix(z_near, z_far); let eye = parent_light_transform.transform_point3(self.position); ( p, - [ - Mat4::look_at_rh(eye, eye + Vec3::X, Vec3::Y), - Mat4::look_at_rh(eye, eye + Vec3::NEG_X, Vec3::Y), - Mat4::look_at_rh(eye, eye + Vec3::Y, Vec3::Z), - Mat4::look_at_rh(eye, eye + Vec3::NEG_Y, Vec3::Z), - Mat4::look_at_rh(eye, eye + Vec3::Z, Vec3::Y), - Mat4::look_at_rh(eye, eye + Vec3::NEG_Z, Vec3::Y), - ], + CubemapFaceDirection::FACES.map(|mut face| { + face.eye = eye; + face.view() + }), ) } } @@ -483,11 +499,11 @@ impl Light { /// /// This is mostly just to appease clippy. pub struct ShadowCalculation { - pub shadow_map_atlas_texture: AtlasTexture, + pub shadow_map_desc: ShadowMapDescriptor, pub shadow_map_atlas_size: UVec2, - pub frag_pos_in_light_space: Vec3, - pub surface_normal: Vec3, - pub light_direction: Vec3, + pub surface_normal_in_world_space: Vec3, + pub frag_pos_in_world_space: Vec3, + pub frag_to_light_in_world_space: Vec3, pub bias_min: f32, pub bias_max: f32, pub pcf_samples: u32, @@ -502,13 +518,7 @@ impl ShadowCalculation { surface_normal: Vec3, light_direction: Vec3, ) -> Self { - let shadow_map_descr = light_slab.read_unchecked(light.shadow_map_desc_id); - let atlas_texture = { - let atlas_texture_id = - // TODO: for point lights we have to pick all 6 shadow map textures - light_slab.read_unchecked(shadow_map_descr.atlas_textures_array.at(0)); - light_slab.read_unchecked(atlas_texture_id) - }; + let shadow_map_desc = light_slab.read_unchecked(light.shadow_map_desc_id); let atlas_size = { let lighting_desc_id = Id::::new(0); let atlas_desc_id = light_slab.read_unchecked( @@ -517,41 +527,56 @@ impl ShadowCalculation { let atlas_desc = light_slab.read_unchecked(atlas_desc_id); atlas_desc.size }; - let light_space_transform_id = shadow_map_descr.light_space_transforms_array.at(0); - let light_space_transform = light_slab.read_unchecked(light_space_transform_id); - let frag_pos_in_light_space = light_space_transform.project_point3(in_pos); ShadowCalculation { - shadow_map_atlas_texture: atlas_texture, + shadow_map_desc, shadow_map_atlas_size: atlas_size.xy(), - frag_pos_in_light_space, - surface_normal, - light_direction, - bias_min: shadow_map_descr.bias_min, - bias_max: shadow_map_descr.bias_max, - pcf_samples: shadow_map_descr.pcf_samples, + surface_normal_in_world_space: surface_normal, + frag_pos_in_world_space: in_pos, + frag_to_light_in_world_space: light_direction, + bias_min: shadow_map_desc.bias_min, + bias_max: shadow_map_desc.bias_max, + pcf_samples: shadow_map_desc.pcf_samples, } } - /// Returns shadow _intensity_. + fn get_atlas_texture_at(&self, light_slab: &[u32], index: usize) -> AtlasTexture { + let atlas_texture_id = + light_slab.read_unchecked(self.shadow_map_desc.atlas_textures_array.at(index)); + light_slab.read_unchecked(atlas_texture_id) + } + + fn get_frag_pos_in_light_space(&self, light_slab: &[u32], index: usize) -> Vec3 { + let light_space_transform_id = self.shadow_map_desc.light_space_transforms_array.at(index); + let light_space_transform = light_slab.read_unchecked(light_space_transform_id); + light_space_transform.project_point3(self.frag_pos_in_world_space) + } + + /// Returns shadow _intensity_ for directional and spot lights. /// /// Returns `0.0` when the fragment is in full light. /// Returns `1.0` when the fragment is in full shadow. - pub fn run(&self, shadow_map: &T, shadow_map_sampler: &S) -> f32 + pub fn run_directional_or_spot( + &self, + light_slab: &[u32], + shadow_map: &T, + shadow_map_sampler: &S, + ) -> f32 where S: IsSampler, T: Sample2dArray, { let ShadowCalculation { - shadow_map_atlas_texture, + shadow_map_desc: _, shadow_map_atlas_size, - frag_pos_in_light_space, - surface_normal, - light_direction, + frag_pos_in_world_space: _, + surface_normal_in_world_space: surface_normal, + frag_to_light_in_world_space: light_direction, bias_min, bias_max, pcf_samples, } = self; + let frag_pos_in_light_space = self.get_frag_pos_in_light_space(light_slab, 0); crate::println!("frag_pos_in_light_space: {frag_pos_in_light_space}"); if !crate::math::is_inside_clip_space(frag_pos_in_light_space.xyz()) { return 0.0; @@ -565,6 +590,7 @@ impl ShadowCalculation { * Vec2::splat(0.5); crate::println!("proj_coords_uv: {proj_coords_uv}"); + let shadow_map_atlas_texture = self.get_atlas_texture_at(light_slab, 0); // With these projected coordinates we can sample the depth map as the // resulting [0,1] coordinates from proj_coords directly correspond to // the transformed NDC coordinates from the `ShadowMap::update` render pass. @@ -583,30 +609,108 @@ impl ShadowCalculation { proj_coords_uv + Vec2::new(x as f32, y as f32) * texel_size, *shadow_map_atlas_size, ); - let closest_depth = shadow_map + let shadow_map_depth = shadow_map .sample_by_lod(*shadow_map_sampler, proj_coords, 0.0) .x; // To get the current depth at this fragment we simply retrieve the projected vector's z // coordinate which equals the depth of this fragment from the light's perspective. - let current_depth = frag_pos_in_light_space.z; + let fragment_depth = frag_pos_in_light_space.z; // If the `current_depth`, which is the depth of the fragment from the lights POV, is // greater than the `closest_depth` of the shadow map at that fragment, the fragment // is in shadow - crate::println!("current_depth: {current_depth}"); - crate::println!("closest_depth: {closest_depth}"); + crate::println!("current_depth: {fragment_depth}"); + crate::println!("closest_depth: {shadow_map_depth}"); let bias = (bias_max * (1.0 - surface_normal.dot(*light_direction))).max(*bias_min); - shadow += if (current_depth - bias) > closest_depth { - 1.0 - } else { - 0.0 - }; + if (fragment_depth - bias) > shadow_map_depth { + shadow += 1.0 + } total += 1.0; } } shadow / total.max(1.0) } + + pub const POINT_SAMPLE_OFFSET_DIRECTIONS: [Vec3; 21] = [ + Vec3::ZERO, + Vec3::new(1.0, 1.0, 1.0), + Vec3::new(1.0, -1.0, 1.0), + Vec3::new(-1.0, -1.0, 1.0), + Vec3::new(-1.0, 1.0, 1.0), + Vec3::new(1.0, 1.0, -1.0), + Vec3::new(1.0, -1.0, -1.0), + Vec3::new(-1.0, -1.0, -1.0), + Vec3::new(-1.0, 1.0, -1.0), + Vec3::new(1.0, 1.0, 0.0), + Vec3::new(1.0, -1.0, 0.0), + Vec3::new(-1.0, -1.0, 0.0), + Vec3::new(-1.0, 1.0, 0.0), + Vec3::new(1.0, 0.0, 1.0), + Vec3::new(-1.0, 0.0, 1.0), + Vec3::new(1.0, 0.0, -1.0), + Vec3::new(-1.0, 0.0, -1.0), + Vec3::new(0.0, 1.0, 1.0), + Vec3::new(0.0, -1.0, 1.0), + Vec3::new(0.0, -1.0, -1.0), + Vec3::new(0.0, 1.0, -1.0), + ]; + /// Returns shadow _intensity_ for point lights. + /// + /// Returns `0.0` when the fragment is in full light. + /// Returns `1.0` when the fragment is in full shadow. + pub fn run_point( + &self, + light_slab: &[u32], + shadow_map: &T, + shadow_map_sampler: &S, + light_pos_in_world_space: Vec3, + ) -> f32 + where + S: IsSampler, + T: Sample2dArray, + { + let ShadowCalculation { + shadow_map_desc, + shadow_map_atlas_size, + frag_pos_in_world_space, + surface_normal_in_world_space: surface_normal, + frag_to_light_in_world_space: frag_to_light, + bias_min, + bias_max, + pcf_samples, + } = self; + + let light_to_frag_dir = frag_pos_in_world_space - light_pos_in_world_space; + crate::println!("light_to_frag_dir: {light_to_frag_dir}"); + + let pcf_samplesf = (*pcf_samples as f32) + .max(1.0) + .min(Self::POINT_SAMPLE_OFFSET_DIRECTIONS.len() as f32); + let pcf_samples = pcf_samplesf as usize; + let view_distance = light_to_frag_dir.length(); + let disk_radius = (1.0 + view_distance / shadow_map_desc.z_far) / 25.0; + let mut shadow = 0.0f32; + for i in 0..pcf_samples { + let sample_offset = Self::POINT_SAMPLE_OFFSET_DIRECTIONS[i] * disk_radius; + crate::println!("sample_offset: {sample_offset}"); + let sample_dir = (light_to_frag_dir + sample_offset).alt_norm_or_zero(); + let (face_index, uv) = CubemapDescriptor::get_face_index_and_uv(sample_dir); + crate::println!("face_index: {face_index}",); + crate::println!("uv: {uv}"); + let frag_pos_in_light_space = self.get_frag_pos_in_light_space(light_slab, face_index); + let face_texture = self.get_atlas_texture_at(light_slab, face_index); + let uv_tex = face_texture.uv(uv, *shadow_map_atlas_size); + let shadow_map_depth = shadow_map.sample_by_lod(*shadow_map_sampler, uv_tex, 0.0).x; + let fragment_depth = frag_pos_in_light_space.z; + let bias = (bias_max * (1.0 - surface_normal.dot(*frag_to_light))).max(*bias_min); + if (fragment_depth - bias) > shadow_map_depth { + shadow += 1.0 + } + } + + shadow / pcf_samplesf + } } #[cfg(test)] diff --git a/crates/renderling/src/light/cpu.rs b/crates/renderling/src/light/cpu.rs index c91a94f0..4c00248a 100644 --- a/crates/renderling/src/light/cpu.rs +++ b/crates/renderling/src/light/cpu.rs @@ -24,9 +24,13 @@ use super::{ pub use super::shadow_map::ShadowMap; #[derive(Debug, Snafu)] +#[snafu(visibility(pub(crate)))] pub enum LightingError { #[snafu(display("{source}"))] Atlas { source: AtlasError }, + + #[snafu(display("AnalyticalLightBundle attached to this ShadowMap was dropped"))] + DroppedAnalyticalLightBundle, } impl From for LightingError { @@ -96,13 +100,21 @@ impl LightDetails { } impl LightDetails { - pub fn from_hybrid(hybrid: &LightDetails) -> Self { + pub(crate) fn from_hybrid(hybrid: &LightDetails) -> Self { match hybrid { LightDetails::Directional(d) => LightDetails::Directional(WeakHybrid::from_hybrid(d)), LightDetails::Point(p) => LightDetails::Point(WeakHybrid::from_hybrid(p)), LightDetails::Spot(s) => LightDetails::Spot(WeakHybrid::from_hybrid(s)), } } + + pub(crate) fn upgrade(&self) -> Option { + Some(match self { + LightDetails::Directional(d) => LightDetails::Directional(d.upgrade()?), + LightDetails::Point(p) => LightDetails::Point(p.upgrade()?), + LightDetails::Spot(s) => LightDetails::Spot(s.upgrade()?), + }) + } } /// A bundle of lighting resources representing one analytical light in a scene. @@ -115,17 +127,44 @@ pub struct AnalyticalLightBundle { pub transform: NestedTransform, } +impl Clone for AnalyticalLightBundle +where + Ct::Container: Clone, + LightDetails: Clone, + NestedTransform: Clone, +{ + fn clone(&self) -> Self { + Self { + light: self.light.clone(), + light_details: self.light_details.clone(), + transform: self.transform.clone(), + } + } +} + impl AnalyticalLightBundle { - fn from_hybrid(light: &AnalyticalLightBundle) -> Self { + pub(crate) fn from_hybrid(light: &AnalyticalLightBundle) -> Self { AnalyticalLightBundle { light: WeakHybrid::from_hybrid(&light.light), light_details: LightDetails::from_hybrid(&light.light_details), transform: NestedTransform::from_hybrid(&light.transform), } } + + pub(crate) fn upgrade(&self) -> Option { + Some(AnalyticalLightBundle { + light: self.light.upgrade()?, + light_details: self.light_details.upgrade()?, + transform: self.transform.upgrade()?, + }) + } } impl AnalyticalLightBundle { + pub fn weak(&self) -> AnalyticalLightBundle { + AnalyticalLightBundle::from_hybrid(self) + } + pub fn light_space_transforms(&self, z_near: f32, z_far: f32) -> Vec { let t = self.transform.get(); let m = Mat4::from(t); diff --git a/crates/renderling/src/light/shadow_map.rs b/crates/renderling/src/light/shadow_map.rs index 379c5eba..df3cb5ca 100644 --- a/crates/renderling/src/light/shadow_map.rs +++ b/crates/renderling/src/light/shadow_map.rs @@ -5,10 +5,11 @@ use std::sync::Arc; use craballoc::{ prelude::Hybrid, - value::{HybridArray, HybridWriteGuard}, + value::{HybridArray, HybridWriteGuard, WeakContainer}, }; use crabslab::Id; use glam::{Mat4, UVec2}; +use snafu::OptionExt; use crate::{ atlas::{AtlasBlittingOperation, AtlasImage, AtlasTexture}, @@ -16,7 +17,10 @@ use crate::{ stage::Renderlet, }; -use super::{AnalyticalLightBundle, Lighting, LightingError, ShadowMapDescriptor}; +use super::{ + AnalyticalLightBundle, DroppedAnalyticalLightBundleSnafu, Lighting, LightingError, + ShadowMapDescriptor, +}; /// A depth map rendering of the scene from a light's point of view. /// @@ -37,9 +41,10 @@ pub struct ShadowMap { /// Bindgroup for the shadow map update shader pub(crate) update_bindgroup: ManagedBindGroup, pub(crate) atlas_textures: Vec>, - pub(crate) atlas_textures_array: HybridArray>, + pub(crate) _atlas_textures_array: HybridArray>, pub(crate) update_texture: crate::texture::Texture, pub(crate) blitting_op: AtlasBlittingOperation, + pub(crate) light_bundle: AnalyticalLightBundle, } impl ShadowMap { @@ -155,13 +160,106 @@ impl ShadowMap { self.shadowmap_descriptor.lock() } - /// Update the shadow map, rendering the given [`Renderlet`]s to the map as shadow casters. - // TODO: pass `AnalyticalLightBundle` to `ShadowMap::update` + /// Enable shadow mapping for the given [`AnalyticalLightBundle`], creating + /// a new [`ShadowMap`]. + pub fn new( + lighting: &Lighting, + analytical_light_bundle: &AnalyticalLightBundle, + // Size of the shadow map + size: UVec2, + // Distance to the shadow map frustum's near plane + z_near: f32, + // Distance to the shadow map frustum's far plane + z_far: f32, + ) -> Result { + let stage_slab_buffer = lighting.geometry_slab_buffer.read().unwrap(); + let is_point_light = + analytical_light_bundle.light_details.style() == super::LightStyle::Point; + let count = if is_point_light { 6 } else { 1 }; + let atlas = &lighting.shadow_map_atlas; + let image = AtlasImage::new(size, crate::atlas::AtlasImageFormat::R32FLOAT); + // UNWRAP: safe because we know there's one in here + let atlas_textures = atlas.add_images(vec![ℑ count])?; + let atlas_len = atlas.len(); + // Regardless of light type, we only create one depth texture, + // but that texture may be of layer 1 or 6 + let label = format!("shadow-map-{atlas_len}"); + let update_texture = crate::texture::Texture::create_depth_texture_for_shadow_map( + atlas.device(), + size.x, + size.y, + 1, + Some(&label), + is_point_light, + ); + let atlas_textures_array = lighting + .light_slab + .new_array(atlas_textures.iter().map(|t| t.id())); + let blitting_op = lighting + .shadow_map_update_blitter + .new_blitting_operation(atlas, if is_point_light { 6 } else { 1 }); + let light_space_transforms = lighting + .light_slab + .new_array(analytical_light_bundle.light_space_transforms(z_near, z_far)); + let shadowmap_descriptor = lighting.light_slab.new_value(ShadowMapDescriptor { + light_space_transforms_array: light_space_transforms.array(), + z_near, + z_far, + atlas_textures_array: atlas_textures_array.array(), + bias_min: 0.0005, + bias_max: 0.005, + pcf_samples: 4, + }); + // Set the descriptor in the light, so the shader knows to use it + analytical_light_bundle.light.modify(|light| { + light.shadow_map_desc_id = shadowmap_descriptor.id(); + }); + let light_slab_buffer = lighting.light_slab.commit(); + let update_bindgroup = ManagedBindGroup::from(ShadowMap::create_update_bindgroup( + lighting.light_slab.device(), + &lighting.shadow_map_update_bindgroup_layout, + stage_slab_buffer.deref(), + &light_slab_buffer, + )); + + Ok(ShadowMap { + stage_slab_buffer_creation_time: Arc::new(stage_slab_buffer.creation_time().into()), + light_slab_buffer_creation_time: Arc::new(light_slab_buffer.creation_time().into()), + shadowmap_descriptor, + light_space_transforms, + update_bindgroup, + atlas_textures, + _atlas_textures_array: atlas_textures_array, + update_texture, + blitting_op, + light_bundle: analytical_light_bundle.weak(), + }) + } + + /// Update the `ShadowMap`, rendering the given [`Renderlet`]s to the map as shadow casters. + /// + /// The `ShadowMap` contains a weak referenc to the [`AnalyticalLightBundle`] used to create + /// it. Updates made to this `AnalyticalLightBundle` will automatically propogate to this + /// `ShadowMap`. + /// + /// ## Errors + /// If the `AnalyticalLightBundle` used to create this `ShadowMap` has been + /// dropped, calling this function will err. pub fn update<'a>( &self, lighting: &Lighting, renderlets: impl IntoIterator>, ) -> Result<(), LightingError> { + let light_bundle = self + .light_bundle + .upgrade() + .context(DroppedAnalyticalLightBundleSnafu)?; + let shadow_desc = self.shadowmap_descriptor.get(); + let new_transforms = + light_bundle.light_space_transforms(shadow_desc.z_near, shadow_desc.z_far); + for (i, t) in (0..self.light_space_transforms.len()).zip(new_transforms) { + self.light_space_transforms.set_item(i, t); + } if lighting.geometry_slab.has_queued_updates() { lighting.geometry_slab.commit(); } @@ -262,79 +360,6 @@ impl ShadowMap { } Ok(()) } - - /// Enable shadow mapping for the given [`AnalyticalLightBundle`], creating - /// a new [`ShadowMap`]. - pub fn new( - lighting: &Lighting, - analytical_light_bundle: &AnalyticalLightBundle, - // Size of the shadow map - size: UVec2, - // Distance to the shadow map frustum's near plane - z_near: f32, - // Distance to the shadow map frustum's far plane - z_far: f32, - ) -> Result { - let stage_slab_buffer = lighting.geometry_slab_buffer.read().unwrap(); - let is_point_light = - analytical_light_bundle.light_details.style() == super::LightStyle::Point; - let count = if is_point_light { 6 } else { 1 }; - let atlas = &lighting.shadow_map_atlas; - let image = AtlasImage::new(size, crate::atlas::AtlasImageFormat::R32FLOAT); - // UNWRAP: safe because we know there's one in here - let atlas_textures = atlas.add_images(vec![ℑ count])?; - let atlas_len = atlas.len(); - // Regardless of light type, we only create one depth texture, - // but that texture may be of layer 1 or 6 - let label = format!("shadow-map-{atlas_len}"); - let update_texture = crate::texture::Texture::create_depth_texture_for_shadow_map( - atlas.device(), - size.x, - size.y, - 1, - Some(&label), - is_point_light, - ); - let atlas_textures_array = lighting - .light_slab - .new_array(atlas_textures.iter().map(|t| t.id())); - let blitting_op = lighting - .shadow_map_update_blitter - .new_blitting_operation(atlas, if is_point_light { 6 } else { 1 }); - let light_space_transforms = lighting - .light_slab - .new_array(analytical_light_bundle.light_space_transforms(z_near, z_far)); - let shadowmap_descriptor = lighting.light_slab.new_value(ShadowMapDescriptor { - light_space_transforms_array: light_space_transforms.array(), - atlas_textures_array: atlas_textures_array.array(), - bias_min: 0.0005, - bias_max: 0.005, - pcf_samples: 4, - }); - // Set the descriptor in the light, so the shader knows to use it - analytical_light_bundle.light.modify(|light| { - light.shadow_map_desc_id = shadowmap_descriptor.id(); - }); - let light_slab_buffer = lighting.light_slab.commit(); - let update_bindgroup = ManagedBindGroup::from(ShadowMap::create_update_bindgroup( - lighting.light_slab.device(), - &lighting.shadow_map_update_bindgroup_layout, - stage_slab_buffer.deref(), - &light_slab_buffer, - )); - - Ok(ShadowMap { - stage_slab_buffer_creation_time: Arc::new(stage_slab_buffer.creation_time().into()), - light_slab_buffer_creation_time: Arc::new(light_slab_buffer.creation_time().into()), - shadowmap_descriptor, - light_space_transforms, - update_bindgroup, - atlas_textures, - atlas_textures_array, - update_texture, - blitting_op, - }) - } } #[cfg(test)] @@ -651,7 +676,7 @@ mod test { let frame = ctx.get_next_frame().unwrap(); stage.render(&frame.view()); let img = frame.read_image().unwrap(); - img_diff::save( + img_diff::assert_img_eq( &format!("shadows/shadow_mapping_points/light_{i}_pov_{j}.png"), img, ); @@ -663,23 +688,21 @@ mod test { .new_shadow_map(light_bundle, UVec2::splat(256), z_near, z_far) .unwrap(); shadow.shadowmap_descriptor.modify(|desc| { - desc.bias_min = f32::EPSILON; - desc.bias_max = f32::EPSILON; + desc.pcf_samples = 16; + desc.bias_min = 0.00010; + desc.bias_max = 0.010; }); shadow .update(stage.lighting(), doc.renderlets_iter()) .unwrap(); shadows.push(shadow); } + camera.set(c); let frame = ctx.get_next_frame().unwrap(); - crate::test::capture_gpu_frame( - &ctx, - "shadows/shadow_mapping_points/frame.gputrace", - || stage.render(&frame.view()), - ); + stage.render(&frame.view()); let img = frame.read_image().unwrap(); - img_diff::save("shadows/shadow_mapping_points/frame.png", img); + img_diff::assert_img_eq("shadows/shadow_mapping_points/frame.png", img); frame.present(); } } diff --git a/crates/renderling/src/math.rs b/crates/renderling/src/math.rs index 7dd5c501..530d13ae 100644 --- a/crates/renderling/src/math.rs +++ b/crates/renderling/src/math.rs @@ -145,6 +145,7 @@ mod cpu { // TODO: use configurable wrap mode on CPU sampling let px = uv.x.clamp(0.0, 1.0) * self.image.width() as f32; let py = uv.y.clamp(0.0, 1.0) * self.image.height() as f32; + println!("sampling: ({px}, {py})"); let p = self.image.get_pixel( px.round().min(self.image.width() as f32) as u32, py.round().min(self.image.height() as f32) as u32, @@ -180,12 +181,10 @@ mod cpu { // TODO: lerp the CPU texture sampling // TODO: use configurable wrap mode on CPU sampling let img = &self.images[uv.z as usize]; - let px = uv.x.clamp(0.0, 1.0) * img.width() as f32; - let py = uv.y.clamp(0.0, 1.0) * img.height() as f32; - let p = img.get_pixel( - px.round().min(img.width() as f32) as u32, - py.round().min(img.height() as f32) as u32, - ); + let px = (uv.x.clamp(0.0, 1.0) * (img.width() as f32 - 1.0)).round() as u32; + let py = (uv.y.clamp(0.0, 1.0) * (img.height() as f32 - 1.0)).round() as u32; + println!("sampling: ({px}, {py})"); + let p = img.get_pixel(px, py); (self.convert_fn)(p) } } @@ -580,11 +579,6 @@ pub fn is_inside_clip_space(p: Vec3) -> bool { p.x.abs() <= 1.0 && p.y.abs() <= 1.0 && p.z.abs() <= 1.0 } -pub struct Plane { - pub point: Vec3, - pub norm: Vec3, -} - pub const fn convex_mesh([p0, p1, p2, p3, p4, p5, p6, p7]: [Vec3; 8]) -> [Vec3; 36] { [ p0, p2, p1, p0, p3, p2, // top diff --git a/crates/renderling/src/pbr.rs b/crates/renderling/src/pbr.rs index bb119403..d895fa2e 100644 --- a/crates/renderling/src/pbr.rs +++ b/crates/renderling/src/pbr.rs @@ -609,7 +609,7 @@ where let transform = Mat4::from(transform); // determine the light ray and the radiance - match light.light_type { + let (radiance, shadow) = match light.light_type { LightStyle::Point => { let PointLightDescriptor { position, @@ -624,7 +624,21 @@ where } let l = frag_to_light.alt_norm_or_zero(); let attenuation = intensity * 1.0 / (distance * distance); - lo += outgoing_radiance(color, albedo, attenuation, v, l, n, metallic, roughness); + let radiance = + outgoing_radiance(color, albedo, attenuation, v, l, n, metallic, roughness); + let shadow = if light.shadow_map_desc_id.is_some() { + // Shadow is 1.0 when the fragment is in the shadow of this light, + // and 0.0 in darkness + ShadowCalculation::new(light_slab, light, in_pos, n, l).run_point( + light_slab, + shadow_map, + shadow_map_sampler, + position, + ) + } else { + 0.0 + }; + (radiance, shadow) } LightStyle::Spot => { @@ -649,11 +663,11 @@ where // Shadow is 1.0 when the fragment is in the shadow of this light, // and 0.0 in darkness ShadowCalculation::new(light_slab, light, in_pos, n, calculation.frag_to_light) - .run(shadow_map, shadow_map_sampler) + .run_directional_or_spot(light_slab, shadow_map, shadow_map_sampler) } else { 0.0 }; - lo += radiance * (1.0 - shadow); + (radiance, shadow) } LightStyle::Directional => { @@ -667,19 +681,19 @@ where let attenuation = intensity; let radiance = outgoing_radiance(color, albedo, attenuation, v, l, n, metallic, roughness); - my_println!("radiance: {radiance:?}"); - - let shadow = if light.shadow_map_desc_id.is_some() { - // Shadow is 1.0 when the fragment is in the shadow of this light, - // and 0.0 in darkness - ShadowCalculation::new(light_slab, light, in_pos, n, l) - .run(shadow_map, shadow_map_sampler) - } else { - 0.0 - }; - lo += radiance * (1.0 - shadow); + let shadow = + if light.shadow_map_desc_id.is_some() { + // Shadow is 1.0 when the fragment is in the shadow of this light, + // and 0.0 in darkness + ShadowCalculation::new(light_slab, light, in_pos, n, l) + .run_directional_or_spot(light_slab, shadow_map, shadow_map_sampler) + } else { + 0.0 + }; + (radiance, shadow) } - } + }; + lo += radiance * (1.0 - shadow); } my_println!("lo: {lo:?}"); diff --git a/crates/renderling/src/skybox/cpu.rs b/crates/renderling/src/skybox/cpu.rs index 16243db9..52079f89 100644 --- a/crates/renderling/src/skybox/cpu.rs +++ b/crates/renderling/src/skybox/cpu.rs @@ -151,6 +151,10 @@ pub(crate) fn create_skybox_render_pipeline( /// A clone of a skybox is a reference to the same skybox. /// /// Only available on the CPU. Not available in shaders. +// TODO: spilt Skybox into Skybox and IBL components. +// Skybox and IBL are different things. Sometimes you want to use a +// skybox without having it shade things. +// Also, the brdf_lut doesn't change, so should probably live in `Lighting` #[derive(Debug, Clone)] pub struct Skybox { // Cubemap texture of the environment cubemap diff --git a/crates/renderling/src/stage/cpu.rs b/crates/renderling/src/stage/cpu.rs index ce4a61f4..601cee0b 100644 --- a/crates/renderling/src/stage/cpu.rs +++ b/crates/renderling/src/stage/cpu.rs @@ -1172,6 +1172,15 @@ impl NestedTransform { parent: hybrid.parent.clone(), } } + + pub(crate) fn upgrade(&self) -> Option { + Some(NestedTransform { + global_transform: self.global_transform.upgrade()?, + local_transform: self.local_transform.clone(), + children: self.children.clone(), + parent: self.parent.clone(), + }) + } } impl NestedTransform { diff --git a/crates/renderling/src/texture.rs b/crates/renderling/src/texture.rs index d7a77150..c844abbe 100644 --- a/crates/renderling/src/texture.rs +++ b/crates/renderling/src/texture.rs @@ -61,7 +61,7 @@ pub fn wgpu_texture_format_channels_and_subpixel_bytes(format: wgpu::TextureForm static NEXT_TEXTURE_ID: LazyLock> = LazyLock::new(|| Arc::new(0.into())); -fn get_next_texture_id() -> usize { +pub(crate) fn get_next_texture_id() -> usize { NEXT_TEXTURE_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed) } @@ -71,7 +71,7 @@ pub struct Texture { pub texture: Arc, pub view: Arc, pub sampler: Arc, - id: usize, + pub(crate) id: usize, } impl Texture { diff --git a/gltf/shadow_mapping_point.glb b/gltf/shadow_mapping_point.glb new file mode 100644 index 00000000..9008568f Binary files /dev/null and b/gltf/shadow_mapping_point.glb differ diff --git a/test_img/cubemap/hand_rolled_cubemap_sampling/cube.png b/test_img/cubemap/hand_rolled_cubemap_sampling/cube.png new file mode 100644 index 00000000..4da9f70d Binary files /dev/null and b/test_img/cubemap/hand_rolled_cubemap_sampling/cube.png differ diff --git a/test_img/cubemap/hand_rolled_cubemap_sampling/face_+X.png b/test_img/cubemap/hand_rolled_cubemap_sampling/face_+X.png new file mode 100644 index 00000000..8a16c0d4 Binary files /dev/null and b/test_img/cubemap/hand_rolled_cubemap_sampling/face_+X.png differ diff --git a/test_img/cubemap/hand_rolled_cubemap_sampling/face_+Y.png b/test_img/cubemap/hand_rolled_cubemap_sampling/face_+Y.png new file mode 100644 index 00000000..58b24c73 Binary files /dev/null and b/test_img/cubemap/hand_rolled_cubemap_sampling/face_+Y.png differ diff --git a/test_img/cubemap/hand_rolled_cubemap_sampling/face_+Z.png b/test_img/cubemap/hand_rolled_cubemap_sampling/face_+Z.png new file mode 100644 index 00000000..3431e572 Binary files /dev/null and b/test_img/cubemap/hand_rolled_cubemap_sampling/face_+Z.png differ diff --git a/test_img/cubemap/hand_rolled_cubemap_sampling/face_-X.png b/test_img/cubemap/hand_rolled_cubemap_sampling/face_-X.png new file mode 100644 index 00000000..06fab6c7 Binary files /dev/null and b/test_img/cubemap/hand_rolled_cubemap_sampling/face_-X.png differ diff --git a/test_img/cubemap/hand_rolled_cubemap_sampling/face_-Y.png b/test_img/cubemap/hand_rolled_cubemap_sampling/face_-Y.png new file mode 100644 index 00000000..4d504ac9 Binary files /dev/null and b/test_img/cubemap/hand_rolled_cubemap_sampling/face_-Y.png differ diff --git a/test_img/cubemap/hand_rolled_cubemap_sampling/face_-Z.png b/test_img/cubemap/hand_rolled_cubemap_sampling/face_-Z.png new file mode 100644 index 00000000..80c49975 Binary files /dev/null and b/test_img/cubemap/hand_rolled_cubemap_sampling/face_-Z.png differ diff --git a/test_img/shadows/shadow_mapping_points/frame.png b/test_img/shadows/shadow_mapping_points/frame.png new file mode 100644 index 00000000..0c2a962d Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/frame.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_0_pov_0.png b/test_img/shadows/shadow_mapping_points/light_0_pov_0.png new file mode 100644 index 00000000..f3c3f7a5 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_0_pov_0.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_0_pov_1.png b/test_img/shadows/shadow_mapping_points/light_0_pov_1.png new file mode 100644 index 00000000..7115d72c Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_0_pov_1.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_0_pov_2.png b/test_img/shadows/shadow_mapping_points/light_0_pov_2.png new file mode 100644 index 00000000..ae5ab94e Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_0_pov_2.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_0_pov_3.png b/test_img/shadows/shadow_mapping_points/light_0_pov_3.png new file mode 100644 index 00000000..c38fcf28 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_0_pov_3.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_0_pov_4.png b/test_img/shadows/shadow_mapping_points/light_0_pov_4.png new file mode 100644 index 00000000..e2cf8b2f Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_0_pov_4.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_0_pov_5.png b/test_img/shadows/shadow_mapping_points/light_0_pov_5.png new file mode 100644 index 00000000..b9116b2e Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_0_pov_5.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_1_pov_0.png b/test_img/shadows/shadow_mapping_points/light_1_pov_0.png new file mode 100644 index 00000000..9b0563a5 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_1_pov_0.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_1_pov_1.png b/test_img/shadows/shadow_mapping_points/light_1_pov_1.png new file mode 100644 index 00000000..894f2fea Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_1_pov_1.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_1_pov_2.png b/test_img/shadows/shadow_mapping_points/light_1_pov_2.png new file mode 100644 index 00000000..a1d185f5 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_1_pov_2.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_1_pov_3.png b/test_img/shadows/shadow_mapping_points/light_1_pov_3.png new file mode 100644 index 00000000..a6cf0b2a Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_1_pov_3.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_1_pov_4.png b/test_img/shadows/shadow_mapping_points/light_1_pov_4.png new file mode 100644 index 00000000..b5425edf Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_1_pov_4.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_1_pov_5.png b/test_img/shadows/shadow_mapping_points/light_1_pov_5.png new file mode 100644 index 00000000..5bd8474c Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_1_pov_5.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_2_pov_0.png b/test_img/shadows/shadow_mapping_points/light_2_pov_0.png new file mode 100644 index 00000000..1d0fdc9e Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_2_pov_0.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_2_pov_1.png b/test_img/shadows/shadow_mapping_points/light_2_pov_1.png new file mode 100644 index 00000000..ef4b785d Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_2_pov_1.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_2_pov_2.png b/test_img/shadows/shadow_mapping_points/light_2_pov_2.png new file mode 100644 index 00000000..22117716 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_2_pov_2.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_2_pov_3.png b/test_img/shadows/shadow_mapping_points/light_2_pov_3.png new file mode 100644 index 00000000..21412898 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_2_pov_3.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_2_pov_4.png b/test_img/shadows/shadow_mapping_points/light_2_pov_4.png new file mode 100644 index 00000000..567fbf12 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_2_pov_4.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_2_pov_5.png b/test_img/shadows/shadow_mapping_points/light_2_pov_5.png new file mode 100644 index 00000000..8669d934 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_2_pov_5.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_3_pov_0.png b/test_img/shadows/shadow_mapping_points/light_3_pov_0.png new file mode 100644 index 00000000..be1f7820 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_3_pov_0.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_3_pov_1.png b/test_img/shadows/shadow_mapping_points/light_3_pov_1.png new file mode 100644 index 00000000..b49f1d7b Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_3_pov_1.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_3_pov_2.png b/test_img/shadows/shadow_mapping_points/light_3_pov_2.png new file mode 100644 index 00000000..6a781e8d Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_3_pov_2.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_3_pov_3.png b/test_img/shadows/shadow_mapping_points/light_3_pov_3.png new file mode 100644 index 00000000..d0ec85b9 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_3_pov_3.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_3_pov_4.png b/test_img/shadows/shadow_mapping_points/light_3_pov_4.png new file mode 100644 index 00000000..99b7c83c Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_3_pov_4.png differ diff --git a/test_img/shadows/shadow_mapping_points/light_3_pov_5.png b/test_img/shadows/shadow_mapping_points/light_3_pov_5.png new file mode 100644 index 00000000..0f6d8cc7 Binary files /dev/null and b/test_img/shadows/shadow_mapping_points/light_3_pov_5.png differ