From d955a8f114e04e37ff5376abaeca256b1b206ee2 Mon Sep 17 00:00:00 2001 From: Schell Carl Scivally Date: Wed, 6 Nov 2024 11:56:49 +1300 Subject: [PATCH] add shaders and shaders cargo alias, github workflow --- .cargo/config.toml | 3 + .github/workflows/push.yaml | 5 +- .../bloom-bloom_downsample_fragment.spv | Bin 0 -> 4916 bytes .../bloom-bloom_downsample_fragment.wgsl | 65 + .../shaders/bloom-bloom_mix_fragment.spv | Bin 0 -> 1776 bytes .../shaders/bloom-bloom_mix_fragment.wgsl | 52 + .../shaders/bloom-bloom_upsample_fragment.spv | Bin 0 -> 3324 bytes .../bloom-bloom_upsample_fragment.wgsl | 60 + .../renderling/shaders/bloom-bloom_vertex.spv | Bin 0 -> 1304 bytes .../shaders/bloom-bloom_vertex.wgsl | 46 + ...volution-brdf_lut_convolution_fragment.spv | Bin 0 -> 5212 bytes ...olution-brdf_lut_convolution_fragment.wgsl | 172 ++ ...onvolution-brdf_lut_convolution_vertex.spv | Bin 0 -> 1388 bytes ...nvolution-brdf_lut_convolution_vertex.wgsl | 38 + .../convolution-generate_mipmap_fragment.spv | Bin 0 -> 608 bytes .../convolution-generate_mipmap_fragment.wgsl | 21 + .../convolution-generate_mipmap_vertex.spv | Bin 0 -> 1172 bytes .../convolution-generate_mipmap_vertex.wgsl | 38 + ...prefilter_environment_cubemap_fragment.spv | Bin 0 -> 6456 bytes ...refilter_environment_cubemap_fragment.wgsl | 164 ++ ...n-prefilter_environment_cubemap_vertex.spv | Bin 0 -> 12180 bytes ...-prefilter_environment_cubemap_vertex.wgsl | 267 ++ .../shaders/cull-compute_frustum_culling.spv | Bin 0 -> 19688 bytes .../shaders/cull-compute_frustum_culling.wgsl | 862 ++++++ crates/renderling/shaders/manifest.json | 122 + .../skybox-skybox_cubemap_fragment.spv | Bin 0 -> 1100 bytes .../skybox-skybox_cubemap_fragment.wgsl | 30 + .../shaders/skybox-skybox_cubemap_vertex.spv | Bin 0 -> 11340 bytes .../shaders/skybox-skybox_cubemap_vertex.wgsl | 232 ++ ...skybox-skybox_equirectangular_fragment.spv | Bin 0 -> 1368 bytes ...kybox-skybox_equirectangular_fragment.wgsl | 30 + .../shaders/skybox-skybox_vertex.spv | Bin 0 -> 9888 bytes .../shaders/skybox-skybox_vertex.wgsl | 233 ++ .../shaders/stage-renderlet_fragment.spv | Bin 0 -> 74564 bytes .../shaders/stage-renderlet_fragment.wgsl | 2510 +++++++++++++++++ .../shaders/stage-renderlet_vertex.spv | Bin 0 -> 43336 bytes .../shaders/stage-renderlet_vertex.wgsl | 1183 ++++++++ .../tonemapping-tonemapping_fragment.spv | Bin 0 -> 5488 bytes .../tonemapping-tonemapping_fragment.wgsl | 86 + .../tonemapping-tonemapping_vertex.spv | Bin 0 -> 1148 bytes .../tonemapping-tonemapping_vertex.wgsl | 38 + ...ial-tutorial_implicit_isosceles_vertex.spv | Bin 0 -> 756 bytes ...al-tutorial_implicit_isosceles_vertex.wgsl | 26 + .../tutorial-tutorial_passthru_fragment.spv | Bin 0 -> 328 bytes .../tutorial-tutorial_passthru_fragment.wgsl | 16 + .../tutorial-tutorial_slabbed_renderlet.spv | Bin 0 -> 19376 bytes .../tutorial-tutorial_slabbed_renderlet.wgsl | 447 +++ .../tutorial-tutorial_slabbed_vertices.spv | Bin 0 -> 5860 bytes .../tutorial-tutorial_slabbed_vertices.wgsl | 218 ++ ...-tutorial_slabbed_vertices_no_instance.spv | Bin 0 -> 5236 bytes ...tutorial_slabbed_vertices_no_instance.wgsl | 193 ++ crates/renderling/src/build.rs | 170 ++ 52 files changed, 7325 insertions(+), 2 deletions(-) create mode 100644 crates/renderling/shaders/bloom-bloom_downsample_fragment.spv create mode 100644 crates/renderling/shaders/bloom-bloom_downsample_fragment.wgsl create mode 100644 crates/renderling/shaders/bloom-bloom_mix_fragment.spv create mode 100644 crates/renderling/shaders/bloom-bloom_mix_fragment.wgsl create mode 100644 crates/renderling/shaders/bloom-bloom_upsample_fragment.spv create mode 100644 crates/renderling/shaders/bloom-bloom_upsample_fragment.wgsl create mode 100644 crates/renderling/shaders/bloom-bloom_vertex.spv create mode 100644 crates/renderling/shaders/bloom-bloom_vertex.wgsl create mode 100644 crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv create mode 100644 crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.wgsl create mode 100644 crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv create mode 100644 crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.wgsl create mode 100644 crates/renderling/shaders/convolution-generate_mipmap_fragment.spv create mode 100644 crates/renderling/shaders/convolution-generate_mipmap_fragment.wgsl create mode 100644 crates/renderling/shaders/convolution-generate_mipmap_vertex.spv create mode 100644 crates/renderling/shaders/convolution-generate_mipmap_vertex.wgsl create mode 100644 crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv create mode 100644 crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.wgsl create mode 100644 crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv create mode 100644 crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.wgsl create mode 100644 crates/renderling/shaders/cull-compute_frustum_culling.spv create mode 100644 crates/renderling/shaders/cull-compute_frustum_culling.wgsl create mode 100644 crates/renderling/shaders/manifest.json create mode 100644 crates/renderling/shaders/skybox-skybox_cubemap_fragment.spv create mode 100644 crates/renderling/shaders/skybox-skybox_cubemap_fragment.wgsl create mode 100644 crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv create mode 100644 crates/renderling/shaders/skybox-skybox_cubemap_vertex.wgsl create mode 100644 crates/renderling/shaders/skybox-skybox_equirectangular_fragment.spv create mode 100644 crates/renderling/shaders/skybox-skybox_equirectangular_fragment.wgsl create mode 100644 crates/renderling/shaders/skybox-skybox_vertex.spv create mode 100644 crates/renderling/shaders/skybox-skybox_vertex.wgsl create mode 100644 crates/renderling/shaders/stage-renderlet_fragment.spv create mode 100644 crates/renderling/shaders/stage-renderlet_fragment.wgsl create mode 100644 crates/renderling/shaders/stage-renderlet_vertex.spv create mode 100644 crates/renderling/shaders/stage-renderlet_vertex.wgsl create mode 100644 crates/renderling/shaders/tonemapping-tonemapping_fragment.spv create mode 100644 crates/renderling/shaders/tonemapping-tonemapping_fragment.wgsl create mode 100644 crates/renderling/shaders/tonemapping-tonemapping_vertex.spv create mode 100644 crates/renderling/shaders/tonemapping-tonemapping_vertex.wgsl create mode 100644 crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.spv create mode 100644 crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.wgsl create mode 100644 crates/renderling/shaders/tutorial-tutorial_passthru_fragment.spv create mode 100644 crates/renderling/shaders/tutorial-tutorial_passthru_fragment.wgsl create mode 100644 crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv create mode 100644 crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.wgsl create mode 100644 crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv create mode 100644 crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.wgsl create mode 100644 crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv create mode 100644 crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl create mode 100644 crates/renderling/src/build.rs 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 0000000000000000000000000000000000000000..7eee219c817aeff7e2a8896950761829b2f5ee98 GIT binary patch literal 4916 zcmZvfS!`BS6ooG>V$ z!NjP97)3?FiBTM1oaY(mc}50B{l5F(T~3<+#N%Cit+n^r``r5@R#pt}l6C5kWm(T` zj}O*ySw$xFxvx)_9g}s=-lQlgRy;D%d;a+YuTTA_>EKD z+2X9e)Ei7(&308258-L9d_Ov`%K0qok7k~+XB!VIV$U$Qny0hM_r_Jjvj)cV#eLws zqtSS+e*)WOY~2&{=x975k6WjVVQSAlsqpBlqOR}6Izz#}17rIb$+J7V#C6L~23x-a z+umatyUZC?g1L7PuF(ZQrr;w!h1fj%nN*zR%${eg?)%hZ?0xzUjbrZ9!1ghUzP*oe zYl%+-U;BSWiP&eSKQg@rSPo5)H)OFte)#Uz86<`CzZmwh$rW9Yi-1}CA}@K zE5+liR}J>tan|tfwy`YRJ%O%j0CBgz?}J2Bc%FmiJoRjIUA5Hn{-(0MD`P!pv%Ra$ z?8Mp8`##H&a48~1W4*t7I`m;P?%k>GEpk^cNG%_o*~mIZMBxz+yk#`&KD0;XKPEXpy4P|PthLhKSb1{1>xc%&F%H*zvlh+@8 ztp!81eLH>+={vuL*!QF_?)BC(wb#MP>yMdk13OcidqFg~oyl+dc6R9-F1=&9 z^=x}9{dP+4{Z3-NYSG_@GH2WkC$B%gnY+N=o4>=zy}wNEMmTx>apxP#ogOk@Ezxj<|ze87Wo4|6?!97rL6$$rX!TD!r z_%?&RLsxJQgS{J9%=QRauUhyX1)H0my9Lf%xyXGCtXC~^9|xP8_O}(zT)D{I2G*+< zxle%2P3L$L&Rn_3eG05sEpnd*`|e!fdj{-$YT?@s)~7XmJHXDO7QUTeeQD3T;Otv1 ze7nK=(*E|q*`r$co(22fU2*PSusy1U?>VqOt>JqfY>#T;djYI3?e9f6dsGYGONB4( z?`60>Y_;&c0$%8$tl(Y+w-j9T@*138weYr4CF2WO9J;rkrC+Cy1!?iXNtR14piV0~J{_Z8S4)x!5RSYO)T zH*of-7QSx_U)tYyaQoP5@%NGM!S*vb;eG&ncFO%o>^Uj-6R|br;@qFXjSj&I?iX-V z!NqL9!s%5D-)~@ZwFdV)*j%~D{R6C5Eqs51&GlY_+YdH3y{o_A^s0sL0N7mbD!7AS zbJP1f1gBRme22kn@wuYEzroI@7QTPL`m~1c2-sQF!uKy&U)uA3aQ3YhJ`3qf`|Ch# zk80to0Iz4e;@nDNdsGWw$HJ#Ie4PmFQ7wF(3t!q_7dU%V3t!j5m-g2U&K}j`jP2l! zE0^#^0-Y!SPT2_o_)et?xG;dhd3+XZgK{ z-lv`Jxqkbh_id-!gTI5&`z5;fT#IH;q4!U8?^oTPLLZRm-mAJjg+4IRy-#&}>dyZU zRe=W;`be<7)bR{$aH82qstrjrdq}maMDzR+)SS(E!*~uQ_DpMALvI~lW!FMG!rM55 F{XZm$q0s;U literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..a04b917bf09495398058e293c6743db359f9f41e GIT binary patch literal 1776 zcmYk5TT7Ht6o$7m9+E^m*h$l7nljUnD3dTM0%@eI6wA(tW<}5>lovrlruWrVbzy&@ zi~dnRB050O^L(@S_-%M+o!_)NI52{R`*ouB8wZ_53E%$H)3`BaL%?zf5R?jGjw8G z>paGsMce*z$(igtmtVqo%Gb`v-NAT$kLGNreB5tg+&cNS^KrjTnspEHUhER^l&}vX zn}Ghku=HjA5cUzXPP+iK4@KKqtSuq!tA96HWn>wT{nfkiRglBv%6|lSwB+JbrWEi7{>G@SA$Ho!9T`NpatS zC&j&Ik9G;^JzF!z3n(My_IMY+*?9svLCpCsgY>P=Q}4c2;BMOHOaf>8MvZ&E0oJ+G zFFLIwJ%7nJwhG<>d#SI-UT@J;-S^0~hEINDf5?~1I_vYc{+~=`{|&GPl{~* z9_KLUDwqQDsbAtBO-Nxtt=wtMIA2ayuF&q7ehVN$ddCw{DR`j`Nnqdyz zx07c0gzno(GkiwZXI`4&3%dUN40o{gds4r<==$1VE*ogDrN4MTRlJ5b!_3n{; z57Di6j}Bg+yDxxE;GN6k_m(Hc7tvE(PUCW>_@i80e&g~_bANvCC14ME%pCw1xF!Ej K#{RM0S@0h#wQ+X< literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..64a6fd88cfc90229c4508df28f9960ab014f6fc0 GIT binary patch literal 3324 zcmZ9OOKg=z7={N56eFP+Q4oZl3Z}KxN>re!6frTW3l zs4FBfMu-6y8YC_Zx=_5|!Mn!G!f4`ct)Pj~=lRckI60Gi%sbC~x0(6d(lUKnYnnMN zrPP+zIWf*j)05KqhxsX;oo1y0z~F`(HuO&J*xY;Ns+Ic9O)XB?wObz9-9~)8QQXacx+uDb(a=vYv^yB@vcjMPwKw?x$pY_{g$fFxp~i?%^kj; zCu*HX>|)k6%u!=~A+x^n^U1uV;wdd)&p6li<+?qu?a$a6v%SdA#jAt417dIL`7rNj z1-|BAjyYVL_u^`mQV(}(t?c);WIaq_8mAcX9pN83c z4A%~0Ry1Vgy9lqI%rDJ6*1fEav%jlyEpuAWwfnxOK5@<~(E4=Kr{`aVS#veBah@T3 z*Px9xm$kiHN1VT}v0T5HT>WUzrmy{b_YT*-qi-L5c>c9mO7->b*HC^7#zgM5I;Z-; zYEICBs+P>Y-)T;8GxN3V+3zh_+~olIypLNk&+b~EAMx&N(b{e9cWbvrt8xgWXiK)V;Y?nKKr zlFK{33p2mmbK1Lo+Hbj*dv0S!G2=W-C#LW9&`A@6`yOB7*^;4PI%T2I$=F^!Q zA2oMo&UA*|o0)xt->%Gjhv?&ev}dr7sQWM4Udp;2NUne6djK6jG{Nebm34P#W?k>Z zH`;@FPu_dfZ6&C=?rfM`|EMvAmOFy&Ma#s&9?Gmd@53#PZ3H#fod=WaANd|Z z%N@ZUMa#s&9?Q(SQDXrP%{3On?O2J9PH)H%J1M6m_M6-ukkzRRdgNmdkuEH(kc19273){yl)@u zb+qvZ3iby2ICijLZ=#L&&LZ|LwDI0qu(#31duLO8FTUG5nDKoDdlzkd$=+jaylhUI zUB$kS_W#J2Gw;LvyKlbO{{S8P{w%p~?%4mZ*x#S`trPuzgx-lw73>7s-?4iOb`re{ z^Y>1~evCH$P{BSy8-KW9pQ4TTn~vDe(8eDt*ym{D{T9OS3$*cm3&FlbdoSh)_7&Q@ zFh{Vj(VpKN@fP2pjradY!M?|v7yj=yTH%, +} + +@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 0000000000000000000000000000000000000000..0d08a095944e573f0a6f1c233ea404e07c31ef74 GIT binary patch literal 1304 zcmZwG*-n%}5Cz~K7#zoi5!s@m4&n-Uiloso}Rwj z+pFUB$CLLTPCn&CsnPw&x!_!IT>9mF(@A{T_?5<;yBKUXt`@%4xO}$)pY!ta`;Jpl zt@*0=t1ecL%Za@ZISzc|aOe2gS911JwU@FQpXqS@h?P?>?D(j0XT|GZy#DwXBE_>W zCd<{x^;i}o>060$HfyajtcBZ&{A_Y8M-BpZe!G&d^RGnbXWx(CJo@cTaXsKm@vKIw ztIunJujAJ%J3HFW*7R^A5X0Wt)*7F--E20oU7Vfc6Wg%%e>+@GIh+A;Y-Sxtnni81 z*tcEkzw2>5dMRgLJAS9~lAZ^3FB{=vfN#?0#CNyx|M~7UpZI^z-H*+gzkS2H^9Ql3 zDYqOTp3O`TBhBQ_%;ZgYuV%u%A@3F6iRNAO0-tyCBX{;FQmnVI8OVpbd;baiAlzHp z4%~moA4iw_b8_=P3B-6mhw;egUcSWdZ9EOc@PCj0S)}h*^7B0pb^?8oKO@E9e6Nyc z9Qh)UTQ0r0)7^kwUH6L9&0vq}?M3>!di&8|2J(~YiNX2Qv*Uw6p01vKA2z!hc8=5S S+g_$~$vHiXnSSRcc7s0yM?JCt literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..4dbda3721537d2c37020012958ca2a3f14d823a8 GIT binary patch literal 5212 zcmZvgX^53&7>2*mTuO7S%q2Bv&S>RS+A>Ow%Zz1?l|O9z7f5ABP#R`MVJJk@uYS~@ zvI5ICZL_ivZK0?nvW+5&XpvT;#THwMx~?db*WXa`jTDiNQ%Mpf0YYH%~|TXfE%X;-dVI<0HQaq31?{T=+jwHjIN$8!L7 z(Te3)uej{0RhO<<-rarS%B9Pe5G<*oOO~y?;F8NPUcRboX0YE#Jo^s8`p9I?!!g^! zY7k@TZyn_s%yEjD!+t)~?@*#~#BG>uG+7Vh*@lgQ8_(0&x^2W0cv@Hd5YUM{+d<5y zKMHIT&!hLrYiyo&%$B&(jMny;+cCCa=AKnzYl$V_WPHccNloiasc}c(t8IZZ$B~7z z?ok-6H+84>$6d~`6JL$BQs-#=q1fT@uB&ULncMhSEZS-Ku4&@w_#-jb)bVGM5v;lA{aXq}Fq6Giuz)_~+50?IzwtOFWDCL|Wq6#5-w;=McBj63->x zO-tNE{4f6!_Yw;jJC=FI)!ONa=M!D?{FVCG1^8YHfGo9^#K$Uz?Tqv?gEmB<}0izu*E=DWzE_l z6ZqDWGoM`M{v^J`0kv0Ax$E^A!D*v$1ezGHs5?7@D#C5*k>UMkq&8um)T zhJdM++flHg_~PDM$#(#;xO*Diu%hd()i@ALTwQ96Ahy3;`nKYWd-tWrLB!&dYc&oo zI`72HV-%RUy3{z7*#2^H3!p#_Mw$?EWyq$7|`A|Iu}gb zI(|1fAK$*>?ZlbutpyX$dftX_e%I4Jn!2pT?S*$vYPXd6-GMJ>e(%1A@ojz%$gRWf z#Ju11y`$6^i{~tC#Bb2gT(^+h@o&O+4s!K=_V?~q^9a7*!OX4RoLQqK`0~8=Viy$5 zx#nyw1rtxdWkrKz@0wi;rp~?3I$npbRxInd8b9kO=ee?P`0H!DHRa6{{-zr5_~kwK z+0&cxtzjOu8OzfJ6Hl&Z@G}IhZT9?Ge7WrToA@^OT<$sS zdCWc5ckk2~i)YVw;y37LuI%|6@|aw`pZ&AvZ{fS==2mac?A;4YSl$-w#e%sO!Co$y z(yZYtV1AF2%No6k&#U>q@Ozv2)uqo4e7_T_3-&s`xOH>JPUZb;|KxoWpI0-lTJx$2 z|Mot-WAeLX&cQpx=CGF9)c$}8iD}98AsAt^mVGpJ;XkhN=F;qwbMQ&wJqK!Y4nD<~ zYX@(B@4>fu4&*+=c46+jzWe!8iN$jce#CFk&s;eNyYZc)T)m(Da}IvS_Z*m8y*abL z@6uPE7xU=<4*wn)ujYQqx7WD$Yn*Fc=RU1*?z7ysa{qlsY+fdl+I8-uULx{iB1 zzRhvVjm5@cj$7Y7P-85fy*muw{N}1_)Vfc8eoer)j(ODEKjZAcXZp>v={oK^&dKm< zGR~v$ZH`lJ3U&nMxbz)^8e{Q{^GJO2o2#x-n{iIXw~l$#+dq5Kitjws1pAzPo*VZs z*cbR}Ju|8OCBC@&8_H+;SNQIix}1rx@p(1ZOy1wv(SJj%UQO2STYO&4wUf8b1}yw{ z_`I6D{p9`q;QT$Ou90W69*bu^e#AG2Yh*vQ;dbL&U(TAzlixBv_f-2gzXSb@@85R( zz2np0IiB18TKhMD>-_@eZ#XqR)ojM1@f`h1?B7n*_*CN<>zY0Pqj9X!_?ziBV*j3G m9)CZX$5@SP;cscz#;51Z@vj#vxX-y9dcW(L>mOG6B 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 0000000000000000000000000000000000000000..23afd6ddb76ad4d4e649926803a997c079cf212c GIT binary patch literal 1388 zcmZ9L%T8255Qd8ZBq}m0f})56qo^?P3IxGRbRjNWzy{q-qCi4on1mp4=_C0DK8sJ` zB{A{)=5&Pw@A*0|L?dLhKQ2X##bBTJ+k|zff9xF` z_db0-+V35#t$jG$+3VtTYi##;_wZ=wE?{^wrOTh2k5h?@&L3Jq0pf zE&Vq!9H;Re?aD-Q)+sj%Tt{mjZN&usIcy6!TKHpFbL1zfvf1Y&E~A}iu5YczdJ^^_ zuYM7$ZjI{WSatbvvfOhPW&-Pck(g?qtf|2|C;S!W4&z*Rs_&inSNs0g7whO*i~D8# zwMze<`%L3od-~Uz+pGEZt)`#4_v3o%_F`Z9)6BdNYcfXP`_Olf8GP@<7dV?(-yXHbdS>^qo>_HPLvg?O z?ycPp1UZ<$+zBe^Z+a;}rycHumyO-|2$`5iFdcy;gFJ^Vk^>Sy7Z J{AI;e@DIJXM8g08 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..e1f12d06d03210cf8ed1244398eb8c2ce42f6a47 GIT binary patch literal 608 zcmYk2%}T>i5QVR;rTEuaD-{)_wQj7gMJl@W4Rl$8#8NOxDbe@!E!+rxUz!UJOy-_5 ze<#y!O}e486+%eDEnlr4T0zG6eH=nBv}@jP0=rE#|5g@X<;Q2WEQ{G}krmlGt+IK( zT;=I%{=QBZc~(@^wQzgw>)?kV`@8rvto#M8iLLpM?H%Lxm=|B-n%Mc~wTNSWNcArK z2tT2Ak0`cByx(9ojKBv(=gSYM>Ji5<3DNgy*g^khhI*V6O{_Vmzj@ZRXH*?E{Gj0@ z=DhWPsq2A0alG$2dxv26nNyp$QJ>gZzBREsqn5^<3f3 i6T9;ocis!L)G=*1>t5l!(M`iU>xpjl$^EkV9{&TY10D|m literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..49223d8cd9acf869cc6f15868e76c2ff131481d2 GIT binary patch literal 1172 zcmZvaX-We@5QQrmjd4kg#>6FRV%#^}k%$WZ@fab9mUW|p>7{TUe>Fc|z>)+}X%AbU%^#cfy~8*w<{@T9}6u_R-VPyLu|+hKITj2Xqz zDFQT#!by30gU@N@(U3RGD@Gj{O>)QOSr4B0ggkN9AfA#Z4nM6bc3u)gugrIp!#Wum zdnyRy(St){O5X30ICJ!TeA>m~vsy#P9qQ7@jEuoL;9Q8FuXk<8^&I8Edv4a{^>cHM zL(k{UYYvXMWZ3tDa9)N6H5hqt?4=-2pX~2K*q>M95ugV$*|Y5c-Ab+(7?!#xVWuq?(c*>@qTz8F&UUQzXzetyR-;xpMZM-YKEzkH; zEwLThu8cLA->8l|*^{9~E$eVU`!aaep?5HI`r%B_Kagj5{X@-<1M|J!}8~ literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..efcb42aaa7c89b4ff99ad579c1081e434f64719b GIT binary patch literal 6456 zcmZ9Qd$5*O6~cmVB!aR8Z| zYMLf5Q-4_un4&dSrkIFCFs7(fQ%ojhUeZ!)Y9>uH$9})>?C1Cn+p}2DTI<Ssq()qAVKE&HO5%R45lUH7>OQ>LCRZ&)=@ z)%tgM^}(tgY>H*8yRTina{aol)!j2@tm#?4qHE>43&AdH1@`W$TwN zU$taS=Zc;sSLkTvaQ+}YhCl{KaQQ8iXMgMLul~` ze5awumAt2e9ojYe3=Kx?Gh0^g?AT-b?1y8IYuVN8lgK+B>>AGM^R;Ywu73j3hKyw` z)}M$Z=3x&&W|q0`#gQ84^qF&FPwum)$alYoQ_yv>lYc7qdytXDJu}y%3}BY_ zG$h>VVC%;|7kn%t*W5D@&txXLMqKxJPSn^(5c?N7v+VUed?!}NRI|`E;#%!RhB+Me zZgw9m-1ce?w(-7wwO8jCyGFbJIcV>f9Bt#?FYWB%0x%(beRpSWBQ_7bkP+^D?469* z7h_Lm#Qqreumt$SGXJh|;TZp~o z&26(zX6=i>_RxLWC;R9aU!KK7G}Zg;ev|KTtI@r4b4E{Lzk5FKp4}htd)E`o{3EUT zd*{dg6ZX@?AD!u4dj;%Wb{!vP4X2`8bhOXg8(5z~p9k0T>qI;&?Haup@vJ_Mw?^N_ zp~-Q?x2^b4)z-q>j-g)}%FV8c?Ev#vO+w70$V;Bv!RB^-nR6#T{#tX4E9M!>s%rc@ z!ThzJ6}k6P-~HYNHfFE>!|orF#P~1!GIlre1H}D{-$cvN)_-H!$Ae&dZmw_Ovq!tZ zuG3g^p7UShNtd$+?6YQW`R2?%mzFrL{(db3>-V$EoGZ|-MQu($1Fk^4Ki0Vt+*M-M zy9%+Mv8&OE)!>zgeK58PZR~aW&|NU9RdY4knrhd23VID8s;-^=6(@;Ix-D$ zGI;At!2!7#B9gY4vVjXiB_gR?5o`#@}HP`Dt*0BE?y^jUhm;L3O4;I^Z)xP3;qTxGGd{5$& zYwVHYI|SB0uaWQ9*!sN>;r*uY<~M5m7N353sqs5(=Nrr1!(javH){MITfg56!h5Rl ze8*%TPvg@sFEx%}JKtF5{t>Ldqfz4-Z2i8|!~1jL`JPIR=kV#5mm1GwJKtF5z5v$m zJ1xC`5nKP%Mva#W&v#vF{0*Oed8zR-w)2hUY+nKE-^%&aa9;)MTL6ylU)YPWmH7UR z&wJtfX=Ax3&w!nq&->TG{Ix#sjhWLsm-rivxHXiqjrd!QxLnuf{5%W)!?uRJyhGjw z^Vj;kGoH0QOMPRh{Z8Te{z|NGZGG<|AExAyoBRWce;D)ZLHg0AA8}r|0}JyIl-J`MQJm=>-&swnGLCh`RoH@JGz{dIO_nlFE_9Fcni%-92nzQ%|SbzF6 z4xIjZ4(67VT4#Z+S9N+n1Yd3u##Wt6|3640ojW9Oo+Yfa_mMjg?~K^H zAV*t&?$CW;?~u82hwcZvM`O)-&d(is0PGzyw|sNvobSMI+!5bSus(Z{e%%H34jD^7 z?gpn{p0T;)CC?AR<}rQd+yl;>K?LNOXDI)NP@{i@7`In))juoWNq!7AuFvKiJ_sW4n+C5a)^Qqa1Dh>A`N+YyE{t*832?tk<|T!v8t; zVMI>&`@rEFpA0|e`wQ$Nh@9N1{b2bc5#z~y06Y$#@#cD6x947?A4FV_dy?;7{GDbz zdN>PRd{CFJf zTFfnX6aA^tParE1`S#zt=za12HEsQQ4xa>@&ogoza&uOPz~(e&-sI^8n^*lBzqk6` z{8z|CWK+?b(f%IWSL>M8Zy#4;PebIW<@g&$I8(q^BmVX)M=i%ShEs!AA#)KqYB{b| aj{EFFyFRtglWX%gsP5udzfFgyBmW0xRfrb= literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..8d2ee73228b1556c7302c626ed7186cf2c5c6413 GIT binary patch literal 12180 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, +} + +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 0000000000000000000000000000000000000000..3dc27c521ecab9a9df3fff14de7092bb56d40375 GIT binary patch literal 19688 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 LzvkE5rnLVBWZsh_ literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..fb9e97a220ee7ec835cb5bb7855d23d8533e72fa GIT binary patch literal 1100 zcmYk5T}xC^6o$7msYQ~Crm2;VN;kz2p(2WP>5Y+L>7_V2evqTmj9@o9UYK6>Yx+a| z2vLKe=h^NpZg|gH>s=pvt#!^R7RK5`YfA{BGhFcWbcaHaQU2)-;c;k-_WZ)qLb=}9 zC{IkjHSS3$D&n(~{0Ha-Q2+L$vVSx)b1PTZ4=dH$+QI7P_qDBBb*~ZQjco;OpbN&l zb}&yBeI+25?NM}(ws|k3b!*#&@%F4=`+mH4wLM*obxsSUY1N zJc={rICqmzOH#aREa}d#J&x3G%^_}hh16#s`rM^{ZFB9xqwOx-o!k_W&Y$mfAJDuK6ih`^i8DaFVpDT2M56U)o+l^WXoTqIgZi& z9<22X&U;RPed@cP*TlZ$4>0Bwlz_F3x28KCMVEdu2 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 0000000000000000000000000000000000000000..4cd01e1ec955d15a2e76531566d09e8d32d7b673 GIT binary patch literal 11340 zcmaKy2eehi6^0*O1;Ij5L_|@kA}XN4!b4C{Q4wrW6r^Mch^VMhV+?jpSJd=aQ^W*I zdNs|K*n1c3Xp9wW)O_E4^FJr7tenL-|K9(efA5*I&$;)$q+Q$ootiqdX=-Zf*7Q<4 zCa!gx+BWHNUeUd&sdH1urj>9LCQY3*Y|-(vhm9CH+_@C4+C-;ELR)5118~yk^Cw;Dq&zki0 zt9Z+P+bX7;M}^hIwmSiOyyz3Mo9iE9QYE_oMMzT}<30^|C?dDVLQqStb^?Hgy| z*?W0j-lx6|tHm~#{18SD_<_v*7+(Fb2QjOuzbE&?d)SZB3(hs#<}!9DvvulUpF6r0 z^QL%)F^h)~qt4b0?@=FY>o;DX8lGz>hW;I~&9A04bVqX==ICq-_R_YF?Hbl6_K1eP zcue?_E&Lesi~^g-+#8c&b7pJn3$_QfjoY5N3qzmvXuDs1sbeRw=QxmRt^zXsY=UF@A-?Q?`$G;ai@wIrPJac&^VX<@Vf`=wKlP}Xp7CS?QBl5!#u`_^=rG{ zJg#$gO*G_<()(4i+h7Qu6%19sVznXmjwtW`sl0Cu;^ zeh_=z%6KZ@O>vLD0lS=oG zW9;SFK2xz*U~gR6Ph9GZ%XvLp||Wp5QU?^TF=P=fK?A`%z%IQ(*_gEdc9VT zYC>CJ6iJ5Ivy++trNidqIDuzE#K>@>$BL= zl8@F&V7X|W4AwW9v-RD63fO&HuX*H?=W}55_<4~$r(!3MeDZuAESEf|f%Qe}3t+W; z_e5(kcC_T9bvjrsT4#V8zH(pA#8%69Xtd74j+T71&IZdx>m0DY)O9XcE#HCBIuAQq z^3ggUEElaWg7xJrzXW#Q)@vU50n0_}8(@9W`X*Q{KOds?E$nE?N9)^Q zxoCX{tS@KzU9kJMUh~K&&-cLQ@q0`1d>=b`uRuCes)G{DR#8vqje2fE?PeU z>&sdG6zsmO*F5raekLvh`wp;oJ#%AI!?j>*@cUqDxDGot$ft(u!E&kL2C%+p{S2&@ zpZ(GLId-(1$6MeBE9wfxQzt>0ru zOFmkE0Lw+|k6?W{=NrN9+j`9-pFDp8o5$}m$@6FIn7}I$w%vEuw1lm0qcv_tzfnM4i&B2u%jg(t-piiqV*53zG&SJR?F{S(YgaWTJq7l z6D$|4yTJN#mUn~QxAmGwK6&l|o5$Z5$#XAu^2jI8ePFrdxgV@AS`UEL@;hR*9>k88 ze6$_{%SG#9u)b(L0#?iKm(h9@J6iJ5dJHTVt;fOoqV)t=Ex(&a>q+cr$w%ucuw1m3 zgZ1SsSAgBO^_oXMd7cKFXL*(98SLbdPo8JNa>?@?SYNcB2dm}x<<$HFcC_T9^&(g< zS}Vc&qV*D3Ex&6=>t*a{$w%v-V7X|$0@fF;e}UEVdwR59#g3MIv|a24UHT^2cYwX?nH!rL-U3^LzYS8uD(uuCpBml<%cX{Q!1|)~E?6ypS48VQ z>}bhH>wU0Xv_1gqi`KuvYWbTaS|4IZOFmj3f#st0F<9T^^7kLUb~jn8IpmU~4SsX@ zJ7*WZx6c6k`_=FJ?cw~s?(Fw{e|L2N`#X6qaUH>(7;jV28U+*5Si2^+Yn}Hi-woFS zyWT6l&c%mZ({;r8o1zOoW99rUu{N`pza`|lGP*I;7iTZ)f?d~4>=gEGz3XA?Pu|Jo z(7%3(Gv2+LLp^n~wmaD0B~uw*b)4}zlOAC6Sc`eo2-g#AE;;q&viDwKd9V03C_c}_ zd+FbCHpFMFXVJUFe_&sOH!5}?X4h=Y>^}5cukqUQ_DX+Z`hvaBIk!!)?E!z=+5^+U z{vE^ho0av>*;9Y8f4fj~bH)}7dtl3gNzqt40NdQo+2260>%HO|RD9N-9vFU_ilM$Zd)XT7x@KZ?ABSV>Pu}#vHYLt@_i7IH)Xmy$!K?Q`;+%6P+kwqv zE#^@p+z7C_D%Xn>h zd%(XT?*#Tfdlvq^WoK-C_J;3F|K_p_co{LiJLQr1FFo^|Ri5oJVC(jGZ|+4iw!I~n z_t#i(dty9O`Mke&HHMM**Eq1gXpILO-^{vb?S>sK`DpD9mW$Q|u)b(b1glm5-roZ| zTJq7_6D$|4y} zd#|)TV`F?T?kkrVW@BbBC&u@h&!g`vb)1c{H;pm3&#JxP?6ah%&$iF5erMx)7u)wq z?(t->?U#BBd~@3g&V>6zJJd&U@NV`fw__Dn~7 z_KGpi#`IvQWA0AO_J*@Pqh@=?8pZEy+>z97+&t#m*6+K}KA%ghb-TvDjT`HG&+lkg zW6OKRx3u^OYdMof{3o9i^N62~Z#Q_~jq}TT>y$f+v4CM+;$6%0c{F$?>s;%-8_W8I z`1E`B{taH+I{aJQ?O<#1iti45)*PRIr@RxNv9<3mY-4NRJ;g`*hMsHhD?UTbq3?m> zGfnb7gwMS7+K2I(xAr}PZLHVXMek8;{l+K9V_@T4o4CiZ_1AGvlsKl=xF<36*Ktpk zIBSmHa(w!Y>%#wX>fTm>R}$oBfoJ5|Szq|4E8g>xx32KdRJ>;=Z$06kt$5E--a2xQ z&w)Khrq;7~9>a62eJ@}b>y)@#n^WGi2ygMxH^01Rk$ty?_ZhBhZ;!3tE46nmzWRAs z2cOT4TzYyvu+K>C>yFRoq4xE}XYcDvt-Zjh)!w%bbA;cZ;_ZET^M&8A;_ZETbBFI; z@%FyFb!3ly!0sEWb)^46J}27|4M zf30h_!$?i`j4{?3%@GxE&&XS6_>mQF&&XS6_)!&a&&XS6dS(akQU+9Oouje!d!_dA z#aH*t?)dB(x%A9Lusu`z_QYq;)V@jh>=}Kjb#HLa!k)1XbA;cg;_VrE^M&8H;_VrE zbBCW?@%D_ob!3lI!0sEWbWz&dFu>+SjF2j^41yt@QSx*Y{y|613~#Yj!|j4{?3&3P4X&&XS6`1uuY&&XS6_@gS`o{_iC^vuya?9^n>7-OB$ys+Z!8F}jrzog>r8F}jre^JHT zGxFA%nl1rb6aQM*T#AvJ>=|RMGn$uGygegto#8L9czZ_PI>TR4@%D_ob*83c@hxO{ z#dlos)t^_3iqFvW#}_bsPZ}TJ>0sZDweL)Pz7K2P+4x2kUur!EU(UkMY-=+|_;V}X z&un?~g+H(2KQ6qv!=GRA-UQcMNBAWbKNsFTTT}RpD&A*V-kQQ+T=723^41jol8X0P zmba$U%Xj3ldGF)95?g)mcYgC-g{`I, +} + +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 0000000000000000000000000000000000000000..a039280dca1a82e1174800c6e7b9469cbd1bdd59 GIT binary patch literal 1368 zcmYk5&2NlR6o;=Fogo^nXjDHi(~(A$5<#S5y6mQliiDj`)pQ6drqcw87@>4!>0^Pi zz{1DIKV)q!R3h;_@7ycB$?rYq{LaTc=e+Nm&sB<{Yf}iJCw%4U*%5L*V+_h@^&etS*!M!$9U0*`+0NcJwW`>{)) zAK&gwcJ9(1h_*eHum_ReC%==9hLB~LVWfH=+#ci@vDQuZBzqrR2<^#amohs{4uq}Q z4CXk8v!_ATf*SB7?jCv#c;`xtyN@m}y2F+%w~cPhF<>2GT&nW`y$0+jE#bTgIx ztN{JKQ)9nzzwiDr(C6-cG5rgq=MQt~djeL0^Qx~SjnS50jdMIhx3;yO!nyb7pa%49 z%rpNde~d9Nf$z`S##=MZ`3haXb0+R}kM*tq^NrW; +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 0000000000000000000000000000000000000000..550db981d79875c4fb02c795212ea51112f1f345 GIT binary patch literal 9888 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 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..5fcbcf48898e22ee02f8df8cb9a5a6fa9e9c7cbe GIT binary patch literal 74564 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 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..a1b8d4e7917b1b260a107ffd4400b95c07dcb4b9 GIT binary patch literal 43336 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, +} + +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 0000000000000000000000000000000000000000..c13cc9f5b403bcf57e4dc814ac9ed5b1fd464676 GIT binary patch literal 5488 zcmZ9PeUOf26vkg`?IN``#74Fi`EDzrX0y8(T54%2E7|h3cGomM!XJuiDaA-WCaI8J z5>ZS=$y!EI)8r$~Xv-i**y_KcL}t2vulqdCywB{t_qon>zV7?EpYuF#{iL?3u?F>G zu~=H{e3B+zH^q`-XqZnmi^Z;srNnW5!J`FP)25eXb?$vRmwA*N5B zG=AckDN`m)D$CAxU{vYUF=Z3SPnsTluy3G|qLHd`qaxvtoUdqYHN#<-FRq;D~^Gc~xHtIGD8Gc{U>>!2A-P2i3Jlee?#WUak4$eE)VKh|KjxsvfE z7P+~{T&?8WTQh5cqh9uyi+%5_nKe>NS5*M+r@?;Nz>oXEIlwMMm@`0rd~MJ3CD*Ra z>}_~}@S-m-^fEk9__n#NBK{%aoW?EkjDJ|TQ*m0Z;R4~Qr_v*SknrhsD{_nmS7%CR{qOB8pceoIax{@*g3bHsafe zA1S=?$jpc@7T&YzcohFh;o09!i||vz)5;G-_M?P{rX8-a^^6vNaZpjU;jzNU&Zq7+ zJWjZK?ZU{vM7Uf1Ws!fWaKXtpBU~ojEbr?mUb%2e_58d};XIv8;+|i9o=-{U8RDK> zzSGh*J@7)5?^ofvt@WbyoDqKeWS?mN&I&Idc&WeDO)-|EKVl6E)j=s%CnCVEm#dTojt2xt}=B<#QUGRjwSJSDw3> z8a!iQp37MpJSSkDkHva`cs7cp?X7u6S=l|G4G`yQPxRV{g81NX8CRvs)$^y|-H)>{L!<_m*Vz-tL`X$6i^y6_U|o zSEw~|Z&zwi54nhg4fk!8X0FTnT41g3YEav14RTj%5W7kvS!0a``-vU`CLg`u;{WJ)Vw2DFwT>q?`QYb;Gxd`&>nD%tewNJo ziEX;0l373Tn&=F0ZjVXUU;I1}Crh$%CmcsS&z*D}ap4NX`}CYJaq-8Fczwm!N!DNd z8N#NYWP1kI1zuC6dq3##F}w9a$2qifyg@Sl*u!&<{W+`@w)_9Lf)xt0&!)R59q&%B zyCmJvptJjQSvvj2&k65p?j`Yz|IhKfyWxp#{1wL!4m^2`Ptl?TTV^S-50*MsDpUM-|Be2 zzu<{&d~3m^2`Z}0e0@zhUF<2yLMEb!zszN6#I15ZxtF`Wb7Q5?B^kLl_-@^~)G zapds*r-v|c@yE{kPfyA074L9teE-=b9XyxynhzzLkLf-NI!vwqY?h2a_V9`Qr%F1z zuTRU7K66&H=_Ur-n9ICpI}ezt{2fA9DEq@l^s(4$tpP;K||n{f;L#`Fwvl;CNz_&+`WzPi*q}{&Pr} zJtB|wn(rmEFT^(8VaerF4Y?Th4%X-Z=$>w9a&w>t9>p!1M#vgn5#Qw8J zI{P-;E}7mz58@fOeX3PJyN~w!gx|)-A9cL_F7f4Ebk#vejb^tq=;RvhMU7CGi&fHHh+QB5-rXg6r3SxSHfZpBgn2w(sJ literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..cd32400debe50c38db80c405ef1e1204089cb51f GIT binary patch literal 1148 zcmYk5Nls%y42I1-lMXX9LqZq?1Q4j3Q4JCsSi%Wfy@(JC=m;Uik|S{g&cZ1eBqYA? z@d{GX|Los(xolUxmgY)Fv^7OUA$Iw?iqRZeluttu{n3)y{T5&@{Wt%wYM1}&^^2?X zy}btV_qKL@Q@dk#WIJ1t$I+VU)95a_{vNQLbK~T$lW2?1Pc zo|$?vz6?sh`cvF2x^Y6AaTTE58Kt;6baOSv&BL`jx3qU5=gzH4Mb@+kJlnkPQCAwf z#hKo36L5LoFHB1^!HcWi%u;J$$s;Jgl)kUsN2kjM8>1^S)MGyYYi>y5qo*1$UO z4D};kllQj)%;jF+l4m*ZO`tEu{X$Q1-eHRSjjqp{yf^t7HTf2|fO%ZWwvDdMzEA1S g|6vChtIxOPyv^rZ(DzEs_G9h#(8#sFlWhll0A`UkGXMYp literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..a8e4054515b7a3d81dabf26a09ffebb096f7db00 GIT binary patch literal 756 zcmYk4y-q?w5QRq&Q9%$9u`(DtLHq+H7=Jn%3KJiI7^Juf2Ex4>3kzc6b6NTvzJ-m6 z=UaCZH#s|VW@l#4&b{f>Ue+=TW>&P0c2>z!Mg;q{X_m7kYm4{#cl~CZJTzPFBk~HC z#<;y`8_uULc}ga;=ziSo25%5OPRG$ON(NCpiHD={C>}hIX36M!ht=W{&;c!OWlCZZGpGGilc*XKs2{Cx^bb{@thYxsS8(?ki1( Q*)S7)W=GzSzCcI#1+#rFGynhq literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..14696161ec74a7bddaa81465f15e6a6e6943e466 GIT binary patch literal 328 zcmYj~%L>9!3`ApVsn4n?x|53kAX3q-pHaH-1-@u+KiI!;BRHp0Fqg^PBr}QcEkg?$ zW;W3K#mGFP1HUF_k@?ktjH)SS?n?K_FWEIo>R2|m~jGlmZsEjWZ z_S!;kE)dk{>Uydvx>%TL))G^5J63Ls@zWp6*%2?)>5BQI>4~|AX7lI4N6nm@XjT?f bKK=xI-kSEsTWQ%53Fvpa!w%|?+-uK literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..1f0d74b8fd42516e3b73ed3f2d5640adaa507e75 GIT binary patch literal 19376 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 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..66dd71649d107c845cf2a0c074fa3e947d1320e5 GIT binary patch literal 5860 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, +} + +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 0000000000000000000000000000000000000000..1ab9440df77aebe3b990f16ba5decd930b0098c3 GIT binary patch literal 5236 zcmZ9P35-_d6^8FDNQ(?HD0Z+-#Yi#?FclO*VO(mJB5tj= z?rW=c>E5~p6}7EVt5)cexOUOFFLjAlZBRj}KF|H{D>vTcaNe_g?>XQ3zx!RLrFmrk zqF+-{6a$NIs(1z!&4p0?!r-FVp=c@n{yVVPsl>+nPUu^{VoA@^Nt1%QS1#>Yu%LHQ z_ldnL`j#y0UD>^CdH0fKEBktuE$oG@D4AN({g4?&Yw6n-Jhrmi(Ayy9%piL>+I2Ho zA@&*BP-Wbnc1Gk9CnxrZD%bTxDxCH4xfgwnnyqDT_T(dv{$Zunu;tv^V{5rKwwyz& z+4}J4%zW$YOG5X8wW;b*j;?ssb z3T7LXB=8Qx#D-dH3pN@jvj~K zdgBovZR_k=T3hYCN_+K`cIIj?&cqyLSL(E(9ed;s5H`=+l zHoZ&$+viv^?QtSv?mlSO)pI9dHzCesGTPqdABOEYGgoQCtGzFhI{SgmjlDm(74f&3 zf^I|PZs(NA-GOA!>M>P+o#1wM;q0eYInFD&S${yyXWTtaL%V} z5FdedKlZ9U675>;Va0&*%-gHIM7zd3e>cUt2coU3Uwe9Go11ye0DlE>cD^^WknHnd zuzRSBG1t#VJWqA;+&KR!O%1>Ons5CMe3?~rd$DanTp8o8qc7Teh|#&H-lk^Hz;@4x&&2*h%{~bGi#2-|_JEpwFt+zm)*piHd5k?9d;6MwDE1CD`|H>P zYjzj*jx~D@_Mn=581|QH_BXJd;RJT+JB?XBzT+Pj&BeFSo*94J!x8tY?Qc7`viHOG z{2YNaBh%p0J`!m`e9o+V^T6hL4sOQhySN)g&DHk-E5=n#Y?c>13K@&ok9bYRH5#0C zYb&lX_^e@U6Zvwv&h>R$|3-FW{dTbHP|WqY_HZZmKw{zjs0z{u^eA&7*CDkz{XPJc(A^3tpLmAJDYx2g2QDz zTzz0;;W`1VFI*>rw(*GbsnG9Ipz!N$V%9k9M|odTB2_dHzR#SWM8aGeS^7OvAu z>>L~S_9|@mZNJtro;u$HTgUq&byj1ij`7qv9c(Oh)_@zn#(Q=Kwp`vl;W`sLT*kw7 z7T8$0&Iar2;!N&=J_nIse|r5sSbp!a@c#fi{Kmt7F4$Q3&jafV*AKyRc@Ku`N7&&q z9<0SYLX*5G=p`@LvR$-+MLu7h{Ltc=#^?8w>xXV141b3@n#-a=0$X4wvz8 zT>&;0t}DU%!gUo`F7NYj{TMr3#>4d!u(5Dm4c3?U^BS$hOJ{H}%Tci7=F9P4X?gG2sC%(JE`k*XsC9fU* zd&FF0exLq;_VN2QW{N~_xD(j6IJS z%idoC8~2ItWw1Wyku&fL*j#7vD%!_0p#MLmRTQtGUGqBPKJ>dU^RVG% zs=pQ91Rsm6Lasr)Gdw5eorCxds&iQ*Gk**08M5!(Rd0h^5NBsRch!Hv#&TD^1J>8c zdpQmLE@EGDc^0+Jsn>Qt8~JNvDEd8Q7UEvrgL~ArKXbfK{)bFN%u$=ui6mzT*mLZA zZjRab0zyd29l^{|$(, +} + +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(); + } +}