diff --git a/.cargo/config.toml b/.cargo/config.toml index facd0f19..a0f7958c 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -1,3 +1,6 @@ +[alias] +shaders = "gpu --output-dir crates/renderling/shaders --shader-crate crates/renderling/ --shader-manifest crates/renderling/shaders/manifest.json" + [build] rustflags = ["--cfg=web_sys_unstable_apis"] rustdocflags = ["--cfg=web_sys_unstable_apis"] diff --git a/.github/workflows/push.yaml b/.github/workflows/push.yaml index e5bf69b4..d92f4b53 100644 --- a/.github/workflows/push.yaml +++ b/.github/workflows/push.yaml @@ -20,8 +20,9 @@ jobs: with: workspaces: shaders # ensure the shader binaries were properly checked in - - run: rm -rf crates/renderling/src/linkage/*.spv - - run: cd shaders && cargo run --release && cd .. + - run: cargo +nightly-2024-04-24 install --git https://github.com/rust-gpu/cargo-gpu + - run: rm -rf crates/renderling/src/linkage/* + - run: RUST_LOG=trace cargo shaders - run: git diff --exit-code --no-ext-diff crates/renderling/src/linkage renderling-clippy: diff --git a/crates/renderling/shaders/bloom-bloom_downsample_fragment.spv b/crates/renderling/shaders/bloom-bloom_downsample_fragment.spv new file mode 100644 index 00000000..7eee219c Binary files /dev/null and b/crates/renderling/shaders/bloom-bloom_downsample_fragment.spv differ diff --git a/crates/renderling/shaders/bloom-bloom_downsample_fragment.wgsl b/crates/renderling/shaders/bloom-bloom_downsample_fragment.wgsl new file mode 100644 index 00000000..fd80780e --- /dev/null +++ b/crates/renderling/shaders/bloom-bloom_downsample_fragment.wgsl @@ -0,0 +1,65 @@ +struct type_8 { + member: array, +} + +@group(0) @binding(0) +var global: type_8; +var global_1: vec2; +var global_2: u32; +@group(0) @binding(2) +var global_3: sampler; +@group(0) @binding(1) +var global_4: texture_2d; +var global_5: vec4; + +fn function() { + var phi_329_: bool; + var phi_80_: vec2; + + let _e20 = arrayLength((&global.member)); + let _e21 = global_1; + let _e22 = global_2; + if (_e20 >= 2u) { + phi_329_ = (_e22 <= (_e20 - 2u)); + } else { + phi_329_ = false; + } + let _e27 = phi_329_; + if _e27 { + let _e30 = global.member[_e22]; + let _e35 = global.member[(_e22 + 1u)]; + phi_80_ = vec2(bitcast(_e30), bitcast(_e35)); + } else { + phi_80_ = vec2(0f, 0f); + } + let _e39 = phi_80_; + let _e44 = fma(-2f, _e39.x, _e21.x); + let _e47 = fma(2f, _e39.y, _e21.y); + let _e49 = textureSample(global_4, global_3, vec2(_e44, _e47)); + let _e51 = textureSample(global_4, global_3, vec2(_e21.x, _e47)); + let _e52 = vec2((2f * _e39.x), (2f * _e39.y)); + let _e54 = textureSample(global_4, global_3, (_e21 + _e52)); + let _e56 = textureSample(global_4, global_3, vec2(_e44, _e21.y)); + let _e57 = textureSample(global_4, global_3, _e21); + let _e58 = fma(2f, _e39.x, _e21.x); + let _e60 = textureSample(global_4, global_3, vec2(_e58, _e21.y)); + let _e62 = textureSample(global_4, global_3, (_e21 - _e52)); + let _e63 = fma(-2f, _e39.y, _e21.y); + let _e65 = textureSample(global_4, global_3, vec2(_e21.x, _e63)); + let _e67 = textureSample(global_4, global_3, vec2(_e58, _e63)); + let _e71 = textureSample(global_4, global_3, vec2((_e21.x - _e39.x), (_e21.y + _e39.y))); + let _e73 = textureSample(global_4, global_3, (_e21 + _e39)); + let _e75 = textureSample(global_4, global_3, (_e21 - _e39)); + let _e79 = textureSample(global_4, global_3, vec2((_e21.x + _e39.x), (_e21.y - _e39.y))); + global_5 = vec4(max(fma((((_e49.x + _e54.x) + _e62.x) + _e67.x), 0.03125f, fma(0.125f, (_e57.x + (((_e71.x + _e73.x) + _e75.x) + _e79.x)), ((((_e51.x + _e56.x) + _e65.x) + _e60.x) * 0.0625f))), 0.00000011920929f), max(fma((((_e49.y + _e54.y) + _e62.y) + _e67.y), 0.03125f, fma(0.125f, (_e57.y + (((_e71.y + _e73.y) + _e75.y) + _e79.y)), ((((_e51.y + _e56.y) + _e65.y) + _e60.y) * 0.0625f))), 0.00000011920929f), max(fma((((_e49.z + _e54.z) + _e62.z) + _e67.z), 0.03125f, fma(0.125f, (_e57.z + (((_e71.z + _e73.z) + _e75.z) + _e79.z)), ((((_e51.z + _e56.z) + _e65.z) + _e60.z) * 0.0625f))), 0.00000011920929f), max(fma((((_e49.w + _e54.w) + _e62.w) + _e67.w), 0.03125f, fma(0.125f, (_e57.w + (((_e71.w + _e73.w) + _e75.w) + _e79.w)), ((((_e51.w + _e56.w) + _e65.w) + _e60.w) * 0.0625f))), 1f)); + return; +} + +@fragment +fn bloombloom_downsample_fragment(@location(0) param: vec2, @location(1) @interpolate(flat) param_1: u32) -> @location(0) vec4 { + global_1 = param; + global_2 = param_1; + function(); + let _e5 = global_5; + return _e5; +} diff --git a/crates/renderling/shaders/bloom-bloom_mix_fragment.spv b/crates/renderling/shaders/bloom-bloom_mix_fragment.spv new file mode 100644 index 00000000..a04b917b Binary files /dev/null and b/crates/renderling/shaders/bloom-bloom_mix_fragment.spv differ diff --git a/crates/renderling/shaders/bloom-bloom_mix_fragment.wgsl b/crates/renderling/shaders/bloom-bloom_mix_fragment.wgsl new file mode 100644 index 00000000..ab6213fd --- /dev/null +++ b/crates/renderling/shaders/bloom-bloom_mix_fragment.wgsl @@ -0,0 +1,52 @@ +struct type_8 { + member: array, +} + +@group(0) @binding(0) +var global: type_8; +var global_1: vec2; +var global_2: u32; +@group(0) @binding(2) +var global_3: sampler; +@group(0) @binding(1) +var global_4: texture_2d; +@group(0) @binding(4) +var global_5: sampler; +@group(0) @binding(3) +var global_6: texture_2d; +var global_7: vec4; + +fn function() { + var phi_131_: bool; + var phi_80_: f32; + + let _e14 = arrayLength((&global.member)); + let _e15 = global_1; + let _e16 = global_2; + if (_e14 >= 1u) { + phi_131_ = (_e16 <= (_e14 - 1u)); + } else { + phi_131_ = false; + } + let _e21 = phi_131_; + if _e21 { + let _e24 = global.member[_e16]; + phi_80_ = bitcast(_e24); + } else { + phi_80_ = 0f; + } + let _e27 = phi_80_; + let _e28 = textureSample(global_4, global_3, _e15); + let _e32 = textureSample(global_6, global_5, _e15); + global_7 = vec4(fma((_e32.x - _e28.x), _e27, _e28.x), fma((_e32.y - _e28.y), _e27, _e28.y), fma((_e32.z - _e28.z), _e27, _e28.z), 1f); + return; +} + +@fragment +fn bloombloom_mix_fragment(@location(0) param: vec2, @location(1) @interpolate(flat) param_1: u32) -> @location(0) vec4 { + global_1 = param; + global_2 = param_1; + function(); + let _e5 = global_7; + return _e5; +} diff --git a/crates/renderling/shaders/bloom-bloom_upsample_fragment.spv b/crates/renderling/shaders/bloom-bloom_upsample_fragment.spv new file mode 100644 index 00000000..64a6fd88 Binary files /dev/null and b/crates/renderling/shaders/bloom-bloom_upsample_fragment.spv differ diff --git a/crates/renderling/shaders/bloom-bloom_upsample_fragment.wgsl b/crates/renderling/shaders/bloom-bloom_upsample_fragment.wgsl new file mode 100644 index 00000000..65f9b7f2 --- /dev/null +++ b/crates/renderling/shaders/bloom-bloom_upsample_fragment.wgsl @@ -0,0 +1,60 @@ +struct type_8 { + member: array, +} + +@group(0) @binding(0) +var global: type_8; +var global_1: vec2; +@group(0) @binding(2) +var global_2: sampler; +@group(0) @binding(1) +var global_3: texture_2d; +var global_4: u32; +var global_5: vec4; + +fn function() { + var phi_235_: bool; + var phi_108_: vec2; + + let _e17 = arrayLength((&global.member)); + let _e18 = global_1; + let _e19 = global_4; + if (_e17 >= 2u) { + phi_235_ = (_e19 <= (_e17 - 2u)); + } else { + phi_235_ = false; + } + let _e24 = phi_235_; + if _e24 { + let _e27 = global.member[_e19]; + let _e32 = global.member[(_e19 + 1u)]; + phi_108_ = vec2(bitcast(_e27), bitcast(_e32)); + } else { + phi_108_ = vec2(0f, 0f); + } + let _e36 = phi_108_; + let _e40 = (_e18.x - _e36.x); + let _e42 = (_e18.y + _e36.y); + let _e44 = textureSample(global_3, global_2, vec2(_e40, _e42)); + let _e49 = textureSample(global_3, global_2, vec2(_e18.x, _e42)); + let _e54 = textureSample(global_3, global_2, (_e18 + _e36)); + let _e59 = textureSample(global_3, global_2, vec2(_e40, _e18.y)); + let _e63 = textureSample(global_3, global_2, _e18); + let _e67 = (_e18.x + _e36.x); + let _e69 = textureSample(global_3, global_2, vec2(_e67, _e18.y)); + let _e74 = textureSample(global_3, global_2, (_e18 - _e36)); + let _e78 = (_e18.y - _e36.y); + let _e80 = textureSample(global_3, global_2, vec2(_e18.x, _e78)); + let _e85 = textureSample(global_3, global_2, vec2(_e67, _e78)); + global_5 = vec4(((fma(_e63.x, 4f, ((((_e49.x + _e59.x) + _e69.x) + _e80.x) * 2f)) + (((_e44.x + _e54.x) + _e74.x) + _e85.x)) * 0.0625f), ((fma(_e63.y, 4f, ((((_e49.y + _e59.y) + _e69.y) + _e80.y) * 2f)) + (((_e44.y + _e54.y) + _e74.y) + _e85.y)) * 0.0625f), ((fma(_e63.z, 4f, ((((_e49.z + _e59.z) + _e69.z) + _e80.z) * 2f)) + (((_e44.z + _e54.z) + _e74.z) + _e85.z)) * 0.0625f), 0.5f); + return; +} + +@fragment +fn bloombloom_upsample_fragment(@location(0) param: vec2, @location(1) @interpolate(flat) param_1: u32) -> @location(0) vec4 { + global_1 = param; + global_4 = param_1; + function(); + let _e5 = global_5; + return _e5; +} diff --git a/crates/renderling/shaders/bloom-bloom_vertex.spv b/crates/renderling/shaders/bloom-bloom_vertex.spv new file mode 100644 index 00000000..0d08a095 Binary files /dev/null and b/crates/renderling/shaders/bloom-bloom_vertex.spv differ diff --git a/crates/renderling/shaders/bloom-bloom_vertex.wgsl b/crates/renderling/shaders/bloom-bloom_vertex.wgsl new file mode 100644 index 00000000..799a7bf2 --- /dev/null +++ b/crates/renderling/shaders/bloom-bloom_vertex.wgsl @@ -0,0 +1,46 @@ +struct VertexOutput { + @location(0) member: vec2, + @location(1) @interpolate(flat) member_1: u32, + @builtin(position) member_2: vec4, +} + +var global: u32; +var global_1: u32; +var global_2: vec2; +var global_3: vec4 = vec4(0f, 0f, 0f, 1f); +var global_4: u32; + +fn function() { + var local: array, 6>; + var local_1: array, 6>; + + let _e22 = global; + let _e23 = global_1; + let _e24 = (_e22 % 6u); + local = array, 6>(vec2(0f, 1f), vec2(1f, 1f), vec2(1f, 0f), vec2(1f, 0f), vec2(0f, 0f), vec2(0f, 1f)); + let _e25 = (_e24 < 6u); + if _e25 { + let _e27 = local[_e24]; + global_2 = _e27; + local_1 = array, 6>(vec4(-1f, -1f, 0.5f, 1f), vec4(1f, -1f, 0.5f, 1f), vec4(1f, 1f, 0.5f, 1f), vec4(1f, 1f, 0.5f, 1f), vec4(-1f, 1f, 0.5f, 1f), vec4(-1f, -1f, 0.5f, 1f)); + if _e25 { + let _e29 = local_1[_e24]; + global_3 = _e29; + global_4 = _e23; + } + } + return; +} + +@vertex +fn bloombloom_vertex(@builtin(vertex_index) param: u32, @builtin(instance_index) param_1: u32) -> VertexOutput { + global = param; + global_1 = param_1; + function(); + let _e8 = global_3.y; + global_3.y = -(_e8); + let _e10 = global_2; + let _e11 = global_4; + let _e12 = global_3; + return VertexOutput(_e10, _e11, _e12); +} diff --git a/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv new file mode 100644 index 00000000..4dbda372 Binary files /dev/null and b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv differ diff --git a/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.wgsl b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.wgsl new file mode 100644 index 00000000..f692963b --- /dev/null +++ b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.wgsl @@ -0,0 +1,172 @@ +struct type_6 { + member: u32, + member_1: u32, +} + +var global: vec2; +var global_1: vec2; + +fn function() { + var phi_417_: type_6; + var phi_418_: f32; + var phi_419_: f32; + var phi_432_: type_6; + var phi_433_: type_6; + var phi_684_: vec3; + var phi_719_: vec3; + var phi_754_: vec3; + var phi_796_: f32; + var phi_809_: f32; + var phi_495_: f32; + var phi_496_: f32; + var phi_498_: bool; + var phi_499_: type_6; + var phi_500_: f32; + var phi_501_: f32; + var phi_502_: vec2; + var local: vec2; + + let _e37 = global; + let _e40 = max(_e37.x, 0.00000011920929f); + let _e41 = -(_e40); + let _e43 = sqrt(fma(_e41, _e40, 1f)); + phi_417_ = type_6(1u, 1024u); + phi_418_ = 0f; + phi_419_ = 0f; + loop { + let _e45 = phi_417_; + let _e47 = phi_418_; + let _e49 = phi_419_; + if (_e45.member < _e45.member_1) { + phi_432_ = type_6((_e45.member + 1u), _e45.member_1); + phi_433_ = type_6(1u, _e45.member); + } else { + phi_432_ = _e45; + phi_433_ = type_6(0u, type_6().member_1); + } + let _e62 = phi_432_; + let _e64 = phi_433_; + switch bitcast(_e64.member) { + case 0: { + phi_498_ = false; + phi_499_ = type_6(); + phi_500_ = f32(); + phi_501_ = f32(); + phi_502_ = vec2((_e49 * 0.0009765625f), (_e47 * 0.0009765625f)); + break; + } + case 1: { + let _e76 = ((_e64.member_1 << bitcast(16u)) | (_e64.member_1 >> bitcast(16u))); + let _e83 = (((_e76 & 1431655765u) << bitcast(1u)) | ((_e76 & 2863311530u) >> bitcast(1u))); + let _e90 = (((_e83 & 858993459u) << bitcast(2u)) | ((_e83 & 3435973836u) >> bitcast(2u))); + let _e97 = (((_e90 & 252645135u) << bitcast(4u)) | ((_e90 & 4042322160u) >> bitcast(4u))); + let _e105 = f32((((_e97 & 16711935u) << bitcast(8u)) | ((_e97 & 4278255360u) >> bitcast(8u)))); + let _e107 = (_e37.y * _e37.y); + let _e108 = (f32(_e64.member_1) * 0.0061359233f); + let _e114 = sqrt((fma(-(_e105), 0.00000000023283064f, 1f) / fma(fma(_e107, _e107, -1f), (_e105 * 0.00000000023283064f), 1f))); + let _e117 = sqrt(fma(-(_e114), _e114, 1f)); + let _e119 = (cos(_e108) * _e117); + let _e121 = (sin(_e108) * _e117); + let _e125 = select(vec3(1f, 0f, 0f), vec3(0f, 0f, 1f), vec3((abs(1f) < 0.999f))); + let _e128 = -(_e125.x); + let _e132 = sqrt(fma(_e125.y, _e125.y, (_e128 * _e128))); + if (_e132 == 0f) { + phi_684_ = vec3(0f, 0f, 0f); + } else { + phi_684_ = (vec3(_e125.y, _e128, 0f) * (1f / _e132)); + } + let _e137 = phi_684_; + let _e144 = fma(_e137.x, _e119, (-(_e137.y) * _e121)); + let _e145 = fma(_e137.y, _e119, (_e137.x * _e121)); + let _e146 = fma(_e137.z, _e119, _e114); + let _e151 = sqrt(fma(_e146, _e146, fma(_e144, _e144, (_e145 * _e145)))); + if (_e151 == 0f) { + phi_719_ = vec3(0f, 0f, 0f); + } else { + phi_719_ = (vec3(_e144, _e145, _e146) * (1f / _e151)); + } + let _e156 = phi_719_; + let _e161 = fma(_e43, _e156.x, (_e40 * _e156.z)); + let _e162 = (2f * _e161); + let _e163 = (_e162 * _e156.y); + let _e165 = fma(_e162, _e156.x, -(_e43)); + let _e166 = fma(_e162, _e156.z, _e41); + let _e171 = sqrt(fma(_e166, _e166, fma(_e165, _e165, (_e163 * _e163)))); + if (_e171 == 0f) { + phi_754_ = vec3(0f, 0f, 0f); + } else { + phi_754_ = (vec3(_e165, _e163, _e166) * (1f / _e171)); + } + let _e176 = phi_754_; + let _e178 = max(_e176.z, 0f); + let _e180 = max(_e161, 0f); + if (_e178 > 0f) { + let _e182 = max(_e40, 0f); + let _e183 = (_e107 * 0.5f); + let _e185 = fma(-(_e107), 0.5f, 1f); + let _e186 = fma(_e182, _e185, _e183); + if (_e186 == 0f) { + phi_796_ = 0f; + } else { + phi_796_ = (_e182 / _e186); + } + let _e190 = phi_796_; + let _e191 = fma(_e178, _e185, _e183); + if (_e191 == 0f) { + phi_809_ = 0f; + } else { + phi_809_ = (_e178 / _e191); + } + let _e195 = phi_809_; + let _e199 = (((_e190 * _e195) * _e180) / (max(_e156.z, 0f) * _e40)); + let _e201 = pow((1f - _e180), 5f); + phi_495_ = fma(_e201, _e199, _e47); + phi_496_ = fma((1f - _e201), _e199, _e49); + } else { + phi_495_ = _e47; + phi_496_ = _e49; + } + let _e206 = phi_495_; + let _e208 = phi_496_; + phi_498_ = true; + phi_499_ = _e62; + phi_500_ = _e206; + phi_501_ = _e208; + phi_502_ = vec2(); + break; + } + default: { + phi_498_ = false; + phi_499_ = type_6(); + phi_500_ = f32(); + phi_501_ = f32(); + phi_502_ = vec2(); + break; + } + } + let _e210 = phi_498_; + let _e212 = phi_499_; + let _e214 = phi_500_; + let _e216 = phi_501_; + let _e218 = phi_502_; + local = _e218; + continue; + continuing { + phi_417_ = _e212; + phi_418_ = _e214; + phi_419_ = _e216; + break if !(_e210); + } + } + let _e221 = local; + global_1 = _e221; + return; +} + +@fragment +fn convolutionbrdf_lut_convolution_fragment(@location(0) param: vec2) -> @location(0) vec2 { + global = param; + function(); + let _e3 = global_1; + return _e3; +} diff --git a/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv new file mode 100644 index 00000000..23afd6dd Binary files /dev/null and b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv differ diff --git a/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.wgsl b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.wgsl new file mode 100644 index 00000000..2ee9750b --- /dev/null +++ b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.wgsl @@ -0,0 +1,38 @@ +struct type_10 { + member: array, + member_1: array, +} + +struct VertexOutput { + @location(0) member: vec2, + @builtin(position) member_1: vec4, +} + +var global: vec2; +var global_1: u32; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); + +fn function() { + var local: array; + + let _e25 = global_1; + local = array(type_10(array(-1f, -1f, 0f), array(0f, 1f)), type_10(array(1f, -1f, 0f), array(1f, 1f)), type_10(array(1f, 1f, 0f), array(1f, 0f)), type_10(array(-1f, -1f, 0f), array(0f, 1f)), type_10(array(1f, 1f, 0f), array(1f, 0f)), type_10(array(-1f, 1f, 0f), array(0f, 0f))); + if (_e25 < 6u) { + let _e29 = local[_e25].member; + let _e32 = local[_e25].member_1; + global = vec2(_e32[0], _e32[1]); + global_2 = vec4(_e29[0], _e29[1], _e29[2], 1f); + } + return; +} + +@vertex +fn convolutionbrdf_lut_convolution_vertex(@builtin(vertex_index) param: u32) -> VertexOutput { + global_1 = param; + function(); + let _e5 = global_2.y; + global_2.y = -(_e5); + let _e7 = global; + let _e8 = global_2; + return VertexOutput(_e7, _e8); +} diff --git a/crates/renderling/shaders/convolution-generate_mipmap_fragment.spv b/crates/renderling/shaders/convolution-generate_mipmap_fragment.spv new file mode 100644 index 00000000..e1f12d06 Binary files /dev/null and b/crates/renderling/shaders/convolution-generate_mipmap_fragment.spv differ diff --git a/crates/renderling/shaders/convolution-generate_mipmap_fragment.wgsl b/crates/renderling/shaders/convolution-generate_mipmap_fragment.wgsl new file mode 100644 index 00000000..47e27000 --- /dev/null +++ b/crates/renderling/shaders/convolution-generate_mipmap_fragment.wgsl @@ -0,0 +1,21 @@ +var global: vec2; +var global_1: vec4; +@group(0) @binding(1) +var global_2: sampler; +@group(0) @binding(0) +var global_3: texture_2d; + +fn function() { + let _e4 = global; + let _e5 = textureSample(global_3, global_2, _e4); + global_1 = _e5; + return; +} + +@fragment +fn convolutiongenerate_mipmap_fragment(@location(0) param: vec2) -> @location(0) vec4 { + global = param; + function(); + let _e3 = global_1; + return _e3; +} diff --git a/crates/renderling/shaders/convolution-generate_mipmap_vertex.spv b/crates/renderling/shaders/convolution-generate_mipmap_vertex.spv new file mode 100644 index 00000000..49223d8c Binary files /dev/null and b/crates/renderling/shaders/convolution-generate_mipmap_vertex.spv differ diff --git a/crates/renderling/shaders/convolution-generate_mipmap_vertex.wgsl b/crates/renderling/shaders/convolution-generate_mipmap_vertex.wgsl new file mode 100644 index 00000000..47453d6e --- /dev/null +++ b/crates/renderling/shaders/convolution-generate_mipmap_vertex.wgsl @@ -0,0 +1,38 @@ +struct VertexOutput { + @location(0) member: vec2, + @builtin(position) member_1: vec4, +} + +var global: vec2; +var global_1: u32; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); + +fn function() { + var local: array, 6>; + var local_1: array, 6>; + + let _e20 = global_1; + local = array, 6>(vec2(0f, 1f), vec2(1f, 1f), vec2(1f, 0f), vec2(1f, 0f), vec2(0f, 0f), vec2(0f, 1f)); + let _e21 = (_e20 < 6u); + if _e21 { + let _e23 = local[_e20]; + global = _e23; + local_1 = array, 6>(vec4(-1f, -1f, 0.5f, 1f), vec4(1f, -1f, 0.5f, 1f), vec4(1f, 1f, 0.5f, 1f), vec4(1f, 1f, 0.5f, 1f), vec4(-1f, 1f, 0.5f, 1f), vec4(-1f, -1f, 0.5f, 1f)); + if _e21 { + let _e25 = local_1[_e20]; + global_2 = _e25; + } + } + return; +} + +@vertex +fn convolutiongenerate_mipmap_vertex(@builtin(vertex_index) param: u32) -> VertexOutput { + global_1 = param; + function(); + let _e5 = global_2.y; + global_2.y = -(_e5); + let _e7 = global; + let _e8 = global_2; + return VertexOutput(_e7, _e8); +} diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv new file mode 100644 index 00000000..efcb42aa Binary files /dev/null and b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv differ diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.wgsl b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.wgsl new file mode 100644 index 00000000..cbff26f6 --- /dev/null +++ b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.wgsl @@ -0,0 +1,164 @@ +struct type_7 { + member: u32, + member_1: u32, +} + +@group(0) @binding(2) +var global: sampler; +var global_1: vec4; +var global_2: vec3; +var global_3: f32; +@group(0) @binding(1) +var global_4: texture_cube; + +fn function() { + var phi_446_: vec3; + var phi_103_: type_7; + var phi_106_: vec3; + var phi_108_: f32; + var phi_123_: type_7; + var phi_124_: type_7; + var phi_627_: vec3; + var phi_662_: vec3; + var phi_697_: vec3; + var phi_187_: f32; + var phi_206_: vec3; + var phi_207_: f32; + var phi_208_: bool; + var phi_104_: type_7; + var phi_107_: vec3; + var phi_109_: f32; + + let _e41 = global_2; + let _e42 = global_3; + let _e49 = sqrt(fma(_e41.z, _e41.z, fma(_e41.x, _e41.x, (_e41.y * _e41.y)))); + if (_e49 == 0f) { + phi_446_ = vec3(0f, 0f, 0f); + } else { + phi_446_ = (_e41 * (1f / _e49)); + } + let _e54 = phi_446_; + let _e56 = (_e54.y * -1f); + phi_103_ = type_7(0u, 1024u); + phi_106_ = vec3(0f, 0f, 0f); + phi_108_ = 0f; + loop { + let _e58 = phi_103_; + let _e60 = phi_106_; + let _e62 = phi_108_; + if (_e58.member < _e58.member_1) { + phi_123_ = type_7((_e58.member + 1u), _e58.member_1); + phi_124_ = type_7(1u, _e58.member); + } else { + phi_123_ = _e58; + phi_124_ = type_7(0u, type_7().member_1); + } + let _e75 = phi_123_; + let _e77 = phi_124_; + switch bitcast(_e77.member) { + case 0: { + global_1 = vec4((_e60.x / _e62), (_e60.y / _e62), (_e60.z / _e62), 1f); + phi_208_ = false; + phi_104_ = type_7(); + phi_107_ = vec3(); + phi_109_ = f32(); + break; + } + case 1: { + let _e93 = ((_e77.member_1 << bitcast(16u)) | (_e77.member_1 >> bitcast(16u))); + let _e100 = (((_e93 & 1431655765u) << bitcast(1u)) | ((_e93 & 2863311530u) >> bitcast(1u))); + let _e107 = (((_e100 & 858993459u) << bitcast(2u)) | ((_e100 & 3435973836u) >> bitcast(2u))); + let _e114 = (((_e107 & 252645135u) << bitcast(4u)) | ((_e107 & 4042322160u) >> bitcast(4u))); + let _e122 = f32((((_e114 & 16711935u) << bitcast(8u)) | ((_e114 & 4278255360u) >> bitcast(8u)))); + let _e124 = (_e42 * _e42); + let _e125 = (f32(_e77.member_1) * 0.0061359233f); + let _e131 = sqrt((fma(-(_e122), 0.00000000023283064f, 1f) / fma(fma(_e124, _e124, -1f), (_e122 * 0.00000000023283064f), 1f))); + let _e134 = sqrt(fma(-(_e131), _e131, 1f)); + let _e136 = (cos(_e125) * _e134); + let _e138 = (sin(_e125) * _e134); + let _e143 = select(vec3(1f, 0f, 0f), vec3(0f, 0f, 1f), vec3((abs(_e54.z) < 0.999f))); + let _e148 = fma(_e143.y, _e54.z, -((_e56 * _e143.z))); + let _e153 = fma(_e143.z, _e54.x, -((_e54.z * _e143.x))); + let _e156 = fma(_e143.x, _e56, -((_e54.x * _e143.y))); + let _e161 = sqrt(fma(_e156, _e156, fma(_e148, _e148, (_e153 * _e153)))); + if (_e161 == 0f) { + phi_627_ = vec3(0f, 0f, 0f); + } else { + phi_627_ = (vec3(_e148, _e153, _e156) * (1f / _e161)); + } + let _e166 = phi_627_; + let _e185 = fma(_e54.x, _e131, fma(_e166.x, _e136, (fma(_e56, _e166.z, -((_e166.y * _e54.z))) * _e138))); + let _e186 = fma(_e56, _e131, fma(_e166.y, _e136, (fma(_e54.z, _e166.x, -((_e166.z * _e54.x))) * _e138))); + let _e187 = fma(_e54.z, _e131, fma(_e166.z, _e136, (fma(_e54.x, _e166.y, -((_e166.x * _e56))) * _e138))); + let _e192 = sqrt(fma(_e187, _e187, fma(_e185, _e185, (_e186 * _e186)))); + if (_e192 == 0f) { + phi_662_ = vec3(0f, 0f, 0f); + } else { + phi_662_ = (vec3(_e185, _e186, _e187) * (1f / _e192)); + } + let _e197 = phi_662_; + let _e204 = (2f * fma(_e54.z, _e197.z, fma(_e54.x, _e197.x, (_e56 * _e197.y)))); + let _e206 = fma(_e204, _e197.x, -(_e54.x)); + let _e207 = fma(_e204, _e197.y, _e54.y); + let _e209 = fma(_e204, _e197.z, -(_e54.z)); + let _e214 = sqrt(fma(_e209, _e209, fma(_e206, _e206, (_e207 * _e207)))); + if (_e214 == 0f) { + phi_697_ = vec3(0f, 0f, 0f); + } else { + phi_697_ = (vec3(_e206, _e207, _e209) * (1f / _e214)); + } + let _e219 = phi_697_; + let _e226 = max(fma(_e54.z, _e219.z, fma(_e54.x, _e219.x, (_e56 * _e219.y))), 0f); + if (_e226 > 0f) { + if (_e42 == 0f) { + phi_187_ = 0f; + } else { + phi_187_ = (0.5f * log2((1572864f / max((1024f * max((_e226 * 0.31830987f), 0f)), 0.00000011920929f)))); + } + let _e237 = phi_187_; + let _e238 = textureSampleLevel(global_4, global, _e219, _e237); + phi_206_ = vec3(fma(_e238.x, _e226, _e60.x), fma(_e238.y, _e226, _e60.y), fma(_e238.z, _e226, _e60.z)); + phi_207_ = (_e62 + _e226); + } else { + phi_206_ = _e60; + phi_207_ = _e62; + } + let _e251 = phi_206_; + let _e253 = phi_207_; + phi_208_ = true; + phi_104_ = _e75; + phi_107_ = _e251; + phi_109_ = _e253; + break; + } + default: { + phi_208_ = false; + phi_104_ = type_7(); + phi_107_ = vec3(); + phi_109_ = f32(); + break; + } + } + let _e255 = phi_208_; + let _e257 = phi_104_; + let _e259 = phi_107_; + let _e261 = phi_109_; + continue; + continuing { + phi_103_ = _e257; + phi_106_ = _e259; + phi_108_ = _e261; + break if !(_e255); + } + } + return; +} + +@fragment +fn convolutionprefilter_environment_cubemap_fragment(@location(0) param: vec3, @location(1) param_1: f32) -> @location(0) vec4 { + global_2 = param; + global_3 = param_1; + function(); + let _e5 = global_1; + return _e5; +} diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv new file mode 100644 index 00000000..8d2ee732 Binary files /dev/null and b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv differ diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.wgsl b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.wgsl new file mode 100644 index 00000000..316c0686 --- /dev/null +++ b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.wgsl @@ -0,0 +1,267 @@ +struct type_10 { + member: array, +} + +struct type_20 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_21 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_22 { + member: type_20, + member_1: type_20, + member_2: type_21, + member_3: vec3, +} + +struct type_24 { + member: u32, + member_1: u32, +} + +struct VertexOutput { + @location(0) member: vec3, + @location(1) member_1: f32, + @builtin(position) member_2: vec4, +} + +@group(0) @binding(0) +var global: type_10; +var global_1: u32; +var global_2: u32; +var global_3: f32; +var global_4: vec3; +var global_5: vec4 = vec4(0f, 0f, 0f, 1f); + +fn function() { + var local: array, 8>; + var local_1: array, 6>; + var local_2: array, 36>; + var phi_768_: bool; + var phi_165_: type_24; + var phi_796_: bool; + var phi_326_: type_24; + var phi_342_: type_24; + var phi_343_: type_24; + var phi_356_: type_24; + var phi_372_: type_24; + var phi_373_: type_24; + var phi_399_: type_22; + var phi_400_: bool; + var phi_357_: type_24; + var phi_420_: type_22; + var phi_421_: bool; + var phi_327_: type_24; + var phi_426_: type_22; + var phi_828_: bool; + var phi_434_: f32; + var local_3: type_22; + var local_4: type_22; + + let _e80 = global_1; + let _e81 = global_2; + let _e83 = arrayLength((&global.member)); + local_2 = array, 36>(vec3(-0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f)); + if (_e81 < 36u) { + let _e86 = local_2[_e81]; + if (_e83 >= 2u) { + phi_768_ = (_e80 <= (_e83 - 2u)); + } else { + phi_768_ = false; + } + let _e91 = phi_768_; + if _e91 { + let _e94 = global.member[_e80]; + let _e98 = global.member[(_e80 + 1u)]; + phi_165_ = type_24(_e94, _e98); + } else { + phi_165_ = type_24(4294967295u, 4294967295u); + } + let _e101 = phi_165_; + if (_e83 >= 83u) { + phi_796_ = (_e101.member <= (_e83 - 83u)); + } else { + phi_796_ = false; + } + let _e108 = phi_796_; + if _e108 { + let _e111 = global.member[_e101.member]; + let _e116 = global.member[(_e101.member + 1u)]; + let _e121 = global.member[(_e101.member + 2u)]; + let _e126 = global.member[(_e101.member + 3u)]; + let _e132 = global.member[(_e101.member + 4u)]; + let _e137 = global.member[(_e101.member + 5u)]; + let _e142 = global.member[(_e101.member + 6u)]; + let _e147 = global.member[(_e101.member + 7u)]; + let _e153 = global.member[(_e101.member + 8u)]; + let _e158 = global.member[(_e101.member + 9u)]; + let _e163 = global.member[(_e101.member + 10u)]; + let _e168 = global.member[(_e101.member + 11u)]; + let _e174 = global.member[(_e101.member + 12u)]; + let _e179 = global.member[(_e101.member + 13u)]; + let _e184 = global.member[(_e101.member + 14u)]; + let _e189 = global.member[(_e101.member + 15u)]; + let _e196 = global.member[(_e101.member + 16u)]; + let _e201 = global.member[(_e101.member + 17u)]; + let _e206 = global.member[(_e101.member + 18u)]; + let _e211 = global.member[(_e101.member + 19u)]; + let _e217 = global.member[(_e101.member + 20u)]; + let _e222 = global.member[(_e101.member + 21u)]; + let _e227 = global.member[(_e101.member + 22u)]; + let _e232 = global.member[(_e101.member + 23u)]; + let _e238 = global.member[(_e101.member + 24u)]; + let _e243 = global.member[(_e101.member + 25u)]; + let _e248 = global.member[(_e101.member + 26u)]; + let _e253 = global.member[(_e101.member + 27u)]; + let _e259 = global.member[(_e101.member + 28u)]; + let _e264 = global.member[(_e101.member + 29u)]; + let _e269 = global.member[(_e101.member + 30u)]; + let _e274 = global.member[(_e101.member + 31u)]; + let _e281 = global.member[(_e101.member + 32u)]; + let _e286 = global.member[(_e101.member + 33u)]; + let _e291 = global.member[(_e101.member + 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_326_ = type_24(0u, 6u); + loop { + let _e296 = phi_326_; + if (_e296.member < _e296.member_1) { + phi_342_ = type_24((_e296.member + 1u), _e296.member_1); + phi_343_ = type_24(1u, _e296.member); + } else { + phi_342_ = _e296; + phi_343_ = type_24(0u, type_24().member_1); + } + let _e309 = phi_342_; + let _e311 = phi_343_; + switch bitcast(_e311.member) { + case 0: { + let _e315 = 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_356_ = type_24(0u, 8u); + loop { + let _e318 = phi_356_; + if (_e318.member < _e318.member_1) { + phi_372_ = type_24((_e318.member + 1u), _e318.member_1); + phi_373_ = type_24(1u, _e318.member); + } else { + phi_372_ = _e318; + phi_373_ = type_24(0u, type_24().member_1); + } + let _e331 = phi_372_; + let _e333 = phi_373_; + switch bitcast(_e333.member) { + case 0: { + let _e337 = local; + phi_399_ = type_22(type_20(vec4(bitcast(_e111), bitcast(_e116), bitcast(_e121), bitcast(_e126)), vec4(bitcast(_e132), bitcast(_e137), bitcast(_e142), bitcast(_e147)), vec4(bitcast(_e153), bitcast(_e158), bitcast(_e163), bitcast(_e168)), vec4(bitcast(_e174), bitcast(_e179), bitcast(_e184), bitcast(_e189))), type_20(vec4(bitcast(_e196), bitcast(_e201), bitcast(_e206), bitcast(_e211)), vec4(bitcast(_e217), bitcast(_e222), bitcast(_e227), bitcast(_e232)), vec4(bitcast(_e238), bitcast(_e243), bitcast(_e248), bitcast(_e253)), vec4(bitcast(_e259), bitcast(_e264), bitcast(_e269), bitcast(_e274))), type_21(_e337, _e315), vec3(bitcast(_e281), bitcast(_e286), bitcast(_e291))); + phi_400_ = false; + phi_357_ = type_24(); + break; + } + case 1: { + let _e341 = ((_e101.member + 59u) + (_e333.member_1 * 3u)); + let _e344 = global.member[_e341]; + let _e349 = global.member[(_e341 + 1u)]; + let _e354 = global.member[(_e341 + 2u)]; + local[_e333.member_1] = vec3(bitcast(_e344), bitcast(_e349), bitcast(_e354)); + phi_399_ = type_22(); + phi_400_ = true; + phi_357_ = _e331; + break; + } + default: { + phi_399_ = type_22(); + phi_400_ = false; + phi_357_ = type_24(); + break; + } + } + let _e359 = phi_399_; + let _e361 = phi_400_; + let _e363 = phi_357_; + local_3 = _e359; + continue; + continuing { + phi_356_ = _e363; + break if !(_e361); + } + } + let _e548 = local_3; + phi_420_ = _e548; + phi_421_ = false; + phi_327_ = type_24(); + break; + } + case 1: { + let _e366 = ((_e101.member + 35u) + (_e311.member_1 * 4u)); + let _e369 = global.member[_e366]; + let _e374 = global.member[(_e366 + 1u)]; + let _e379 = global.member[(_e366 + 2u)]; + let _e384 = global.member[(_e366 + 3u)]; + local_1[_e311.member_1] = vec4(bitcast(_e369), bitcast(_e374), bitcast(_e379), bitcast(_e384)); + phi_420_ = type_22(); + phi_421_ = true; + phi_327_ = _e309; + break; + } + default: { + phi_420_ = type_22(); + phi_421_ = false; + phi_327_ = type_24(); + break; + } + } + let _e389 = phi_420_; + let _e391 = phi_421_; + let _e393 = phi_327_; + local_4 = _e389; + continue; + continuing { + phi_326_ = _e393; + break if !(_e391); + } + } + let _e553 = local_4; + phi_426_ = _e553; + } else { + phi_426_ = type_22(type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_21(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 _e396 = phi_426_; + if (_e83 >= 1u) { + phi_828_ = (_e101.member_1 <= (_e83 - 1u)); + } else { + phi_828_ = false; + } + let _e403 = phi_828_; + if _e403 { + let _e406 = global.member[_e101.member_1]; + phi_434_ = bitcast(_e406); + } else { + phi_434_ = 0f; + } + let _e409 = phi_434_; + global_3 = _e409; + global_4 = _e86; + global_5 = vec4((fma(fma(_e396.member.member_3.x, _e396.member_1.member_2.w, fma(_e396.member.member_2.x, _e396.member_1.member_2.z, fma(_e396.member.member.x, _e396.member_1.member_2.x, (_e396.member.member_1.x * _e396.member_1.member_2.y)))), _e86.z, fma(fma(_e396.member.member_3.x, _e396.member_1.member.w, fma(_e396.member.member_2.x, _e396.member_1.member.z, fma(_e396.member.member.x, _e396.member_1.member.x, (_e396.member.member_1.x * _e396.member_1.member.y)))), _e86.x, (fma(_e396.member.member_3.x, _e396.member_1.member_1.w, fma(_e396.member.member_2.x, _e396.member_1.member_1.z, fma(_e396.member.member.x, _e396.member_1.member_1.x, (_e396.member.member_1.x * _e396.member_1.member_1.y)))) * _e86.y))) + fma(_e396.member.member_3.x, _e396.member_1.member_3.w, fma(_e396.member.member_2.x, _e396.member_1.member_3.z, fma(_e396.member.member.x, _e396.member_1.member_3.x, (_e396.member.member_1.x * _e396.member_1.member_3.y))))), (fma(fma(_e396.member.member_3.y, _e396.member_1.member_2.w, fma(_e396.member.member_2.y, _e396.member_1.member_2.z, fma(_e396.member.member.y, _e396.member_1.member_2.x, (_e396.member.member_1.y * _e396.member_1.member_2.y)))), _e86.z, fma(fma(_e396.member.member_3.y, _e396.member_1.member.w, fma(_e396.member.member_2.y, _e396.member_1.member.z, fma(_e396.member.member.y, _e396.member_1.member.x, (_e396.member.member_1.y * _e396.member_1.member.y)))), _e86.x, (fma(_e396.member.member_3.y, _e396.member_1.member_1.w, fma(_e396.member.member_2.y, _e396.member_1.member_1.z, fma(_e396.member.member.y, _e396.member_1.member_1.x, (_e396.member.member_1.y * _e396.member_1.member_1.y)))) * _e86.y))) + fma(_e396.member.member_3.y, _e396.member_1.member_3.w, fma(_e396.member.member_2.y, _e396.member_1.member_3.z, fma(_e396.member.member.y, _e396.member_1.member_3.x, (_e396.member.member_1.y * _e396.member_1.member_3.y))))), (fma(fma(_e396.member.member_3.z, _e396.member_1.member_2.w, fma(_e396.member.member_2.z, _e396.member_1.member_2.z, fma(_e396.member.member.z, _e396.member_1.member_2.x, (_e396.member.member_1.z * _e396.member_1.member_2.y)))), _e86.z, fma(fma(_e396.member.member_3.z, _e396.member_1.member.w, fma(_e396.member.member_2.z, _e396.member_1.member.z, fma(_e396.member.member.z, _e396.member_1.member.x, (_e396.member.member_1.z * _e396.member_1.member.y)))), _e86.x, (fma(_e396.member.member_3.z, _e396.member_1.member_1.w, fma(_e396.member.member_2.z, _e396.member_1.member_1.z, fma(_e396.member.member.z, _e396.member_1.member_1.x, (_e396.member.member_1.z * _e396.member_1.member_1.y)))) * _e86.y))) + fma(_e396.member.member_3.z, _e396.member_1.member_3.w, fma(_e396.member.member_2.z, _e396.member_1.member_3.z, fma(_e396.member.member.z, _e396.member_1.member_3.x, (_e396.member.member_1.z * _e396.member_1.member_3.y))))), (fma(fma(_e396.member.member_3.w, _e396.member_1.member_2.w, fma(_e396.member.member_2.w, _e396.member_1.member_2.z, fma(_e396.member.member.w, _e396.member_1.member_2.x, (_e396.member.member_1.w * _e396.member_1.member_2.y)))), _e86.z, fma(fma(_e396.member.member_3.w, _e396.member_1.member.w, fma(_e396.member.member_2.w, _e396.member_1.member.z, fma(_e396.member.member.w, _e396.member_1.member.x, (_e396.member.member_1.w * _e396.member_1.member.y)))), _e86.x, (fma(_e396.member.member_3.w, _e396.member_1.member_1.w, fma(_e396.member.member_2.w, _e396.member_1.member_1.z, fma(_e396.member.member.w, _e396.member_1.member_1.x, (_e396.member.member_1.w * _e396.member_1.member_1.y)))) * _e86.y))) + fma(_e396.member.member_3.w, _e396.member_1.member_3.w, fma(_e396.member.member_2.w, _e396.member_1.member_3.z, fma(_e396.member.member.w, _e396.member_1.member_3.x, (_e396.member.member_1.w * _e396.member_1.member_3.y)))))); + } + return; +} + +@vertex +fn convolutionprefilter_environment_cubemap_vertex(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_1 = param; + global_2 = param_1; + function(); + let _e8 = global_5.y; + global_5.y = -(_e8); + let _e10 = global_4; + let _e11 = global_3; + let _e12 = global_5; + return VertexOutput(_e10, _e11, _e12); +} diff --git a/crates/renderling/shaders/cull-compute_frustum_culling.spv b/crates/renderling/shaders/cull-compute_frustum_culling.spv new file mode 100644 index 00000000..3dc27c52 Binary files /dev/null and b/crates/renderling/shaders/cull-compute_frustum_culling.spv differ diff --git a/crates/renderling/shaders/cull-compute_frustum_culling.wgsl b/crates/renderling/shaders/cull-compute_frustum_culling.wgsl new file mode 100644 index 00000000..e4c981c2 --- /dev/null +++ b/crates/renderling/shaders/cull-compute_frustum_culling.wgsl @@ -0,0 +1,862 @@ +struct type_8 { + member: array, +} + +struct type_14 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_15 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_16 { + member: type_14, + member_1: type_14, + member_2: type_15, + member_3: vec3, +} + +struct type_18 { + member: u32, + member_1: u32, +} + +struct type_22 { + member: u32, + member_1: u32, + member_2: u32, + member_3: u32, +} + +struct type_24 { + member: array, +} + +struct type_29 { + member: vec3, + member_1: vec4, + member_2: vec3, +} + +struct type_30 { + member: bool, + member_1: u32, +} + +@group(0) @binding(0) +var global: type_8; +@group(0) @binding(1) +var global_1: type_24; +var global_2: vec3; + +fn function() { + var local: array, 6>; + var local_1: array, 8>; + var local_2: array; + var local_3: array; + var local_4: array; + var local_5: array; + var local_6: array, 8>; + var local_7: array, 6>; + var phi_1260_: bool; + var phi_461_: type_18; + var phi_477_: type_18; + var phi_478_: type_18; + var phi_491_: type_18; + var phi_507_: type_18; + var phi_508_: type_18; + var phi_534_: type_16; + var phi_535_: bool; + var phi_492_: type_18; + var phi_555_: type_16; + var phi_556_: bool; + var phi_462_: type_18; + var phi_561_: type_16; + var phi_1292_: bool; + var phi_612_: type_29; + var phi_744_: type_18; + var phi_760_: type_18; + var phi_761_: type_18; + var phi_1039_: type_30; + var phi_1041_: bool; + var phi_1042_: type_30; + var phi_1043_: bool; + var phi_1044_: bool; + var phi_1045_: type_30; + var phi_1046_: bool; + var phi_1051_: type_18; + var phi_1053_: type_30; + var phi_772_: type_18; + var phi_788_: type_18; + var phi_789_: type_18; + var phi_799_: type_18; + var phi_802_: i32; + var phi_817_: type_18; + var phi_818_: type_18; + var phi_962_: i32; + var phi_964_: type_18; + var phi_965_: i32; + var phi_966_: bool; + var phi_967_: type_18; + var phi_968_: i32; + var phi_969_: bool; + var phi_970_: type_18; + var phi_971_: i32; + var phi_832_: type_18; + var phi_835_: i32; + var phi_850_: type_18; + var phi_851_: type_18; + var phi_900_: i32; + var phi_902_: type_18; + var phi_903_: i32; + var phi_904_: bool; + var phi_905_: type_18; + var phi_906_: i32; + var phi_907_: bool; + var phi_908_: type_18; + var phi_909_: i32; + var phi_866_: type_18; + var phi_910_: bool; + var phi_911_: bool; + var phi_912_: bool; + var phi_913_: bool; + var phi_914_: type_18; + var phi_915_: bool; + var phi_833_: type_18; + var phi_836_: i32; + var phi_916_: bool; + var phi_917_: bool; + var phi_918_: bool; + var phi_919_: bool; + var phi_920_: type_18; + var phi_928_: type_18; + var phi_972_: bool; + var phi_973_: bool; + var phi_974_: bool; + var phi_975_: bool; + var phi_976_: type_18; + var phi_977_: bool; + var phi_800_: type_18; + var phi_803_: i32; + var phi_978_: bool; + var phi_979_: bool; + var phi_980_: bool; + var phi_981_: bool; + var phi_982_: type_18; + var phi_989_: type_18; + var phi_998_: type_30; + var phi_1000_: type_30; + var phi_773_: type_18; + var phi_1054_: bool; + var phi_1055_: type_30; + var phi_1056_: bool; + var phi_745_: type_18; + var phi_1057_: bool; + var phi_1058_: type_30; + var local_8: type_16; + var local_9: type_16; + var local_10: bool; + var local_11: bool; + var local_12: bool; + var local_13: bool; + var local_14: type_18; + var local_15: bool; + var local_16: bool; + var local_17: bool; + var local_18: bool; + var local_19: type_18; + var local_20: bool; + var local_21: type_30; + var local_22: bool; + var local_23: type_30; + + let _e81 = arrayLength((&global.member)); + let _e84 = global_2; + if (_e84.x >= arrayLength((&global_1.member))) { + } else { + let _e90 = global_1.member[_e84.x].member_3; + let _e93 = global.member[_e90]; + let _e98 = global.member[(_e90 + 2u)]; + let _e102 = global.member[(_e90 + 3u)]; + let _e103 = bitcast(_e102); + let _e107 = global.member[(_e90 + 4u)]; + let _e108 = bitcast(_e107); + let _e112 = global.member[(_e90 + 5u)]; + let _e113 = bitcast(_e112); + let _e117 = global.member[(_e90 + 6u)]; + let _e118 = bitcast(_e117); + let _e122 = global.member[(_e90 + 7u)]; + let _e126 = global.member[(_e90 + 8u)]; + let _e130 = global.member[(_e90 + 9u)]; + let _e134 = global.member[(_e90 + 10u)]; + global_1.member[_e84.x].member = select(_e126, _e98, (_e122 == 4294967295u)); + global_1.member[_e84.x].member_1 = select(0u, 1u, (_e93 == 1u)); + if (_e118 == 0f) { + } else { + if (_e81 >= 83u) { + phi_1260_ = (_e130 <= (_e81 - 83u)); + } else { + phi_1260_ = false; + } + let _e149 = phi_1260_; + if _e149 { + let _e152 = global.member[_e130]; + let _e157 = global.member[(_e130 + 1u)]; + let _e162 = global.member[(_e130 + 2u)]; + let _e167 = global.member[(_e130 + 3u)]; + let _e173 = global.member[(_e130 + 4u)]; + let _e178 = global.member[(_e130 + 5u)]; + let _e183 = global.member[(_e130 + 6u)]; + let _e188 = global.member[(_e130 + 7u)]; + let _e194 = global.member[(_e130 + 8u)]; + let _e199 = global.member[(_e130 + 9u)]; + let _e204 = global.member[(_e130 + 10u)]; + let _e209 = global.member[(_e130 + 11u)]; + let _e215 = global.member[(_e130 + 12u)]; + let _e220 = global.member[(_e130 + 13u)]; + let _e225 = global.member[(_e130 + 14u)]; + let _e230 = global.member[(_e130 + 15u)]; + let _e237 = global.member[(_e130 + 16u)]; + let _e242 = global.member[(_e130 + 17u)]; + let _e247 = global.member[(_e130 + 18u)]; + let _e252 = global.member[(_e130 + 19u)]; + let _e258 = global.member[(_e130 + 20u)]; + let _e263 = global.member[(_e130 + 21u)]; + let _e268 = global.member[(_e130 + 22u)]; + let _e273 = global.member[(_e130 + 23u)]; + let _e279 = global.member[(_e130 + 24u)]; + let _e284 = global.member[(_e130 + 25u)]; + let _e289 = global.member[(_e130 + 26u)]; + let _e294 = global.member[(_e130 + 27u)]; + let _e300 = global.member[(_e130 + 28u)]; + let _e305 = global.member[(_e130 + 29u)]; + let _e310 = global.member[(_e130 + 30u)]; + let _e315 = global.member[(_e130 + 31u)]; + let _e322 = global.member[(_e130 + 32u)]; + let _e327 = global.member[(_e130 + 33u)]; + let _e332 = global.member[(_e130 + 34u)]; + local_7 = 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_461_ = type_18(0u, 6u); + loop { + let _e337 = phi_461_; + if (_e337.member < _e337.member_1) { + phi_477_ = type_18((_e337.member + 1u), _e337.member_1); + phi_478_ = type_18(1u, _e337.member); + } else { + phi_477_ = _e337; + phi_478_ = type_18(0u, type_18().member_1); + } + let _e350 = phi_477_; + let _e352 = phi_478_; + switch bitcast(_e352.member) { + case 0: { + let _e379 = local_7; + local_6 = 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_491_ = type_18(0u, 8u); + loop { + let _e382 = phi_491_; + if (_e382.member < _e382.member_1) { + phi_507_ = type_18((_e382.member + 1u), _e382.member_1); + phi_508_ = type_18(1u, _e382.member); + } else { + phi_507_ = _e382; + phi_508_ = type_18(0u, type_18().member_1); + } + let _e395 = phi_507_; + let _e397 = phi_508_; + switch bitcast(_e397.member) { + case 0: { + let _e419 = local_6; + phi_534_ = type_16(type_14(vec4(bitcast(_e152), bitcast(_e157), bitcast(_e162), bitcast(_e167)), vec4(bitcast(_e173), bitcast(_e178), bitcast(_e183), bitcast(_e188)), vec4(bitcast(_e194), bitcast(_e199), bitcast(_e204), bitcast(_e209)), vec4(bitcast(_e215), bitcast(_e220), bitcast(_e225), bitcast(_e230))), type_14(vec4(bitcast(_e237), bitcast(_e242), bitcast(_e247), bitcast(_e252)), vec4(bitcast(_e258), bitcast(_e263), bitcast(_e268), bitcast(_e273)), vec4(bitcast(_e279), bitcast(_e284), bitcast(_e289), bitcast(_e294)), vec4(bitcast(_e300), bitcast(_e305), bitcast(_e310), bitcast(_e315))), type_15(_e419, _e379), vec3(bitcast(_e322), bitcast(_e327), bitcast(_e332))); + phi_535_ = false; + phi_492_ = type_18(); + break; + } + case 1: { + let _e402 = ((_e130 + 59u) + (_e397.member_1 * 3u)); + let _e405 = global.member[_e402]; + let _e410 = global.member[(_e402 + 1u)]; + let _e415 = global.member[(_e402 + 2u)]; + local_6[_e397.member_1] = vec3(bitcast(_e405), bitcast(_e410), bitcast(_e415)); + phi_534_ = type_16(); + phi_535_ = true; + phi_492_ = _e395; + break; + } + default: { + phi_534_ = type_16(); + phi_535_ = false; + phi_492_ = type_18(); + break; + } + } + let _e423 = phi_534_; + let _e425 = phi_535_; + let _e427 = phi_492_; + local_8 = _e423; + continue; + continuing { + phi_491_ = _e427; + break if !(_e425); + } + } + let _e907 = local_8; + phi_555_ = _e907; + phi_556_ = false; + phi_462_ = type_18(); + break; + } + case 1: { + let _e357 = ((_e130 + 35u) + (_e352.member_1 * 4u)); + let _e360 = global.member[_e357]; + let _e365 = global.member[(_e357 + 1u)]; + let _e370 = global.member[(_e357 + 2u)]; + let _e375 = global.member[(_e357 + 3u)]; + local_7[_e352.member_1] = vec4(bitcast(_e360), bitcast(_e365), bitcast(_e370), bitcast(_e375)); + phi_555_ = type_16(); + phi_556_ = true; + phi_462_ = _e350; + break; + } + default: { + phi_555_ = type_16(); + phi_556_ = false; + phi_462_ = type_18(); + break; + } + } + let _e430 = phi_555_; + let _e432 = phi_556_; + let _e434 = phi_462_; + local_9 = _e430; + continue; + continuing { + phi_461_ = _e434; + break if !(_e432); + } + } + let _e912 = local_9; + phi_561_ = _e912; + } else { + phi_561_ = type_16(type_14(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_14(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_15(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 _e437 = phi_561_; + if (_e81 >= 10u) { + phi_1292_ = (_e134 <= (_e81 - 10u)); + } else { + phi_1292_ = false; + } + let _e443 = phi_1292_; + if _e443 { + let _e446 = global.member[_e134]; + let _e451 = global.member[(_e134 + 1u)]; + let _e456 = global.member[(_e134 + 2u)]; + let _e462 = global.member[(_e134 + 3u)]; + let _e467 = global.member[(_e134 + 4u)]; + let _e472 = global.member[(_e134 + 5u)]; + let _e477 = global.member[(_e134 + 6u)]; + let _e483 = global.member[(_e134 + 7u)]; + let _e488 = global.member[(_e134 + 8u)]; + let _e493 = global.member[(_e134 + 9u)]; + phi_612_ = type_29(vec3(bitcast(_e446), bitcast(_e451), bitcast(_e456)), vec4(bitcast(_e462), bitcast(_e467), bitcast(_e472), bitcast(_e477)), vec3(bitcast(_e483), bitcast(_e488), bitcast(_e493))); + } else { + phi_612_ = type_29(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e498 = phi_612_; + let _e506 = (_e498.member_1.x + _e498.member_1.x); + let _e507 = (_e498.member_1.y + _e498.member_1.y); + let _e508 = (_e498.member_1.z + _e498.member_1.z); + let _e510 = (_e498.member_1.z * _e508); + let _e511 = (_e498.member_1.w * _e506); + let _e512 = (_e498.member_1.w * _e507); + let _e513 = (_e498.member_1.w * _e508); + let _e533 = (vec4((1f - fma(_e498.member_1.y, _e507, _e510)), fma(_e498.member_1.x, _e507, _e513), fma(_e498.member_1.x, _e508, -(_e512)), 0f) * _e498.member_2.x); + let _e535 = (vec4(fma(_e498.member_1.x, _e507, -(_e513)), (1f - fma(_e498.member_1.x, _e506, _e510)), fma(_e498.member_1.y, _e508, _e511), 0f) * _e498.member_2.y); + let _e537 = (vec4(fma(_e498.member_1.x, _e508, _e512), fma(_e498.member_1.y, _e508, -(_e511)), (1f - fma(_e498.member_1.x, _e506, (_e498.member_1.y * _e507))), 0f) * _e498.member_2.z); + let _e559 = (_e498.member.x + fma(_e537.x, _e113, fma(_e535.x, _e108, (_e533.x * _e103)))); + let _e560 = (_e498.member.y + fma(_e537.y, _e113, fma(_e535.y, _e108, (_e533.y * _e103)))); + let _e561 = (_e498.member.z + fma(_e537.z, _e113, fma(_e535.z, _e108, (_e533.z * _e103)))); + let _e562 = vec3(_e559, _e560, _e561); + let _e565 = (max(_e498.member_2.x, max(_e498.member_2.y, _e498.member_2.z)) * _e118); + let _e567 = sqrt((_e565 * _e565)); + local_1 = _e437.member_2.member; + local = _e437.member_2.member_1; + let _e572 = local[0u][0u]; + let _e575 = local[0u][1u]; + let _e580 = local[0u][2u]; + let _e584 = local[0u][3u]; + let _e586 = -(_e567); + if ((fma(_e580, _e561, fma(_e572, _e559, (_e575 * _e560))) + _e584) < _e586) { + phi_1057_ = true; + phi_1058_ = type_30(true, 0u); + } else { + phi_744_ = type_18(0u, 6u); + loop { + let _e589 = phi_744_; + if (_e589.member < _e589.member_1) { + phi_760_ = type_18((_e589.member + 1u), _e589.member_1); + phi_761_ = type_18(1u, _e589.member); + } else { + phi_760_ = _e589; + phi_761_ = type_18(0u, type_18().member_1); + } + let _e602 = phi_760_; + let _e604 = phi_761_; + switch bitcast(_e604.member) { + case 0: { + let _e650 = vec3(_e567); + let _e651 = (_e562 - _e650); + let _e652 = (_e562 + _e650); + phi_772_ = type_18(0u, 3u); + loop { + let _e654 = phi_772_; + if (_e654.member < _e654.member_1) { + phi_788_ = type_18((_e654.member + 1u), _e654.member_1); + phi_789_ = type_18(1u, _e654.member); + } else { + phi_788_ = _e654; + phi_789_ = type_18(0u, type_18().member_1); + } + let _e667 = phi_788_; + let _e669 = phi_789_; + switch bitcast(_e669.member) { + case 0: { + phi_978_ = false; + phi_979_ = true; + phi_980_ = true; + phi_981_ = false; + phi_982_ = type_18(); + break; + } + case 1: { + phi_799_ = type_18(0u, 8u); + phi_802_ = 0i; + loop { + let _e674 = phi_799_; + let _e676 = phi_802_; + if (_e674.member < _e674.member_1) { + phi_817_ = type_18((_e674.member + 1u), _e674.member_1); + phi_818_ = type_18(1u, _e674.member); + } else { + phi_817_ = _e674; + phi_818_ = type_18(0u, type_18().member_1); + } + let _e689 = phi_817_; + let _e691 = phi_818_; + switch bitcast(_e691.member) { + case 0: { + if (_e676 == 8i) { + phi_916_ = true; + phi_917_ = false; + phi_918_ = false; + phi_919_ = false; + phi_920_ = type_18(); + } else { + phi_832_ = type_18(0u, 8u); + phi_835_ = 0i; + loop { + let _e738 = phi_832_; + let _e740 = phi_835_; + if (_e738.member < _e738.member_1) { + phi_850_ = type_18((_e738.member + 1u), _e738.member_1); + phi_851_ = type_18(1u, _e738.member); + } else { + phi_850_ = _e738; + phi_851_ = type_18(0u, type_18().member_1); + } + let _e753 = phi_850_; + let _e755 = phi_851_; + switch bitcast(_e755.member) { + case 0: { + let _e800 = (_e740 == 8i); + if _e800 { + phi_866_ = type_18(); + } else { + phi_866_ = _e667; + } + let _e802 = phi_866_; + phi_910_ = false; + phi_911_ = select(false, true, _e800); + phi_912_ = select(bool(), false, _e800); + phi_913_ = select(true, false, _e800); + phi_914_ = _e802; + phi_915_ = false; + phi_833_ = type_18(); + phi_836_ = i32(); + break; + } + case 1: { + if (_e755.member_1 < 8u) { + let _e762 = local_1[_e755.member_1][0u]; + let _e765 = local_1[_e755.member_1][1u]; + let _e768 = local_1[_e755.member_1][2u]; + local_4 = array(_e762, _e765, _e768); + let _e770 = (_e669.member_1 < 3u); + if _e770 { + let _e772 = local_4[_e669.member_1]; + local_5 = array(_e652.x, _e652.y, _e652.z); + if _e770 { + let _e778 = local_5[_e669.member_1]; + if (_e772 > _e778) { + phi_900_ = (_e740 + 1i); + } else { + phi_900_ = _e740; + } + let _e782 = phi_900_; + phi_902_ = _e753; + phi_903_ = _e782; + } else { + phi_902_ = type_18(); + phi_903_ = i32(); + } + let _e784 = phi_902_; + let _e786 = phi_903_; + phi_904_ = select(false, true, _e770); + phi_905_ = _e784; + phi_906_ = _e786; + } else { + phi_904_ = false; + phi_905_ = type_18(); + phi_906_ = i32(); + } + let _e789 = phi_904_; + let _e791 = phi_905_; + let _e793 = phi_906_; + phi_907_ = _e789; + phi_908_ = _e791; + phi_909_ = _e793; + } else { + phi_907_ = false; + phi_908_ = type_18(); + phi_909_ = i32(); + } + let _e795 = phi_907_; + let _e797 = phi_908_; + let _e799 = phi_909_; + phi_910_ = false; + phi_911_ = false; + phi_912_ = bool(); + phi_913_ = false; + phi_914_ = type_18(); + phi_915_ = _e795; + phi_833_ = _e797; + phi_836_ = _e799; + break; + } + default: { + phi_910_ = true; + phi_911_ = false; + phi_912_ = bool(); + phi_913_ = false; + phi_914_ = type_18(); + phi_915_ = false; + phi_833_ = type_18(); + phi_836_ = i32(); + break; + } + } + let _e807 = phi_910_; + let _e809 = phi_911_; + let _e811 = phi_912_; + let _e813 = phi_913_; + let _e815 = phi_914_; + let _e817 = phi_915_; + let _e819 = phi_833_; + let _e821 = phi_836_; + local_10 = _e809; + local_11 = _e811; + local_12 = _e807; + local_13 = _e813; + local_14 = _e815; + continue; + continuing { + phi_832_ = _e819; + phi_835_ = _e821; + break if !(_e817); + } + } + let _e967 = local_10; + phi_916_ = _e967; + let _e970 = local_11; + phi_917_ = _e970; + let _e973 = local_12; + phi_918_ = _e973; + let _e976 = local_13; + phi_919_ = _e976; + let _e979 = local_14; + phi_920_ = _e979; + } + let _e824 = phi_916_; + let _e826 = phi_917_; + let _e828 = phi_918_; + let _e830 = phi_919_; + let _e832 = phi_920_; + if _e824 { + phi_928_ = type_18(); + } else { + phi_928_ = _e832; + } + let _e834 = phi_928_; + phi_972_ = select(_e828, false, _e824); + phi_973_ = select(false, true, _e824); + phi_974_ = select(bool(), _e826, _e824); + phi_975_ = select(_e830, false, _e824); + phi_976_ = _e834; + phi_977_ = false; + phi_800_ = type_18(); + phi_803_ = i32(); + break; + } + case 1: { + if (_e691.member_1 < 8u) { + let _e698 = local_1[_e691.member_1][0u]; + let _e701 = local_1[_e691.member_1][1u]; + let _e704 = local_1[_e691.member_1][2u]; + local_2 = array(_e698, _e701, _e704); + let _e706 = (_e669.member_1 < 3u); + if _e706 { + let _e708 = local_2[_e669.member_1]; + local_3 = array(_e651.x, _e651.y, _e651.z); + if _e706 { + let _e714 = local_3[_e669.member_1]; + if (_e708 < _e714) { + phi_962_ = (_e676 + 1i); + } else { + phi_962_ = _e676; + } + let _e718 = phi_962_; + phi_964_ = _e689; + phi_965_ = _e718; + } else { + phi_964_ = type_18(); + phi_965_ = i32(); + } + let _e720 = phi_964_; + let _e722 = phi_965_; + phi_966_ = select(false, true, _e706); + phi_967_ = _e720; + phi_968_ = _e722; + } else { + phi_966_ = false; + phi_967_ = type_18(); + phi_968_ = i32(); + } + let _e725 = phi_966_; + let _e727 = phi_967_; + let _e729 = phi_968_; + phi_969_ = _e725; + phi_970_ = _e727; + phi_971_ = _e729; + } else { + phi_969_ = false; + phi_970_ = type_18(); + phi_971_ = i32(); + } + let _e731 = phi_969_; + let _e733 = phi_970_; + let _e735 = phi_971_; + phi_972_ = false; + phi_973_ = false; + phi_974_ = bool(); + phi_975_ = false; + phi_976_ = type_18(); + phi_977_ = _e731; + phi_800_ = _e733; + phi_803_ = _e735; + break; + } + default: { + phi_972_ = true; + phi_973_ = false; + phi_974_ = bool(); + phi_975_ = false; + phi_976_ = type_18(); + phi_977_ = false; + phi_800_ = type_18(); + phi_803_ = i32(); + break; + } + } + let _e840 = phi_972_; + let _e842 = phi_973_; + let _e844 = phi_974_; + let _e846 = phi_975_; + let _e848 = phi_976_; + let _e850 = phi_977_; + let _e852 = phi_800_; + let _e854 = phi_803_; + local_15 = _e840; + local_16 = _e842; + local_17 = _e844; + local_18 = _e846; + local_19 = _e848; + continue; + continuing { + phi_799_ = _e852; + phi_802_ = _e854; + break if !(_e850); + } + } + let _e991 = local_15; + phi_978_ = _e991; + let _e994 = local_16; + phi_979_ = _e994; + let _e997 = local_17; + phi_980_ = _e997; + let _e1000 = local_18; + phi_981_ = _e1000; + let _e1003 = local_19; + phi_982_ = _e1003; + break; + } + default: { + phi_978_ = true; + phi_979_ = false; + phi_980_ = bool(); + phi_981_ = false; + phi_982_ = type_18(); + break; + } + } + let _e857 = phi_978_; + let _e859 = phi_979_; + let _e861 = phi_980_; + let _e863 = phi_981_; + let _e865 = phi_982_; + if _e857 { + phi_989_ = type_18(); + } else { + phi_989_ = _e865; + } + let _e867 = phi_989_; + let _e868 = select(_e859, false, _e857); + if _e868 { + if select(_e861, bool(), _e857) { + phi_998_ = type_30(false, 0u); + } else { + phi_998_ = type_30(true, 0u); + } + let _e872 = phi_998_; + phi_1000_ = _e872; + phi_773_ = type_18(); + } else { + phi_1000_ = type_30(); + phi_773_ = _e867; + } + let _e874 = phi_1000_; + let _e876 = phi_773_; + local_20 = select(false, true, _e868); + local_21 = _e874; + continue; + continuing { + phi_772_ = _e876; + break if !(select(select(_e863, false, _e857), false, _e868)); + } + } + let _e1010 = local_20; + phi_1054_ = _e1010; + let _e1013 = local_21; + phi_1055_ = _e1013; + phi_1056_ = false; + phi_745_ = type_18(); + break; + } + case 1: { + if (_e604.member_1 != 0u) { + if (_e604.member_1 < 6u) { + let _e612 = local[_e604.member_1][0u]; + let _e615 = local[_e604.member_1][1u]; + let _e620 = local[_e604.member_1][2u]; + let _e624 = local[_e604.member_1][3u]; + let _e626 = ((fma(_e620, _e561, fma(_e612, _e559, (_e615 * _e560))) + _e624) < _e586); + if _e626 { + phi_1039_ = type_30(true, _e604.member_1); + } else { + phi_1039_ = type_30(); + } + let _e629 = phi_1039_; + phi_1041_ = select(false, true, _e626); + phi_1042_ = _e629; + phi_1043_ = select(true, false, _e626); + } else { + phi_1041_ = false; + phi_1042_ = type_30(); + phi_1043_ = false; + } + let _e633 = phi_1041_; + let _e635 = phi_1042_; + let _e637 = phi_1043_; + phi_1044_ = _e633; + phi_1045_ = _e635; + phi_1046_ = _e637; + } else { + phi_1044_ = false; + phi_1045_ = type_30(); + phi_1046_ = true; + } + let _e639 = phi_1044_; + let _e641 = phi_1045_; + let _e643 = phi_1046_; + if _e643 { + phi_1051_ = _e602; + phi_1053_ = type_30(); + } else { + phi_1051_ = type_18(); + phi_1053_ = _e641; + } + let _e645 = phi_1051_; + let _e647 = phi_1053_; + phi_1054_ = select(_e639, false, _e643); + phi_1055_ = _e647; + phi_1056_ = select(false, true, _e643); + phi_745_ = _e645; + break; + } + default: { + phi_1054_ = false; + phi_1055_ = type_30(); + phi_1056_ = false; + phi_745_ = type_18(); + break; + } + } + let _e881 = phi_1054_; + let _e883 = phi_1055_; + let _e885 = phi_1056_; + let _e887 = phi_745_; + local_22 = _e881; + local_23 = _e883; + continue; + continuing { + phi_744_ = _e887; + break if !(_e885); + } + } + let _e1018 = local_22; + phi_1057_ = _e1018; + let _e1021 = local_23; + phi_1058_ = _e1021; + } + let _e890 = phi_1057_; + let _e892 = phi_1058_; + if _e890 { + if (_e892.member != true) { + } else { + global_1.member[_e84.x].member_1 = 0u; + } + } + } + } + return; +} + +@compute @workgroup_size(32, 1, 1) +fn cullcompute_frustum_culling(@builtin(global_invocation_id) param: vec3) { + global_2 = param; + function(); +} diff --git a/crates/renderling/shaders/manifest.json b/crates/renderling/shaders/manifest.json new file mode 100644 index 00000000..150eea7c --- /dev/null +++ b/crates/renderling/shaders/manifest.json @@ -0,0 +1,122 @@ +[ + { + "source_path": "crates/renderling/shaders/bloom-bloom_downsample_fragment.spv", + "entry_point": "bloom::bloom_downsample_fragment", + "wgsl_entry_point": "bloombloom_downsample_fragment" + }, + { + "source_path": "crates/renderling/shaders/bloom-bloom_mix_fragment.spv", + "entry_point": "bloom::bloom_mix_fragment", + "wgsl_entry_point": "bloombloom_mix_fragment" + }, + { + "source_path": "crates/renderling/shaders/bloom-bloom_upsample_fragment.spv", + "entry_point": "bloom::bloom_upsample_fragment", + "wgsl_entry_point": "bloombloom_upsample_fragment" + }, + { + "source_path": "crates/renderling/shaders/bloom-bloom_vertex.spv", + "entry_point": "bloom::bloom_vertex", + "wgsl_entry_point": "bloombloom_vertex" + }, + { + "source_path": "crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv", + "entry_point": "convolution::brdf_lut_convolution_fragment", + "wgsl_entry_point": "convolutionbrdf_lut_convolution_fragment" + }, + { + "source_path": "crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv", + "entry_point": "convolution::brdf_lut_convolution_vertex", + "wgsl_entry_point": "convolutionbrdf_lut_convolution_vertex" + }, + { + "source_path": "crates/renderling/shaders/convolution-generate_mipmap_fragment.spv", + "entry_point": "convolution::generate_mipmap_fragment", + "wgsl_entry_point": "convolutiongenerate_mipmap_fragment" + }, + { + "source_path": "crates/renderling/shaders/convolution-generate_mipmap_vertex.spv", + "entry_point": "convolution::generate_mipmap_vertex", + "wgsl_entry_point": "convolutiongenerate_mipmap_vertex" + }, + { + "source_path": "crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv", + "entry_point": "convolution::prefilter_environment_cubemap_fragment", + "wgsl_entry_point": "convolutionprefilter_environment_cubemap_fragment" + }, + { + "source_path": "crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv", + "entry_point": "convolution::prefilter_environment_cubemap_vertex", + "wgsl_entry_point": "convolutionprefilter_environment_cubemap_vertex" + }, + { + "source_path": "crates/renderling/shaders/cull-compute_frustum_culling.spv", + "entry_point": "cull::compute_frustum_culling", + "wgsl_entry_point": "cullcompute_frustum_culling" + }, + { + "source_path": "crates/renderling/shaders/skybox-skybox_cubemap_fragment.spv", + "entry_point": "skybox::skybox_cubemap_fragment", + "wgsl_entry_point": "skyboxskybox_cubemap_fragment" + }, + { + "source_path": "crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv", + "entry_point": "skybox::skybox_cubemap_vertex", + "wgsl_entry_point": "skyboxskybox_cubemap_vertex" + }, + { + "source_path": "crates/renderling/shaders/skybox-skybox_equirectangular_fragment.spv", + "entry_point": "skybox::skybox_equirectangular_fragment", + "wgsl_entry_point": "skyboxskybox_equirectangular_fragment" + }, + { + "source_path": "crates/renderling/shaders/skybox-skybox_vertex.spv", + "entry_point": "skybox::skybox_vertex", + "wgsl_entry_point": "skyboxskybox_vertex" + }, + { + "source_path": "crates/renderling/shaders/stage-renderlet_fragment.spv", + "entry_point": "stage::renderlet_fragment", + "wgsl_entry_point": "stagerenderlet_fragment" + }, + { + "source_path": "crates/renderling/shaders/stage-renderlet_vertex.spv", + "entry_point": "stage::renderlet_vertex", + "wgsl_entry_point": "stagerenderlet_vertex" + }, + { + "source_path": "crates/renderling/shaders/tonemapping-tonemapping_fragment.spv", + "entry_point": "tonemapping::tonemapping_fragment", + "wgsl_entry_point": "tonemappingtonemapping_fragment" + }, + { + "source_path": "crates/renderling/shaders/tonemapping-tonemapping_vertex.spv", + "entry_point": "tonemapping::tonemapping_vertex", + "wgsl_entry_point": "tonemappingtonemapping_vertex" + }, + { + "source_path": "crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.spv", + "entry_point": "tutorial::tutorial_implicit_isosceles_vertex", + "wgsl_entry_point": "tutorialtutorial_implicit_isosceles_vertex" + }, + { + "source_path": "crates/renderling/shaders/tutorial-tutorial_passthru_fragment.spv", + "entry_point": "tutorial::tutorial_passthru_fragment", + "wgsl_entry_point": "tutorialtutorial_passthru_fragment" + }, + { + "source_path": "crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv", + "entry_point": "tutorial::tutorial_slabbed_renderlet", + "wgsl_entry_point": "tutorialtutorial_slabbed_renderlet" + }, + { + "source_path": "crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv", + "entry_point": "tutorial::tutorial_slabbed_vertices", + "wgsl_entry_point": "tutorialtutorial_slabbed_vertices" + }, + { + "source_path": "crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv", + "entry_point": "tutorial::tutorial_slabbed_vertices_no_instance", + "wgsl_entry_point": "tutorialtutorial_slabbed_vertices_no_instance" + } +] \ No newline at end of file diff --git a/crates/renderling/shaders/skybox-skybox_cubemap_fragment.spv b/crates/renderling/shaders/skybox-skybox_cubemap_fragment.spv new file mode 100644 index 00000000..fb9e97a2 Binary files /dev/null and b/crates/renderling/shaders/skybox-skybox_cubemap_fragment.spv differ diff --git a/crates/renderling/shaders/skybox-skybox_cubemap_fragment.wgsl b/crates/renderling/shaders/skybox-skybox_cubemap_fragment.wgsl new file mode 100644 index 00000000..777d4032 --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_cubemap_fragment.wgsl @@ -0,0 +1,30 @@ +@group(0) @binding(2) +var global: sampler; +var global_1: vec3; +@group(0) @binding(1) +var global_2: texture_cube; +var global_3: vec4; + +fn function() { + var phi_129_: vec3; + + let _e7 = global_1; + let _e14 = sqrt(fma(_e7.z, _e7.z, fma(_e7.x, _e7.x, (_e7.y * _e7.y)))); + if (_e14 == 0f) { + phi_129_ = vec3(0f, 0f, 0f); + } else { + phi_129_ = (_e7 * (1f / _e14)); + } + let _e19 = phi_129_; + let _e20 = textureSample(global_2, global, _e19); + global_3 = vec4(_e20.x, _e20.y, _e20.z, 1f); + return; +} + +@fragment +fn skyboxskybox_cubemap_fragment(@location(0) param: vec3) -> @location(0) vec4 { + global_1 = param; + function(); + let _e3 = global_3; + return _e3; +} diff --git a/crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv new file mode 100644 index 00000000..4cd01e1e Binary files /dev/null and b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv differ diff --git a/crates/renderling/shaders/skybox-skybox_cubemap_vertex.wgsl b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.wgsl new file mode 100644 index 00000000..15bd31da --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.wgsl @@ -0,0 +1,232 @@ +struct type_10 { + member: array, +} + +struct type_19 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_20 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_21 { + member: type_19, + member_1: type_19, + member_2: type_20, + member_3: vec3, +} + +struct type_23 { + member: u32, + member_1: u32, +} + +struct VertexOutput { + @location(0) member: vec3, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_10; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); +var global_3: vec3; +var global_4: u32; + +fn function() { + var local: array, 8>; + var local_1: array, 6>; + var local_2: array, 36>; + var phi_690_: bool; + var phi_517_: type_23; + var phi_533_: type_23; + var phi_534_: type_23; + var phi_547_: type_23; + var phi_563_: type_23; + var phi_564_: type_23; + var phi_590_: type_21; + var phi_591_: bool; + var phi_548_: type_23; + var phi_611_: type_21; + var phi_612_: bool; + var phi_518_: type_23; + var phi_617_: type_21; + var local_3: type_21; + var local_4: type_21; + + let _e77 = global_4; + let _e78 = global; + let _e80 = arrayLength((&global_1.member)); + if (_e80 >= 83u) { + phi_690_ = (_e77 <= (_e80 - 83u)); + } else { + phi_690_ = false; + } + let _e85 = phi_690_; + if _e85 { + let _e88 = global_1.member[_e77]; + let _e93 = global_1.member[(_e77 + 1u)]; + let _e98 = global_1.member[(_e77 + 2u)]; + let _e103 = global_1.member[(_e77 + 3u)]; + let _e109 = global_1.member[(_e77 + 4u)]; + let _e114 = global_1.member[(_e77 + 5u)]; + let _e119 = global_1.member[(_e77 + 6u)]; + let _e124 = global_1.member[(_e77 + 7u)]; + let _e130 = global_1.member[(_e77 + 8u)]; + let _e135 = global_1.member[(_e77 + 9u)]; + let _e140 = global_1.member[(_e77 + 10u)]; + let _e145 = global_1.member[(_e77 + 11u)]; + let _e151 = global_1.member[(_e77 + 12u)]; + let _e156 = global_1.member[(_e77 + 13u)]; + let _e161 = global_1.member[(_e77 + 14u)]; + let _e166 = global_1.member[(_e77 + 15u)]; + let _e173 = global_1.member[(_e77 + 16u)]; + let _e178 = global_1.member[(_e77 + 17u)]; + let _e183 = global_1.member[(_e77 + 18u)]; + let _e188 = global_1.member[(_e77 + 19u)]; + let _e194 = global_1.member[(_e77 + 20u)]; + let _e199 = global_1.member[(_e77 + 21u)]; + let _e204 = global_1.member[(_e77 + 22u)]; + let _e209 = global_1.member[(_e77 + 23u)]; + let _e215 = global_1.member[(_e77 + 24u)]; + let _e220 = global_1.member[(_e77 + 25u)]; + let _e225 = global_1.member[(_e77 + 26u)]; + let _e230 = global_1.member[(_e77 + 27u)]; + let _e236 = global_1.member[(_e77 + 28u)]; + let _e241 = global_1.member[(_e77 + 29u)]; + let _e246 = global_1.member[(_e77 + 30u)]; + let _e251 = global_1.member[(_e77 + 31u)]; + let _e258 = global_1.member[(_e77 + 32u)]; + let _e263 = global_1.member[(_e77 + 33u)]; + let _e268 = global_1.member[(_e77 + 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_517_ = type_23(0u, 6u); + loop { + let _e273 = phi_517_; + if (_e273.member < _e273.member_1) { + phi_533_ = type_23((_e273.member + 1u), _e273.member_1); + phi_534_ = type_23(1u, _e273.member); + } else { + phi_533_ = _e273; + phi_534_ = type_23(0u, type_23().member_1); + } + let _e286 = phi_533_; + let _e288 = phi_534_; + switch bitcast(_e288.member) { + case 0: { + let _e292 = 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_547_ = type_23(0u, 8u); + loop { + let _e295 = phi_547_; + if (_e295.member < _e295.member_1) { + phi_563_ = type_23((_e295.member + 1u), _e295.member_1); + phi_564_ = type_23(1u, _e295.member); + } else { + phi_563_ = _e295; + phi_564_ = type_23(0u, type_23().member_1); + } + let _e308 = phi_563_; + let _e310 = phi_564_; + switch bitcast(_e310.member) { + case 0: { + let _e314 = local; + phi_590_ = type_21(type_19(vec4(bitcast(_e88), bitcast(_e93), bitcast(_e98), bitcast(_e103)), vec4(bitcast(_e109), bitcast(_e114), bitcast(_e119), bitcast(_e124)), vec4(bitcast(_e130), bitcast(_e135), bitcast(_e140), bitcast(_e145)), vec4(bitcast(_e151), bitcast(_e156), bitcast(_e161), bitcast(_e166))), type_19(vec4(bitcast(_e173), bitcast(_e178), bitcast(_e183), bitcast(_e188)), vec4(bitcast(_e194), bitcast(_e199), bitcast(_e204), bitcast(_e209)), vec4(bitcast(_e215), bitcast(_e220), bitcast(_e225), bitcast(_e230)), vec4(bitcast(_e236), bitcast(_e241), bitcast(_e246), bitcast(_e251))), type_20(_e314, _e292), vec3(bitcast(_e258), bitcast(_e263), bitcast(_e268))); + phi_591_ = false; + phi_548_ = type_23(); + break; + } + case 1: { + let _e318 = ((_e77 + 59u) + (_e310.member_1 * 3u)); + let _e321 = global_1.member[_e318]; + let _e326 = global_1.member[(_e318 + 1u)]; + let _e331 = global_1.member[(_e318 + 2u)]; + local[_e310.member_1] = vec3(bitcast(_e321), bitcast(_e326), bitcast(_e331)); + phi_590_ = type_21(); + phi_591_ = true; + phi_548_ = _e308; + break; + } + default: { + phi_590_ = type_21(); + phi_591_ = false; + phi_548_ = type_23(); + break; + } + } + let _e336 = phi_590_; + let _e338 = phi_591_; + let _e340 = phi_548_; + local_3 = _e336; + continue; + continuing { + phi_547_ = _e340; + break if !(_e338); + } + } + let _e515 = local_3; + phi_611_ = _e515; + phi_612_ = false; + phi_518_ = type_23(); + break; + } + case 1: { + let _e343 = ((_e77 + 35u) + (_e288.member_1 * 4u)); + let _e346 = global_1.member[_e343]; + let _e351 = global_1.member[(_e343 + 1u)]; + let _e356 = global_1.member[(_e343 + 2u)]; + let _e361 = global_1.member[(_e343 + 3u)]; + local_1[_e288.member_1] = vec4(bitcast(_e346), bitcast(_e351), bitcast(_e356), bitcast(_e361)); + phi_611_ = type_21(); + phi_612_ = true; + phi_518_ = _e286; + break; + } + default: { + phi_611_ = type_21(); + phi_612_ = false; + phi_518_ = type_23(); + break; + } + } + let _e366 = phi_611_; + let _e368 = phi_612_; + let _e370 = phi_518_; + local_4 = _e366; + continue; + continuing { + phi_517_ = _e370; + break if !(_e368); + } + } + let _e520 = local_4; + phi_617_ = _e520; + } else { + phi_617_ = type_21(type_19(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_19(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_20(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 _e373 = phi_617_; + local_2 = array, 36>(vec3(-0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f)); + if (_e78 < 36u) { + let _e378 = local_2[_e78]; + global_3 = _e378; + global_2 = vec4((fma(fma(_e373.member.member_3.x, _e373.member_1.member_2.w, fma(_e373.member.member_2.x, _e373.member_1.member_2.z, fma(_e373.member.member.x, _e373.member_1.member_2.x, (_e373.member.member_1.x * _e373.member_1.member_2.y)))), _e378.z, fma(fma(_e373.member.member_3.x, _e373.member_1.member.w, fma(_e373.member.member_2.x, _e373.member_1.member.z, fma(_e373.member.member.x, _e373.member_1.member.x, (_e373.member.member_1.x * _e373.member_1.member.y)))), _e378.x, (fma(_e373.member.member_3.x, _e373.member_1.member_1.w, fma(_e373.member.member_2.x, _e373.member_1.member_1.z, fma(_e373.member.member.x, _e373.member_1.member_1.x, (_e373.member.member_1.x * _e373.member_1.member_1.y)))) * _e378.y))) + fma(_e373.member.member_3.x, _e373.member_1.member_3.w, fma(_e373.member.member_2.x, _e373.member_1.member_3.z, fma(_e373.member.member.x, _e373.member_1.member_3.x, (_e373.member.member_1.x * _e373.member_1.member_3.y))))), (fma(fma(_e373.member.member_3.y, _e373.member_1.member_2.w, fma(_e373.member.member_2.y, _e373.member_1.member_2.z, fma(_e373.member.member.y, _e373.member_1.member_2.x, (_e373.member.member_1.y * _e373.member_1.member_2.y)))), _e378.z, fma(fma(_e373.member.member_3.y, _e373.member_1.member.w, fma(_e373.member.member_2.y, _e373.member_1.member.z, fma(_e373.member.member.y, _e373.member_1.member.x, (_e373.member.member_1.y * _e373.member_1.member.y)))), _e378.x, (fma(_e373.member.member_3.y, _e373.member_1.member_1.w, fma(_e373.member.member_2.y, _e373.member_1.member_1.z, fma(_e373.member.member.y, _e373.member_1.member_1.x, (_e373.member.member_1.y * _e373.member_1.member_1.y)))) * _e378.y))) + fma(_e373.member.member_3.y, _e373.member_1.member_3.w, fma(_e373.member.member_2.y, _e373.member_1.member_3.z, fma(_e373.member.member.y, _e373.member_1.member_3.x, (_e373.member.member_1.y * _e373.member_1.member_3.y))))), (fma(fma(_e373.member.member_3.z, _e373.member_1.member_2.w, fma(_e373.member.member_2.z, _e373.member_1.member_2.z, fma(_e373.member.member.z, _e373.member_1.member_2.x, (_e373.member.member_1.z * _e373.member_1.member_2.y)))), _e378.z, fma(fma(_e373.member.member_3.z, _e373.member_1.member.w, fma(_e373.member.member_2.z, _e373.member_1.member.z, fma(_e373.member.member.z, _e373.member_1.member.x, (_e373.member.member_1.z * _e373.member_1.member.y)))), _e378.x, (fma(_e373.member.member_3.z, _e373.member_1.member_1.w, fma(_e373.member.member_2.z, _e373.member_1.member_1.z, fma(_e373.member.member.z, _e373.member_1.member_1.x, (_e373.member.member_1.z * _e373.member_1.member_1.y)))) * _e378.y))) + fma(_e373.member.member_3.z, _e373.member_1.member_3.w, fma(_e373.member.member_2.z, _e373.member_1.member_3.z, fma(_e373.member.member.z, _e373.member_1.member_3.x, (_e373.member.member_1.z * _e373.member_1.member_3.y))))), (fma(fma(_e373.member.member_3.w, _e373.member_1.member_2.w, fma(_e373.member.member_2.w, _e373.member_1.member_2.z, fma(_e373.member.member.w, _e373.member_1.member_2.x, (_e373.member.member_1.w * _e373.member_1.member_2.y)))), _e378.z, fma(fma(_e373.member.member_3.w, _e373.member_1.member.w, fma(_e373.member.member_2.w, _e373.member_1.member.z, fma(_e373.member.member.w, _e373.member_1.member.x, (_e373.member.member_1.w * _e373.member_1.member.y)))), _e378.x, (fma(_e373.member.member_3.w, _e373.member_1.member_1.w, fma(_e373.member.member_2.w, _e373.member_1.member_1.z, fma(_e373.member.member.w, _e373.member_1.member_1.x, (_e373.member.member_1.w * _e373.member_1.member_1.y)))) * _e378.y))) + fma(_e373.member.member_3.w, _e373.member_1.member_3.w, fma(_e373.member.member_2.w, _e373.member_1.member_3.z, fma(_e373.member.member.w, _e373.member_1.member_3.x, (_e373.member.member_1.w * _e373.member_1.member_3.y)))))); + } + return; +} + +@vertex +fn skyboxskybox_cubemap_vertex(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_4 = param; + global = param_1; + function(); + let _e7 = global_2.y; + global_2.y = -(_e7); + let _e9 = global_3; + let _e10 = global_2; + return VertexOutput(_e9, _e10); +} diff --git a/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.spv b/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.spv new file mode 100644 index 00000000..a039280d Binary files /dev/null and b/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.spv differ diff --git a/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.wgsl b/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.wgsl new file mode 100644 index 00000000..8ab36b8c --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.wgsl @@ -0,0 +1,30 @@ +@group(0) @binding(2) +var global: sampler; +@group(0) @binding(1) +var global_1: texture_2d; +var global_2: vec3; +var global_3: vec4; + +fn function() { + var phi_153_: vec3; + + let _e10 = global_2; + let _e17 = sqrt(fma(_e10.z, _e10.z, fma(_e10.x, _e10.x, (_e10.y * _e10.y)))); + if (_e17 == 0f) { + phi_153_ = vec3(0f, 0f, 0f); + } else { + phi_153_ = (_e10 * (1f / _e17)); + } + let _e22 = phi_153_; + let _e31 = textureSample(global_1, global, vec2(fma(atan2(_e22.z, _e22.x), 0.1591f, 0.5f), fma(asin(_e22.y), 0.31830987f, 0.5f))); + global_3 = vec4(_e31.x, _e31.y, _e31.z, 1f); + return; +} + +@fragment +fn skyboxskybox_equirectangular_fragment(@location(0) param: vec3) -> @location(0) vec4 { + global_2 = param; + function(); + let _e3 = global_3; + return _e3; +} diff --git a/crates/renderling/shaders/skybox-skybox_vertex.spv b/crates/renderling/shaders/skybox-skybox_vertex.spv new file mode 100644 index 00000000..550db981 Binary files /dev/null and b/crates/renderling/shaders/skybox-skybox_vertex.spv differ diff --git a/crates/renderling/shaders/skybox-skybox_vertex.wgsl b/crates/renderling/shaders/skybox-skybox_vertex.wgsl new file mode 100644 index 00000000..72837db8 --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_vertex.wgsl @@ -0,0 +1,233 @@ +struct type_10 { + member: array, +} + +struct type_19 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_20 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_21 { + member: type_19, + member_1: type_19, + member_2: type_20, + member_3: vec3, +} + +struct type_23 { + member: u32, + member_1: u32, +} + +struct VertexOutput { + @location(0) member: vec3, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_10; +var global_2: u32; +var global_3: vec3; +var global_4: vec4 = vec4(0f, 0f, 0f, 1f); + +fn function() { + var local: array, 8>; + var local_1: array, 6>; + var local_2: array, 36>; + var phi_726_: bool; + var phi_305_: type_23; + var phi_321_: type_23; + var phi_322_: type_23; + var phi_335_: type_23; + var phi_351_: type_23; + var phi_352_: type_23; + var phi_378_: type_21; + var phi_379_: bool; + var phi_336_: type_23; + var phi_399_: type_21; + var phi_400_: bool; + var phi_306_: type_23; + var phi_405_: type_21; + var local_3: type_21; + var local_4: type_21; + + let _e77 = global_2; + let _e78 = global; + let _e80 = arrayLength((&global_1.member)); + if (_e80 >= 83u) { + phi_726_ = (_e77 <= (_e80 - 83u)); + } else { + phi_726_ = false; + } + let _e85 = phi_726_; + if _e85 { + let _e88 = global_1.member[_e77]; + let _e93 = global_1.member[(_e77 + 1u)]; + let _e98 = global_1.member[(_e77 + 2u)]; + let _e103 = global_1.member[(_e77 + 3u)]; + let _e109 = global_1.member[(_e77 + 4u)]; + let _e114 = global_1.member[(_e77 + 5u)]; + let _e119 = global_1.member[(_e77 + 6u)]; + let _e124 = global_1.member[(_e77 + 7u)]; + let _e130 = global_1.member[(_e77 + 8u)]; + let _e135 = global_1.member[(_e77 + 9u)]; + let _e140 = global_1.member[(_e77 + 10u)]; + let _e145 = global_1.member[(_e77 + 11u)]; + let _e151 = global_1.member[(_e77 + 12u)]; + let _e156 = global_1.member[(_e77 + 13u)]; + let _e161 = global_1.member[(_e77 + 14u)]; + let _e166 = global_1.member[(_e77 + 15u)]; + let _e173 = global_1.member[(_e77 + 16u)]; + let _e178 = global_1.member[(_e77 + 17u)]; + let _e183 = global_1.member[(_e77 + 18u)]; + let _e188 = global_1.member[(_e77 + 19u)]; + let _e194 = global_1.member[(_e77 + 20u)]; + let _e199 = global_1.member[(_e77 + 21u)]; + let _e204 = global_1.member[(_e77 + 22u)]; + let _e209 = global_1.member[(_e77 + 23u)]; + let _e215 = global_1.member[(_e77 + 24u)]; + let _e220 = global_1.member[(_e77 + 25u)]; + let _e225 = global_1.member[(_e77 + 26u)]; + let _e230 = global_1.member[(_e77 + 27u)]; + let _e236 = global_1.member[(_e77 + 28u)]; + let _e241 = global_1.member[(_e77 + 29u)]; + let _e246 = global_1.member[(_e77 + 30u)]; + let _e251 = global_1.member[(_e77 + 31u)]; + let _e258 = global_1.member[(_e77 + 32u)]; + let _e263 = global_1.member[(_e77 + 33u)]; + let _e268 = global_1.member[(_e77 + 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_305_ = type_23(0u, 6u); + loop { + let _e273 = phi_305_; + if (_e273.member < _e273.member_1) { + phi_321_ = type_23((_e273.member + 1u), _e273.member_1); + phi_322_ = type_23(1u, _e273.member); + } else { + phi_321_ = _e273; + phi_322_ = type_23(0u, type_23().member_1); + } + let _e286 = phi_321_; + let _e288 = phi_322_; + switch bitcast(_e288.member) { + case 0: { + let _e292 = 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_335_ = type_23(0u, 8u); + loop { + let _e295 = phi_335_; + if (_e295.member < _e295.member_1) { + phi_351_ = type_23((_e295.member + 1u), _e295.member_1); + phi_352_ = type_23(1u, _e295.member); + } else { + phi_351_ = _e295; + phi_352_ = type_23(0u, type_23().member_1); + } + let _e308 = phi_351_; + let _e310 = phi_352_; + switch bitcast(_e310.member) { + case 0: { + let _e314 = local; + phi_378_ = type_21(type_19(vec4(bitcast(_e88), bitcast(_e93), bitcast(_e98), bitcast(_e103)), vec4(bitcast(_e109), bitcast(_e114), bitcast(_e119), bitcast(_e124)), vec4(bitcast(_e130), bitcast(_e135), bitcast(_e140), bitcast(_e145)), vec4(bitcast(_e151), bitcast(_e156), bitcast(_e161), bitcast(_e166))), type_19(vec4(bitcast(_e173), bitcast(_e178), bitcast(_e183), bitcast(_e188)), vec4(bitcast(_e194), bitcast(_e199), bitcast(_e204), bitcast(_e209)), vec4(bitcast(_e215), bitcast(_e220), bitcast(_e225), bitcast(_e230)), vec4(bitcast(_e236), bitcast(_e241), bitcast(_e246), bitcast(_e251))), type_20(_e314, _e292), vec3(bitcast(_e258), bitcast(_e263), bitcast(_e268))); + phi_379_ = false; + phi_336_ = type_23(); + break; + } + case 1: { + let _e318 = ((_e77 + 59u) + (_e310.member_1 * 3u)); + let _e321 = global_1.member[_e318]; + let _e326 = global_1.member[(_e318 + 1u)]; + let _e331 = global_1.member[(_e318 + 2u)]; + local[_e310.member_1] = vec3(bitcast(_e321), bitcast(_e326), bitcast(_e331)); + phi_378_ = type_21(); + phi_379_ = true; + phi_336_ = _e308; + break; + } + default: { + phi_378_ = type_21(); + phi_379_ = false; + phi_336_ = type_23(); + break; + } + } + let _e336 = phi_378_; + let _e338 = phi_379_; + let _e340 = phi_336_; + local_3 = _e336; + continue; + continuing { + phi_335_ = _e340; + break if !(_e338); + } + } + let _e462 = local_3; + phi_399_ = _e462; + phi_400_ = false; + phi_306_ = type_23(); + break; + } + case 1: { + let _e343 = ((_e77 + 35u) + (_e288.member_1 * 4u)); + let _e346 = global_1.member[_e343]; + let _e351 = global_1.member[(_e343 + 1u)]; + let _e356 = global_1.member[(_e343 + 2u)]; + let _e361 = global_1.member[(_e343 + 3u)]; + local_1[_e288.member_1] = vec4(bitcast(_e346), bitcast(_e351), bitcast(_e356), bitcast(_e361)); + phi_399_ = type_21(); + phi_400_ = true; + phi_306_ = _e286; + break; + } + default: { + phi_399_ = type_21(); + phi_400_ = false; + phi_306_ = type_23(); + break; + } + } + let _e366 = phi_399_; + let _e368 = phi_400_; + let _e370 = phi_306_; + local_4 = _e366; + continue; + continuing { + phi_305_ = _e370; + break if !(_e368); + } + } + let _e467 = local_4; + phi_405_ = _e467; + } else { + phi_405_ = type_21(type_19(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_19(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_20(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 _e373 = phi_405_; + local_2 = array, 36>(vec3(-0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(0.5f, 0.5f, 0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(-0.5f, 0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, -0.5f, 0.5f), vec3(-0.5f, -0.5f, 0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f), vec3(-0.5f, 0.5f, -0.5f), vec3(0.5f, 0.5f, -0.5f), vec3(0.5f, -0.5f, -0.5f), vec3(-0.5f, -0.5f, -0.5f)); + if (_e78 < 36u) { + let _e381 = local_2[_e78]; + global_3 = _e381; + let _e448 = (fma(fma(_e373.member.member_2.w, _e373.member_1.member_2.z, fma(_e373.member.member.w, _e373.member_1.member_2.x, (_e373.member.member_1.w * _e373.member_1.member_2.y))), _e381.z, fma(fma(_e373.member.member_2.w, _e373.member_1.member.z, fma(_e373.member.member.w, _e373.member_1.member.x, (_e373.member.member_1.w * _e373.member_1.member.y))), _e381.x, (fma(_e373.member.member_2.w, _e373.member_1.member_1.z, fma(_e373.member.member.w, _e373.member_1.member_1.x, (_e373.member.member_1.w * _e373.member_1.member_1.y))) * _e381.y))) + _e373.member.member_3.w); + global_4 = vec4((fma(fma(_e373.member.member_2.x, _e373.member_1.member_2.z, fma(_e373.member.member.x, _e373.member_1.member_2.x, (_e373.member.member_1.x * _e373.member_1.member_2.y))), _e381.z, fma(fma(_e373.member.member_2.x, _e373.member_1.member.z, fma(_e373.member.member.x, _e373.member_1.member.x, (_e373.member.member_1.x * _e373.member_1.member.y))), _e381.x, (fma(_e373.member.member_2.x, _e373.member_1.member_1.z, fma(_e373.member.member.x, _e373.member_1.member_1.x, (_e373.member.member_1.x * _e373.member_1.member_1.y))) * _e381.y))) + _e373.member.member_3.x), (fma(fma(_e373.member.member_2.y, _e373.member_1.member_2.z, fma(_e373.member.member.y, _e373.member_1.member_2.x, (_e373.member.member_1.y * _e373.member_1.member_2.y))), _e381.z, fma(fma(_e373.member.member_2.y, _e373.member_1.member.z, fma(_e373.member.member.y, _e373.member_1.member.x, (_e373.member.member_1.y * _e373.member_1.member.y))), _e381.x, (fma(_e373.member.member_2.y, _e373.member_1.member_1.z, fma(_e373.member.member.y, _e373.member_1.member_1.x, (_e373.member.member_1.y * _e373.member_1.member_1.y))) * _e381.y))) + _e373.member.member_3.y), _e448, _e448); + } + return; +} + +@vertex +fn skyboxskybox_vertex(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_2 = param; + global = param_1; + function(); + let _e7 = global_4.y; + global_4.y = -(_e7); + let _e9 = global_3; + let _e10 = global_4; + return VertexOutput(_e9, _e10); +} diff --git a/crates/renderling/shaders/stage-renderlet_fragment.spv b/crates/renderling/shaders/stage-renderlet_fragment.spv new file mode 100644 index 00000000..5fcbcf48 Binary files /dev/null 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 new file mode 100644 index 00000000..940fcab2 --- /dev/null +++ b/crates/renderling/shaders/stage-renderlet_fragment.wgsl @@ -0,0 +1,2510 @@ +struct type_11 { + member: array, +} + +struct type_20 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_21 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_22 { + member: type_20, + member_1: type_20, + member_2: type_21, + member_3: vec3, +} + +struct type_24 { + member: u32, + member_1: u32, +} + +struct type_28 { + member: vec3, + member_1: vec4, + member_2: vec3, +} + +struct type_30 { + member: vec2, + member_1: vec2, + member_2: type_24, + member_3: u32, + member_4: bool, + member_5: bool, +} + +struct type_32 { + member: vec3, + member_1: f32, + member_2: vec4, + member_3: f32, + member_4: f32, + member_5: u32, + member_6: u32, + member_7: u32, + member_8: u32, + member_9: u32, + member_10: u32, + member_11: u32, + member_12: u32, + member_13: u32, + member_14: u32, + member_15: bool, + member_16: f32, +} + +struct type_33 { + member: type_24, + member_1: vec2, + member_2: vec2, + member_3: u32, + member_4: u32, +} + +struct type_34 { + member: u32, + member_1: u32, + member_2: u32, +} + +struct type_35 { + member: vec3, + member_1: vec4, + member_2: f32, +} + +struct type_36 { + member: vec3, + member_1: vec3, + member_2: f32, + member_3: f32, + member_4: vec4, + member_5: f32, +} + +@group(0) @binding(0) +var global: type_11; +var global_1: u32; +var global_2: u32; +var global_3: u32; +var global_4: vec4; +var global_5: vec2; +var global_6: vec2; +var global_7: vec3; +var global_8: vec3; +var global_9: vec3; +var global_10: vec3; +@group(1) @binding(1) +var global_11: sampler; +@group(1) @binding(0) +var global_12: texture_2d_array; +@group(1) @binding(2) +var global_13: texture_cube; +@group(1) @binding(3) +var global_14: sampler; +@group(1) @binding(4) +var global_15: texture_cube; +@group(1) @binding(5) +var global_16: sampler; +@group(1) @binding(6) +var global_17: texture_2d; +@group(1) @binding(7) +var global_18: sampler; +var global_19: vec4; + +fn function() { + var local: array, 8>; + var local_1: array, 6>; + var phi_3787_: bool; + var phi_501_: u32; + var phi_527_: type_30; + var phi_3838_: bool; + var phi_646_: type_32; + var phi_650_: type_32; + var phi_3871_: bool; + var phi_690_: u32; + var phi_699_: u32; + var phi_712_: type_33; + var phi_3931_: f32; + var phi_3912_: f32; + var phi_3913_: bool; + var phi_766_: f32; + var phi_761_: f32; + var phi_767_: f32; + var phi_3893_: f32; + var phi_3894_: bool; + var phi_732_: f32; + var phi_771_: bool; + var phi_772_: f32; + var phi_3983_: f32; + var phi_3964_: f32; + var phi_3965_: bool; + var phi_830_: f32; + var phi_825_: f32; + var phi_831_: f32; + var phi_3945_: f32; + var phi_3946_: bool; + var phi_796_: f32; + var phi_835_: bool; + var phi_836_: f32; + var phi_4015_: bool; + var phi_922_: u32; + var phi_931_: u32; + var phi_944_: type_33; + var phi_4074_: f32; + var phi_4055_: f32; + var phi_4056_: bool; + var phi_998_: f32; + var phi_993_: f32; + var phi_999_: f32; + var phi_4036_: f32; + var phi_4037_: bool; + var phi_964_: f32; + var phi_1003_: bool; + var phi_1004_: f32; + var phi_4126_: f32; + var phi_4107_: f32; + var phi_4108_: bool; + var phi_1062_: f32; + var phi_1057_: f32; + var phi_1063_: f32; + var phi_4088_: f32; + var phi_4089_: bool; + var phi_1028_: f32; + var phi_1067_: bool; + var phi_1068_: f32; + var phi_4158_: bool; + var phi_1154_: u32; + var phi_1163_: u32; + var phi_1176_: type_33; + var phi_4217_: f32; + var phi_4198_: f32; + var phi_4199_: bool; + var phi_1230_: f32; + var phi_1225_: f32; + var phi_1231_: f32; + var phi_4179_: f32; + var phi_4180_: bool; + var phi_1196_: f32; + var phi_1235_: bool; + var phi_1236_: f32; + var phi_4269_: f32; + var phi_4250_: f32; + var phi_4251_: bool; + var phi_1294_: f32; + var phi_1289_: f32; + var phi_1295_: f32; + var phi_4231_: f32; + var phi_4232_: bool; + var phi_1260_: f32; + var phi_1299_: bool; + var phi_1300_: f32; + var phi_4301_: bool; + var phi_1386_: u32; + var phi_1395_: u32; + var phi_1408_: type_33; + var phi_4360_: f32; + var phi_4341_: f32; + var phi_4342_: bool; + var phi_1462_: f32; + var phi_1457_: f32; + var phi_1463_: f32; + var phi_4322_: f32; + var phi_4323_: bool; + var phi_1428_: f32; + var phi_1467_: bool; + var phi_1468_: f32; + var phi_4412_: f32; + var phi_4393_: f32; + var phi_4394_: bool; + var phi_1526_: f32; + var phi_1521_: f32; + var phi_1527_: f32; + var phi_4374_: f32; + var phi_4375_: bool; + var phi_1492_: f32; + var phi_1531_: bool; + var phi_1532_: f32; + var phi_4444_: bool; + var phi_1618_: u32; + var phi_1627_: u32; + var phi_1640_: type_33; + var phi_4503_: f32; + var phi_4484_: f32; + var phi_4485_: bool; + var phi_1694_: f32; + var phi_1689_: f32; + var phi_1695_: f32; + var phi_4465_: f32; + var phi_4466_: bool; + var phi_1660_: f32; + var phi_1699_: bool; + var phi_1700_: f32; + var phi_4555_: f32; + var phi_4536_: f32; + var phi_4537_: bool; + var phi_1758_: f32; + var phi_1753_: f32; + var phi_1759_: f32; + var phi_4517_: f32; + var phi_4518_: bool; + var phi_1724_: f32; + var phi_1763_: bool; + var phi_1764_: f32; + var phi_4609_: vec3; + var phi_4644_: vec3; + var phi_4679_: vec3; + var phi_4714_: vec3; + var phi_4749_: vec3; + var phi_1861_: vec3; + var phi_1862_: vec3; + var phi_4781_: bool; + var phi_2068_: type_24; + var phi_2084_: type_24; + var phi_2085_: type_24; + var phi_2098_: type_24; + var phi_2114_: type_24; + var phi_2115_: type_24; + var phi_2141_: type_22; + var phi_2142_: bool; + var phi_2099_: type_24; + var phi_2162_: type_22; + var phi_2163_: bool; + var phi_2069_: type_24; + var phi_2168_: type_22; + var phi_4853_: vec3; + var phi_4912_: vec3; + var phi_4986_: vec3; + var phi_6131_: vec3; + var phi_6082_: vec3; + var phi_6033_: vec3; + var phi_5984_: vec3; + var phi_5935_: vec3; + var phi_5886_: vec3; + var phi_5837_: vec3; + var phi_5036_: vec3; + var phi_5071_: vec3; + var phi_2208_: type_24; + var phi_2211_: vec3; + var phi_2226_: type_24; + var phi_2227_: type_24; + var phi_5088_: u32; + var phi_5107_: bool; + var phi_2244_: u32; + var phi_5139_: bool; + var phi_2261_: u32; + var phi_2271_: type_34; + var phi_5169_: bool; + var phi_2321_: type_28; + var phi_5598_: bool; + var phi_2824_: type_36; + var phi_5648_: vec3; + var phi_5683_: vec3; + var phi_5718_: vec3; + var phi_3076_: vec3; + var phi_5425_: bool; + var phi_2573_: type_35; + var phi_5471_: vec3; + var phi_5506_: vec3; + var phi_2762_: vec3; + var phi_5250_: bool; + var phi_2369_: type_35; + var phi_5298_: vec3; + var phi_5333_: vec3; + var phi_3077_: bool; + var phi_3078_: bool; + var phi_3079_: vec3; + var phi_3080_: bool; + var phi_3085_: type_24; + var phi_3093_: type_24; + var phi_3097_: bool; + var phi_3098_: type_24; + var phi_3099_: vec3; + var phi_3100_: bool; + var phi_3101_: bool; + var phi_3102_: bool; + var phi_3103_: bool; + var phi_3104_: type_24; + var phi_3105_: vec3; + var phi_3111_: type_24; + var phi_3215_: vec4; + var phi_2209_: type_24; + var phi_3232_: bool; + var phi_3233_: vec4; + var local_2: type_22; + var local_3: type_22; + var local_4: bool; + var local_5: vec4; + + let _e118 = arrayLength((&global.member)); + let _e119 = global_1; + let _e120 = global_2; + let _e121 = global_3; + let _e122 = global_4; + let _e123 = global_5; + let _e124 = global_6; + let _e125 = global_7; + let _e126 = global_8; + let _e127 = global_9; + let _e128 = global_10; + if (_e118 >= 9u) { + phi_3787_ = (_e121 <= (_e118 - 9u)); + } else { + phi_3787_ = false; + } + let _e133 = phi_3787_; + if _e133 { + let _e136 = global.member[_e121]; + let _e140 = global.member[(_e121 + 1u)]; + let _e145 = global.member[(_e121 + 2u)]; + let _e149 = global.member[(_e121 + 3u)]; + let _e154 = global.member[(_e121 + 4u)]; + switch bitcast(_e154) { + case 0: { + phi_501_ = 0u; + break; + } + case 1: { + phi_501_ = 1u; + break; + } + case 2: { + phi_501_ = 2u; + break; + } + case 3: { + phi_501_ = 3u; + break; + } + case 4: { + phi_501_ = 4u; + break; + } + case 5: { + phi_501_ = 5u; + break; + } + case 6: { + phi_501_ = 6u; + break; + } + case 7: { + phi_501_ = 7u; + break; + } + case 8: { + phi_501_ = 8u; + break; + } + case 9: { + phi_501_ = 9u; + break; + } + case 10: { + phi_501_ = 10u; + break; + } + case 11: { + phi_501_ = 11u; + break; + } + case 12: { + phi_501_ = 12u; + break; + } + case 13: { + phi_501_ = 13u; + break; + } + case 14: { + phi_501_ = 14u; + break; + } + case 15: { + phi_501_ = 15u; + break; + } + case 16: { + phi_501_ = 16u; + break; + } + case 17: { + phi_501_ = 17u; + break; + } + case 18: { + phi_501_ = 18u; + break; + } + case 19: { + phi_501_ = 19u; + break; + } + default: { + phi_501_ = 0u; + break; + } + } + let _e157 = phi_501_; + let _e161 = global.member[(_e121 + 5u)]; + let _e166 = global.member[(_e121 + 6u)]; + let _e171 = global.member[(_e121 + 7u)]; + let _e175 = global.member[(_e121 + 8u)]; + phi_527_ = type_30(vec2(_e136, _e140), vec2(_e145, _e149), type_24(_e171, _e175), _e157, (_e161 == 1u), (_e166 == 1u)); + } else { + phi_527_ = type_30(vec2(0u, 0u), vec2(1u, 1u), type_24(4294967295u, 0u), 0u, true, true); + } + let _e179 = phi_527_; + if (_e120 == 4294967295u) { + phi_650_ = type_32(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 (_e118 >= 22u) { + phi_3838_ = (_e120 <= (_e118 - 22u)); + } else { + phi_3838_ = false; + } + let _e192 = phi_3838_; + if _e192 { + let _e195 = global.member[_e120]; + let _e200 = global.member[(_e120 + 1u)]; + let _e205 = global.member[(_e120 + 2u)]; + let _e211 = global.member[(_e120 + 3u)]; + let _e216 = global.member[(_e120 + 4u)]; + let _e221 = global.member[(_e120 + 5u)]; + let _e226 = global.member[(_e120 + 6u)]; + let _e231 = global.member[(_e120 + 7u)]; + let _e237 = global.member[(_e120 + 8u)]; + let _e242 = global.member[(_e120 + 9u)]; + let _e247 = global.member[(_e120 + 10u)]; + let _e251 = global.member[(_e120 + 11u)]; + let _e255 = global.member[(_e120 + 12u)]; + let _e259 = global.member[(_e120 + 13u)]; + let _e263 = global.member[(_e120 + 14u)]; + let _e267 = global.member[(_e120 + 15u)]; + let _e271 = global.member[(_e120 + 16u)]; + let _e275 = global.member[(_e120 + 17u)]; + let _e279 = global.member[(_e120 + 18u)]; + let _e283 = global.member[(_e120 + 19u)]; + let _e287 = global.member[(_e120 + 20u)]; + let _e292 = global.member[(_e120 + 21u)]; + phi_646_ = type_32(vec3(bitcast(_e195), bitcast(_e200), bitcast(_e205)), bitcast(_e211), vec4(bitcast(_e216), bitcast(_e221), bitcast(_e226), bitcast(_e231)), bitcast(_e237), bitcast(_e242), _e247, _e251, _e255, _e259, _e263, _e267, _e271, _e275, _e279, _e283, (_e287 == 1u), bitcast(_e292)); + } else { + phi_646_ = type_32(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 _e296 = phi_646_; + phi_650_ = type_32(_e296.member, _e296.member_1, _e296.member_2, _e296.member_3, _e296.member_4, _e296.member_5, _e296.member_6, _e296.member_7, _e296.member_8, _e296.member_9, _e296.member_10, _e296.member_11, _e296.member_12, _e296.member_13, _e296.member_14, (_e296.member_15 && _e179.member_4), _e296.member_16); + } + let _e318 = phi_650_; + let _e322 = select(_e124, _e123, vec2((_e318.member_10 == 0u))); + let _e324 = (_e118 >= 8u); + if _e324 { + phi_3871_ = (_e318.member_5 <= (_e118 - 8u)); + } else { + phi_3871_ = false; + } + let _e328 = phi_3871_; + if _e328 { + let _e331 = global.member[_e318.member_5]; + let _e335 = global.member[(_e318.member_5 + 1u)]; + let _e340 = global.member[(_e318.member_5 + 2u)]; + let _e344 = global.member[(_e318.member_5 + 3u)]; + let _e349 = global.member[(_e318.member_5 + 4u)]; + let _e353 = global.member[(_e318.member_5 + 5u)]; + let _e357 = global.member[(_e318.member_5 + 6u)]; + switch bitcast(_e357) { + case 0: { + phi_690_ = 0u; + break; + } + case 1: { + phi_690_ = 1u; + break; + } + case 2: { + phi_690_ = 2u; + break; + } + default: { + phi_690_ = 0u; + break; + } + } + let _e360 = phi_690_; + let _e364 = global.member[(_e318.member_5 + 7u)]; + switch bitcast(_e364) { + case 0: { + phi_699_ = 0u; + break; + } + case 1: { + phi_699_ = 1u; + break; + } + case 2: { + phi_699_ = 2u; + break; + } + default: { + phi_699_ = 0u; + break; + } + } + let _e367 = phi_699_; + phi_712_ = type_33(type_24(_e360, _e367), vec2(_e331, _e335), vec2(_e340, _e344), _e349, _e353); + } else { + phi_712_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e371 = phi_712_; + switch bitcast(_e371.member.member) { + case 1: { + let _e412 = abs(_e322.x); + let _e414 = (_e412 % 1f); + if (_e412 >= 1f) { + let _e415 = (_e414 == 0f); + phi_3893_ = select(f32(), 1f, _e415); + phi_3894_ = select(true, false, _e415); + } else { + phi_3893_ = f32(); + phi_3894_ = true; + } + let _e419 = phi_3893_; + let _e421 = phi_3894_; + let _e422 = select(_e419, _e414, _e421); + if (select(-1f, 1f, (_e322.x >= 0f)) > 0f) { + phi_732_ = _e422; + } else { + phi_732_ = (1f - _e422); + } + let _e426 = phi_732_; + phi_771_ = true; + phi_772_ = _e426; + break; + } + case 2: { + let _e383 = abs(_e322.x); + let _e390 = ((select(select(u32(_e383), 0u, (_e383 < 0f)), 4294967295u, (_e383 > 4294967000f)) % 2u) == 0u); + let _e392 = (_e383 % 1f); + if (_e383 >= 1f) { + let _e393 = (_e392 == 0f); + phi_3912_ = select(f32(), 1f, _e393); + phi_3913_ = select(true, false, _e393); + } else { + phi_3912_ = f32(); + phi_3913_ = true; + } + let _e397 = phi_3912_; + let _e399 = phi_3913_; + let _e400 = select(_e397, _e392, _e399); + if (select(-1f, 1f, (_e322.x >= 0f)) > 0f) { + if _e390 { + phi_761_ = _e400; + } else { + phi_761_ = (1f - _e400); + } + let _e407 = phi_761_; + phi_767_ = _e407; + } else { + if _e390 { + phi_766_ = (1f - _e400); + } else { + phi_766_ = _e400; + } + let _e404 = phi_766_; + phi_767_ = _e404; + } + let _e409 = phi_767_; + phi_771_ = true; + phi_772_ = _e409; + break; + } + case 0: { + if (_e322.x > 1f) { + phi_3931_ = 0.9999999f; + } else { + phi_3931_ = select(_e322.x, 0.00000011920929f, (_e322.x < 0f)); + } + let _e380 = phi_3931_; + phi_771_ = true; + phi_772_ = _e380; + break; + } + default: { + phi_771_ = false; + phi_772_ = f32(); + break; + } + } + let _e428 = phi_771_; + let _e430 = phi_772_; + if _e428 { + switch bitcast(_e371.member.member_1) { + case 1: { + let _e471 = abs(_e322.y); + let _e473 = (_e471 % 1f); + if (_e471 >= 1f) { + let _e474 = (_e473 == 0f); + phi_3945_ = select(f32(), 1f, _e474); + phi_3946_ = select(true, false, _e474); + } else { + phi_3945_ = f32(); + phi_3946_ = true; + } + let _e478 = phi_3945_; + let _e480 = phi_3946_; + let _e481 = select(_e478, _e473, _e480); + if (select(-1f, 1f, (_e322.y >= 0f)) > 0f) { + phi_796_ = _e481; + } else { + phi_796_ = (1f - _e481); + } + let _e485 = phi_796_; + phi_835_ = true; + phi_836_ = _e485; + break; + } + case 2: { + let _e442 = abs(_e322.y); + let _e449 = ((select(select(u32(_e442), 0u, (_e442 < 0f)), 4294967295u, (_e442 > 4294967000f)) % 2u) == 0u); + let _e451 = (_e442 % 1f); + if (_e442 >= 1f) { + let _e452 = (_e451 == 0f); + phi_3964_ = select(f32(), 1f, _e452); + phi_3965_ = select(true, false, _e452); + } else { + phi_3964_ = f32(); + phi_3965_ = true; + } + let _e456 = phi_3964_; + let _e458 = phi_3965_; + let _e459 = select(_e456, _e451, _e458); + if (select(-1f, 1f, (_e322.y >= 0f)) > 0f) { + if _e449 { + phi_825_ = _e459; + } else { + phi_825_ = (1f - _e459); + } + let _e466 = phi_825_; + phi_831_ = _e466; + } else { + if _e449 { + phi_830_ = (1f - _e459); + } else { + phi_830_ = _e459; + } + let _e463 = phi_830_; + phi_831_ = _e463; + } + let _e468 = phi_831_; + phi_835_ = true; + phi_836_ = _e468; + break; + } + case 0: { + if (_e322.y > 1f) { + phi_3983_ = 0.9999999f; + } else { + phi_3983_ = select(_e322.y, 0.00000011920929f, (_e322.y < 0f)); + } + let _e439 = phi_3983_; + phi_835_ = true; + phi_836_ = _e439; + break; + } + default: { + phi_835_ = false; + phi_836_ = f32(); + break; + } + } + let _e487 = phi_835_; + let _e489 = phi_836_; + if _e487 { + let _e493 = (_e430 * f32(_e371.member_2.x)); + let _e502 = (_e489 * f32(_e371.member_2.y)); + let _e515 = f32(_e179.member.x); + let _e517 = f32(_e179.member.y); + let _e524 = vec3((f32((select(select(u32(_e493), 0u, (_e493 < 0f)), 4294967295u, (_e493 > 4294967000f)) + _e371.member_1.x)) / _e515), (f32((select(select(u32(_e502), 0u, (_e502 < 0f)), 4294967295u, (_e502 > 4294967000f)) + _e371.member_1.y)) / _e517), f32(_e371.member_3)); + let _e530 = textureSampleLevel(global_12, global_11, vec2(_e524.x, _e524.y), i32(_e524.z), 0f); + let _e533 = select(_e530, vec4(1f, 1f, 1f, 1f), vec4((_e318.member_5 == 4294967295u))); + let _e537 = select(_e124, _e123, vec2((_e318.member_11 == 0u))); + if _e324 { + phi_4015_ = (_e318.member_6 <= (_e118 - 8u)); + } else { + phi_4015_ = false; + } + let _e542 = phi_4015_; + if _e542 { + let _e545 = global.member[_e318.member_6]; + let _e549 = global.member[(_e318.member_6 + 1u)]; + let _e554 = global.member[(_e318.member_6 + 2u)]; + let _e558 = global.member[(_e318.member_6 + 3u)]; + let _e563 = global.member[(_e318.member_6 + 4u)]; + let _e567 = global.member[(_e318.member_6 + 5u)]; + let _e571 = global.member[(_e318.member_6 + 6u)]; + switch bitcast(_e571) { + case 0: { + phi_922_ = 0u; + break; + } + case 1: { + phi_922_ = 1u; + break; + } + case 2: { + phi_922_ = 2u; + break; + } + default: { + phi_922_ = 0u; + break; + } + } + let _e574 = phi_922_; + let _e578 = global.member[(_e318.member_6 + 7u)]; + switch bitcast(_e578) { + case 0: { + phi_931_ = 0u; + break; + } + case 1: { + phi_931_ = 1u; + break; + } + case 2: { + phi_931_ = 2u; + break; + } + default: { + phi_931_ = 0u; + break; + } + } + let _e581 = phi_931_; + phi_944_ = type_33(type_24(_e574, _e581), vec2(_e545, _e549), vec2(_e554, _e558), _e563, _e567); + } else { + phi_944_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e585 = phi_944_; + switch bitcast(_e585.member.member) { + case 1: { + let _e626 = abs(_e537.x); + let _e628 = (_e626 % 1f); + if (_e626 >= 1f) { + let _e629 = (_e628 == 0f); + phi_4036_ = select(f32(), 1f, _e629); + phi_4037_ = select(true, false, _e629); + } else { + phi_4036_ = f32(); + phi_4037_ = true; + } + let _e633 = phi_4036_; + let _e635 = phi_4037_; + let _e636 = select(_e633, _e628, _e635); + if (select(-1f, 1f, (_e537.x >= 0f)) > 0f) { + phi_964_ = _e636; + } else { + phi_964_ = (1f - _e636); + } + let _e640 = phi_964_; + phi_1003_ = true; + phi_1004_ = _e640; + break; + } + case 2: { + let _e597 = abs(_e537.x); + let _e604 = ((select(select(u32(_e597), 0u, (_e597 < 0f)), 4294967295u, (_e597 > 4294967000f)) % 2u) == 0u); + let _e606 = (_e597 % 1f); + if (_e597 >= 1f) { + let _e607 = (_e606 == 0f); + phi_4055_ = select(f32(), 1f, _e607); + phi_4056_ = select(true, false, _e607); + } else { + phi_4055_ = f32(); + phi_4056_ = true; + } + let _e611 = phi_4055_; + let _e613 = phi_4056_; + let _e614 = select(_e611, _e606, _e613); + if (select(-1f, 1f, (_e537.x >= 0f)) > 0f) { + if _e604 { + phi_993_ = _e614; + } else { + phi_993_ = (1f - _e614); + } + let _e621 = phi_993_; + phi_999_ = _e621; + } else { + if _e604 { + phi_998_ = (1f - _e614); + } else { + phi_998_ = _e614; + } + let _e618 = phi_998_; + phi_999_ = _e618; + } + let _e623 = phi_999_; + phi_1003_ = true; + phi_1004_ = _e623; + break; + } + case 0: { + if (_e537.x > 1f) { + phi_4074_ = 0.9999999f; + } else { + phi_4074_ = select(_e537.x, 0.00000011920929f, (_e537.x < 0f)); + } + let _e594 = phi_4074_; + phi_1003_ = true; + phi_1004_ = _e594; + break; + } + default: { + phi_1003_ = false; + phi_1004_ = f32(); + break; + } + } + let _e642 = phi_1003_; + let _e644 = phi_1004_; + if _e642 { + switch bitcast(_e585.member.member_1) { + case 1: { + let _e685 = abs(_e537.y); + let _e687 = (_e685 % 1f); + if (_e685 >= 1f) { + let _e688 = (_e687 == 0f); + phi_4088_ = select(f32(), 1f, _e688); + phi_4089_ = select(true, false, _e688); + } else { + phi_4088_ = f32(); + phi_4089_ = true; + } + let _e692 = phi_4088_; + let _e694 = phi_4089_; + let _e695 = select(_e692, _e687, _e694); + if (select(-1f, 1f, (_e537.y >= 0f)) > 0f) { + phi_1028_ = _e695; + } else { + phi_1028_ = (1f - _e695); + } + let _e699 = phi_1028_; + phi_1067_ = true; + phi_1068_ = _e699; + break; + } + case 2: { + let _e656 = abs(_e537.y); + let _e663 = ((select(select(u32(_e656), 0u, (_e656 < 0f)), 4294967295u, (_e656 > 4294967000f)) % 2u) == 0u); + let _e665 = (_e656 % 1f); + if (_e656 >= 1f) { + let _e666 = (_e665 == 0f); + phi_4107_ = select(f32(), 1f, _e666); + phi_4108_ = select(true, false, _e666); + } else { + phi_4107_ = f32(); + phi_4108_ = true; + } + let _e670 = phi_4107_; + let _e672 = phi_4108_; + let _e673 = select(_e670, _e665, _e672); + if (select(-1f, 1f, (_e537.y >= 0f)) > 0f) { + if _e663 { + phi_1057_ = _e673; + } else { + phi_1057_ = (1f - _e673); + } + let _e680 = phi_1057_; + phi_1063_ = _e680; + } else { + if _e663 { + phi_1062_ = (1f - _e673); + } else { + phi_1062_ = _e673; + } + let _e677 = phi_1062_; + phi_1063_ = _e677; + } + let _e682 = phi_1063_; + phi_1067_ = true; + phi_1068_ = _e682; + break; + } + case 0: { + if (_e537.y > 1f) { + phi_4126_ = 0.9999999f; + } else { + phi_4126_ = select(_e537.y, 0.00000011920929f, (_e537.y < 0f)); + } + let _e653 = phi_4126_; + phi_1067_ = true; + phi_1068_ = _e653; + break; + } + default: { + phi_1067_ = false; + phi_1068_ = f32(); + break; + } + } + let _e701 = phi_1067_; + let _e703 = phi_1068_; + if _e701 { + let _e707 = (_e644 * f32(_e585.member_2.x)); + let _e716 = (_e703 * f32(_e585.member_2.y)); + let _e734 = vec3((f32((select(select(u32(_e707), 0u, (_e707 < 0f)), 4294967295u, (_e707 > 4294967000f)) + _e585.member_1.x)) / _e515), (f32((select(select(u32(_e716), 0u, (_e716 < 0f)), 4294967295u, (_e716 > 4294967000f)) + _e585.member_1.y)) / _e517), f32(_e585.member_3)); + let _e740 = textureSampleLevel(global_12, global_11, vec2(_e734.x, _e734.y), i32(_e734.z), 0f); + let _e743 = select(_e740, vec4(1f, 1f, 1f, 1f), vec4((_e318.member_6 == 4294967295u))); + let _e747 = select(_e124, _e123, vec2((_e318.member_12 == 0u))); + if _e324 { + phi_4158_ = (_e318.member_7 <= (_e118 - 8u)); + } else { + phi_4158_ = false; + } + let _e752 = phi_4158_; + if _e752 { + let _e755 = global.member[_e318.member_7]; + let _e759 = global.member[(_e318.member_7 + 1u)]; + let _e764 = global.member[(_e318.member_7 + 2u)]; + let _e768 = global.member[(_e318.member_7 + 3u)]; + let _e773 = global.member[(_e318.member_7 + 4u)]; + let _e777 = global.member[(_e318.member_7 + 5u)]; + let _e781 = global.member[(_e318.member_7 + 6u)]; + switch bitcast(_e781) { + case 0: { + phi_1154_ = 0u; + break; + } + case 1: { + phi_1154_ = 1u; + break; + } + case 2: { + phi_1154_ = 2u; + break; + } + default: { + phi_1154_ = 0u; + break; + } + } + let _e784 = phi_1154_; + let _e788 = global.member[(_e318.member_7 + 7u)]; + switch bitcast(_e788) { + case 0: { + phi_1163_ = 0u; + break; + } + case 1: { + phi_1163_ = 1u; + break; + } + case 2: { + phi_1163_ = 2u; + break; + } + default: { + phi_1163_ = 0u; + break; + } + } + let _e791 = phi_1163_; + phi_1176_ = type_33(type_24(_e784, _e791), vec2(_e755, _e759), vec2(_e764, _e768), _e773, _e777); + } else { + phi_1176_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e795 = phi_1176_; + switch bitcast(_e795.member.member) { + case 1: { + let _e836 = abs(_e747.x); + let _e838 = (_e836 % 1f); + if (_e836 >= 1f) { + let _e839 = (_e838 == 0f); + phi_4179_ = select(f32(), 1f, _e839); + phi_4180_ = select(true, false, _e839); + } else { + phi_4179_ = f32(); + phi_4180_ = true; + } + let _e843 = phi_4179_; + let _e845 = phi_4180_; + let _e846 = select(_e843, _e838, _e845); + if (select(-1f, 1f, (_e747.x >= 0f)) > 0f) { + phi_1196_ = _e846; + } else { + phi_1196_ = (1f - _e846); + } + let _e850 = phi_1196_; + phi_1235_ = true; + phi_1236_ = _e850; + break; + } + case 2: { + let _e807 = abs(_e747.x); + let _e814 = ((select(select(u32(_e807), 0u, (_e807 < 0f)), 4294967295u, (_e807 > 4294967000f)) % 2u) == 0u); + let _e816 = (_e807 % 1f); + if (_e807 >= 1f) { + let _e817 = (_e816 == 0f); + phi_4198_ = select(f32(), 1f, _e817); + phi_4199_ = select(true, false, _e817); + } else { + phi_4198_ = f32(); + phi_4199_ = true; + } + let _e821 = phi_4198_; + let _e823 = phi_4199_; + let _e824 = select(_e821, _e816, _e823); + if (select(-1f, 1f, (_e747.x >= 0f)) > 0f) { + if _e814 { + phi_1225_ = _e824; + } else { + phi_1225_ = (1f - _e824); + } + let _e831 = phi_1225_; + phi_1231_ = _e831; + } else { + if _e814 { + phi_1230_ = (1f - _e824); + } else { + phi_1230_ = _e824; + } + let _e828 = phi_1230_; + phi_1231_ = _e828; + } + let _e833 = phi_1231_; + phi_1235_ = true; + phi_1236_ = _e833; + break; + } + case 0: { + if (_e747.x > 1f) { + phi_4217_ = 0.9999999f; + } else { + phi_4217_ = select(_e747.x, 0.00000011920929f, (_e747.x < 0f)); + } + let _e804 = phi_4217_; + phi_1235_ = true; + phi_1236_ = _e804; + break; + } + default: { + phi_1235_ = false; + phi_1236_ = f32(); + break; + } + } + let _e852 = phi_1235_; + let _e854 = phi_1236_; + if _e852 { + switch bitcast(_e795.member.member_1) { + case 1: { + let _e895 = abs(_e747.y); + let _e897 = (_e895 % 1f); + if (_e895 >= 1f) { + let _e898 = (_e897 == 0f); + phi_4231_ = select(f32(), 1f, _e898); + phi_4232_ = select(true, false, _e898); + } else { + phi_4231_ = f32(); + phi_4232_ = true; + } + let _e902 = phi_4231_; + let _e904 = phi_4232_; + let _e905 = select(_e902, _e897, _e904); + if (select(-1f, 1f, (_e747.y >= 0f)) > 0f) { + phi_1260_ = _e905; + } else { + phi_1260_ = (1f - _e905); + } + let _e909 = phi_1260_; + phi_1299_ = true; + phi_1300_ = _e909; + break; + } + case 2: { + let _e866 = abs(_e747.y); + let _e873 = ((select(select(u32(_e866), 0u, (_e866 < 0f)), 4294967295u, (_e866 > 4294967000f)) % 2u) == 0u); + let _e875 = (_e866 % 1f); + if (_e866 >= 1f) { + let _e876 = (_e875 == 0f); + phi_4250_ = select(f32(), 1f, _e876); + phi_4251_ = select(true, false, _e876); + } else { + phi_4250_ = f32(); + phi_4251_ = true; + } + let _e880 = phi_4250_; + let _e882 = phi_4251_; + let _e883 = select(_e880, _e875, _e882); + if (select(-1f, 1f, (_e747.y >= 0f)) > 0f) { + if _e873 { + phi_1289_ = _e883; + } else { + phi_1289_ = (1f - _e883); + } + let _e890 = phi_1289_; + phi_1295_ = _e890; + } else { + if _e873 { + phi_1294_ = (1f - _e883); + } else { + phi_1294_ = _e883; + } + let _e887 = phi_1294_; + phi_1295_ = _e887; + } + let _e892 = phi_1295_; + phi_1299_ = true; + phi_1300_ = _e892; + break; + } + case 0: { + if (_e747.y > 1f) { + phi_4269_ = 0.9999999f; + } else { + phi_4269_ = select(_e747.y, 0.00000011920929f, (_e747.y < 0f)); + } + let _e863 = phi_4269_; + phi_1299_ = true; + phi_1300_ = _e863; + break; + } + default: { + phi_1299_ = false; + phi_1300_ = f32(); + break; + } + } + let _e911 = phi_1299_; + let _e913 = phi_1300_; + if _e911 { + let _e917 = (_e854 * f32(_e795.member_2.x)); + let _e926 = (_e913 * f32(_e795.member_2.y)); + let _e944 = vec3((f32((select(select(u32(_e917), 0u, (_e917 < 0f)), 4294967295u, (_e917 > 4294967000f)) + _e795.member_1.x)) / _e515), (f32((select(select(u32(_e926), 0u, (_e926 < 0f)), 4294967295u, (_e926 > 4294967000f)) + _e795.member_1.y)) / _e517), f32(_e795.member_3)); + let _e950 = textureSampleLevel(global_12, global_11, vec2(_e944.x, _e944.y), i32(_e944.z), 0f); + let _e951 = (_e318.member_7 == 4294967295u); + let _e953 = select(_e950, vec4(1f, 1f, 1f, 1f), vec4(_e951)); + let _e957 = select(_e124, _e123, vec2((_e318.member_13 == 0u))); + if _e324 { + phi_4301_ = (_e318.member_8 <= (_e118 - 8u)); + } else { + phi_4301_ = false; + } + let _e962 = phi_4301_; + if _e962 { + let _e965 = global.member[_e318.member_8]; + let _e969 = global.member[(_e318.member_8 + 1u)]; + let _e974 = global.member[(_e318.member_8 + 2u)]; + let _e978 = global.member[(_e318.member_8 + 3u)]; + let _e983 = global.member[(_e318.member_8 + 4u)]; + let _e987 = global.member[(_e318.member_8 + 5u)]; + let _e991 = global.member[(_e318.member_8 + 6u)]; + switch bitcast(_e991) { + case 0: { + phi_1386_ = 0u; + break; + } + case 1: { + phi_1386_ = 1u; + break; + } + case 2: { + phi_1386_ = 2u; + break; + } + default: { + phi_1386_ = 0u; + break; + } + } + let _e994 = phi_1386_; + let _e998 = global.member[(_e318.member_8 + 7u)]; + switch bitcast(_e998) { + case 0: { + phi_1395_ = 0u; + break; + } + case 1: { + phi_1395_ = 1u; + break; + } + case 2: { + phi_1395_ = 2u; + break; + } + default: { + phi_1395_ = 0u; + break; + } + } + let _e1001 = phi_1395_; + phi_1408_ = type_33(type_24(_e994, _e1001), vec2(_e965, _e969), vec2(_e974, _e978), _e983, _e987); + } else { + phi_1408_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e1005 = phi_1408_; + switch bitcast(_e1005.member.member) { + case 1: { + let _e1046 = abs(_e957.x); + let _e1048 = (_e1046 % 1f); + if (_e1046 >= 1f) { + let _e1049 = (_e1048 == 0f); + phi_4322_ = select(f32(), 1f, _e1049); + phi_4323_ = select(true, false, _e1049); + } else { + phi_4322_ = f32(); + phi_4323_ = true; + } + let _e1053 = phi_4322_; + let _e1055 = phi_4323_; + let _e1056 = select(_e1053, _e1048, _e1055); + if (select(-1f, 1f, (_e957.x >= 0f)) > 0f) { + phi_1428_ = _e1056; + } else { + phi_1428_ = (1f - _e1056); + } + let _e1060 = phi_1428_; + phi_1467_ = true; + phi_1468_ = _e1060; + break; + } + case 2: { + let _e1017 = abs(_e957.x); + let _e1024 = ((select(select(u32(_e1017), 0u, (_e1017 < 0f)), 4294967295u, (_e1017 > 4294967000f)) % 2u) == 0u); + let _e1026 = (_e1017 % 1f); + if (_e1017 >= 1f) { + let _e1027 = (_e1026 == 0f); + phi_4341_ = select(f32(), 1f, _e1027); + phi_4342_ = select(true, false, _e1027); + } else { + phi_4341_ = f32(); + phi_4342_ = true; + } + let _e1031 = phi_4341_; + let _e1033 = phi_4342_; + let _e1034 = select(_e1031, _e1026, _e1033); + if (select(-1f, 1f, (_e957.x >= 0f)) > 0f) { + if _e1024 { + phi_1457_ = _e1034; + } else { + phi_1457_ = (1f - _e1034); + } + let _e1041 = phi_1457_; + phi_1463_ = _e1041; + } else { + if _e1024 { + phi_1462_ = (1f - _e1034); + } else { + phi_1462_ = _e1034; + } + let _e1038 = phi_1462_; + phi_1463_ = _e1038; + } + let _e1043 = phi_1463_; + phi_1467_ = true; + phi_1468_ = _e1043; + break; + } + case 0: { + if (_e957.x > 1f) { + phi_4360_ = 0.9999999f; + } else { + phi_4360_ = select(_e957.x, 0.00000011920929f, (_e957.x < 0f)); + } + let _e1014 = phi_4360_; + phi_1467_ = true; + phi_1468_ = _e1014; + break; + } + default: { + phi_1467_ = false; + phi_1468_ = f32(); + break; + } + } + let _e1062 = phi_1467_; + let _e1064 = phi_1468_; + if _e1062 { + switch bitcast(_e1005.member.member_1) { + case 1: { + let _e1105 = abs(_e957.y); + let _e1107 = (_e1105 % 1f); + if (_e1105 >= 1f) { + let _e1108 = (_e1107 == 0f); + phi_4374_ = select(f32(), 1f, _e1108); + phi_4375_ = select(true, false, _e1108); + } else { + phi_4374_ = f32(); + phi_4375_ = true; + } + let _e1112 = phi_4374_; + let _e1114 = phi_4375_; + let _e1115 = select(_e1112, _e1107, _e1114); + if (select(-1f, 1f, (_e957.y >= 0f)) > 0f) { + phi_1492_ = _e1115; + } else { + phi_1492_ = (1f - _e1115); + } + let _e1119 = phi_1492_; + phi_1531_ = true; + phi_1532_ = _e1119; + break; + } + case 2: { + let _e1076 = abs(_e957.y); + let _e1083 = ((select(select(u32(_e1076), 0u, (_e1076 < 0f)), 4294967295u, (_e1076 > 4294967000f)) % 2u) == 0u); + let _e1085 = (_e1076 % 1f); + if (_e1076 >= 1f) { + let _e1086 = (_e1085 == 0f); + phi_4393_ = select(f32(), 1f, _e1086); + phi_4394_ = select(true, false, _e1086); + } else { + phi_4393_ = f32(); + phi_4394_ = true; + } + let _e1090 = phi_4393_; + let _e1092 = phi_4394_; + let _e1093 = select(_e1090, _e1085, _e1092); + if (select(-1f, 1f, (_e957.y >= 0f)) > 0f) { + if _e1083 { + phi_1521_ = _e1093; + } else { + phi_1521_ = (1f - _e1093); + } + let _e1100 = phi_1521_; + phi_1527_ = _e1100; + } else { + if _e1083 { + phi_1526_ = (1f - _e1093); + } else { + phi_1526_ = _e1093; + } + let _e1097 = phi_1526_; + phi_1527_ = _e1097; + } + let _e1102 = phi_1527_; + phi_1531_ = true; + phi_1532_ = _e1102; + break; + } + case 0: { + if (_e957.y > 1f) { + phi_4412_ = 0.9999999f; + } else { + phi_4412_ = select(_e957.y, 0.00000011920929f, (_e957.y < 0f)); + } + let _e1073 = phi_4412_; + phi_1531_ = true; + phi_1532_ = _e1073; + break; + } + default: { + phi_1531_ = false; + phi_1532_ = f32(); + break; + } + } + let _e1121 = phi_1531_; + let _e1123 = phi_1532_; + if _e1121 { + let _e1127 = (_e1064 * f32(_e1005.member_2.x)); + let _e1136 = (_e1123 * f32(_e1005.member_2.y)); + let _e1154 = vec3((f32((select(select(u32(_e1127), 0u, (_e1127 < 0f)), 4294967295u, (_e1127 > 4294967000f)) + _e1005.member_1.x)) / _e515), (f32((select(select(u32(_e1136), 0u, (_e1136 < 0f)), 4294967295u, (_e1136 > 4294967000f)) + _e1005.member_1.y)) / _e517), f32(_e1005.member_3)); + let _e1160 = textureSampleLevel(global_12, global_11, vec2(_e1154.x, _e1154.y), i32(_e1154.z), 0f); + let _e1167 = select(_e124, _e123, vec2((_e318.member_14 == 0u))); + if _e324 { + phi_4444_ = (_e318.member_9 <= (_e118 - 8u)); + } else { + phi_4444_ = false; + } + let _e1172 = phi_4444_; + if _e1172 { + let _e1175 = global.member[_e318.member_9]; + let _e1179 = global.member[(_e318.member_9 + 1u)]; + let _e1184 = global.member[(_e318.member_9 + 2u)]; + let _e1188 = global.member[(_e318.member_9 + 3u)]; + let _e1193 = global.member[(_e318.member_9 + 4u)]; + let _e1197 = global.member[(_e318.member_9 + 5u)]; + let _e1201 = global.member[(_e318.member_9 + 6u)]; + switch bitcast(_e1201) { + case 0: { + phi_1618_ = 0u; + break; + } + case 1: { + phi_1618_ = 1u; + break; + } + case 2: { + phi_1618_ = 2u; + break; + } + default: { + phi_1618_ = 0u; + break; + } + } + let _e1204 = phi_1618_; + let _e1208 = global.member[(_e318.member_9 + 7u)]; + switch bitcast(_e1208) { + case 0: { + phi_1627_ = 0u; + break; + } + case 1: { + phi_1627_ = 1u; + break; + } + case 2: { + phi_1627_ = 2u; + break; + } + default: { + phi_1627_ = 0u; + break; + } + } + let _e1211 = phi_1627_; + phi_1640_ = type_33(type_24(_e1204, _e1211), vec2(_e1175, _e1179), vec2(_e1184, _e1188), _e1193, _e1197); + } else { + phi_1640_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e1215 = phi_1640_; + switch bitcast(_e1215.member.member) { + case 1: { + let _e1256 = abs(_e1167.x); + let _e1258 = (_e1256 % 1f); + if (_e1256 >= 1f) { + let _e1259 = (_e1258 == 0f); + phi_4465_ = select(f32(), 1f, _e1259); + phi_4466_ = select(true, false, _e1259); + } else { + phi_4465_ = f32(); + phi_4466_ = true; + } + let _e1263 = phi_4465_; + let _e1265 = phi_4466_; + let _e1266 = select(_e1263, _e1258, _e1265); + if (select(-1f, 1f, (_e1167.x >= 0f)) > 0f) { + phi_1660_ = _e1266; + } else { + phi_1660_ = (1f - _e1266); + } + let _e1270 = phi_1660_; + phi_1699_ = true; + phi_1700_ = _e1270; + break; + } + case 2: { + let _e1227 = abs(_e1167.x); + let _e1234 = ((select(select(u32(_e1227), 0u, (_e1227 < 0f)), 4294967295u, (_e1227 > 4294967000f)) % 2u) == 0u); + let _e1236 = (_e1227 % 1f); + if (_e1227 >= 1f) { + let _e1237 = (_e1236 == 0f); + phi_4484_ = select(f32(), 1f, _e1237); + phi_4485_ = select(true, false, _e1237); + } else { + phi_4484_ = f32(); + phi_4485_ = true; + } + let _e1241 = phi_4484_; + let _e1243 = phi_4485_; + let _e1244 = select(_e1241, _e1236, _e1243); + if (select(-1f, 1f, (_e1167.x >= 0f)) > 0f) { + if _e1234 { + phi_1689_ = _e1244; + } else { + phi_1689_ = (1f - _e1244); + } + let _e1251 = phi_1689_; + phi_1695_ = _e1251; + } else { + if _e1234 { + phi_1694_ = (1f - _e1244); + } else { + phi_1694_ = _e1244; + } + let _e1248 = phi_1694_; + phi_1695_ = _e1248; + } + let _e1253 = phi_1695_; + phi_1699_ = true; + phi_1700_ = _e1253; + break; + } + case 0: { + if (_e1167.x > 1f) { + phi_4503_ = 0.9999999f; + } else { + phi_4503_ = select(_e1167.x, 0.00000011920929f, (_e1167.x < 0f)); + } + let _e1224 = phi_4503_; + phi_1699_ = true; + phi_1700_ = _e1224; + break; + } + default: { + phi_1699_ = false; + phi_1700_ = f32(); + break; + } + } + let _e1272 = phi_1699_; + let _e1274 = phi_1700_; + if _e1272 { + switch bitcast(_e1215.member.member_1) { + case 1: { + let _e1315 = abs(_e1167.y); + let _e1317 = (_e1315 % 1f); + if (_e1315 >= 1f) { + let _e1318 = (_e1317 == 0f); + phi_4517_ = select(f32(), 1f, _e1318); + phi_4518_ = select(true, false, _e1318); + } else { + phi_4517_ = f32(); + phi_4518_ = true; + } + let _e1322 = phi_4517_; + let _e1324 = phi_4518_; + let _e1325 = select(_e1322, _e1317, _e1324); + if (select(-1f, 1f, (_e1167.y >= 0f)) > 0f) { + phi_1724_ = _e1325; + } else { + phi_1724_ = (1f - _e1325); + } + let _e1329 = phi_1724_; + phi_1763_ = true; + phi_1764_ = _e1329; + break; + } + case 2: { + let _e1286 = abs(_e1167.y); + let _e1293 = ((select(select(u32(_e1286), 0u, (_e1286 < 0f)), 4294967295u, (_e1286 > 4294967000f)) % 2u) == 0u); + let _e1295 = (_e1286 % 1f); + if (_e1286 >= 1f) { + let _e1296 = (_e1295 == 0f); + phi_4536_ = select(f32(), 1f, _e1296); + phi_4537_ = select(true, false, _e1296); + } else { + phi_4536_ = f32(); + phi_4537_ = true; + } + let _e1300 = phi_4536_; + let _e1302 = phi_4537_; + let _e1303 = select(_e1300, _e1295, _e1302); + if (select(-1f, 1f, (_e1167.y >= 0f)) > 0f) { + if _e1293 { + phi_1753_ = _e1303; + } else { + phi_1753_ = (1f - _e1303); + } + let _e1310 = phi_1753_; + phi_1759_ = _e1310; + } else { + if _e1293 { + phi_1758_ = (1f - _e1303); + } else { + phi_1758_ = _e1303; + } + let _e1307 = phi_1758_; + phi_1759_ = _e1307; + } + let _e1312 = phi_1759_; + phi_1763_ = true; + phi_1764_ = _e1312; + break; + } + case 0: { + if (_e1167.y > 1f) { + phi_4555_ = 0.9999999f; + } else { + phi_4555_ = select(_e1167.y, 0.00000011920929f, (_e1167.y < 0f)); + } + let _e1283 = phi_4555_; + phi_1763_ = true; + phi_1764_ = _e1283; + break; + } + default: { + phi_1763_ = false; + phi_1764_ = f32(); + break; + } + } + let _e1331 = phi_1763_; + let _e1333 = phi_1764_; + if _e1331 { + let _e1337 = (_e1274 * f32(_e1215.member_2.x)); + let _e1346 = (_e1333 * f32(_e1215.member_2.y)); + let _e1364 = vec3((f32((select(select(u32(_e1337), 0u, (_e1337 < 0f)), 4294967295u, (_e1337 > 4294967000f)) + _e1215.member_1.x)) / _e515), (f32((select(select(u32(_e1346), 0u, (_e1346 < 0f)), 4294967295u, (_e1346 > 4294967000f)) + _e1215.member_1.y)) / _e517), f32(_e1215.member_3)); + let _e1370 = textureSampleLevel(global_12, global_11, vec2(_e1364.x, _e1364.y), i32(_e1364.z), 0f); + let _e1373 = select(_e1370, vec4(1f, 1f, 1f, 1f), vec4((_e318.member_9 == 4294967295u))); + if _e951 { + phi_1861_ = vec3(0f, 0f, 0f); + phi_1862_ = _e125; + } else { + let _e1377 = fma(_e953.x, 2f, -1f); + let _e1378 = fma(_e953.y, 2f, -1f); + let _e1379 = fma(_e953.z, 2f, -1f); + let _e1384 = sqrt(fma(_e1379, _e1379, fma(_e1377, _e1377, (_e1378 * _e1378)))); + if (_e1384 == 0f) { + phi_4609_ = vec3(0f, 0f, 0f); + } else { + phi_4609_ = (vec3(_e1377, _e1378, _e1379) * (1f / _e1384)); + } + let _e1389 = phi_4609_; + let _e1396 = sqrt(fma(_e126.z, _e126.z, fma(_e126.x, _e126.x, (_e126.y * _e126.y)))); + if (_e1396 == 0f) { + phi_4644_ = vec3(0f, 0f, 0f); + } else { + phi_4644_ = (_e126 * (1f / _e1396)); + } + let _e1401 = phi_4644_; + let _e1408 = sqrt(fma(_e127.z, _e127.z, fma(_e127.x, _e127.x, (_e127.y * _e127.y)))); + if (_e1408 == 0f) { + phi_4679_ = vec3(0f, 0f, 0f); + } else { + phi_4679_ = (_e127 * (1f / _e1408)); + } + let _e1413 = phi_4679_; + let _e1420 = sqrt(fma(_e125.z, _e125.z, fma(_e125.x, _e125.x, (_e125.y * _e125.y)))); + if (_e1420 == 0f) { + phi_4714_ = vec3(0f, 0f, 0f); + } else { + phi_4714_ = (_e125 * (1f / _e1420)); + } + let _e1425 = phi_4714_; + let _e1444 = fma(_e1425.x, _e1389.z, fma(_e1401.x, _e1389.x, (_e1413.x * _e1389.y))); + let _e1445 = fma(_e1425.y, _e1389.z, fma(_e1401.y, _e1389.x, (_e1413.y * _e1389.y))); + let _e1446 = fma(_e1425.z, _e1389.z, fma(_e1401.z, _e1389.x, (_e1413.z * _e1389.y))); + let _e1451 = sqrt(fma(_e1446, _e1446, fma(_e1444, _e1444, (_e1445 * _e1445)))); + if (_e1451 == 0f) { + phi_4749_ = vec3(0f, 0f, 0f); + } else { + phi_4749_ = (vec3(_e1444, _e1445, _e1446) * (1f / _e1451)); + } + let _e1456 = phi_4749_; + phi_1861_ = _e1389; + phi_1862_ = _e1456; + } + let _e1458 = phi_1861_; + let _e1460 = phi_1862_; + let _e1464 = (_e533.x * _e318.member_2.x); + let _e1467 = (_e533.y * _e318.member_2.y); + let _e1470 = (_e533.z * _e318.member_2.z); + let _e1475 = (_e1464 * _e122.x); + let _e1477 = (_e1467 * _e122.y); + let _e1479 = (_e1470 * _e122.z); + let _e1484 = (_e743.y * _e318.member_4); + let _e1487 = (_e743.z * _e318.member_3); + let _e1491 = fma(_e318.member_16, (select(_e1160, vec4(1f, 1f, 1f, 1f), vec4((_e318.member_8 == 4294967295u))).x - 1f), 1f); + let _e1497 = (_e1373.x * _e318.member.x); + let _e1499 = (_e1373.y * _e318.member.y); + let _e1501 = (_e1373.z * _e318.member.z); + let _e1506 = textureSampleLevel(global_13, global_14, _e1460, 0f); + if (_e118 >= 83u) { + phi_4781_ = (_e119 <= (_e118 - 83u)); + } else { + phi_4781_ = false; + } + let _e1514 = phi_4781_; + if _e1514 { + let _e1517 = global.member[_e119]; + let _e1522 = global.member[(_e119 + 1u)]; + let _e1527 = global.member[(_e119 + 2u)]; + let _e1532 = global.member[(_e119 + 3u)]; + let _e1538 = global.member[(_e119 + 4u)]; + let _e1543 = global.member[(_e119 + 5u)]; + let _e1548 = global.member[(_e119 + 6u)]; + let _e1553 = global.member[(_e119 + 7u)]; + let _e1559 = global.member[(_e119 + 8u)]; + let _e1564 = global.member[(_e119 + 9u)]; + let _e1569 = global.member[(_e119 + 10u)]; + let _e1574 = global.member[(_e119 + 11u)]; + let _e1580 = global.member[(_e119 + 12u)]; + let _e1585 = global.member[(_e119 + 13u)]; + let _e1590 = global.member[(_e119 + 14u)]; + let _e1595 = global.member[(_e119 + 15u)]; + let _e1602 = global.member[(_e119 + 16u)]; + let _e1607 = global.member[(_e119 + 17u)]; + let _e1612 = global.member[(_e119 + 18u)]; + let _e1617 = global.member[(_e119 + 19u)]; + let _e1623 = global.member[(_e119 + 20u)]; + let _e1628 = global.member[(_e119 + 21u)]; + let _e1633 = global.member[(_e119 + 22u)]; + let _e1638 = global.member[(_e119 + 23u)]; + let _e1644 = global.member[(_e119 + 24u)]; + let _e1649 = global.member[(_e119 + 25u)]; + let _e1654 = global.member[(_e119 + 26u)]; + let _e1659 = global.member[(_e119 + 27u)]; + let _e1665 = global.member[(_e119 + 28u)]; + let _e1670 = global.member[(_e119 + 29u)]; + let _e1675 = global.member[(_e119 + 30u)]; + let _e1680 = global.member[(_e119 + 31u)]; + let _e1687 = global.member[(_e119 + 32u)]; + let _e1692 = global.member[(_e119 + 33u)]; + let _e1697 = global.member[(_e119 + 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_2068_ = type_24(0u, 6u); + loop { + let _e1702 = phi_2068_; + if (_e1702.member < _e1702.member_1) { + phi_2084_ = type_24((_e1702.member + 1u), _e1702.member_1); + phi_2085_ = type_24(1u, _e1702.member); + } else { + phi_2084_ = _e1702; + phi_2085_ = type_24(0u, type_24().member_1); + } + let _e1715 = phi_2084_; + let _e1717 = phi_2085_; + switch bitcast(_e1717.member) { + case 0: { + let _e1744 = 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_2098_ = type_24(0u, 8u); + loop { + let _e1747 = phi_2098_; + if (_e1747.member < _e1747.member_1) { + phi_2114_ = type_24((_e1747.member + 1u), _e1747.member_1); + phi_2115_ = type_24(1u, _e1747.member); + } else { + phi_2114_ = _e1747; + phi_2115_ = type_24(0u, type_24().member_1); + } + let _e1760 = phi_2114_; + let _e1762 = phi_2115_; + switch bitcast(_e1762.member) { + case 0: { + let _e1784 = local; + phi_2141_ = type_22(type_20(vec4(bitcast(_e1517), bitcast(_e1522), bitcast(_e1527), bitcast(_e1532)), vec4(bitcast(_e1538), bitcast(_e1543), bitcast(_e1548), bitcast(_e1553)), vec4(bitcast(_e1559), bitcast(_e1564), bitcast(_e1569), bitcast(_e1574)), vec4(bitcast(_e1580), bitcast(_e1585), bitcast(_e1590), bitcast(_e1595))), type_20(vec4(bitcast(_e1602), bitcast(_e1607), bitcast(_e1612), bitcast(_e1617)), vec4(bitcast(_e1623), bitcast(_e1628), bitcast(_e1633), bitcast(_e1638)), vec4(bitcast(_e1644), bitcast(_e1649), bitcast(_e1654), bitcast(_e1659)), vec4(bitcast(_e1665), bitcast(_e1670), bitcast(_e1675), bitcast(_e1680))), type_21(_e1784, _e1744), vec3(bitcast(_e1687), bitcast(_e1692), bitcast(_e1697))); + phi_2142_ = false; + phi_2099_ = type_24(); + break; + } + case 1: { + let _e1767 = ((_e119 + 59u) + (_e1762.member_1 * 3u)); + let _e1770 = global.member[_e1767]; + let _e1775 = global.member[(_e1767 + 1u)]; + let _e1780 = global.member[(_e1767 + 2u)]; + local[_e1762.member_1] = vec3(bitcast(_e1770), bitcast(_e1775), bitcast(_e1780)); + phi_2141_ = type_22(); + phi_2142_ = true; + phi_2099_ = _e1760; + break; + } + default: { + phi_2141_ = type_22(); + phi_2142_ = false; + phi_2099_ = type_24(); + break; + } + } + let _e1788 = phi_2141_; + let _e1790 = phi_2142_; + let _e1792 = phi_2099_; + local_2 = _e1788; + continue; + continuing { + phi_2098_ = _e1792; + break if !(_e1790); + } + } + let _e3177 = local_2; + phi_2162_ = _e3177; + phi_2163_ = false; + phi_2069_ = type_24(); + break; + } + case 1: { + let _e1722 = ((_e119 + 35u) + (_e1717.member_1 * 4u)); + let _e1725 = global.member[_e1722]; + let _e1730 = global.member[(_e1722 + 1u)]; + let _e1735 = global.member[(_e1722 + 2u)]; + let _e1740 = global.member[(_e1722 + 3u)]; + local_1[_e1717.member_1] = vec4(bitcast(_e1725), bitcast(_e1730), bitcast(_e1735), bitcast(_e1740)); + phi_2162_ = type_22(); + phi_2163_ = true; + phi_2069_ = _e1715; + break; + } + default: { + phi_2162_ = type_22(); + phi_2163_ = false; + phi_2069_ = type_24(); + break; + } + } + let _e1795 = phi_2162_; + let _e1797 = phi_2163_; + let _e1799 = phi_2069_; + local_3 = _e1795; + continue; + continuing { + phi_2068_ = _e1799; + break if !(_e1797); + } + } + let _e3182 = local_3; + phi_2168_ = _e3182; + } else { + phi_2168_ = type_22(type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_21(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 _e1802 = phi_2168_; + let _e1804 = (_e1802.member_3 - _e128); + let _e1811 = sqrt(fma(_e1804.z, _e1804.z, fma(_e1804.x, _e1804.x, (_e1804.y * _e1804.y)))); + let _e1812 = (_e1811 == 0f); + if _e1812 { + phi_4853_ = vec3(0f, 0f, 0f); + } else { + phi_4853_ = (_e1804 * (1f / _e1811)); + } + let _e1816 = phi_4853_; + let _e1817 = -(_e1816); + let _e1824 = sqrt(fma(_e1460.z, _e1460.z, fma(_e1460.x, _e1460.x, (_e1460.y * _e1460.y)))); + let _e1825 = (_e1824 == 0f); + if _e1825 { + phi_4912_ = vec3(0f, 0f, 0f); + } else { + phi_4912_ = (_e1460 * (1f / _e1824)); + } + let _e1829 = phi_4912_; + let _e1839 = (2f * fma(_e1829.z, _e1817.z, fma(_e1829.x, _e1817.x, (_e1829.y * _e1817.y)))); + let _e1846 = textureSampleLevel(global_15, global_16, (_e1817 - vec3((_e1839 * _e1829.x), (_e1839 * _e1829.y), (_e1839 * _e1829.z))), (_e1484 * 4f)); + if _e1812 { + phi_4986_ = vec3(0f, 0f, 0f); + } else { + phi_4986_ = (_e1804 * (1f / _e1811)); + } + let _e1853 = phi_4986_; + let _e1862 = textureSampleLevel(global_17, global_18, vec2(max(fma(_e1460.z, _e1853.z, fma(_e1460.x, _e1853.x, (_e1460.y * _e1853.y))), 0f), _e1484), 0f); + switch bitcast(_e179.member_3) { + case 0: { + if _e318.member_15 { + if _e1825 { + phi_5036_ = vec3(0f, 0f, 0f); + } else { + phi_5036_ = (_e1460 * (1f / _e1824)); + } + let _e2031 = phi_5036_; + if _e1812 { + phi_5071_ = vec3(0f, 0f, 0f); + } else { + phi_5071_ = (_e1804 * (1f / _e1811)); + } + let _e2035 = phi_5071_; + phi_2208_ = type_24(0u, _e179.member_2.member_1); + phi_2211_ = vec3(0f, 0f, 0f); + loop { + let _e2038 = phi_2208_; + let _e2040 = phi_2211_; + if (_e2038.member < _e2038.member_1) { + phi_2226_ = type_24((_e2038.member + 1u), _e2038.member_1); + phi_2227_ = type_24(1u, _e2038.member); + } else { + phi_2226_ = _e2038; + phi_2227_ = type_24(0u, type_24().member_1); + } + let _e2053 = phi_2226_; + let _e2055 = phi_2227_; + switch bitcast(_e2055.member) { + case 0: { + phi_3101_ = false; + phi_3102_ = true; + phi_3103_ = false; + phi_3104_ = type_24(); + phi_3105_ = vec3(); + break; + } + case 1: { + if (_e2055.member_1 >= _e179.member_2.member_1) { + phi_5088_ = 4294967295u; + } else { + phi_5088_ = (_e179.member_2.member + _e2055.member_1); + } + let _e2062 = phi_5088_; + if (_e118 >= 1u) { + phi_5107_ = (_e2062 <= (_e118 - 1u)); + } else { + phi_5107_ = false; + } + let _e2067 = phi_5107_; + if _e2067 { + let _e2070 = global.member[_e2062]; + phi_2244_ = _e2070; + } else { + phi_2244_ = 4294967295u; + } + let _e2072 = phi_2244_; + let _e2073 = (_e2072 == 4294967295u); + if _e2073 { + phi_3097_ = false; + phi_3098_ = type_24(); + phi_3099_ = vec3(); + phi_3100_ = false; + } else { + if (_e118 >= 3u) { + phi_5139_ = (_e2072 <= (_e118 - 3u)); + } else { + phi_5139_ = false; + } + let _e2078 = phi_5139_; + if _e2078 { + let _e2081 = global.member[_e2072]; + switch bitcast(_e2081) { + case 0: { + phi_2261_ = 0u; + break; + } + case 1: { + phi_2261_ = 1u; + break; + } + case 2: { + phi_2261_ = 2u; + break; + } + default: { + phi_2261_ = 0u; + break; + } + } + let _e2084 = phi_2261_; + let _e2088 = global.member[(_e2072 + 1u)]; + let _e2092 = global.member[(_e2072 + 2u)]; + phi_2271_ = type_34(_e2084, _e2088, _e2092); + } else { + phi_2271_ = type_34(0u, 4294967295u, 4294967295u); + } + let _e2095 = phi_2271_; + if (_e118 >= 10u) { + phi_5169_ = (_e2095.member_2 <= (_e118 - 10u)); + } else { + phi_5169_ = false; + } + let _e2101 = phi_5169_; + if _e2101 { + let _e2104 = global.member[_e2095.member_2]; + let _e2109 = global.member[(_e2095.member_2 + 1u)]; + let _e2114 = global.member[(_e2095.member_2 + 2u)]; + let _e2120 = global.member[(_e2095.member_2 + 3u)]; + let _e2125 = global.member[(_e2095.member_2 + 4u)]; + let _e2130 = global.member[(_e2095.member_2 + 5u)]; + let _e2135 = global.member[(_e2095.member_2 + 6u)]; + let _e2141 = global.member[(_e2095.member_2 + 7u)]; + let _e2146 = global.member[(_e2095.member_2 + 8u)]; + let _e2151 = global.member[(_e2095.member_2 + 9u)]; + phi_2321_ = type_28(vec3(bitcast(_e2104), bitcast(_e2109), bitcast(_e2114)), vec4(bitcast(_e2120), bitcast(_e2125), bitcast(_e2130), bitcast(_e2135)), vec3(bitcast(_e2141), bitcast(_e2146), bitcast(_e2151))); + } else { + phi_2321_ = type_28(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e2156 = phi_2321_; + let _e2164 = (_e2156.member_1.x + _e2156.member_1.x); + let _e2165 = (_e2156.member_1.y + _e2156.member_1.y); + let _e2166 = (_e2156.member_1.z + _e2156.member_1.z); + let _e2168 = (_e2156.member_1.z * _e2166); + let _e2169 = (_e2156.member_1.w * _e2164); + let _e2170 = (_e2156.member_1.w * _e2165); + let _e2171 = (_e2156.member_1.w * _e2166); + let _e2191 = (vec4((1f - fma(_e2156.member_1.y, _e2165, _e2168)), fma(_e2156.member_1.x, _e2165, _e2171), fma(_e2156.member_1.x, _e2166, -(_e2170)), 0f) * _e2156.member_2.x); + let _e2193 = (vec4(fma(_e2156.member_1.x, _e2165, -(_e2171)), (1f - fma(_e2156.member_1.x, _e2164, _e2168)), fma(_e2156.member_1.y, _e2166, _e2169), 0f) * _e2156.member_2.y); + let _e2195 = (vec4(fma(_e2156.member_1.x, _e2166, _e2170), fma(_e2156.member_1.y, _e2166, -(_e2169)), (1f - fma(_e2156.member_1.x, _e2164, (_e2156.member_1.y * _e2165))), 0f) * _e2156.member_2.z); + switch bitcast(_e2095.member) { + case 0: { + if _e324 { + phi_5250_ = (_e2095.member_1 <= (_e118 - 8u)); + } else { + phi_5250_ = false; + } + let _e2693 = phi_5250_; + if _e2693 { + let _e2696 = global.member[_e2095.member_1]; + let _e2701 = global.member[(_e2095.member_1 + 1u)]; + let _e2706 = global.member[(_e2095.member_1 + 2u)]; + let _e2712 = global.member[(_e2095.member_1 + 3u)]; + let _e2717 = global.member[(_e2095.member_1 + 4u)]; + let _e2722 = global.member[(_e2095.member_1 + 5u)]; + let _e2727 = global.member[(_e2095.member_1 + 6u)]; + let _e2733 = global.member[(_e2095.member_1 + 7u)]; + phi_2369_ = type_35(vec3(bitcast(_e2696), bitcast(_e2701), bitcast(_e2706)), vec4(bitcast(_e2712), bitcast(_e2717), bitcast(_e2722), bitcast(_e2727)), bitcast(_e2733)); + } else { + phi_2369_ = type_35(vec3(0f, -1f, 0f), vec4(1f, 1f, 1f, 1f), 1f); + } + let _e2737 = phi_2369_; + let _e2759 = fma(_e2195.x, _e2737.member.z, fma(_e2193.x, _e2737.member.y, (_e2191.x * _e2737.member.x))); + let _e2760 = fma(_e2195.y, _e2737.member.z, fma(_e2193.y, _e2737.member.y, (_e2191.y * _e2737.member.x))); + let _e2761 = fma(_e2195.z, _e2737.member.z, fma(_e2193.z, _e2737.member.y, (_e2191.z * _e2737.member.x))); + let _e2766 = sqrt(fma(_e2761, _e2761, fma(_e2759, _e2759, (_e2760 * _e2760)))); + if (_e2766 == 0f) { + phi_5298_ = vec3(0f, 0f, 0f); + } else { + phi_5298_ = (vec3(_e2759, _e2760, _e2761) * (1f / _e2766)); + } + let _e2771 = phi_5298_; + let _e2773 = -(_e2771.x); + let _e2775 = -(_e2771.y); + let _e2777 = -(_e2771.z); + let _e2778 = -(_e2771); + let _e2782 = fma(fma(_e1464, _e122.x, -0.4f), _e1487, 0.4f); + let _e2783 = fma(fma(_e1467, _e122.y, -0.4f), _e1487, 0.4f); + let _e2784 = fma(fma(_e1470, _e122.z, -0.4f), _e1487, 0.4f); + let _e2792 = (_e2035 + vec3(_e2773, _e2775, _e2777)); + let _e2799 = sqrt(fma(_e2792.z, _e2792.z, fma(_e2792.x, _e2792.x, (_e2792.y * _e2792.y)))); + if (_e2799 == 0f) { + phi_5333_ = vec3(0f, 0f, 0f); + } else { + phi_5333_ = (_e2792 * (1f / _e2799)); + } + let _e2804 = phi_5333_; + let _e2805 = (_e1484 * _e1484); + let _e2816 = max(fma(_e2031.z, _e2804.z, fma(_e2031.x, _e2804.x, (_e2031.y * _e2804.y))), 0f); + let _e2829 = max(fma(_e2031.z, _e2035.z, fma(_e2031.x, _e2035.x, (_e2031.y * _e2035.y))), 0f); + let _e2836 = max(fma(_e2031.z, _e2778.z, fma(_e2031.x, _e2778.x, (_e2031.y * _e2778.y))), 0f); + let _e2837 = fma(_e743.y, _e318.member_4, 1f); + let _e2838 = (_e2837 * _e2837); + let _e2839 = (_e2838 * 0.125f); + let _e2841 = fma(-(_e2838), 0.125f, 1f); + let _e2854 = (1f - max(fma(_e2804.z, _e2035.z, fma(_e2804.x, _e2035.x, (_e2804.y * _e2035.y))), 0f)); + let _e2856 = select(_e2854, 0f, (_e2854 < 0f)); + let _e2859 = pow(select(_e2856, 1f, (_e2856 > 1f)), 5f); + let _e2860 = fma((1f - _e2782), _e2859, _e2782); + let _e2861 = fma((1f - _e2783), _e2859, _e2783); + let _e2862 = fma((1f - _e2784), _e2859, _e2784); + let _e2867 = fma(-(_e743.z), _e318.member_3, 1f); + let _e2871 = (((_e2805 * _e2805) / (pow(fma((_e2816 * _e2816), fma(_e2805, _e2805, -1f), 1f), 2f) * 3.1415927f)) * ((_e2829 / fma(_e2829, _e2841, _e2839)) * (_e2836 / fma(_e2836, _e2841, _e2839)))); + let _e2878 = max(fma(_e2031.z, _e2777, fma(_e2031.x, _e2773, (_e2031.y * _e2775))), 0f); + let _e2880 = fma((4f * _e2829), _e2878, 0.0001f); + phi_3077_ = false; + phi_3078_ = true; + phi_3079_ = vec3(fma((fma((((1f - _e2860) * _e2867) * _e1475), 0.31830987f, ((_e2871 * _e2860) / _e2880)) * (_e2737.member_1.x * _e2737.member_2)), _e2878, _e2040.x), fma((fma((((1f - _e2861) * _e2867) * _e1477), 0.31830987f, ((_e2871 * _e2861) / _e2880)) * (_e2737.member_1.y * _e2737.member_2)), _e2878, _e2040.y), fma((fma((((1f - _e2862) * _e2867) * _e1479), 0.31830987f, ((_e2871 * _e2862) / _e2880)) * (_e2737.member_1.z * _e2737.member_2)), _e2878, _e2040.z)); + phi_3080_ = false; + break; + } + case 1: { + if _e324 { + phi_5425_ = (_e2095.member_1 <= (_e118 - 8u)); + } else { + phi_5425_ = false; + } + let _e2481 = phi_5425_; + if _e2481 { + let _e2484 = global.member[_e2095.member_1]; + let _e2489 = global.member[(_e2095.member_1 + 1u)]; + let _e2494 = global.member[(_e2095.member_1 + 2u)]; + let _e2500 = global.member[(_e2095.member_1 + 3u)]; + let _e2505 = global.member[(_e2095.member_1 + 4u)]; + let _e2510 = global.member[(_e2095.member_1 + 5u)]; + let _e2515 = global.member[(_e2095.member_1 + 6u)]; + let _e2521 = global.member[(_e2095.member_1 + 7u)]; + phi_2573_ = type_35(vec3(bitcast(_e2484), bitcast(_e2489), bitcast(_e2494)), vec4(bitcast(_e2500), bitcast(_e2505), bitcast(_e2510), bitcast(_e2515)), bitcast(_e2521)); + } else { + phi_2573_ = type_35(vec3(0f, 0f, 0f), vec4(1f, 1f, 1f, 1f), 1f); + } + let _e2525 = phi_2573_; + let _e2554 = (vec3((_e2156.member.x + fma(_e2195.x, _e2525.member.z, fma(_e2193.x, _e2525.member.y, (_e2191.x * _e2525.member.x)))), (_e2156.member.y + fma(_e2195.y, _e2525.member.z, fma(_e2193.y, _e2525.member.y, (_e2191.y * _e2525.member.x)))), (_e2156.member.z + fma(_e2195.z, _e2525.member.z, fma(_e2193.z, _e2525.member.y, (_e2191.z * _e2525.member.x))))) - _e128); + let _e2561 = sqrt(fma(_e2554.z, _e2554.z, fma(_e2554.x, _e2554.x, (_e2554.y * _e2554.y)))); + let _e2562 = (_e2561 == 0f); + if _e2562 { + phi_2762_ = vec3(); + } else { + if _e2562 { + phi_5471_ = vec3(0f, 0f, 0f); + } else { + phi_5471_ = (_e2554 * (1f / _e2561)); + } + let _e2566 = phi_5471_; + let _e2568 = (_e2525.member_2 / (_e2561 * _e2561)); + let _e2572 = fma(fma(_e1464, _e122.x, -0.4f), _e1487, 0.4f); + let _e2573 = fma(fma(_e1467, _e122.y, -0.4f), _e1487, 0.4f); + let _e2574 = fma(fma(_e1470, _e122.z, -0.4f), _e1487, 0.4f); + let _e2581 = (_e2035 + _e2566); + let _e2588 = sqrt(fma(_e2581.z, _e2581.z, fma(_e2581.x, _e2581.x, (_e2581.y * _e2581.y)))); + if (_e2588 == 0f) { + phi_5506_ = vec3(0f, 0f, 0f); + } else { + phi_5506_ = (_e2581 * (1f / _e2588)); + } + let _e2593 = phi_5506_; + let _e2594 = (_e1484 * _e1484); + let _e2605 = max(fma(_e2031.z, _e2593.z, fma(_e2031.x, _e2593.x, (_e2031.y * _e2593.y))), 0f); + let _e2618 = max(fma(_e2031.z, _e2035.z, fma(_e2031.x, _e2035.x, (_e2031.y * _e2035.y))), 0f); + let _e2625 = max(fma(_e2031.z, _e2566.z, fma(_e2031.x, _e2566.x, (_e2031.y * _e2566.y))), 0f); + let _e2626 = fma(_e743.y, _e318.member_4, 1f); + let _e2627 = (_e2626 * _e2626); + let _e2628 = (_e2627 * 0.125f); + let _e2630 = fma(-(_e2627), 0.125f, 1f); + let _e2643 = (1f - max(fma(_e2593.z, _e2035.z, fma(_e2593.x, _e2035.x, (_e2593.y * _e2035.y))), 0f)); + let _e2645 = select(_e2643, 0f, (_e2643 < 0f)); + let _e2648 = pow(select(_e2645, 1f, (_e2645 > 1f)), 5f); + let _e2649 = fma((1f - _e2572), _e2648, _e2572); + let _e2650 = fma((1f - _e2573), _e2648, _e2573); + let _e2651 = fma((1f - _e2574), _e2648, _e2574); + let _e2656 = fma(-(_e743.z), _e318.member_3, 1f); + let _e2660 = (((_e2594 * _e2594) / (pow(fma((_e2605 * _e2605), fma(_e2594, _e2594, -1f), 1f), 2f) * 3.1415927f)) * ((_e2618 / fma(_e2618, _e2630, _e2628)) * (_e2625 / fma(_e2625, _e2630, _e2628)))); + let _e2665 = fma((4f * _e2618), _e2625, 0.0001f); + phi_2762_ = vec3(fma((fma((((1f - _e2649) * _e2656) * _e1475), 0.31830987f, ((_e2660 * _e2649) / _e2665)) * (_e2525.member_1.x * _e2568)), _e2625, _e2040.x), fma((fma((((1f - _e2650) * _e2656) * _e1477), 0.31830987f, ((_e2660 * _e2650) / _e2665)) * (_e2525.member_1.y * _e2568)), _e2625, _e2040.y), fma((fma((((1f - _e2651) * _e2656) * _e1479), 0.31830987f, ((_e2660 * _e2651) / _e2665)) * (_e2525.member_1.z * _e2568)), _e2625, _e2040.z)); + } + let _e2686 = phi_2762_; + phi_3077_ = false; + phi_3078_ = select(true, false, _e2562); + phi_3079_ = _e2686; + phi_3080_ = select(false, true, _e2562); + break; + } + case 2: { + if (_e118 >= 13u) { + phi_5598_ = (_e2095.member_1 <= (_e118 - 13u)); + } else { + phi_5598_ = false; + } + let _e2206 = phi_5598_; + if _e2206 { + let _e2209 = global.member[_e2095.member_1]; + let _e2214 = global.member[(_e2095.member_1 + 1u)]; + let _e2219 = global.member[(_e2095.member_1 + 2u)]; + let _e2225 = global.member[(_e2095.member_1 + 3u)]; + let _e2230 = global.member[(_e2095.member_1 + 4u)]; + let _e2235 = global.member[(_e2095.member_1 + 5u)]; + let _e2241 = global.member[(_e2095.member_1 + 6u)]; + let _e2246 = global.member[(_e2095.member_1 + 7u)]; + let _e2251 = global.member[(_e2095.member_1 + 8u)]; + let _e2256 = global.member[(_e2095.member_1 + 9u)]; + let _e2261 = global.member[(_e2095.member_1 + 10u)]; + let _e2266 = global.member[(_e2095.member_1 + 11u)]; + let _e2272 = global.member[(_e2095.member_1 + 12u)]; + phi_2824_ = type_36(vec3(bitcast(_e2209), bitcast(_e2214), bitcast(_e2219)), vec3(bitcast(_e2225), bitcast(_e2230), bitcast(_e2235)), bitcast(_e2241), bitcast(_e2246), vec4(bitcast(_e2251), bitcast(_e2256), bitcast(_e2261), bitcast(_e2266)), bitcast(_e2272)); + } else { + phi_2824_ = type_36(vec3(0f, 0f, 0f), vec3(0f, -1f, 0f), 1.0471976f, 1.5707964f, vec4(1f, 1f, 1f, 1f), 1f); + } + let _e2276 = phi_2824_; + let _e2308 = (vec3((_e2156.member.x + fma(_e2195.x, _e2276.member.z, fma(_e2193.x, _e2276.member.y, (_e2191.x * _e2276.member.x)))), (_e2156.member.y + fma(_e2195.y, _e2276.member.z, fma(_e2193.y, _e2276.member.y, (_e2191.y * _e2276.member.x)))), (_e2156.member.z + fma(_e2195.z, _e2276.member.z, fma(_e2193.z, _e2276.member.y, (_e2191.z * _e2276.member.x))))) - _e128); + let _e2315 = sqrt(fma(_e2308.z, _e2308.z, fma(_e2308.x, _e2308.x, (_e2308.y * _e2308.y)))); + let _e2316 = (_e2315 == 0f); + if _e2316 { + phi_3076_ = vec3(); + } else { + if _e2316 { + phi_5648_ = vec3(0f, 0f, 0f); + } else { + phi_5648_ = (_e2308 * (1f / _e2315)); + } + let _e2320 = phi_5648_; + let _e2330 = fma(_e2195.x, _e2276.member_1.z, fma(_e2193.x, _e2276.member_1.y, (_e2191.x * _e2276.member_1.x))); + let _e2331 = fma(_e2195.y, _e2276.member_1.z, fma(_e2193.y, _e2276.member_1.y, (_e2191.y * _e2276.member_1.x))); + let _e2332 = fma(_e2195.z, _e2276.member_1.z, fma(_e2193.z, _e2276.member_1.y, (_e2191.z * _e2276.member_1.x))); + let _e2337 = sqrt(fma(_e2332, _e2332, fma(_e2330, _e2330, (_e2331 * _e2331)))); + if (_e2337 == 0f) { + phi_5683_ = vec3(0f, 0f, 0f); + } else { + phi_5683_ = (vec3(_e2330, _e2331, _e2332) * (1f / _e2337)); + } + let _e2342 = phi_5683_; + let _e2354 = ((fma(_e2320.z, _e2342.z, fma(_e2320.x, _e2342.x, (_e2320.y * _e2342.y))) - _e2276.member_3) / (_e2276.member_2 - _e2276.member_3)); + let _e2356 = select(_e2354, 0f, (_e2354 < 0f)); + let _e2359 = (_e2276.member_5 * select(_e2356, 1f, (_e2356 > 1f))); + let _e2363 = fma(fma(_e1464, _e122.x, -0.4f), _e1487, 0.4f); + let _e2364 = fma(fma(_e1467, _e122.y, -0.4f), _e1487, 0.4f); + let _e2365 = fma(fma(_e1470, _e122.z, -0.4f), _e1487, 0.4f); + let _e2372 = (_e2035 + _e2320); + let _e2379 = sqrt(fma(_e2372.z, _e2372.z, fma(_e2372.x, _e2372.x, (_e2372.y * _e2372.y)))); + if (_e2379 == 0f) { + phi_5718_ = vec3(0f, 0f, 0f); + } else { + phi_5718_ = (_e2372 * (1f / _e2379)); + } + let _e2384 = phi_5718_; + let _e2385 = (_e1484 * _e1484); + let _e2396 = max(fma(_e2031.z, _e2384.z, fma(_e2031.x, _e2384.x, (_e2031.y * _e2384.y))), 0f); + let _e2409 = max(fma(_e2031.z, _e2035.z, fma(_e2031.x, _e2035.x, (_e2031.y * _e2035.y))), 0f); + let _e2413 = max(fma(_e2031.z, _e2320.z, fma(_e2031.x, _e2320.x, (_e2031.y * _e2320.y))), 0f); + let _e2414 = fma(_e743.y, _e318.member_4, 1f); + let _e2415 = (_e2414 * _e2414); + let _e2416 = (_e2415 * 0.125f); + let _e2418 = fma(-(_e2415), 0.125f, 1f); + let _e2431 = (1f - max(fma(_e2384.z, _e2035.z, fma(_e2384.x, _e2035.x, (_e2384.y * _e2035.y))), 0f)); + let _e2433 = select(_e2431, 0f, (_e2431 < 0f)); + let _e2436 = pow(select(_e2433, 1f, (_e2433 > 1f)), 5f); + let _e2437 = fma((1f - _e2363), _e2436, _e2363); + let _e2438 = fma((1f - _e2364), _e2436, _e2364); + let _e2439 = fma((1f - _e2365), _e2436, _e2365); + let _e2444 = fma(-(_e743.z), _e318.member_3, 1f); + let _e2448 = (((_e2385 * _e2385) / (pow(fma((_e2396 * _e2396), fma(_e2385, _e2385, -1f), 1f), 2f) * 3.1415927f)) * ((_e2409 / fma(_e2409, _e2418, _e2416)) * (_e2413 / fma(_e2413, _e2418, _e2416)))); + let _e2453 = fma((4f * _e2409), _e2413, 0.0001f); + phi_3076_ = vec3(fma((fma((((1f - _e2437) * _e2444) * _e1475), 0.31830987f, ((_e2448 * _e2437) / _e2453)) * (_e2276.member_4.x * _e2359)), _e2413, _e2040.x), fma((fma((((1f - _e2438) * _e2444) * _e1477), 0.31830987f, ((_e2448 * _e2438) / _e2453)) * (_e2276.member_4.y * _e2359)), _e2413, _e2040.y), fma((fma((((1f - _e2439) * _e2444) * _e1479), 0.31830987f, ((_e2448 * _e2439) / _e2453)) * (_e2276.member_4.z * _e2359)), _e2413, _e2040.z)); + } + let _e2474 = phi_3076_; + phi_3077_ = false; + phi_3078_ = select(true, false, _e2316); + phi_3079_ = _e2474; + phi_3080_ = select(false, true, _e2316); + break; + } + default: { + phi_3077_ = true; + phi_3078_ = false; + phi_3079_ = vec3(); + phi_3080_ = false; + break; + } + } + let _e2901 = phi_3077_; + let _e2903 = phi_3078_; + let _e2905 = phi_3079_; + let _e2907 = phi_3080_; + if _e2903 { + phi_3085_ = _e2053; + } else { + phi_3085_ = type_24(); + } + let _e2909 = phi_3085_; + let _e2914 = select(_e2907, false, _e2903); + if _e2914 { + phi_3093_ = _e2053; + } else { + phi_3093_ = _e2909; + } + let _e2916 = phi_3093_; + phi_3097_ = select(select(false, true, _e2903), true, _e2914); + phi_3098_ = _e2916; + phi_3099_ = select(select(vec3(), _e2905, vec3(_e2903)), _e2040, vec3(_e2914)); + phi_3100_ = select(select(_e2901, false, _e2903), false, _e2914); + } + let _e2922 = phi_3097_; + let _e2924 = phi_3098_; + let _e2926 = phi_3099_; + let _e2928 = phi_3100_; + phi_3101_ = _e2928; + phi_3102_ = select(false, true, _e2073); + phi_3103_ = _e2922; + phi_3104_ = _e2924; + phi_3105_ = _e2926; + break; + } + default: { + phi_3101_ = true; + phi_3102_ = false; + phi_3103_ = false; + phi_3104_ = type_24(); + phi_3105_ = vec3(); + break; + } + } + let _e2931 = phi_3101_; + let _e2933 = phi_3102_; + let _e2935 = phi_3103_; + let _e2937 = phi_3104_; + let _e2939 = phi_3105_; + if _e2931 { + phi_3111_ = type_24(); + } else { + phi_3111_ = _e2937; + } + let _e2941 = phi_3111_; + let _e2942 = select(_e2933, false, _e2931); + if _e2942 { + let _e2949 = fma(fma(_e1464, _e122.x, -0.04f), _e1487, 0.04f); + let _e2950 = fma(fma(_e1467, _e122.y, -0.04f), _e1487, 0.04f); + let _e2951 = fma(fma(_e1470, _e122.z, -0.04f), _e1487, 0.04f); + let _e2963 = fma(-(_e743.y), _e318.member_4, 1f); + let _e2970 = (1f - max(fma(_e2031.z, _e2035.z, fma(_e2031.x, _e2035.x, (_e2031.y * _e2035.y))), 0f)); + let _e2972 = select(_e2970, 0f, (_e2970 < 0f)); + let _e2975 = pow(select(_e2972, 1f, (_e2972 > 1f)), 5f); + let _e2976 = fma((max(_e2963, _e2949) - _e2949), _e2975, _e2949); + let _e2977 = fma((max(_e2963, _e2950) - _e2950), _e2975, _e2950); + let _e2978 = fma((max(_e2963, _e2951) - _e2951), _e2975, _e2951); + let _e2983 = fma(-(_e743.z), _e318.member_3, 1f); + phi_3215_ = vec4(fma(_e1497, _e318.member_1, fma(fma(((1f - _e2976) * _e2983), (_e1506.x * _e1475), (_e1846.x * fma(_e2976, _e1862.x, _e1862.y))), _e1491, _e2040.x)), fma(_e1499, _e318.member_1, fma(fma(((1f - _e2977) * _e2983), (_e1506.y * _e1477), (_e1846.y * fma(_e2977, _e1862.x, _e1862.y))), _e1491, _e2040.y)), fma(_e1501, _e318.member_1, fma(fma(((1f - _e2978) * _e2983), (_e1506.z * _e1479), (_e1846.z * fma(_e2978, _e1862.x, _e1862.y))), _e1491, _e2040.z)), 1f); + phi_2209_ = type_24(); + } else { + phi_3215_ = vec4(); + phi_2209_ = _e2941; + } + let _e3010 = phi_3215_; + let _e3012 = phi_2209_; + local_4 = select(false, true, _e2942); + local_5 = _e3010; + continue; + continuing { + phi_2208_ = _e3012; + phi_2211_ = select(select(_e2939, vec3(), vec3(_e2931)), vec3(), vec3(_e2942)); + break if !(select(select(_e2935, false, _e2931), false, _e2942)); + } + } + let _e3242 = local_4; + phi_3232_ = _e3242; + let _e3245 = local_5; + phi_3233_ = _e3245; + } else { + phi_3232_ = true; + phi_3233_ = (vec4((_e122.x * _e533.x), (_e122.y * _e533.y), (_e122.z * _e533.z), (_e122.w * _e533.w)) * _e318.member_2); + } + let _e3019 = phi_3232_; + let _e3021 = phi_3233_; + if _e3019 { + global_19 = _e3021; + } + break; + } + case 1: { + let _e2004 = sqrt(fma(_e123.x, _e123.x, (_e123.y * _e123.y))); + if (_e2004 == 0f) { + phi_5837_ = vec3(0f, 0f, 0f); + } else { + phi_5837_ = (vec3(_e123.x, _e123.y, 0f) * (1f / _e2004)); + } + let _e2009 = phi_5837_; + global_19 = vec4(((_e2009.x + 1f) * 0.5f), ((_e2009.y + 1f) * 0.5f), ((_e2009.z + 1f) * 0.5f), 1f); + break; + } + case 2: { + let _e1983 = sqrt(fma(_e124.x, _e124.x, (_e124.y * _e124.y))); + if (_e1983 == 0f) { + phi_5886_ = vec3(0f, 0f, 0f); + } else { + phi_5886_ = (vec3(_e124.x, _e124.y, 0f) * (1f / _e1983)); + } + let _e1988 = phi_5886_; + global_19 = vec4(((_e1988.x + 1f) * 0.5f), ((_e1988.y + 1f) * 0.5f), ((_e1988.z + 1f) * 0.5f), 1f); + break; + } + case 3: { + if _e1825 { + phi_5935_ = vec3(0f, 0f, 0f); + } else { + phi_5935_ = (_e1460 * (1f / _e1824)); + } + let _e1967 = phi_5935_; + global_19 = vec4(((_e1967.x + 1f) * 0.5f), ((_e1967.y + 1f) * 0.5f), ((_e1967.z + 1f) * 0.5f), 1f); + break; + } + case 4: { + global_19 = _e122; + break; + } + case 5: { + let _e1948 = sqrt(fma(_e125.z, _e125.z, fma(_e125.x, _e125.x, (_e125.y * _e125.y)))); + if (_e1948 == 0f) { + phi_5984_ = vec3(0f, 0f, 0f); + } else { + phi_5984_ = (_e125 * (1f / _e1948)); + } + let _e1953 = phi_5984_; + global_19 = vec4(((_e1953.x + 1f) * 0.5f), ((_e1953.y + 1f) * 0.5f), ((_e1953.z + 1f) * 0.5f), 1f); + break; + } + case 6: { + let _e1926 = sqrt(fma(_e1458.z, _e1458.z, fma(_e1458.x, _e1458.x, (_e1458.y * _e1458.y)))); + if (_e1926 == 0f) { + phi_6033_ = vec3(0f, 0f, 0f); + } else { + phi_6033_ = (_e1458 * (1f / _e1926)); + } + let _e1931 = phi_6033_; + global_19 = vec4(((_e1931.x + 1f) * 0.5f), ((_e1931.y + 1f) * 0.5f), ((_e1931.z + 1f) * 0.5f), 1f); + break; + } + case 7: { + let _e1904 = sqrt(fma(_e126.z, _e126.z, fma(_e126.x, _e126.x, (_e126.y * _e126.y)))); + if (_e1904 == 0f) { + phi_6082_ = vec3(0f, 0f, 0f); + } else { + phi_6082_ = (_e126 * (1f / _e1904)); + } + let _e1909 = phi_6082_; + global_19 = vec4(((_e1909.x + 1f) * 0.5f), ((_e1909.y + 1f) * 0.5f), ((_e1909.z + 1f) * 0.5f), 1f); + break; + } + case 8: { + let _e1882 = sqrt(fma(_e127.z, _e127.z, fma(_e127.x, _e127.x, (_e127.y * _e127.y)))); + if (_e1882 == 0f) { + phi_6131_ = vec3(0f, 0f, 0f); + } else { + phi_6131_ = (_e127 * (1f / _e1882)); + } + let _e1887 = phi_6131_; + global_19 = vec4(((_e1887.x + 1f) * 0.5f), ((_e1887.y + 1f) * 0.5f), ((_e1887.z + 1f) * 0.5f), 1f); + break; + } + case 9: { + global_19 = vec4(_e1506.x, _e1506.y, _e1506.z, 1f); + break; + } + case 10: { + global_19 = vec4(_e1846.x, _e1846.y, _e1846.z, 1f); + break; + } + case 11: { + global_19 = vec4(_e1862.x, _e1862.y, 1f, 1f); + break; + } + case 12: { + global_19 = (vec4(_e1464, _e1467, _e1470, (_e533.w * _e318.member_2.w)) * _e122); + break; + } + case 13: { + global_19 = vec4(_e1484, _e1484, _e1484, 1f); + break; + } + case 14: { + global_19 = vec4(_e1487, _e1487, _e1487, 1f); + break; + } + case 15: { + global_19 = vec4(_e1491, _e1491, _e1491, 1f); + break; + } + case 16: { + global_19 = vec4((_e1497 * _e318.member_1), (_e1499 * _e318.member_1), (_e1501 * _e318.member_1), 1f); + break; + } + case 17: { + global_19 = vec4(_e1373.x, _e1373.y, _e1373.z, 1f); + break; + } + case 18: { + global_19 = vec4(_e318.member.x, _e318.member.y, _e318.member.z, 1f); + break; + } + case 19: { + global_19 = vec4(_e318.member_1, _e318.member_1, _e318.member_1, 1f); + break; + } + default: { + break; + } + } + } + } + } + } + } + } + } + } + } + } + return; +} + +@fragment +fn stagerenderlet_fragment(@location(0) @interpolate(flat) param: u32, @location(1) @interpolate(flat) param_1: u32, @location(2) @interpolate(flat) param_2: u32, @location(3) param_3: vec4, @location(4) param_4: vec2, @location(5) param_5: vec2, @location(6) param_6: vec3, @location(7) param_7: vec3, @location(8) param_8: vec3, @location(9) param_9: vec3) -> @location(0) vec4 { + global_1 = param; + global_2 = param_1; + global_3 = param_2; + global_4 = param_3; + global_5 = param_4; + global_6 = param_5; + global_7 = param_6; + global_8 = param_7; + global_9 = param_8; + global_10 = param_9; + function(); + let _e21 = global_19; + return _e21; +} diff --git a/crates/renderling/shaders/stage-renderlet_vertex.spv b/crates/renderling/shaders/stage-renderlet_vertex.spv new file mode 100644 index 00000000..a1b8d4e7 Binary files /dev/null and b/crates/renderling/shaders/stage-renderlet_vertex.spv differ diff --git a/crates/renderling/shaders/stage-renderlet_vertex.wgsl b/crates/renderling/shaders/stage-renderlet_vertex.wgsl new file mode 100644 index 00000000..47477c5f --- /dev/null +++ b/crates/renderling/shaders/stage-renderlet_vertex.wgsl @@ -0,0 +1,1183 @@ +struct type_12 { + member: array, +} + +struct type_20 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_21 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_22 { + member: type_20, + member_1: type_20, + member_2: type_21, + member_3: vec3, +} + +struct type_24 { + member: u32, + member_1: u32, +} + +struct type_27 { + member: vec3, + member_1: vec4, + member_2: vec3, +} + +struct type_28 { + member: vec3, + member_1: vec3, + member_2: vec3, +} + +struct type_31 { + member: vec3, + member_1: vec4, + member_2: vec3, + member_3: vec4, + member_4: array, + member_5: array, + member_6: vec2, + member_7: vec2, +} + +struct type_34 { + member: type_24, + member_1: type_24, +} + +struct VertexOutput { + @location(0) @interpolate(flat) member: u32, + @location(1) @interpolate(flat) member_1: u32, + @location(2) @interpolate(flat) member_2: u32, + @location(3) member_3: vec4, + @location(4) member_4: vec2, + @location(5) member_5: vec2, + @location(6) member_6: vec3, + @location(7) member_7: vec3, + @location(8) member_8: vec3, + @location(9) member_9: vec3, + @builtin(position) member_10: vec4, +} + +var global: u32; +var global_1: vec4 = vec4(0f, 0f, 0f, 1f); +@group(0) @binding(0) +var global_2: type_12; +var global_3: u32; +var global_4: u32; +var global_5: u32; +var global_6: u32; +var global_7: vec4; +var global_8: vec2; +var global_9: vec2; +var global_10: type_20 = type_20(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)); +var global_11: vec3; +var global_12: vec3; +var global_13: vec3; +var global_14: vec3; + +fn function() { + var local: array; + var local_1: array; + var local_2: array, 8>; + var local_3: array, 6>; + var local_4: array; + var local_5: array; + var phi_742_: u32; + var phi_2870_: bool; + var phi_749_: u32; + var phi_750_: u32; + var phi_760_: u32; + var phi_842_: type_24; + var phi_858_: type_24; + var phi_859_: type_24; + var phi_872_: type_24; + var phi_888_: type_24; + var phi_889_: type_24; + var phi_902_: type_24; + var phi_905_: type_31; + var phi_920_: type_24; + var phi_921_: type_24; + var phi_2901_: bool; + var phi_1042_: type_34; + var phi_1045_: type_24; + var phi_1048_: type_20; + var phi_1063_: type_24; + var phi_1064_: type_24; + var phi_1098_: bool; + var phi_1100_: bool; + var phi_1101_: bool; + var phi_1102_: bool; + var phi_1103_: bool; + var phi_1137_: bool; + var phi_1139_: bool; + var phi_1140_: bool; + var phi_1141_: bool; + var phi_1142_: bool; + var phi_1176_: bool; + var phi_1178_: bool; + var phi_1179_: bool; + var phi_1180_: bool; + var phi_1181_: bool; + var phi_1215_: bool; + var phi_1217_: bool; + var phi_1218_: bool; + var phi_1219_: bool; + var phi_1220_: bool; + var phi_1225_: bool; + var phi_1227_: bool; + var phi_1228_: bool; + var phi_1229_: bool; + var phi_1230_: bool; + var phi_1238_: type_20; + var phi_3005_: bool; + var phi_3006_: bool; + var phi_3069_: vec4; + var phi_3099_: vec4; + var phi_3101_: vec4; + var phi_3112_: type_27; + var phi_3114_: type_27; + var phi_3116_: bool; + var phi_3117_: type_27; + var phi_3118_: type_27; + var phi_3122_: type_27; + var phi_1256_: u32; + var phi_3218_: bool; + var phi_1265_: u32; + var phi_3242_: bool; + var phi_1314_: type_27; + var phi_1324_: u32; + var phi_3267_: bool; + var phi_1397_: type_20; + var phi_1635_: type_24; + var phi_1636_: type_20; + var phi_1637_: bool; + var phi_1638_: type_24; + var phi_1639_: type_20; + var phi_1640_: bool; + var phi_1641_: type_27; + var phi_1642_: bool; + var phi_1046_: type_24; + var phi_1049_: type_20; + var phi_1643_: bool; + var phi_1644_: type_27; + var phi_1646_: bool; + var phi_1647_: type_27; + var phi_1648_: bool; + var phi_3334_: bool; + var phi_1701_: type_27; + var phi_1703_: type_27; + var phi_1750_: vec3; + var phi_3379_: vec3; + var phi_3461_: vec3; + var phi_3496_: vec3; + var phi_3509_: bool; + var phi_2074_: type_24; + var phi_2090_: type_24; + var phi_2091_: type_24; + var phi_2104_: type_24; + var phi_2120_: type_24; + var phi_2121_: type_24; + var phi_2147_: type_22; + var phi_2148_: bool; + var phi_2105_: type_24; + var phi_2168_: type_22; + var phi_2169_: bool; + var phi_2075_: type_24; + var phi_2174_: type_22; + var phi_2235_: u32; + var phi_3766_: bool; + var phi_2253_: type_24; + var phi_3792_: u32; + var phi_3811_: bool; + var phi_2303_: type_28; + var phi_2313_: u32; + var phi_3833_: bool; + var phi_2321_: f32; + var phi_2375_: bool; + var phi_903_: type_24; + var phi_906_: type_31; + var phi_2383_: bool; + var phi_873_: type_24; + var phi_2390_: bool; + var phi_843_: type_24; + var local_6: bool; + var local_7: type_27; + var local_8: type_22; + var local_9: type_22; + + let _e97 = global_3; + let _e98 = global; + let _e100 = arrayLength((&global_2.member)); + let _e103 = global_2.member[_e97]; + let _e108 = global_2.member[(_e97 + 1u)]; + let _e112 = global_2.member[(_e97 + 2u)]; + let _e116 = global_2.member[(_e97 + 7u)]; + let _e120 = global_2.member[(_e97 + 8u)]; + let _e124 = global_2.member[(_e97 + 9u)]; + let _e128 = global_2.member[(_e97 + 10u)]; + let _e132 = global_2.member[(_e97 + 11u)]; + let _e136 = global_2.member[(_e97 + 12u)]; + let _e140 = global_2.member[(_e97 + 13u)]; + let _e144 = global_2.member[(_e97 + 14u)]; + let _e148 = global_2.member[(_e97 + 15u)]; + let _e152 = global_2.member[(_e97 + 16u)]; + let _e156 = global_2.member[(_e97 + 17u)]; + if (_e103 == 1u) { + global_4 = _e124; + global_5 = _e132; + global_6 = _e156; + if (_e116 == 4294967295u) { + phi_750_ = _e98; + } else { + if (_e98 >= _e120) { + phi_742_ = 4294967295u; + } else { + phi_742_ = (_e116 + _e98); + } + let _e161 = phi_742_; + if (_e100 >= 1u) { + phi_2870_ = (_e161 <= (_e100 - 1u)); + } else { + phi_2870_ = false; + } + let _e166 = phi_2870_; + if _e166 { + let _e169 = global_2.member[_e161]; + phi_749_ = _e169; + } else { + phi_749_ = 0u; + } + let _e171 = phi_749_; + phi_750_ = _e171; + } + let _e173 = phi_750_; + if (_e173 >= _e112) { + phi_760_ = 4294967295u; + } else { + phi_760_ = (_e108 + (26u * _e173)); + } + let _e178 = phi_760_; + let _e181 = global_2.member[_e178]; + let _e186 = global_2.member[(_e178 + 1u)]; + let _e191 = global_2.member[(_e178 + 2u)]; + let _e197 = global_2.member[(_e178 + 3u)]; + let _e202 = global_2.member[(_e178 + 4u)]; + let _e207 = global_2.member[(_e178 + 5u)]; + let _e212 = global_2.member[(_e178 + 6u)]; + let _e218 = global_2.member[(_e178 + 7u)]; + let _e223 = global_2.member[(_e178 + 8u)]; + let _e229 = global_2.member[(_e178 + 9u)]; + let _e234 = global_2.member[(_e178 + 10u)]; + let _e240 = global_2.member[(_e178 + 11u)]; + let _e245 = global_2.member[(_e178 + 12u)]; + let _e250 = global_2.member[(_e178 + 13u)]; + let _e256 = global_2.member[(_e178 + 14u)]; + let _e261 = global_2.member[(_e178 + 15u)]; + let _e266 = global_2.member[(_e178 + 16u)]; + let _e271 = global_2.member[(_e178 + 17u)]; + local_5 = array(0u, 0u, 0u, 0u); + phi_842_ = type_24(0u, 4u); + loop { + let _e276 = phi_842_; + if (_e276.member < _e276.member_1) { + phi_858_ = type_24((_e276.member + 1u), _e276.member_1); + phi_859_ = type_24(1u, _e276.member); + } else { + phi_858_ = _e276; + phi_859_ = type_24(0u, type_24().member_1); + } + let _e289 = phi_858_; + let _e291 = phi_859_; + switch bitcast(_e291.member) { + case 0: { + let _e295 = local_5; + local_4 = array(0f, 0f, 0f, 0f); + phi_872_ = type_24(0u, 4u); + loop { + let _e298 = phi_872_; + if (_e298.member < _e298.member_1) { + phi_888_ = type_24((_e298.member + 1u), _e298.member_1); + phi_889_ = type_24(1u, _e298.member); + } else { + phi_888_ = _e298; + phi_889_ = type_24(0u, type_24().member_1); + } + let _e311 = phi_888_; + let _e313 = phi_889_; + switch bitcast(_e313.member) { + case 0: { + let _e317 = local_4; + phi_902_ = type_24(0u, _e144); + phi_905_ = type_31(vec3(bitcast(_e181), bitcast(_e186), bitcast(_e191)), vec4(bitcast(_e197), bitcast(_e202), bitcast(_e207), bitcast(_e212)), vec3(bitcast(_e240), bitcast(_e245), bitcast(_e250)), vec4(bitcast(_e256), bitcast(_e261), bitcast(_e266), bitcast(_e271)), _e295, _e317, vec2(bitcast(_e218), bitcast(_e223)), vec2(bitcast(_e229), bitcast(_e234))); + loop { + let _e321 = phi_902_; + let _e323 = phi_905_; + if (_e321.member < _e321.member_1) { + phi_920_ = type_24((_e321.member + 1u), _e321.member_1); + phi_921_ = type_24(1u, _e321.member); + } else { + phi_920_ = _e321; + phi_921_ = type_24(0u, type_24().member_1); + } + let _e336 = phi_920_; + let _e338 = phi_921_; + switch bitcast(_e338.member) { + case 0: { + global_7 = _e323.member_1; + global_8 = _e323.member_6; + global_9 = _e323.member_7; + let _e348 = global_2.member[(_e156 + 6u)]; + if (_e348 == 1u) { + let _e351 = ((_e136 == 4294967295u) != true); + if _e351 { + if (_e100 >= 4u) { + phi_2901_ = (_e136 <= (_e100 - 4u)); + } else { + phi_2901_ = false; + } + let _e356 = phi_2901_; + if _e356 { + let _e359 = global_2.member[_e136]; + let _e363 = global_2.member[(_e136 + 1u)]; + let _e367 = global_2.member[(_e136 + 2u)]; + let _e371 = global_2.member[(_e136 + 3u)]; + phi_1042_ = type_34(type_24(_e359, _e363), type_24(_e367, _e371)); + } else { + phi_1042_ = type_34(type_24(4294967295u, 0u), type_24(4294967295u, 0u)); + } + let _e376 = phi_1042_; + local = _e323.member_5; + phi_1045_ = type_24(0u, 4u); + phi_1048_ = type_20(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)); + loop { + let _e379 = phi_1045_; + let _e381 = phi_1048_; + if (_e379.member < _e379.member_1) { + phi_1063_ = type_24((_e379.member + 1u), _e379.member_1); + phi_1064_ = type_24(1u, _e379.member); + } else { + phi_1063_ = _e379; + phi_1064_ = type_24(0u, type_24().member_1); + } + let _e394 = phi_1063_; + let _e396 = phi_1064_; + switch bitcast(_e396.member) { + case 0: { + let _e404 = global_10.member[0u]; + if (_e381.member.x == _e404) { + let _e410 = global_10.member[1u]; + if (_e381.member.y == _e410) { + let _e416 = global_10.member[2u]; + let _e417 = (_e381.member.z == _e416); + if _e417 { + let _e422 = global_10.member[3u]; + phi_1098_ = (_e381.member.w == _e422); + } else { + phi_1098_ = bool(); + } + let _e425 = phi_1098_; + phi_1100_ = _e425; + phi_1101_ = select(true, false, _e417); + } else { + phi_1100_ = bool(); + phi_1101_ = true; + } + let _e428 = phi_1100_; + let _e430 = phi_1101_; + phi_1102_ = _e428; + phi_1103_ = _e430; + } else { + phi_1102_ = bool(); + phi_1103_ = true; + } + let _e432 = phi_1102_; + let _e434 = phi_1103_; + if select(_e432, false, _e434) { + let _e440 = global_10.member_1[0u]; + if (_e381.member_1.x == _e440) { + let _e446 = global_10.member_1[1u]; + if (_e381.member_1.y == _e446) { + let _e452 = global_10.member_1[2u]; + let _e453 = (_e381.member_1.z == _e452); + if _e453 { + let _e458 = global_10.member_1[3u]; + phi_1137_ = (_e381.member_1.w == _e458); + } else { + phi_1137_ = bool(); + } + let _e461 = phi_1137_; + phi_1139_ = _e461; + phi_1140_ = select(true, false, _e453); + } else { + phi_1139_ = bool(); + phi_1140_ = true; + } + let _e464 = phi_1139_; + let _e466 = phi_1140_; + phi_1141_ = _e464; + phi_1142_ = _e466; + } else { + phi_1141_ = bool(); + phi_1142_ = true; + } + let _e468 = phi_1141_; + let _e470 = phi_1142_; + if select(_e468, false, _e470) { + let _e476 = global_10.member_2[0u]; + if (_e381.member_2.x == _e476) { + let _e482 = global_10.member_2[1u]; + if (_e381.member_2.y == _e482) { + let _e488 = global_10.member_2[2u]; + let _e489 = (_e381.member_2.z == _e488); + if _e489 { + let _e494 = global_10.member_2[3u]; + phi_1176_ = (_e381.member_2.w == _e494); + } else { + phi_1176_ = bool(); + } + let _e497 = phi_1176_; + phi_1178_ = _e497; + phi_1179_ = select(true, false, _e489); + } else { + phi_1178_ = bool(); + phi_1179_ = true; + } + let _e500 = phi_1178_; + let _e502 = phi_1179_; + phi_1180_ = _e500; + phi_1181_ = _e502; + } else { + phi_1180_ = bool(); + phi_1181_ = true; + } + let _e504 = phi_1180_; + let _e506 = phi_1181_; + let _e507 = select(_e504, false, _e506); + if _e507 { + let _e512 = global_10.member_3[0u]; + if (_e381.member_3.x == _e512) { + let _e518 = global_10.member_3[1u]; + if (_e381.member_3.y == _e518) { + let _e524 = global_10.member_3[2u]; + let _e525 = (_e381.member_3.z == _e524); + if _e525 { + let _e530 = global_10.member_3[3u]; + phi_1215_ = (_e381.member_3.w == _e530); + } else { + phi_1215_ = bool(); + } + let _e533 = phi_1215_; + phi_1217_ = _e533; + phi_1218_ = select(true, false, _e525); + } else { + phi_1217_ = bool(); + phi_1218_ = true; + } + let _e536 = phi_1217_; + let _e538 = phi_1218_; + phi_1219_ = _e536; + phi_1220_ = _e538; + } else { + phi_1219_ = bool(); + phi_1220_ = true; + } + let _e540 = phi_1219_; + let _e542 = phi_1220_; + phi_1225_ = select(_e540, false, _e542); + } else { + phi_1225_ = bool(); + } + let _e545 = phi_1225_; + phi_1227_ = _e545; + phi_1228_ = select(true, false, _e507); + } else { + phi_1227_ = bool(); + phi_1228_ = true; + } + let _e548 = phi_1227_; + let _e550 = phi_1228_; + phi_1229_ = _e548; + phi_1230_ = _e550; + } else { + phi_1229_ = bool(); + phi_1230_ = true; + } + let _e552 = phi_1229_; + let _e554 = phi_1230_; + if select(_e552, false, _e554) { + phi_1238_ = type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)); + } else { + phi_1238_ = _e381; + } + let _e557 = phi_1238_; + let _e580 = fma(_e557.member_2.z, _e557.member_3.w, -((_e557.member_2.w * _e557.member_3.z))); + let _e583 = fma(_e557.member_2.y, _e557.member_3.w, -((_e557.member_2.w * _e557.member_3.y))); + let _e586 = fma(_e557.member_2.y, _e557.member_3.z, -((_e557.member_2.z * _e557.member_3.y))); + let _e589 = fma(_e557.member_2.x, _e557.member_3.w, -((_e557.member_2.w * _e557.member_3.x))); + let _e592 = fma(_e557.member_2.x, _e557.member_3.z, -((_e557.member_2.z * _e557.member_3.x))); + let _e595 = fma(_e557.member_2.x, _e557.member_3.y, -((_e557.member_2.y * _e557.member_3.x))); + let _e617 = fma(-(_e557.member.w), fma(_e557.member_1.z, _e595, fma(_e557.member_1.x, _e586, -((_e557.member_1.y * _e592)))), fma(_e557.member.z, fma(_e557.member_1.w, _e595, fma(_e557.member_1.x, _e583, -((_e557.member_1.y * _e589)))), fma(_e557.member.x, fma(_e557.member_1.w, _e586, fma(_e557.member_1.y, _e580, -((_e557.member_1.z * _e583)))), -((_e557.member.y * fma(_e557.member_1.w, _e592, fma(_e557.member_1.x, _e580, -((_e557.member_1.z * _e589))))))))); + if (_e617 == 0f) { + phi_3116_ = true; + phi_3117_ = type_27(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); + phi_3118_ = type_27(); + } else { + let _e626 = (sqrt(fma(_e557.member.w, _e557.member.w, fma(_e557.member.z, _e557.member.z, fma(_e557.member.x, _e557.member.x, (_e557.member.y * _e557.member.y))))) * select(-1f, 1f, (_e617 >= 0f))); + let _e631 = sqrt(fma(_e557.member_1.w, _e557.member_1.w, fma(_e557.member_1.z, _e557.member_1.z, fma(_e557.member_1.x, _e557.member_1.x, (_e557.member_1.y * _e557.member_1.y))))); + let _e636 = sqrt(fma(_e557.member_2.w, _e557.member_2.w, fma(_e557.member_2.z, _e557.member_2.z, fma(_e557.member_2.x, _e557.member_2.x, (_e557.member_2.y * _e557.member_2.y))))); + let _e639 = (_e631 != 0f); + if (_e626 != 0f) { + phi_3005_ = select(bool(), (_e636 != 0f), _e639); + phi_3006_ = select(true, false, _e639); + } else { + phi_3005_ = bool(); + phi_3006_ = true; + } + let _e644 = phi_3005_; + let _e646 = phi_3006_; + let _e647 = select(_e644, false, _e646); + if _e647 { + let _e648 = (1f / _e626); + let _e649 = (1f / _e631); + let _e650 = (1f / _e636); + let _e651 = (_e557.member.x * _e648); + let _e652 = (_e557.member.z * _e648); + let _e653 = (_e557.member_1.x * _e649); + let _e654 = (_e557.member_2.x * _e650); + let _e655 = (_e557.member_2.y * _e650); + if ((_e557.member_2.z * _e650) <= 0f) { + let _e659 = fma(_e557.member_1.y, _e649, -(_e651)); + let _e661 = fma(-(_e557.member_2.z), _e650, 1f); + if (_e659 <= 0f) { + let _e663 = (_e661 - _e659); + let _e665 = (0.5f / sqrt(_e663)); + phi_3069_ = vec4((_e663 * _e665), (fma(_e557.member.y, _e648, _e653) * _e665), (fma(_e557.member.z, _e648, _e654) * _e665), (fma(_e557.member_1.z, _e649, -(_e655)) * _e665)); + } else { + let _e675 = (_e661 + _e659); + let _e677 = (0.5f / sqrt(_e675)); + phi_3069_ = vec4((fma(_e557.member.y, _e648, _e653) * _e677), (_e675 * _e677), (fma(_e557.member_1.z, _e649, _e655) * _e677), (fma(_e557.member_2.x, _e650, -(_e652)) * _e677)); + } + let _e688 = phi_3069_; + phi_3101_ = _e688; + } else { + let _e689 = fma(_e557.member_1.y, _e649, _e651); + let _e690 = fma(_e557.member_2.z, _e650, 1f); + if (_e689 <= 0f) { + let _e692 = (_e690 - _e689); + let _e694 = (0.5f / sqrt(_e692)); + phi_3099_ = vec4((fma(_e557.member.z, _e648, _e654) * _e694), (fma(_e557.member_1.z, _e649, _e655) * _e694), (_e692 * _e694), (fma(_e557.member.y, _e648, -(_e653)) * _e694)); + } else { + let _e704 = (_e690 + _e689); + let _e706 = (0.5f / sqrt(_e704)); + phi_3099_ = vec4((fma(_e557.member_1.z, _e649, -(_e655)) * _e706), (fma(_e557.member_2.x, _e650, -(_e652)) * _e706), (fma(_e557.member.y, _e648, -(_e653)) * _e706), (_e704 * _e706)); + } + let _e719 = phi_3099_; + phi_3101_ = _e719; + } + let _e721 = phi_3101_; + phi_3112_ = type_27(vec3(_e626, _e631, _e636), _e721, vec3(_e557.member_3.x, _e557.member_3.y, _e557.member_3.z)); + phi_3114_ = type_27(); + } else { + phi_3112_ = type_27(); + phi_3114_ = type_27(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); + } + let _e725 = phi_3112_; + let _e727 = phi_3114_; + phi_3116_ = select(true, false, _e647); + phi_3117_ = _e727; + phi_3118_ = _e725; + } + let _e730 = phi_3116_; + let _e732 = phi_3117_; + let _e734 = phi_3118_; + if _e730 { + phi_3122_ = _e732; + } else { + phi_3122_ = _e734; + } + let _e736 = phi_3122_; + phi_1640_ = true; + phi_1641_ = type_27(_e736.member_2, _e736.member_1, _e736.member); + phi_1642_ = false; + phi_1046_ = type_24(); + phi_1049_ = type_20(); + break; + } + case 1: { + local_1 = _e323.member_4; + let _e742 = (_e396.member_1 < 4u); + if _e742 { + let _e744 = local_1[_e396.member_1]; + if (_e744 >= _e376.member.member_1) { + phi_1256_ = 4294967295u; + } else { + phi_1256_ = (_e376.member.member + _e744); + } + let _e752 = phi_1256_; + if (_e100 >= 1u) { + phi_3218_ = (_e752 <= (_e100 - 1u)); + } else { + phi_3218_ = false; + } + let _e757 = phi_3218_; + if _e757 { + let _e760 = global_2.member[_e752]; + phi_1265_ = _e760; + } else { + phi_1265_ = 4294967295u; + } + let _e762 = phi_1265_; + if (_e100 >= 10u) { + phi_3242_ = (_e762 <= (_e100 - 10u)); + } else { + phi_3242_ = false; + } + let _e767 = phi_3242_; + if _e767 { + let _e770 = global_2.member[_e762]; + let _e775 = global_2.member[(_e762 + 1u)]; + let _e780 = global_2.member[(_e762 + 2u)]; + let _e786 = global_2.member[(_e762 + 3u)]; + let _e791 = global_2.member[(_e762 + 4u)]; + let _e796 = global_2.member[(_e762 + 5u)]; + let _e801 = global_2.member[(_e762 + 6u)]; + let _e807 = global_2.member[(_e762 + 7u)]; + let _e812 = global_2.member[(_e762 + 8u)]; + let _e817 = global_2.member[(_e762 + 9u)]; + phi_1314_ = type_27(vec3(bitcast(_e770), bitcast(_e775), bitcast(_e780)), vec4(bitcast(_e786), bitcast(_e791), bitcast(_e796), bitcast(_e801)), vec3(bitcast(_e807), bitcast(_e812), bitcast(_e817))); + } else { + phi_1314_ = type_27(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e822 = phi_1314_; + if (_e744 >= _e376.member_1.member_1) { + phi_1324_ = 4294967295u; + } else { + phi_1324_ = (_e376.member_1.member + (16u * _e744)); + } + let _e831 = phi_1324_; + if (_e100 >= 16u) { + phi_3267_ = (_e831 <= (_e100 - 16u)); + } else { + phi_3267_ = false; + } + let _e836 = phi_3267_; + if _e836 { + let _e839 = global_2.member[_e831]; + let _e844 = global_2.member[(_e831 + 1u)]; + let _e849 = global_2.member[(_e831 + 2u)]; + let _e854 = global_2.member[(_e831 + 3u)]; + let _e860 = global_2.member[(_e831 + 4u)]; + let _e865 = global_2.member[(_e831 + 5u)]; + let _e870 = global_2.member[(_e831 + 6u)]; + let _e875 = global_2.member[(_e831 + 7u)]; + let _e881 = global_2.member[(_e831 + 8u)]; + let _e886 = global_2.member[(_e831 + 9u)]; + let _e891 = global_2.member[(_e831 + 10u)]; + let _e896 = global_2.member[(_e831 + 11u)]; + let _e902 = global_2.member[(_e831 + 12u)]; + let _e907 = global_2.member[(_e831 + 13u)]; + let _e912 = global_2.member[(_e831 + 14u)]; + let _e917 = global_2.member[(_e831 + 15u)]; + phi_1397_ = type_20(vec4(bitcast(_e839), bitcast(_e844), bitcast(_e849), bitcast(_e854)), vec4(bitcast(_e860), bitcast(_e865), bitcast(_e870), bitcast(_e875)), vec4(bitcast(_e881), bitcast(_e886), bitcast(_e891), bitcast(_e896)), vec4(bitcast(_e902), bitcast(_e907), bitcast(_e912), bitcast(_e917))); + } else { + phi_1397_ = type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)); + } + let _e922 = phi_1397_; + let _e930 = (_e822.member_1.x + _e822.member_1.x); + let _e931 = (_e822.member_1.y + _e822.member_1.y); + let _e932 = (_e822.member_1.z + _e822.member_1.z); + let _e934 = (_e822.member_1.z * _e932); + let _e935 = (_e822.member_1.w * _e930); + let _e936 = (_e822.member_1.w * _e931); + let _e937 = (_e822.member_1.w * _e932); + let _e957 = (vec4((1f - fma(_e822.member_1.y, _e931, _e934)), fma(_e822.member_1.x, _e931, _e937), fma(_e822.member_1.x, _e932, -(_e936)), 0f) * _e822.member_2.x); + let _e959 = (vec4(fma(_e822.member_1.x, _e931, -(_e937)), (1f - fma(_e822.member_1.x, _e930, _e934)), fma(_e822.member_1.y, _e932, _e935), 0f) * _e822.member_2.y); + let _e961 = (vec4(fma(_e822.member_1.x, _e932, _e936), fma(_e822.member_1.y, _e932, -(_e935)), (1f - fma(_e822.member_1.x, _e930, (_e822.member_1.y * _e931))), 0f) * _e822.member_2.z); + if _e742 { + let _e1066 = local[_e396.member_1]; + phi_1635_ = _e394; + phi_1636_ = type_20((_e381.member + (vec4(fma(_e822.member.x, _e922.member.w, fma(_e961.x, _e922.member.z, fma(_e957.x, _e922.member.x, (_e959.x * _e922.member.y)))), fma(_e822.member.y, _e922.member.w, fma(_e961.y, _e922.member.z, fma(_e957.y, _e922.member.x, (_e959.y * _e922.member.y)))), fma(_e822.member.z, _e922.member.w, fma(_e961.z, _e922.member.z, fma(_e957.z, _e922.member.x, (_e959.z * _e922.member.y)))), (fma(_e961.w, _e922.member.z, fma(_e957.w, _e922.member.x, (_e959.w * _e922.member.y))) + _e922.member.w)) * _e1066)), (_e381.member_1 + (vec4(fma(_e822.member.x, _e922.member_1.w, fma(_e961.x, _e922.member_1.z, fma(_e957.x, _e922.member_1.x, (_e959.x * _e922.member_1.y)))), fma(_e822.member.y, _e922.member_1.w, fma(_e961.y, _e922.member_1.z, fma(_e957.y, _e922.member_1.x, (_e959.y * _e922.member_1.y)))), fma(_e822.member.z, _e922.member_1.w, fma(_e961.z, _e922.member_1.z, fma(_e957.z, _e922.member_1.x, (_e959.z * _e922.member_1.y)))), (fma(_e961.w, _e922.member_1.z, fma(_e957.w, _e922.member_1.x, (_e959.w * _e922.member_1.y))) + _e922.member_1.w)) * _e1066)), (_e381.member_2 + (vec4(fma(_e822.member.x, _e922.member_2.w, fma(_e961.x, _e922.member_2.z, fma(_e957.x, _e922.member_2.x, (_e959.x * _e922.member_2.y)))), fma(_e822.member.y, _e922.member_2.w, fma(_e961.y, _e922.member_2.z, fma(_e957.y, _e922.member_2.x, (_e959.y * _e922.member_2.y)))), fma(_e822.member.z, _e922.member_2.w, fma(_e961.z, _e922.member_2.z, fma(_e957.z, _e922.member_2.x, (_e959.z * _e922.member_2.y)))), (fma(_e961.w, _e922.member_2.z, fma(_e957.w, _e922.member_2.x, (_e959.w * _e922.member_2.y))) + _e922.member_2.w)) * _e1066)), (_e381.member_3 + (vec4(fma(_e822.member.x, _e922.member_3.w, fma(_e961.x, _e922.member_3.z, fma(_e957.x, _e922.member_3.x, (_e959.x * _e922.member_3.y)))), fma(_e822.member.y, _e922.member_3.w, fma(_e961.y, _e922.member_3.z, fma(_e957.y, _e922.member_3.x, (_e959.y * _e922.member_3.y)))), fma(_e822.member.z, _e922.member_3.w, fma(_e961.z, _e922.member_3.z, fma(_e957.z, _e922.member_3.x, (_e959.z * _e922.member_3.y)))), (fma(_e961.w, _e922.member_3.z, fma(_e957.w, _e922.member_3.x, (_e959.w * _e922.member_3.y))) + _e922.member_3.w)) * _e1066))); + } else { + phi_1635_ = type_24(); + phi_1636_ = type_20(); + } + let _e1081 = phi_1635_; + let _e1083 = phi_1636_; + phi_1637_ = select(false, true, _e742); + phi_1638_ = _e1081; + phi_1639_ = _e1083; + } else { + phi_1637_ = false; + phi_1638_ = type_24(); + phi_1639_ = type_20(); + } + let _e1086 = phi_1637_; + let _e1088 = phi_1638_; + let _e1090 = phi_1639_; + phi_1640_ = false; + phi_1641_ = type_27(); + phi_1642_ = _e1086; + phi_1046_ = _e1088; + phi_1049_ = _e1090; + break; + } + default: { + phi_1640_ = false; + phi_1641_ = type_27(); + phi_1642_ = false; + phi_1046_ = type_24(); + phi_1049_ = type_20(); + break; + } + } + let _e1092 = phi_1640_; + let _e1094 = phi_1641_; + let _e1096 = phi_1642_; + let _e1098 = phi_1046_; + let _e1100 = phi_1049_; + local_6 = _e1092; + local_7 = _e1094; + continue; + continuing { + phi_1045_ = _e1098; + phi_1048_ = _e1100; + break if !(_e1096); + } + } + let _e2034 = local_6; + phi_1643_ = _e2034; + let _e2037 = local_7; + phi_1644_ = _e2037; + } else { + phi_1643_ = false; + phi_1644_ = type_27(); + } + let _e1103 = phi_1643_; + let _e1105 = phi_1644_; + phi_1646_ = _e1103; + phi_1647_ = _e1105; + phi_1648_ = select(true, false, _e351); + } else { + phi_1646_ = false; + phi_1647_ = type_27(); + phi_1648_ = true; + } + let _e1108 = phi_1646_; + let _e1110 = phi_1647_; + let _e1112 = phi_1648_; + if _e1112 { + if (_e100 >= 10u) { + phi_3334_ = (_e128 <= (_e100 - 10u)); + } else { + phi_3334_ = false; + } + let _e1117 = phi_3334_; + if _e1117 { + let _e1120 = global_2.member[_e128]; + let _e1125 = global_2.member[(_e128 + 1u)]; + let _e1130 = global_2.member[(_e128 + 2u)]; + let _e1136 = global_2.member[(_e128 + 3u)]; + let _e1141 = global_2.member[(_e128 + 4u)]; + let _e1146 = global_2.member[(_e128 + 5u)]; + let _e1151 = global_2.member[(_e128 + 6u)]; + let _e1157 = global_2.member[(_e128 + 7u)]; + let _e1162 = global_2.member[(_e128 + 8u)]; + let _e1167 = global_2.member[(_e128 + 9u)]; + phi_1701_ = type_27(vec3(bitcast(_e1120), bitcast(_e1125), bitcast(_e1130)), vec4(bitcast(_e1136), bitcast(_e1141), bitcast(_e1146), bitcast(_e1151)), vec3(bitcast(_e1157), bitcast(_e1162), bitcast(_e1167))); + } else { + phi_1701_ = type_27(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e1172 = phi_1701_; + phi_1703_ = _e1172; + } else { + phi_1703_ = _e1110; + } + let _e1174 = phi_1703_; + if select(_e1108, true, _e1112) { + let _e1190 = sqrt(fma(_e323.member_2.z, _e323.member_2.z, fma(_e323.member_2.x, _e323.member_2.x, (_e323.member_2.y * _e323.member_2.y)))); + if (_e1190 == 0f) { + phi_1750_ = vec3(0f, 0f, 0f); + } else { + phi_1750_ = (_e323.member_2 * (1f / _e1190)); + } + let _e1195 = phi_1750_; + let _e1204 = sqrt(fma(_e323.member_3.z, _e323.member_3.z, fma(_e323.member_3.x, _e323.member_3.x, (_e323.member_3.y * _e323.member_3.y)))); + if (_e1204 == 0f) { + phi_3379_ = vec3(0f, 0f, 0f); + } else { + phi_3379_ = (vec3(_e323.member_3.x, _e323.member_3.y, _e323.member_3.z) * (1f / _e1204)); + } + let _e1209 = phi_3379_; + let _e1216 = (_e1174.member_1.x + _e1174.member_1.x); + let _e1217 = (_e1174.member_1.y + _e1174.member_1.y); + let _e1218 = (_e1174.member_1.z + _e1174.member_1.z); + let _e1220 = (_e1174.member_1.z * _e1218); + let _e1221 = (_e1174.member_1.w * _e1216); + let _e1222 = (_e1174.member_1.w * _e1217); + let _e1223 = (_e1174.member_1.w * _e1218); + let _e1242 = (vec4((1f - fma(_e1174.member_1.y, _e1217, _e1220)), fma(_e1174.member_1.x, _e1217, _e1223), fma(_e1174.member_1.x, _e1218, -(_e1222)), 0f) * _e1174.member_2.x); + let _e1243 = (vec4(fma(_e1174.member_1.x, _e1217, -(_e1223)), (1f - fma(_e1174.member_1.x, _e1216, _e1220)), fma(_e1174.member_1.y, _e1218, _e1221), 0f) * _e1174.member_2.y); + let _e1244 = (vec4(fma(_e1174.member_1.x, _e1218, _e1222), fma(_e1174.member_1.y, _e1218, -(_e1221)), (1f - fma(_e1174.member_1.x, _e1216, (_e1174.member_1.y * _e1217))), 0f) * _e1174.member_2.z); + let _e1249 = (_e1195.x / (_e1174.member_2.x * _e1174.member_2.x)); + let _e1251 = (_e1195.y / (_e1174.member_2.y * _e1174.member_2.y)); + let _e1253 = (_e1195.z / (_e1174.member_2.z * _e1174.member_2.z)); + let _e1269 = fma(_e1244.x, _e1253, fma(_e1242.x, _e1249, (_e1243.x * _e1251))); + let _e1270 = fma(_e1244.y, _e1253, fma(_e1242.y, _e1249, (_e1243.y * _e1251))); + let _e1271 = fma(_e1244.z, _e1253, fma(_e1242.z, _e1249, (_e1243.z * _e1251))); + let _e1276 = sqrt(fma(_e1271, _e1271, fma(_e1269, _e1269, (_e1270 * _e1270)))); + if (_e1276 == 0f) { + phi_3461_ = vec3(0f, 0f, 0f); + } else { + phi_3461_ = (vec3(_e1269, _e1270, _e1271) * (1f / _e1276)); + } + let _e1281 = phi_3461_; + global_11 = _e1281; + let _e1291 = fma(_e1244.x, _e1209.z, fma(_e1242.x, _e1209.x, (_e1243.x * _e1209.y))); + let _e1292 = fma(_e1244.y, _e1209.z, fma(_e1242.y, _e1209.x, (_e1243.y * _e1209.y))); + let _e1293 = fma(_e1244.z, _e1209.z, fma(_e1242.z, _e1209.x, (_e1243.z * _e1209.y))); + let _e1298 = sqrt(fma(_e1293, _e1293, fma(_e1291, _e1291, (_e1292 * _e1292)))); + if (_e1298 == 0f) { + phi_3496_ = vec3(0f, 0f, 0f); + } else { + phi_3496_ = (vec3(_e1291, _e1292, _e1293) * (1f / _e1298)); + } + let _e1303 = phi_3496_; + global_12 = _e1303; + let _e1322 = select(-1f, 1f, (_e323.member_3.w >= 0f)); + global_13 = vec3((fma(_e1281.y, _e1303.z, -((_e1303.y * _e1281.z))) * _e1322), (fma(_e1281.z, _e1303.x, -((_e1303.z * _e1281.x))) * _e1322), (fma(_e1281.x, _e1303.y, -((_e1303.x * _e1281.y))) * _e1322)); + let _e1340 = (_e1174.member.x + fma(_e1244.x, _e323.member.z, fma(_e1243.x, _e323.member.y, (_e1242.x * _e323.member.x)))); + let _e1341 = (_e1174.member.y + fma(_e1244.y, _e323.member.z, fma(_e1243.y, _e323.member.y, (_e1242.y * _e323.member.x)))); + let _e1342 = (_e1174.member.z + fma(_e1244.z, _e323.member.z, fma(_e1243.z, _e323.member.y, (_e1242.z * _e323.member.x)))); + global_14 = vec3(_e1340, _e1341, _e1342); + if (_e100 >= 83u) { + phi_3509_ = (_e124 <= (_e100 - 83u)); + } else { + phi_3509_ = false; + } + let _e1348 = phi_3509_; + if _e1348 { + let _e1351 = global_2.member[_e124]; + let _e1356 = global_2.member[(_e124 + 1u)]; + let _e1361 = global_2.member[(_e124 + 2u)]; + let _e1366 = global_2.member[(_e124 + 3u)]; + let _e1372 = global_2.member[(_e124 + 4u)]; + let _e1377 = global_2.member[(_e124 + 5u)]; + let _e1382 = global_2.member[(_e124 + 6u)]; + let _e1387 = global_2.member[(_e124 + 7u)]; + let _e1393 = global_2.member[(_e124 + 8u)]; + let _e1398 = global_2.member[(_e124 + 9u)]; + let _e1403 = global_2.member[(_e124 + 10u)]; + let _e1408 = global_2.member[(_e124 + 11u)]; + let _e1414 = global_2.member[(_e124 + 12u)]; + let _e1419 = global_2.member[(_e124 + 13u)]; + let _e1424 = global_2.member[(_e124 + 14u)]; + let _e1429 = global_2.member[(_e124 + 15u)]; + let _e1436 = global_2.member[(_e124 + 16u)]; + let _e1441 = global_2.member[(_e124 + 17u)]; + let _e1446 = global_2.member[(_e124 + 18u)]; + let _e1451 = global_2.member[(_e124 + 19u)]; + let _e1457 = global_2.member[(_e124 + 20u)]; + let _e1462 = global_2.member[(_e124 + 21u)]; + let _e1467 = global_2.member[(_e124 + 22u)]; + let _e1472 = global_2.member[(_e124 + 23u)]; + let _e1478 = global_2.member[(_e124 + 24u)]; + let _e1483 = global_2.member[(_e124 + 25u)]; + let _e1488 = global_2.member[(_e124 + 26u)]; + let _e1493 = global_2.member[(_e124 + 27u)]; + let _e1499 = global_2.member[(_e124 + 28u)]; + let _e1504 = global_2.member[(_e124 + 29u)]; + let _e1509 = global_2.member[(_e124 + 30u)]; + let _e1514 = global_2.member[(_e124 + 31u)]; + let _e1521 = global_2.member[(_e124 + 32u)]; + let _e1526 = global_2.member[(_e124 + 33u)]; + let _e1531 = global_2.member[(_e124 + 34u)]; + local_3 = 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_2074_ = type_24(0u, 6u); + loop { + let _e1536 = phi_2074_; + if (_e1536.member < _e1536.member_1) { + phi_2090_ = type_24((_e1536.member + 1u), _e1536.member_1); + phi_2091_ = type_24(1u, _e1536.member); + } else { + phi_2090_ = _e1536; + phi_2091_ = type_24(0u, type_24().member_1); + } + let _e1549 = phi_2090_; + let _e1551 = phi_2091_; + switch bitcast(_e1551.member) { + case 0: { + let _e1555 = local_3; + local_2 = 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_2104_ = type_24(0u, 8u); + loop { + let _e1558 = phi_2104_; + if (_e1558.member < _e1558.member_1) { + phi_2120_ = type_24((_e1558.member + 1u), _e1558.member_1); + phi_2121_ = type_24(1u, _e1558.member); + } else { + phi_2120_ = _e1558; + phi_2121_ = type_24(0u, type_24().member_1); + } + let _e1571 = phi_2120_; + let _e1573 = phi_2121_; + switch bitcast(_e1573.member) { + case 0: { + let _e1577 = local_2; + phi_2147_ = type_22(type_20(vec4(bitcast(_e1351), bitcast(_e1356), bitcast(_e1361), bitcast(_e1366)), vec4(bitcast(_e1372), bitcast(_e1377), bitcast(_e1382), bitcast(_e1387)), vec4(bitcast(_e1393), bitcast(_e1398), bitcast(_e1403), bitcast(_e1408)), vec4(bitcast(_e1414), bitcast(_e1419), bitcast(_e1424), bitcast(_e1429))), type_20(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_21(_e1577, _e1555), vec3(bitcast(_e1521), bitcast(_e1526), bitcast(_e1531))); + phi_2148_ = false; + phi_2105_ = type_24(); + break; + } + case 1: { + let _e1581 = ((_e124 + 59u) + (_e1573.member_1 * 3u)); + let _e1584 = global_2.member[_e1581]; + let _e1589 = global_2.member[(_e1581 + 1u)]; + let _e1594 = global_2.member[(_e1581 + 2u)]; + local_2[_e1573.member_1] = vec3(bitcast(_e1584), bitcast(_e1589), bitcast(_e1594)); + phi_2147_ = type_22(); + phi_2148_ = true; + phi_2105_ = _e1571; + break; + } + default: { + phi_2147_ = type_22(); + phi_2148_ = false; + phi_2105_ = type_24(); + break; + } + } + let _e1599 = phi_2147_; + let _e1601 = phi_2148_; + let _e1603 = phi_2105_; + local_8 = _e1599; + continue; + continuing { + phi_2104_ = _e1603; + break if !(_e1601); + } + } + let _e2060 = local_8; + phi_2168_ = _e2060; + phi_2169_ = false; + phi_2075_ = type_24(); + break; + } + case 1: { + let _e1606 = ((_e124 + 35u) + (_e1551.member_1 * 4u)); + let _e1609 = global_2.member[_e1606]; + let _e1614 = global_2.member[(_e1606 + 1u)]; + let _e1619 = global_2.member[(_e1606 + 2u)]; + let _e1624 = global_2.member[(_e1606 + 3u)]; + local_3[_e1551.member_1] = vec4(bitcast(_e1609), bitcast(_e1614), bitcast(_e1619), bitcast(_e1624)); + phi_2168_ = type_22(); + phi_2169_ = true; + phi_2075_ = _e1549; + break; + } + default: { + phi_2168_ = type_22(); + phi_2169_ = false; + phi_2075_ = type_24(); + break; + } + } + let _e1629 = phi_2168_; + let _e1631 = phi_2169_; + let _e1633 = phi_2075_; + local_9 = _e1629; + continue; + continuing { + phi_2074_ = _e1633; + break if !(_e1631); + } + } + let _e2065 = local_9; + phi_2174_ = _e2065; + } else { + phi_2174_ = type_22(type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_21(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 _e1636 = phi_2174_; + global_1 = vec4((fma(fma(_e1636.member.member_3.x, _e1636.member_1.member_2.w, fma(_e1636.member.member_2.x, _e1636.member_1.member_2.z, fma(_e1636.member.member.x, _e1636.member_1.member_2.x, (_e1636.member.member_1.x * _e1636.member_1.member_2.y)))), _e1342, fma(fma(_e1636.member.member_3.x, _e1636.member_1.member.w, fma(_e1636.member.member_2.x, _e1636.member_1.member.z, fma(_e1636.member.member.x, _e1636.member_1.member.x, (_e1636.member.member_1.x * _e1636.member_1.member.y)))), _e1340, (fma(_e1636.member.member_3.x, _e1636.member_1.member_1.w, fma(_e1636.member.member_2.x, _e1636.member_1.member_1.z, fma(_e1636.member.member.x, _e1636.member_1.member_1.x, (_e1636.member.member_1.x * _e1636.member_1.member_1.y)))) * _e1341))) + fma(_e1636.member.member_3.x, _e1636.member_1.member_3.w, fma(_e1636.member.member_2.x, _e1636.member_1.member_3.z, fma(_e1636.member.member.x, _e1636.member_1.member_3.x, (_e1636.member.member_1.x * _e1636.member_1.member_3.y))))), (fma(fma(_e1636.member.member_3.y, _e1636.member_1.member_2.w, fma(_e1636.member.member_2.y, _e1636.member_1.member_2.z, fma(_e1636.member.member.y, _e1636.member_1.member_2.x, (_e1636.member.member_1.y * _e1636.member_1.member_2.y)))), _e1342, fma(fma(_e1636.member.member_3.y, _e1636.member_1.member.w, fma(_e1636.member.member_2.y, _e1636.member_1.member.z, fma(_e1636.member.member.y, _e1636.member_1.member.x, (_e1636.member.member_1.y * _e1636.member_1.member.y)))), _e1340, (fma(_e1636.member.member_3.y, _e1636.member_1.member_1.w, fma(_e1636.member.member_2.y, _e1636.member_1.member_1.z, fma(_e1636.member.member.y, _e1636.member_1.member_1.x, (_e1636.member.member_1.y * _e1636.member_1.member_1.y)))) * _e1341))) + fma(_e1636.member.member_3.y, _e1636.member_1.member_3.w, fma(_e1636.member.member_2.y, _e1636.member_1.member_3.z, fma(_e1636.member.member.y, _e1636.member_1.member_3.x, (_e1636.member.member_1.y * _e1636.member_1.member_3.y))))), (fma(fma(_e1636.member.member_3.z, _e1636.member_1.member_2.w, fma(_e1636.member.member_2.z, _e1636.member_1.member_2.z, fma(_e1636.member.member.z, _e1636.member_1.member_2.x, (_e1636.member.member_1.z * _e1636.member_1.member_2.y)))), _e1342, fma(fma(_e1636.member.member_3.z, _e1636.member_1.member.w, fma(_e1636.member.member_2.z, _e1636.member_1.member.z, fma(_e1636.member.member.z, _e1636.member_1.member.x, (_e1636.member.member_1.z * _e1636.member_1.member.y)))), _e1340, (fma(_e1636.member.member_3.z, _e1636.member_1.member_1.w, fma(_e1636.member.member_2.z, _e1636.member_1.member_1.z, fma(_e1636.member.member.z, _e1636.member_1.member_1.x, (_e1636.member.member_1.z * _e1636.member_1.member_1.y)))) * _e1341))) + fma(_e1636.member.member_3.z, _e1636.member_1.member_3.w, fma(_e1636.member.member_2.z, _e1636.member_1.member_3.z, fma(_e1636.member.member.z, _e1636.member_1.member_3.x, (_e1636.member.member_1.z * _e1636.member_1.member_3.y))))), (fma(fma(_e1636.member.member_3.w, _e1636.member_1.member_2.w, fma(_e1636.member.member_2.w, _e1636.member_1.member_2.z, fma(_e1636.member.member.w, _e1636.member_1.member_2.x, (_e1636.member.member_1.w * _e1636.member_1.member_2.y)))), _e1342, fma(fma(_e1636.member.member_3.w, _e1636.member_1.member.w, fma(_e1636.member.member_2.w, _e1636.member_1.member.z, fma(_e1636.member.member.w, _e1636.member_1.member.x, (_e1636.member.member_1.w * _e1636.member_1.member.y)))), _e1340, (fma(_e1636.member.member_3.w, _e1636.member_1.member_1.w, fma(_e1636.member.member_2.w, _e1636.member_1.member_1.z, fma(_e1636.member.member.w, _e1636.member_1.member_1.x, (_e1636.member.member_1.w * _e1636.member_1.member_1.y)))) * _e1341))) + fma(_e1636.member.member_3.w, _e1636.member_1.member_3.w, fma(_e1636.member.member_2.w, _e1636.member_1.member_3.z, fma(_e1636.member.member.w, _e1636.member_1.member_3.x, (_e1636.member.member_1.w * _e1636.member_1.member_3.y)))))); + } + phi_2375_ = false; + phi_903_ = type_24(); + phi_906_ = type_31(); + break; + } + case 1: { + if (_e338.member_1 >= _e144) { + phi_2235_ = 4294967295u; + } else { + phi_2235_ = (_e140 + (2u * _e338.member_1)); + } + let _e1764 = phi_2235_; + if (_e100 >= 2u) { + phi_3766_ = (_e1764 <= (_e100 - 2u)); + } else { + phi_3766_ = false; + } + let _e1769 = phi_3766_; + if _e1769 { + let _e1772 = global_2.member[_e1764]; + let _e1776 = global_2.member[(_e1764 + 1u)]; + phi_2253_ = type_24(_e1772, _e1776); + } else { + phi_2253_ = type_24(4294967295u, 0u); + } + let _e1779 = phi_2253_; + if (_e173 >= _e1779.member_1) { + phi_3792_ = 4294967295u; + } else { + phi_3792_ = (_e1779.member + (9u * _e173)); + } + let _e1786 = phi_3792_; + if (_e100 >= 9u) { + phi_3811_ = (_e1786 <= (_e100 - 9u)); + } else { + phi_3811_ = false; + } + let _e1791 = phi_3811_; + if _e1791 { + let _e1794 = global_2.member[_e1786]; + let _e1799 = global_2.member[(_e1786 + 1u)]; + let _e1804 = global_2.member[(_e1786 + 2u)]; + let _e1810 = global_2.member[(_e1786 + 3u)]; + let _e1815 = global_2.member[(_e1786 + 4u)]; + let _e1820 = global_2.member[(_e1786 + 5u)]; + let _e1826 = global_2.member[(_e1786 + 6u)]; + let _e1831 = global_2.member[(_e1786 + 7u)]; + let _e1836 = global_2.member[(_e1786 + 8u)]; + phi_2303_ = type_28(vec3(bitcast(_e1794), bitcast(_e1799), bitcast(_e1804)), vec3(bitcast(_e1810), bitcast(_e1815), bitcast(_e1820)), vec3(bitcast(_e1826), bitcast(_e1831), bitcast(_e1836))); + } else { + phi_2303_ = type_28(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f)); + } + let _e1841 = phi_2303_; + if (_e338.member_1 >= _e152) { + phi_2313_ = 4294967295u; + } else { + phi_2313_ = (_e148 + _e338.member_1); + } + let _e1845 = phi_2313_; + if (_e100 >= 1u) { + phi_3833_ = (_e1845 <= (_e100 - 1u)); + } else { + phi_3833_ = false; + } + let _e1850 = phi_3833_; + if _e1850 { + let _e1853 = global_2.member[_e1845]; + phi_2321_ = bitcast(_e1853); + } else { + phi_2321_ = 0f; + } + let _e1856 = phi_2321_; + let _e1879 = type_31(vec3(fma(_e1856, _e1841.member.x, _e323.member.x), fma(_e1856, _e1841.member.y, _e323.member.y), fma(_e1856, _e1841.member.z, _e323.member.z)), _e323.member_1, _e323.member_2, _e323.member_3, _e323.member_4, _e323.member_5, _e323.member_6, _e323.member_7); + let _e1902 = type_31(_e1879.member, _e1879.member_1, vec3(fma(_e1856, _e1841.member_1.x, _e323.member_2.x), fma(_e1856, _e1841.member_1.y, _e323.member_2.y), fma(_e1856, _e1841.member_1.z, _e323.member_2.z)), _e1879.member_3, _e1879.member_4, _e1879.member_5, _e1879.member_6, _e1879.member_7); + phi_2375_ = true; + phi_903_ = _e336; + phi_906_ = type_31(_e1902.member, _e1902.member_1, _e1902.member_2, vec4(fma(_e1856, _e1841.member_2.x, _e323.member_3.x), fma(_e1856, _e1841.member_2.y, _e323.member_3.y), fma(_e1856, _e1841.member_2.z, _e323.member_3.z), _e323.member_3.w), _e1902.member_4, _e1902.member_5, _e1902.member_6, _e1902.member_7); + break; + } + default: { + phi_2375_ = false; + phi_903_ = type_24(); + phi_906_ = type_31(); + break; + } + } + let _e1929 = phi_2375_; + let _e1931 = phi_903_; + let _e1933 = phi_906_; + continue; + continuing { + phi_902_ = _e1931; + phi_905_ = _e1933; + break if !(_e1929); + } + } + phi_2383_ = false; + phi_873_ = type_24(); + break; + } + case 1: { + let _e1938 = global_2.member[((_e178 + 22u) + _e313.member_1)]; + local_4[_e313.member_1] = bitcast(_e1938); + phi_2383_ = true; + phi_873_ = _e311; + break; + } + default: { + phi_2383_ = false; + phi_873_ = type_24(); + break; + } + } + let _e1942 = phi_2383_; + let _e1944 = phi_873_; + continue; + continuing { + phi_872_ = _e1944; + break if !(_e1942); + } + } + phi_2390_ = false; + phi_843_ = type_24(); + break; + } + case 1: { + let _e1949 = global_2.member[((_e178 + 18u) + _e291.member_1)]; + local_5[_e291.member_1] = _e1949; + phi_2390_ = true; + phi_843_ = _e289; + break; + } + default: { + phi_2390_ = false; + phi_843_ = type_24(); + break; + } + } + let _e1952 = phi_2390_; + let _e1954 = phi_843_; + continue; + continuing { + phi_842_ = _e1954; + break if !(_e1952); + } + } + } else { + global_1 = vec4(10f, 10f, 10f, 1f); + } + return; +} + +@vertex +fn stagerenderlet_vertex(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_3 = param; + global = param_1; + function(); + let _e16 = global_1.y; + global_1.y = -(_e16); + let _e18 = global_4; + let _e19 = global_5; + let _e20 = global_6; + let _e21 = global_7; + let _e22 = global_8; + let _e23 = global_9; + let _e24 = global_11; + let _e25 = global_12; + let _e26 = global_13; + let _e27 = global_14; + let _e28 = global_1; + return VertexOutput(_e18, _e19, _e20, _e21, _e22, _e23, _e24, _e25, _e26, _e27, _e28); +} diff --git a/crates/renderling/shaders/tonemapping-tonemapping_fragment.spv b/crates/renderling/shaders/tonemapping-tonemapping_fragment.spv new file mode 100644 index 00000000..c13cc9f5 Binary files /dev/null and b/crates/renderling/shaders/tonemapping-tonemapping_fragment.spv differ diff --git a/crates/renderling/shaders/tonemapping-tonemapping_fragment.wgsl b/crates/renderling/shaders/tonemapping-tonemapping_fragment.wgsl new file mode 100644 index 00000000..7f52467a --- /dev/null +++ b/crates/renderling/shaders/tonemapping-tonemapping_fragment.wgsl @@ -0,0 +1,86 @@ +struct type_7 { + member: array, +} + +struct type_14 { + member: u32, + member_1: f32, +} + +@group(0) @binding(0) +var global: type_7; +var global_1: vec2; +@group(0) @binding(2) +var global_2: sampler; +@group(0) @binding(1) +var global_3: texture_2d; +var global_4: vec4; + +fn function() { + var phi_142_: type_14; + var phi_190_: vec4; + + let _e53 = global_1; + let _e54 = textureSample(global_3, global_2, _e53); + if select(false, true, (arrayLength((&global.member)) >= 2u)) { + let _e59 = global.member[0u]; + let _e62 = global.member[1u]; + phi_142_ = type_14(_e59, bitcast(_e62)); + } else { + phi_142_ = type_14(0u, 1f); + } + let _e66 = phi_142_; + let _e70 = (_e54.x * _e66.member_1); + let _e72 = (_e54.y * _e66.member_1); + let _e74 = (_e54.z * _e66.member_1); + let _e76 = (_e54.w * _e66.member_1); + switch bitcast(_e66.member) { + case 1: { + let _e98 = min(vec3(max(((_e70 * fma(2.51f, _e70, 0.03f)) / fma(_e70, fma(2.43f, _e70, 0.59f), 0.14f)), 0f), max(((_e72 * fma(2.51f, _e72, 0.03f)) / fma(_e72, fma(2.43f, _e72, 0.59f), 0.14f)), 0f), max(((_e74 * fma(2.51f, _e74, 0.03f)) / fma(_e74, fma(2.43f, _e74, 0.59f), 0.14f)), 0f)), vec3(1f, 1f, 1f)); + phi_190_ = vec4(_e98.x, _e98.y, _e98.z, _e76); + break; + } + case 2: { + let _e109 = fma(0.04823f, _e74, fma(0.59719f, _e70, (0.35458f * _e72))); + let _e110 = fma(0.01566f, _e74, fma(0.076f, _e70, (0.90834f * _e72))); + let _e111 = fma(0.83777f, _e74, fma(0.0284f, _e70, (0.13383f * _e72))); + let _e124 = (fma(_e109, (_e109 + 0.0245786f), -0.000090537f) / fma(_e109, fma(0.983729f, _e109, 0.432951f), 0.238081f)); + let _e125 = (fma(_e110, (_e110 + 0.0245786f), -0.000090537f) / fma(_e110, fma(0.983729f, _e110, 0.432951f), 0.238081f)); + let _e126 = (fma(_e111, (_e111 + 0.0245786f), -0.000090537f) / fma(_e111, fma(0.983729f, _e111, 0.432951f), 0.238081f)); + let _e140 = min(vec3(max(fma(-0.07367f, _e126, fma(1.60475f, _e124, (-0.53108f * _e125))), 0f), max(fma(-0.00605f, _e126, fma(-0.10208f, _e124, (1.10813f * _e125))), 0f), max(fma(1.07602f, _e126, fma(-0.00327f, _e124, (-0.07276f * _e125))), 0f)), vec3(1f, 1f, 1f)); + phi_190_ = vec4(_e140.x, _e140.y, _e140.z, _e76); + break; + } + case 3: { + let _e151 = fma(_e74, 0.08038333f, fma(_e70, 0.9953167f, (_e72 * 0.59096664f))); + let _e152 = fma(_e74, 0.026099999f, fma(_e70, 0.12666667f, (_e72 * 1.5138999f))); + let _e153 = fma(_e74, 1.3962833f, fma(_e70, 0.047333334f, (_e72 * 0.22304998f))); + let _e166 = (fma(_e151, (_e151 + 0.0245786f), -0.000090537f) / fma(_e151, fma(0.983729f, _e151, 0.432951f), 0.238081f)); + let _e167 = (fma(_e152, (_e152 + 0.0245786f), -0.000090537f) / fma(_e152, fma(0.983729f, _e152, 0.432951f), 0.238081f)); + let _e168 = (fma(_e153, (_e153 + 0.0245786f), -0.000090537f) / fma(_e153, fma(0.983729f, _e153, 0.432951f), 0.238081f)); + let _e182 = min(vec3(max(fma(-0.07367f, _e168, fma(1.60475f, _e166, (-0.53108f * _e167))), 0f), max(fma(-0.00605f, _e168, fma(-0.10208f, _e166, (1.10813f * _e167))), 0f), max(fma(1.07602f, _e168, fma(-0.00327f, _e166, (-0.07276f * _e167))), 0f)), vec3(1f, 1f, 1f)); + phi_190_ = vec4(_e182.x, _e182.y, _e182.z, _e76); + break; + } + case 4: { + let _e192 = (vec3(_e70, _e72, _e74) / vec3(fma(_e54.x, _e66.member_1, 1f), fma(_e54.y, _e66.member_1, 1f), fma(_e54.z, _e66.member_1, 1f))); + phi_190_ = vec4(_e192.x, _e192.y, _e192.z, _e76); + break; + } + default: { + phi_190_ = vec4(_e70, _e72, _e74, _e76); + break; + } + } + let _e198 = phi_190_; + global_4 = _e198; + return; +} + +@fragment +fn tonemappingtonemapping_fragment(@location(0) param: vec2) -> @location(0) vec4 { + global_1 = param; + function(); + let _e3 = global_4; + return _e3; +} diff --git a/crates/renderling/shaders/tonemapping-tonemapping_vertex.spv b/crates/renderling/shaders/tonemapping-tonemapping_vertex.spv new file mode 100644 index 00000000..cd32400d Binary files /dev/null and b/crates/renderling/shaders/tonemapping-tonemapping_vertex.spv differ diff --git a/crates/renderling/shaders/tonemapping-tonemapping_vertex.wgsl b/crates/renderling/shaders/tonemapping-tonemapping_vertex.wgsl new file mode 100644 index 00000000..d1181607 --- /dev/null +++ b/crates/renderling/shaders/tonemapping-tonemapping_vertex.wgsl @@ -0,0 +1,38 @@ +struct type_9 { + member: vec2, + member_1: vec2, +} + +struct VertexOutput { + @location(0) member: vec2, + @builtin(position) member_1: vec4, +} + +var global: vec2; +var global_1: u32; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); + +fn function() { + var local: array; + + let _e22 = global_1; + local = array(type_9(vec2(-1f, 1f), vec2(0f, 0f)), type_9(vec2(-1f, -1f), vec2(0f, 1f)), type_9(vec2(1f, -1f), vec2(1f, 1f)), type_9(vec2(-1f, 1f), vec2(0f, 0f)), type_9(vec2(1f, -1f), vec2(1f, 1f)), type_9(vec2(1f, 1f), vec2(1f, 0f))); + if (_e22 < 6u) { + let _e26 = local[_e22].member; + let _e29 = local[_e22].member_1; + global = _e29; + global_2 = vec4(_e26.x, _e26.y, 0f, 1f); + } + return; +} + +@vertex +fn tonemappingtonemapping_vertex(@builtin(vertex_index) param: u32) -> VertexOutput { + global_1 = param; + function(); + let _e5 = global_2.y; + global_2.y = -(_e5); + let _e7 = global; + let _e8 = global_2; + return VertexOutput(_e7, _e8); +} diff --git a/crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.spv b/crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.spv new file mode 100644 index 00000000..a8e40545 Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.wgsl b/crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.wgsl new file mode 100644 index 00000000..4769c4d2 --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.wgsl @@ -0,0 +1,26 @@ +struct VertexOutput { + @location(0) member: vec4, + @builtin(position) member_1: vec4, +} + +var global: u32; +var global_1: vec4 = vec4(0f, 0f, 0f, 1f); +var global_2: vec4; + +fn function() { + let _e11 = global; + global_2 = vec4(1f, 0f, 0f, 1f); + global_1 = vec4((f32((1i - bitcast(_e11))) * 0.5f), (fma(f32((_e11 & 1u)), 2f, -1f) * 0.5f), 0f, 1f); + return; +} + +@vertex +fn tutorialtutorial_implicit_isosceles_vertex(@builtin(vertex_index) param: u32) -> VertexOutput { + global = param; + function(); + let _e5 = global_1.y; + global_1.y = -(_e5); + let _e7 = global_2; + let _e8 = global_1; + return VertexOutput(_e7, _e8); +} diff --git a/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.spv b/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.spv new file mode 100644 index 00000000..14696161 Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.wgsl b/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.wgsl new file mode 100644 index 00000000..96ad6c46 --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.wgsl @@ -0,0 +1,16 @@ +var global: vec4; +var global_1: vec4; + +fn function() { + let _e2 = global_1; + global = _e2; + return; +} + +@fragment +fn tutorialtutorial_passthru_fragment(@location(0) param: vec4) -> @location(0) vec4 { + global_1 = param; + function(); + let _e3 = global; + return _e3; +} diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv new file mode 100644 index 00000000..1f0d74b8 Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.wgsl b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.wgsl new file mode 100644 index 00000000..8356cb8a --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.wgsl @@ -0,0 +1,447 @@ +struct type_11 { + member: array, +} + +struct type_18 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_19 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_20 { + member: type_18, + member_1: type_18, + member_2: type_19, + member_3: vec3, +} + +struct type_22 { + member: u32, + member_1: u32, +} + +struct type_25 { + member: vec3, + member_1: vec4, + member_2: vec3, +} + +struct type_28 { + member: vec3, + member_1: vec4, + member_2: vec3, + member_3: vec4, + member_4: array, + member_5: array, + member_6: vec2, + member_7: vec2, +} + +struct VertexOutput { + @location(0) member: vec4, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_11; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); +var global_3: vec4; +var global_4: u32; + +fn function() { + var local: array, 8>; + var local_1: array, 6>; + var local_2: array; + var local_3: array; + var phi_614_: u32; + var phi_1390_: bool; + var phi_700_: type_22; + var phi_716_: type_22; + var phi_717_: type_22; + var phi_730_: type_22; + var phi_746_: type_22; + var phi_747_: type_22; + var phi_763_: type_28; + var phi_764_: bool; + var phi_731_: type_22; + var phi_770_: type_28; + var phi_771_: bool; + var phi_701_: type_22; + var phi_773_: type_28; + var phi_1421_: bool; + var phi_824_: type_25; + var phi_1492_: bool; + var phi_985_: type_22; + var phi_1001_: type_22; + var phi_1002_: type_22; + var phi_1015_: type_22; + var phi_1031_: type_22; + var phi_1032_: type_22; + var phi_1058_: type_20; + var phi_1059_: bool; + var phi_1016_: type_22; + var phi_1079_: type_20; + var phi_1080_: bool; + var phi_986_: type_22; + var phi_1085_: type_20; + var local_4: type_28; + var local_5: type_28; + var local_6: type_20; + var local_7: type_20; + + let _e77 = global_4; + let _e78 = global; + let _e80 = arrayLength((&global_1.member)); + let _e84 = global_1.member[(_e77 + 1u)]; + let _e88 = global_1.member[(_e77 + 2u)]; + let _e92 = global_1.member[(_e77 + 9u)]; + let _e96 = global_1.member[(_e77 + 10u)]; + if (_e78 >= _e88) { + phi_614_ = 4294967295u; + } else { + phi_614_ = (_e84 + (26u * _e78)); + } + let _e101 = phi_614_; + if (_e80 >= 26u) { + phi_1390_ = (_e101 <= (_e80 - 26u)); + } else { + phi_1390_ = false; + } + let _e106 = phi_1390_; + if _e106 { + let _e109 = global_1.member[_e101]; + let _e114 = global_1.member[(_e101 + 1u)]; + let _e119 = global_1.member[(_e101 + 2u)]; + let _e125 = global_1.member[(_e101 + 3u)]; + let _e130 = global_1.member[(_e101 + 4u)]; + let _e135 = global_1.member[(_e101 + 5u)]; + let _e140 = global_1.member[(_e101 + 6u)]; + let _e146 = global_1.member[(_e101 + 7u)]; + let _e151 = global_1.member[(_e101 + 8u)]; + let _e157 = global_1.member[(_e101 + 9u)]; + let _e162 = global_1.member[(_e101 + 10u)]; + let _e168 = global_1.member[(_e101 + 11u)]; + let _e173 = global_1.member[(_e101 + 12u)]; + let _e178 = global_1.member[(_e101 + 13u)]; + let _e184 = global_1.member[(_e101 + 14u)]; + let _e189 = global_1.member[(_e101 + 15u)]; + let _e194 = global_1.member[(_e101 + 16u)]; + let _e199 = global_1.member[(_e101 + 17u)]; + local_3 = array(0u, 0u, 0u, 0u); + phi_700_ = type_22(0u, 4u); + loop { + let _e204 = phi_700_; + if (_e204.member < _e204.member_1) { + phi_716_ = type_22((_e204.member + 1u), _e204.member_1); + phi_717_ = type_22(1u, _e204.member); + } else { + phi_716_ = _e204; + phi_717_ = type_22(0u, type_22().member_1); + } + let _e217 = phi_716_; + let _e219 = phi_717_; + switch bitcast(_e219.member) { + case 0: { + let _e223 = local_3; + local_2 = array(0f, 0f, 0f, 0f); + phi_730_ = type_22(0u, 4u); + loop { + let _e226 = phi_730_; + if (_e226.member < _e226.member_1) { + phi_746_ = type_22((_e226.member + 1u), _e226.member_1); + phi_747_ = type_22(1u, _e226.member); + } else { + phi_746_ = _e226; + phi_747_ = type_22(0u, type_22().member_1); + } + let _e239 = phi_746_; + let _e241 = phi_747_; + switch bitcast(_e241.member) { + case 0: { + let _e245 = local_2; + phi_763_ = type_28(vec3(bitcast(_e109), bitcast(_e114), bitcast(_e119)), vec4(bitcast(_e125), bitcast(_e130), bitcast(_e135), bitcast(_e140)), vec3(bitcast(_e168), bitcast(_e173), bitcast(_e178)), vec4(bitcast(_e184), bitcast(_e189), bitcast(_e194), bitcast(_e199)), _e223, _e245, vec2(bitcast(_e146), bitcast(_e151)), vec2(bitcast(_e157), bitcast(_e162))); + phi_764_ = false; + phi_731_ = type_22(); + break; + } + case 1: { + let _e250 = global_1.member[((_e101 + 22u) + _e241.member_1)]; + local_2[_e241.member_1] = bitcast(_e250); + phi_763_ = type_28(); + phi_764_ = true; + phi_731_ = _e239; + break; + } + default: { + phi_763_ = type_28(); + phi_764_ = false; + phi_731_ = type_22(); + break; + } + } + let _e254 = phi_763_; + let _e256 = phi_764_; + let _e258 = phi_731_; + local_4 = _e254; + continue; + continuing { + phi_730_ = _e258; + break if !(_e256); + } + } + let _e886 = local_4; + phi_770_ = _e886; + phi_771_ = false; + phi_701_ = type_22(); + break; + } + case 1: { + let _e263 = global_1.member[((_e101 + 18u) + _e219.member_1)]; + local_3[_e219.member_1] = _e263; + phi_770_ = type_28(); + phi_771_ = true; + phi_701_ = _e217; + break; + } + default: { + phi_770_ = type_28(); + phi_771_ = false; + phi_701_ = type_22(); + break; + } + } + let _e266 = phi_770_; + let _e268 = phi_771_; + let _e270 = phi_701_; + local_5 = _e266; + continue; + continuing { + phi_700_ = _e270; + break if !(_e268); + } + } + let _e891 = local_5; + phi_773_ = _e891; + } else { + phi_773_ = type_28(vec3(0f, 0f, 0f), vec4(1f, 1f, 1f, 1f), vec3(0f, 0f, 1f), vec4(0f, 1f, 0f, 0f), array(0u, 0u, 0u, 0u), array(0f, 0f, 0f, 0f), vec2(0f, 0f), vec2(0f, 0f)); + } + let _e273 = phi_773_; + global_3 = _e273.member_1; + if (_e80 >= 10u) { + phi_1421_ = (_e96 <= (_e80 - 10u)); + } else { + phi_1421_ = false; + } + let _e279 = phi_1421_; + if _e279 { + let _e282 = global_1.member[_e96]; + let _e287 = global_1.member[(_e96 + 1u)]; + let _e292 = global_1.member[(_e96 + 2u)]; + let _e298 = global_1.member[(_e96 + 3u)]; + let _e303 = global_1.member[(_e96 + 4u)]; + let _e308 = global_1.member[(_e96 + 5u)]; + let _e313 = global_1.member[(_e96 + 6u)]; + let _e319 = global_1.member[(_e96 + 7u)]; + let _e324 = global_1.member[(_e96 + 8u)]; + let _e329 = global_1.member[(_e96 + 9u)]; + phi_824_ = type_25(vec3(bitcast(_e282), bitcast(_e287), bitcast(_e292)), vec4(bitcast(_e298), bitcast(_e303), bitcast(_e308), bitcast(_e313)), vec3(bitcast(_e319), bitcast(_e324), bitcast(_e329))); + } else { + phi_824_ = type_25(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e334 = phi_824_; + let _e342 = (_e334.member_1.x + _e334.member_1.x); + let _e343 = (_e334.member_1.y + _e334.member_1.y); + let _e344 = (_e334.member_1.z + _e334.member_1.z); + let _e346 = (_e334.member_1.z * _e344); + let _e347 = (_e334.member_1.w * _e342); + let _e348 = (_e334.member_1.w * _e343); + let _e349 = (_e334.member_1.w * _e344); + let _e369 = (vec4((1f - fma(_e334.member_1.y, _e343, _e346)), fma(_e334.member_1.x, _e343, _e349), fma(_e334.member_1.x, _e344, -(_e348)), 0f) * _e334.member_2.x); + let _e371 = (vec4(fma(_e334.member_1.x, _e343, -(_e349)), (1f - fma(_e334.member_1.x, _e342, _e346)), fma(_e334.member_1.y, _e344, _e347), 0f) * _e334.member_2.y); + let _e373 = (vec4(fma(_e334.member_1.x, _e344, _e348), fma(_e334.member_1.y, _e344, -(_e347)), (1f - fma(_e334.member_1.x, _e342, (_e334.member_1.y * _e343))), 0f) * _e334.member_2.z); + if (_e80 >= 83u) { + phi_1492_ = (_e92 <= (_e80 - 83u)); + } else { + phi_1492_ = false; + } + let _e381 = phi_1492_; + if _e381 { + let _e384 = global_1.member[_e92]; + let _e389 = global_1.member[(_e92 + 1u)]; + let _e394 = global_1.member[(_e92 + 2u)]; + let _e399 = global_1.member[(_e92 + 3u)]; + let _e405 = global_1.member[(_e92 + 4u)]; + let _e410 = global_1.member[(_e92 + 5u)]; + let _e415 = global_1.member[(_e92 + 6u)]; + let _e420 = global_1.member[(_e92 + 7u)]; + let _e426 = global_1.member[(_e92 + 8u)]; + let _e431 = global_1.member[(_e92 + 9u)]; + let _e436 = global_1.member[(_e92 + 10u)]; + let _e441 = global_1.member[(_e92 + 11u)]; + let _e447 = global_1.member[(_e92 + 12u)]; + let _e452 = global_1.member[(_e92 + 13u)]; + let _e457 = global_1.member[(_e92 + 14u)]; + let _e462 = global_1.member[(_e92 + 15u)]; + let _e469 = global_1.member[(_e92 + 16u)]; + let _e474 = global_1.member[(_e92 + 17u)]; + let _e479 = global_1.member[(_e92 + 18u)]; + let _e484 = global_1.member[(_e92 + 19u)]; + let _e490 = global_1.member[(_e92 + 20u)]; + let _e495 = global_1.member[(_e92 + 21u)]; + let _e500 = global_1.member[(_e92 + 22u)]; + let _e505 = global_1.member[(_e92 + 23u)]; + let _e511 = global_1.member[(_e92 + 24u)]; + let _e516 = global_1.member[(_e92 + 25u)]; + let _e521 = global_1.member[(_e92 + 26u)]; + let _e526 = global_1.member[(_e92 + 27u)]; + let _e532 = global_1.member[(_e92 + 28u)]; + let _e537 = global_1.member[(_e92 + 29u)]; + let _e542 = global_1.member[(_e92 + 30u)]; + let _e547 = global_1.member[(_e92 + 31u)]; + let _e554 = global_1.member[(_e92 + 32u)]; + let _e559 = global_1.member[(_e92 + 33u)]; + let _e564 = global_1.member[(_e92 + 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_985_ = type_22(0u, 6u); + loop { + let _e569 = phi_985_; + if (_e569.member < _e569.member_1) { + phi_1001_ = type_22((_e569.member + 1u), _e569.member_1); + phi_1002_ = type_22(1u, _e569.member); + } else { + phi_1001_ = _e569; + phi_1002_ = type_22(0u, type_22().member_1); + } + let _e582 = phi_1001_; + let _e584 = phi_1002_; + switch bitcast(_e584.member) { + case 0: { + let _e588 = 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_1015_ = type_22(0u, 8u); + loop { + let _e591 = phi_1015_; + if (_e591.member < _e591.member_1) { + phi_1031_ = type_22((_e591.member + 1u), _e591.member_1); + phi_1032_ = type_22(1u, _e591.member); + } else { + phi_1031_ = _e591; + phi_1032_ = type_22(0u, type_22().member_1); + } + let _e604 = phi_1031_; + let _e606 = phi_1032_; + switch bitcast(_e606.member) { + case 0: { + let _e610 = local; + phi_1058_ = type_20(type_18(vec4(bitcast(_e384), bitcast(_e389), bitcast(_e394), bitcast(_e399)), vec4(bitcast(_e405), bitcast(_e410), bitcast(_e415), bitcast(_e420)), vec4(bitcast(_e426), bitcast(_e431), bitcast(_e436), bitcast(_e441)), vec4(bitcast(_e447), bitcast(_e452), bitcast(_e457), bitcast(_e462))), type_18(vec4(bitcast(_e469), bitcast(_e474), bitcast(_e479), bitcast(_e484)), vec4(bitcast(_e490), bitcast(_e495), bitcast(_e500), bitcast(_e505)), vec4(bitcast(_e511), bitcast(_e516), bitcast(_e521), bitcast(_e526)), vec4(bitcast(_e532), bitcast(_e537), bitcast(_e542), bitcast(_e547))), type_19(_e610, _e588), vec3(bitcast(_e554), bitcast(_e559), bitcast(_e564))); + phi_1059_ = false; + phi_1016_ = type_22(); + break; + } + case 1: { + let _e614 = ((_e92 + 59u) + (_e606.member_1 * 3u)); + let _e617 = global_1.member[_e614]; + let _e622 = global_1.member[(_e614 + 1u)]; + let _e627 = global_1.member[(_e614 + 2u)]; + local[_e606.member_1] = vec3(bitcast(_e617), bitcast(_e622), bitcast(_e627)); + phi_1058_ = type_20(); + phi_1059_ = true; + phi_1016_ = _e604; + break; + } + default: { + phi_1058_ = type_20(); + phi_1059_ = false; + phi_1016_ = type_22(); + break; + } + } + let _e632 = phi_1058_; + let _e634 = phi_1059_; + let _e636 = phi_1016_; + local_6 = _e632; + continue; + continuing { + phi_1015_ = _e636; + break if !(_e634); + } + } + let _e906 = local_6; + phi_1079_ = _e906; + phi_1080_ = false; + phi_986_ = type_22(); + break; + } + case 1: { + let _e639 = ((_e92 + 35u) + (_e584.member_1 * 4u)); + let _e642 = global_1.member[_e639]; + let _e647 = global_1.member[(_e639 + 1u)]; + let _e652 = global_1.member[(_e639 + 2u)]; + let _e657 = global_1.member[(_e639 + 3u)]; + local_1[_e584.member_1] = vec4(bitcast(_e642), bitcast(_e647), bitcast(_e652), bitcast(_e657)); + phi_1079_ = type_20(); + phi_1080_ = true; + phi_986_ = _e582; + break; + } + default: { + phi_1079_ = type_20(); + phi_1080_ = false; + phi_986_ = type_22(); + break; + } + } + let _e662 = phi_1079_; + let _e664 = phi_1080_; + let _e666 = phi_986_; + local_7 = _e662; + continue; + continuing { + phi_985_ = _e666; + break if !(_e664); + } + } + let _e911 = local_7; + phi_1085_ = _e911; + } else { + phi_1085_ = type_20(type_18(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_18(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)), type_19(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 _e669 = phi_1085_; + let _e709 = fma(_e669.member.member_3.x, _e669.member_1.member.w, fma(_e669.member.member_2.x, _e669.member_1.member.z, fma(_e669.member.member.x, _e669.member_1.member.x, (_e669.member.member_1.x * _e669.member_1.member.y)))); + let _e710 = fma(_e669.member.member_3.y, _e669.member_1.member.w, fma(_e669.member.member_2.y, _e669.member_1.member.z, fma(_e669.member.member.y, _e669.member_1.member.x, (_e669.member.member_1.y * _e669.member_1.member.y)))); + let _e711 = fma(_e669.member.member_3.z, _e669.member_1.member.w, fma(_e669.member.member_2.z, _e669.member_1.member.z, fma(_e669.member.member.z, _e669.member_1.member.x, (_e669.member.member_1.z * _e669.member_1.member.y)))); + let _e712 = fma(_e669.member.member_3.w, _e669.member_1.member.w, fma(_e669.member.member_2.w, _e669.member_1.member.z, fma(_e669.member.member.w, _e669.member_1.member.x, (_e669.member.member_1.w * _e669.member_1.member.y)))); + let _e730 = fma(_e669.member.member_3.x, _e669.member_1.member_1.w, fma(_e669.member.member_2.x, _e669.member_1.member_1.z, fma(_e669.member.member.x, _e669.member_1.member_1.x, (_e669.member.member_1.x * _e669.member_1.member_1.y)))); + let _e731 = fma(_e669.member.member_3.y, _e669.member_1.member_1.w, fma(_e669.member.member_2.y, _e669.member_1.member_1.z, fma(_e669.member.member.y, _e669.member_1.member_1.x, (_e669.member.member_1.y * _e669.member_1.member_1.y)))); + let _e732 = fma(_e669.member.member_3.z, _e669.member_1.member_1.w, fma(_e669.member.member_2.z, _e669.member_1.member_1.z, fma(_e669.member.member.z, _e669.member_1.member_1.x, (_e669.member.member_1.z * _e669.member_1.member_1.y)))); + let _e733 = fma(_e669.member.member_3.w, _e669.member_1.member_1.w, fma(_e669.member.member_2.w, _e669.member_1.member_1.z, fma(_e669.member.member.w, _e669.member_1.member_1.x, (_e669.member.member_1.w * _e669.member_1.member_1.y)))); + let _e751 = fma(_e669.member.member_3.x, _e669.member_1.member_2.w, fma(_e669.member.member_2.x, _e669.member_1.member_2.z, fma(_e669.member.member.x, _e669.member_1.member_2.x, (_e669.member.member_1.x * _e669.member_1.member_2.y)))); + let _e752 = fma(_e669.member.member_3.y, _e669.member_1.member_2.w, fma(_e669.member.member_2.y, _e669.member_1.member_2.z, fma(_e669.member.member.y, _e669.member_1.member_2.x, (_e669.member.member_1.y * _e669.member_1.member_2.y)))); + let _e753 = fma(_e669.member.member_3.z, _e669.member_1.member_2.w, fma(_e669.member.member_2.z, _e669.member_1.member_2.z, fma(_e669.member.member.z, _e669.member_1.member_2.x, (_e669.member.member_1.z * _e669.member_1.member_2.y)))); + let _e754 = fma(_e669.member.member_3.w, _e669.member_1.member_2.w, fma(_e669.member.member_2.w, _e669.member_1.member_2.z, fma(_e669.member.member.w, _e669.member_1.member_2.x, (_e669.member.member_1.w * _e669.member_1.member_2.y)))); + let _e772 = fma(_e669.member.member_3.x, _e669.member_1.member_3.w, fma(_e669.member.member_2.x, _e669.member_1.member_3.z, fma(_e669.member.member.x, _e669.member_1.member_3.x, (_e669.member.member_1.x * _e669.member_1.member_3.y)))); + let _e773 = fma(_e669.member.member_3.y, _e669.member_1.member_3.w, fma(_e669.member.member_2.y, _e669.member_1.member_3.z, fma(_e669.member.member.y, _e669.member_1.member_3.x, (_e669.member.member_1.y * _e669.member_1.member_3.y)))); + let _e774 = fma(_e669.member.member_3.z, _e669.member_1.member_3.w, fma(_e669.member.member_2.z, _e669.member_1.member_3.z, fma(_e669.member.member.z, _e669.member_1.member_3.x, (_e669.member.member_1.z * _e669.member_1.member_3.y)))); + let _e775 = fma(_e669.member.member_3.w, _e669.member_1.member_3.w, fma(_e669.member.member_2.w, _e669.member_1.member_3.z, fma(_e669.member.member.w, _e669.member_1.member_3.x, (_e669.member.member_1.w * _e669.member_1.member_3.y)))); + global_2 = vec4((fma(fma(_e772, _e373.w, fma(_e751, _e373.z, fma(_e709, _e373.x, (_e730 * _e373.y)))), _e273.member.z, fma(fma(_e772, _e369.w, fma(_e751, _e369.z, fma(_e709, _e369.x, (_e730 * _e369.y)))), _e273.member.x, (fma(_e772, _e371.w, fma(_e751, _e371.z, fma(_e709, _e371.x, (_e730 * _e371.y)))) * _e273.member.y))) + (fma(_e751, _e334.member.z, fma(_e709, _e334.member.x, (_e730 * _e334.member.y))) + _e772)), (fma(fma(_e773, _e373.w, fma(_e752, _e373.z, fma(_e710, _e373.x, (_e731 * _e373.y)))), _e273.member.z, fma(fma(_e773, _e369.w, fma(_e752, _e369.z, fma(_e710, _e369.x, (_e731 * _e369.y)))), _e273.member.x, (fma(_e773, _e371.w, fma(_e752, _e371.z, fma(_e710, _e371.x, (_e731 * _e371.y)))) * _e273.member.y))) + (fma(_e752, _e334.member.z, fma(_e710, _e334.member.x, (_e731 * _e334.member.y))) + _e773)), (fma(fma(_e774, _e373.w, fma(_e753, _e373.z, fma(_e711, _e373.x, (_e732 * _e373.y)))), _e273.member.z, fma(fma(_e774, _e369.w, fma(_e753, _e369.z, fma(_e711, _e369.x, (_e732 * _e369.y)))), _e273.member.x, (fma(_e774, _e371.w, fma(_e753, _e371.z, fma(_e711, _e371.x, (_e732 * _e371.y)))) * _e273.member.y))) + (fma(_e753, _e334.member.z, fma(_e711, _e334.member.x, (_e732 * _e334.member.y))) + _e774)), (fma(fma(_e775, _e373.w, fma(_e754, _e373.z, fma(_e712, _e373.x, (_e733 * _e373.y)))), _e273.member.z, fma(fma(_e775, _e369.w, fma(_e754, _e369.z, fma(_e712, _e369.x, (_e733 * _e369.y)))), _e273.member.x, (fma(_e775, _e371.w, fma(_e754, _e371.z, fma(_e712, _e371.x, (_e733 * _e371.y)))) * _e273.member.y))) + (fma(_e754, _e334.member.z, fma(_e712, _e334.member.x, (_e733 * _e334.member.y))) + _e775))); + return; +} + +@vertex +fn tutorialtutorial_slabbed_renderlet(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_4 = param; + global = param_1; + function(); + let _e7 = global_2.y; + global_2.y = -(_e7); + let _e9 = global_3; + let _e10 = global_2; + return VertexOutput(_e9, _e10); +} diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv new file mode 100644 index 00000000..66dd7164 Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.wgsl b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.wgsl new file mode 100644 index 00000000..7dd1ceca --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.wgsl @@ -0,0 +1,218 @@ +struct type_8 { + member: array, +} + +struct type_13 { + member: u32, + member_1: u32, +} + +struct type_18 { + member: vec3, + member_1: vec4, + member_2: vec3, + member_3: vec4, + member_4: array, + member_5: array, + member_6: vec2, + member_7: vec2, +} + +struct VertexOutput { + @location(0) member: vec4, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_8; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); +var global_3: vec4; +var global_4: u32; + +fn function() { + var local: array; + var local_1: array; + var phi_369_: bool; + var phi_148_: type_13; + var phi_395_: u32; + var phi_414_: bool; + var phi_239_: type_13; + var phi_255_: type_13; + var phi_256_: type_13; + var phi_269_: type_13; + var phi_285_: type_13; + var phi_286_: type_13; + var phi_302_: type_18; + var phi_303_: bool; + var phi_270_: type_13; + var phi_309_: type_18; + var phi_310_: bool; + var phi_240_: type_13; + var phi_312_: type_18; + var local_2: type_18; + var local_3: type_18; + + let _e45 = global_4; + let _e46 = global; + let _e48 = arrayLength((&global_1.member)); + if (_e48 >= 2u) { + phi_369_ = (_e45 <= (_e48 - 2u)); + } else { + phi_369_ = false; + } + let _e53 = phi_369_; + if _e53 { + let _e56 = global_1.member[_e45]; + let _e60 = global_1.member[(_e45 + 1u)]; + phi_148_ = type_13(_e56, _e60); + } else { + phi_148_ = type_13(4294967295u, 0u); + } + let _e63 = phi_148_; + if (_e46 >= _e63.member_1) { + phi_395_ = 4294967295u; + } else { + phi_395_ = (_e63.member + (26u * _e46)); + } + let _e70 = phi_395_; + if (_e48 >= 26u) { + phi_414_ = (_e70 <= (_e48 - 26u)); + } else { + phi_414_ = false; + } + let _e75 = phi_414_; + if _e75 { + let _e78 = global_1.member[_e70]; + let _e83 = global_1.member[(_e70 + 1u)]; + let _e88 = global_1.member[(_e70 + 2u)]; + let _e94 = global_1.member[(_e70 + 3u)]; + let _e99 = global_1.member[(_e70 + 4u)]; + let _e104 = global_1.member[(_e70 + 5u)]; + let _e109 = global_1.member[(_e70 + 6u)]; + let _e115 = global_1.member[(_e70 + 7u)]; + let _e120 = global_1.member[(_e70 + 8u)]; + let _e126 = global_1.member[(_e70 + 9u)]; + let _e131 = global_1.member[(_e70 + 10u)]; + let _e137 = global_1.member[(_e70 + 11u)]; + let _e142 = global_1.member[(_e70 + 12u)]; + let _e147 = global_1.member[(_e70 + 13u)]; + let _e153 = global_1.member[(_e70 + 14u)]; + let _e158 = global_1.member[(_e70 + 15u)]; + let _e163 = global_1.member[(_e70 + 16u)]; + let _e168 = global_1.member[(_e70 + 17u)]; + local_1 = array(0u, 0u, 0u, 0u); + phi_239_ = type_13(0u, 4u); + loop { + let _e173 = phi_239_; + if (_e173.member < _e173.member_1) { + phi_255_ = type_13((_e173.member + 1u), _e173.member_1); + phi_256_ = type_13(1u, _e173.member); + } else { + phi_255_ = _e173; + phi_256_ = type_13(0u, type_13().member_1); + } + let _e186 = phi_255_; + let _e188 = phi_256_; + switch bitcast(_e188.member) { + case 0: { + let _e192 = local_1; + local = array(0f, 0f, 0f, 0f); + phi_269_ = type_13(0u, 4u); + loop { + let _e195 = phi_269_; + if (_e195.member < _e195.member_1) { + phi_285_ = type_13((_e195.member + 1u), _e195.member_1); + phi_286_ = type_13(1u, _e195.member); + } else { + phi_285_ = _e195; + phi_286_ = type_13(0u, type_13().member_1); + } + let _e208 = phi_285_; + let _e210 = phi_286_; + switch bitcast(_e210.member) { + case 0: { + let _e214 = local; + phi_302_ = type_18(vec3(bitcast(_e78), bitcast(_e83), bitcast(_e88)), vec4(bitcast(_e94), bitcast(_e99), bitcast(_e104), bitcast(_e109)), vec3(bitcast(_e137), bitcast(_e142), bitcast(_e147)), vec4(bitcast(_e153), bitcast(_e158), bitcast(_e163), bitcast(_e168)), _e192, _e214, vec2(bitcast(_e115), bitcast(_e120)), vec2(bitcast(_e126), bitcast(_e131))); + phi_303_ = false; + phi_270_ = type_13(); + break; + } + case 1: { + let _e219 = global_1.member[((_e70 + 22u) + _e210.member_1)]; + local[_e210.member_1] = bitcast(_e219); + phi_302_ = type_18(); + phi_303_ = true; + phi_270_ = _e208; + break; + } + default: { + phi_302_ = type_18(); + phi_303_ = false; + phi_270_ = type_13(); + break; + } + } + let _e223 = phi_302_; + let _e225 = phi_303_; + let _e227 = phi_270_; + local_2 = _e223; + continue; + continuing { + phi_269_ = _e227; + break if !(_e225); + } + } + let _e264 = local_2; + phi_309_ = _e264; + phi_310_ = false; + phi_240_ = type_13(); + break; + } + case 1: { + let _e232 = global_1.member[((_e70 + 18u) + _e188.member_1)]; + local_1[_e188.member_1] = _e232; + phi_309_ = type_18(); + phi_310_ = true; + phi_240_ = _e186; + break; + } + default: { + phi_309_ = type_18(); + phi_310_ = false; + phi_240_ = type_13(); + break; + } + } + let _e235 = phi_309_; + let _e237 = phi_310_; + let _e239 = phi_240_; + local_3 = _e235; + continue; + continuing { + phi_239_ = _e239; + break if !(_e237); + } + } + let _e269 = local_3; + phi_312_ = _e269; + } else { + phi_312_ = type_18(vec3(0f, 0f, 0f), vec4(1f, 1f, 1f, 1f), vec3(0f, 0f, 1f), vec4(0f, 1f, 0f, 0f), array(0u, 0u, 0u, 0u), array(0f, 0f, 0f, 0f), vec2(0f, 0f), vec2(0f, 0f)); + } + let _e242 = phi_312_; + global_2 = vec4(_e242.member.x, _e242.member.y, _e242.member.z, 1f); + global_3 = _e242.member_1; + return; +} + +@vertex +fn tutorialtutorial_slabbed_vertices(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_4 = param; + global = param_1; + function(); + let _e7 = global_2.y; + global_2.y = -(_e7); + let _e9 = global_3; + let _e10 = global_2; + return VertexOutput(_e9, _e10); +} diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv new file mode 100644 index 00000000..1ab9440d Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl new file mode 100644 index 00000000..244a8536 --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl @@ -0,0 +1,193 @@ +struct type_8 { + member: array, +} + +struct type_13 { + member: u32, + member_1: u32, +} + +struct type_18 { + member: vec3, + member_1: vec4, + member_2: vec3, + member_3: vec4, + member_4: array, + member_5: array, + member_6: vec2, + member_7: vec2, +} + +struct VertexOutput { + @location(0) member: vec4, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_8; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); +var global_3: vec4; + +fn function() { + var local: array; + var local_1: array; + var phi_300_: bool; + var phi_179_: type_13; + var phi_195_: type_13; + var phi_196_: type_13; + var phi_209_: type_13; + var phi_225_: type_13; + var phi_226_: type_13; + var phi_242_: type_18; + var phi_243_: bool; + var phi_210_: type_13; + var phi_249_: type_18; + var phi_250_: bool; + var phi_180_: type_13; + var phi_252_: type_18; + var local_2: type_18; + var local_3: type_18; + + let _e42 = global; + let _e44 = arrayLength((&global_1.member)); + let _e45 = (_e42 * 26u); + if (_e44 >= 26u) { + phi_300_ = (_e45 <= (_e44 - 26u)); + } else { + phi_300_ = false; + } + let _e50 = phi_300_; + if _e50 { + let _e53 = global_1.member[_e45]; + let _e58 = global_1.member[(_e45 + 1u)]; + let _e63 = global_1.member[(_e45 + 2u)]; + let _e69 = global_1.member[(_e45 + 3u)]; + let _e74 = global_1.member[(_e45 + 4u)]; + let _e79 = global_1.member[(_e45 + 5u)]; + let _e84 = global_1.member[(_e45 + 6u)]; + let _e90 = global_1.member[(_e45 + 7u)]; + let _e95 = global_1.member[(_e45 + 8u)]; + let _e101 = global_1.member[(_e45 + 9u)]; + let _e106 = global_1.member[(_e45 + 10u)]; + let _e112 = global_1.member[(_e45 + 11u)]; + let _e117 = global_1.member[(_e45 + 12u)]; + let _e122 = global_1.member[(_e45 + 13u)]; + let _e128 = global_1.member[(_e45 + 14u)]; + let _e133 = global_1.member[(_e45 + 15u)]; + let _e138 = global_1.member[(_e45 + 16u)]; + let _e143 = global_1.member[(_e45 + 17u)]; + local_1 = array(0u, 0u, 0u, 0u); + phi_179_ = type_13(0u, 4u); + loop { + let _e148 = phi_179_; + if (_e148.member < _e148.member_1) { + phi_195_ = type_13((_e148.member + 1u), _e148.member_1); + phi_196_ = type_13(1u, _e148.member); + } else { + phi_195_ = _e148; + phi_196_ = type_13(0u, type_13().member_1); + } + let _e161 = phi_195_; + let _e163 = phi_196_; + switch bitcast(_e163.member) { + case 0: { + let _e167 = local_1; + local = array(0f, 0f, 0f, 0f); + phi_209_ = type_13(0u, 4u); + loop { + let _e170 = phi_209_; + if (_e170.member < _e170.member_1) { + phi_225_ = type_13((_e170.member + 1u), _e170.member_1); + phi_226_ = type_13(1u, _e170.member); + } else { + phi_225_ = _e170; + phi_226_ = type_13(0u, type_13().member_1); + } + let _e183 = phi_225_; + let _e185 = phi_226_; + switch bitcast(_e185.member) { + case 0: { + let _e189 = local; + phi_242_ = type_18(vec3(bitcast(_e53), bitcast(_e58), bitcast(_e63)), vec4(bitcast(_e69), bitcast(_e74), bitcast(_e79), bitcast(_e84)), vec3(bitcast(_e112), bitcast(_e117), bitcast(_e122)), vec4(bitcast(_e128), bitcast(_e133), bitcast(_e138), bitcast(_e143)), _e167, _e189, vec2(bitcast(_e90), bitcast(_e95)), vec2(bitcast(_e101), bitcast(_e106))); + phi_243_ = false; + phi_210_ = type_13(); + break; + } + case 1: { + let _e194 = global_1.member[((_e45 + 22u) + _e185.member_1)]; + local[_e185.member_1] = bitcast(_e194); + phi_242_ = type_18(); + phi_243_ = true; + phi_210_ = _e183; + break; + } + default: { + phi_242_ = type_18(); + phi_243_ = false; + phi_210_ = type_13(); + break; + } + } + let _e198 = phi_242_; + let _e200 = phi_243_; + let _e202 = phi_210_; + local_2 = _e198; + continue; + continuing { + phi_209_ = _e202; + break if !(_e200); + } + } + let _e236 = local_2; + phi_249_ = _e236; + phi_250_ = false; + phi_180_ = type_13(); + break; + } + case 1: { + let _e207 = global_1.member[((_e45 + 18u) + _e163.member_1)]; + local_1[_e163.member_1] = _e207; + phi_249_ = type_18(); + phi_250_ = true; + phi_180_ = _e161; + break; + } + default: { + phi_249_ = type_18(); + phi_250_ = false; + phi_180_ = type_13(); + break; + } + } + let _e210 = phi_249_; + let _e212 = phi_250_; + let _e214 = phi_180_; + local_3 = _e210; + continue; + continuing { + phi_179_ = _e214; + break if !(_e212); + } + } + let _e241 = local_3; + phi_252_ = _e241; + } else { + phi_252_ = type_18(vec3(0f, 0f, 0f), vec4(1f, 1f, 1f, 1f), vec3(0f, 0f, 1f), vec4(0f, 1f, 0f, 0f), array(0u, 0u, 0u, 0u), array(0f, 0f, 0f, 0f), vec2(0f, 0f), vec2(0f, 0f)); + } + let _e217 = phi_252_; + global_2 = vec4(_e217.member.x, _e217.member.y, _e217.member.z, 1f); + global_3 = _e217.member_1; + return; +} + +@vertex +fn tutorialtutorial_slabbed_vertices_no_instance(@builtin(vertex_index) param: u32) -> VertexOutput { + global = param; + function(); + let _e5 = global_2.y; + global_2.y = -(_e5); + let _e7 = global_3; + let _e8 = global_2; + return VertexOutput(_e7, _e8); +} diff --git a/crates/renderling/src/build.rs b/crates/renderling/src/build.rs new file mode 100644 index 00000000..abdc75fc --- /dev/null +++ b/crates/renderling/src/build.rs @@ -0,0 +1,170 @@ +//! Generates linkage for shaders. +#![allow(unexpected_cfgs)] +use quote::quote; + +#[derive(Debug, serde::Deserialize)] +struct Linkage { + source_path: std::path::PathBuf, + entry_point: String, + wgsl_entry_point: String, +} + +impl core::fmt::Display for Linkage { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let spv_source_path = self.source_path.clone(); + let spv_source_filename = spv_source_path.file_name().unwrap().to_str().unwrap(); + let spv_include_source_path = format!("../../shaders/{spv_source_filename}"); + + let wgsl_source_path = self.source_path.with_extension("wgsl"); + let wgsl_source_filename = wgsl_source_path.file_name().unwrap().to_str().unwrap(); + let wgsl_include_source_path = format!("../../shaders/{wgsl_source_filename}"); + + let Linkage { + source_path: _, + entry_point, + wgsl_entry_point, + } = self; + + let quote = quote! { + use crate::linkage::ShaderLinkage; + + mod native { + pub const ENTRY_POINT: &str = #entry_point; + + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!(#spv_include_source_path) + } + + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into() + } + } + } + + mod web { + pub const ENTRY_POINT: &str = #wgsl_entry_point; + + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!(#wgsl_include_source_path) + } + + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into() + } + } + } + + pub fn linkage_native(device: &wgpu::Device) -> ShaderLinkage { + native::linkage(device) + } + + pub fn linkage_web(device: &wgpu::Device) -> ShaderLinkage { + web::linkage(device) + } + + pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + if cfg!(feature = "wasm") { + web::linkage(device) + } else { + native::linkage(device) + } + } + }; + + f.write_fmt(format_args!( + r#"#![allow(dead_code)] + //! Automatically generated by Renderling's `build.rs`. + {quote} + "#, + )) + } +} + +impl Linkage { + pub fn fn_name(&self) -> &str { + self.entry_point.split("::").last().unwrap() + } +} + +fn wgsl(spv_filepath: impl AsRef, destination: impl AsRef) { + let bytes = std::fs::read(spv_filepath.as_ref()).unwrap_or_else(|e| { + panic!( + "could not read spv filepath '{}' while attempting to translate to wgsl: {e}", + spv_filepath.as_ref().display() + ); + }); + let opts = naga::front::spv::Options::default(); + let module = naga::front::spv::parse_u8_slice(&bytes, &opts).unwrap(); + let mut validator = + naga::valid::Validator::new(Default::default(), naga::valid::Capabilities::empty()); + let info = validator.validate(&module).unwrap(); + let wgsl = + naga::back::wgsl::write_string(&module, &info, naga::back::wgsl::WriterFlags::empty()) + .unwrap(); + let destination = destination.as_ref().with_extension("wgsl"); + std::fs::write(destination, wgsl).unwrap(); +} + +/// Generate linkage (Rust source) files for each shader in the manifest. +fn generate_linkage() { + println!("{:#?}", std::env::vars().collect::>()); + let cargo_manifest_dir = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap()); + let shader_dir = cargo_manifest_dir.join("shaders"); + assert!( + shader_dir.is_dir(), + "missing directory '{}', you must first compile the shaders", + shader_dir.display() + ); + println!("cargo:rerun-if-changed={}", shader_dir.display()); + + let shader_manifest = cargo_manifest_dir.join("shaders/manifest.json"); + assert!( + shader_manifest.is_file(), + "missing file '{}', you must first compile the shaders", + shader_manifest.display() + ); + let linkage_dir = cargo_manifest_dir.join("src/linkage"); + assert!( + linkage_dir.is_dir(), + "missing crates/renderling/src/linkage" + ); + + println!("cwd: {:?}", std::env::current_dir().unwrap()); + + let manifest_file = std::fs::File::open(&shader_manifest).unwrap(); + let manifest: Vec = serde_json::from_reader(manifest_file).unwrap(); + let mut set = std::collections::HashSet::new(); + for linkage in manifest.into_iter() { + println!("linkage: {linkage:#?}"); + let fn_name = linkage.fn_name(); + + if set.contains(fn_name) { + panic!("Shader name '{fn_name}' is used for two or more shaders, aborting!"); + } + set.insert(fn_name.to_string()); + + let absolute_source_path = shader_dir.join(linkage.source_path.file_name().unwrap()); + let wgsl_source_path = linkage.source_path.with_extension("wgsl"); + let absolute_wgsl_source_path = shader_dir.join(wgsl_source_path.file_name().unwrap()); + wgsl(absolute_source_path, absolute_wgsl_source_path); + + let filepath = linkage_dir.join(fn_name).with_extension("rs"); + println!("filepath: {}", filepath.display()); + let contents = linkage.to_string(); + std::fs::write(&filepath, contents).unwrap(); + std::process::Command::new("rustfmt") + .args([&format!("{}", filepath.display())]) + .output() + .expect("could not format generated code"); + } +} + +fn main() { + if std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() != Ok("spirv") { + generate_linkage(); + } +}