diff --git a/.cargo/config.toml b/.cargo/config.toml index facd0f19..13ccc194 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -1,3 +1,6 @@ +[alias] +shaders = "gpu build --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..798f4ee5 100644 --- a/.github/workflows/push.yaml +++ b/.github/workflows/push.yaml @@ -15,14 +15,18 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - - uses: moonrepo/setup-rust@v1 - - uses: Swatinem/rust-cache@v2 + - uses: actions/cache@v4 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: git diff --exit-code --no-ext-diff crates/renderling/src/linkage + path: ~/.cache/rust-gpu + key: ${{ runner.os }} + - uses: moonrepo/setup-rust@v1 + - run: rustup toolchain add nightly-2024-04-24 + - run: rustup component add --toolchain nightly-2024-04-24 rust-src rustc-dev llvm-tools + - run: cargo install --git https://github.com/rust-gpu/cargo-gpu + - run: rm -rf crates/renderling/src/linkage/* crates/renderling/shaders + - run: RUST_LOG=trace cargo shaders + - run: cargo build -p renderling + - run: git diff --exit-code --no-ext-diff renderling-clippy: runs-on: ubuntu-latest diff --git a/.gitignore b/.gitignore index aab88c29..1d787510 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ /target/ shaders/target shaders/shader-crate/target +**/spirv-manifest.json # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html diff --git a/Cargo.lock b/Cargo.lock index 468fc2f8..ec941949 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -285,30 +285,15 @@ version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" -[[package]] -name = "bit-set" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" -dependencies = [ - "bit-vec 0.6.3", -] - [[package]] name = "bit-set" version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0481a0e032742109b1133a095184ee93d88f3dc9e0d28a5d033dc77a073f44f" dependencies = [ - "bit-vec 0.7.0", + "bit-vec", ] -[[package]] -name = "bit-vec" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" - [[package]] name = "bit-vec" version = "0.7.0" @@ -1757,27 +1742,6 @@ dependencies = [ "simd-adler32", ] -[[package]] -name = "naga" -version = "0.19.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50e3524642f53d9af419ab5e8dd29d3ba155708267667c2f3f06c88c9e130843" -dependencies = [ - "bit-set 0.5.3", - "bitflags 2.6.0", - "codespan-reporting", - "hexf-parse", - "indexmap", - "log", - "num-traits", - "petgraph", - "rustc-hash 1.1.0", - "spirv", - "termcolor", - "thiserror", - "unicode-xid", -] - [[package]] name = "naga" version = "22.1.0" @@ -1785,7 +1749,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8bd5a652b6faf21496f2cfd88fc49989c8db0825d1f6746b1a71a6ede24a63ad" dependencies = [ "arrayvec", - "bit-set 0.6.0", + "bit-set", "bitflags 2.6.0", "cfg_aliases 0.1.1", "codespan-reporting", @@ -2150,6 +2114,12 @@ version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" +[[package]] +name = "pathdiff" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d61c5ce1153ab5b689d0c074c4e7fc613e942dfb7dd9eea5ab202d2ad91fe361" + [[package]] name = "percent-encoding" version = "2.3.1" @@ -2562,9 +2532,12 @@ dependencies = [ "image 0.24.9", "img-diff", "log", - "naga 0.19.2", + "naga", + "pathdiff", "pretty_assertions", + "quote", "rustc-hash 1.1.0", + "serde", "serde_json", "snafu", "spirv-std", @@ -3322,7 +3295,7 @@ dependencies = [ "document-features", "js-sys", "log", - "naga 22.1.0", + "naga", "parking_lot", "profiling", "raw-window-handle", @@ -3343,14 +3316,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0348c840d1051b8e86c3bcd31206080c5e71e5933dabd79be1ce732b0b2f089a" dependencies = [ "arrayvec", - "bit-vec 0.7.0", + "bit-vec", "bitflags 2.6.0", "bytemuck", "cfg_aliases 0.1.1", "document-features", "indexmap", "log", - "naga 22.1.0", + "naga", "once_cell", "parking_lot", "profiling", @@ -3371,7 +3344,7 @@ dependencies = [ "android_system_properties", "arrayvec", "ash", - "bit-set 0.6.0", + "bit-set", "bitflags 2.6.0", "block", "cfg_aliases 0.1.1", @@ -3389,7 +3362,7 @@ dependencies = [ "libloading", "log", "metal", - "naga 22.1.0", + "naga", "ndk-sys 0.5.0+25.2.9519653", "objc", "once_cell", diff --git a/Cargo.toml b/Cargo.toml index a39b07f2..dce08e7d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -26,7 +26,7 @@ glam = { version = "0.24.2", default-features = false } gltf = { version = "1.4,1", features = ["KHR_lights_punctual", "KHR_materials_unlit", "KHR_materials_emissive_strength", "extras", "extensions"] } image = "0.24" log = "0.4" -naga = { version = "0.19", features = ["spv-in", "wgsl-out", "wgsl-in", "msl-out"] } +naga = { version = "22.1.0", features = ["spv-in", "wgsl-out", "wgsl-in", "msl-out"] } pretty_assertions = "1.4.0" proc-macro2 = { version = "1.0", features = ["span-locations"] } rustc-hash = "1.1" @@ -40,6 +40,7 @@ web-sys = "0.3" winit = { version = "0.30" } wgpu = "22.1.0" + [profile.dev] opt-level = 1 diff --git a/README.md b/README.md index 0d28069c..12f4901f 100644 --- a/README.md +++ b/README.md @@ -133,27 +133,22 @@ A small beast that looks cute up close, ready to do your graphics bidding. > Cute technology. ## Project Organization -* crates/renderling-shader - - Contains Rust shader code that can be shared on CPU and GPU (using `rust-gpu` to compile to SPIR-V). - Most of the shader code is here! - Certain tasks require atomics which doesn't work from `rust-gpu` to `wgpu` yet. See [NOTES.md](NOTES.md). - This crate is a member of the workspace so you get nice editor tooling while writing shaders in Rust. - You can also write sanity tests that run with `cargo test`. - Things just work like BAU. - -* shaders - - Contains a thin crate wrapper around `renderling-shader`. - Provides the spirv annotations for shaders. - Contains a program that compiles Rust into SPIR-V and copies **.spv** files into the main `renderling` crate. * crates/renderling - The main crate. + Main library crate. Contains CPU Rust code for creating pipelines and managing resources, making render passes, etc. + Contains GPU Rust code of the shader operations themselves. Contains tests, some using image comparison of actual frame renders for consistency and backwards compatibility. +* crates/renderling/shaders + + Contains **.spv** and **.wgsl** files generated by [`cargo-gpu`](https://github.com/rust-gpu/cargo-gpu). + +* crates/renderling/src/linkage* + + Contains autogenerated `wgpu` linkage for the generated shaders. + * img Image assets for tests (textures, etc.) @@ -178,13 +173,17 @@ cargo test ## Building the shaders -The `shaders/` folder is a crate that is excluded from the cargo workspace. -It compiles into a program that can be run to generate the shaders: +The `crates/renderling/shaders/` folder contains the generated SPIR-V files. + +To regenerate the shaders, run: ``` -cd shaders/ && cargo run --release +cargo shaders ``` +There is a `.cargo/config.toml` alias for `cargo shaders` that expands into a larger +shader compilation command. + ## Building on WASM ``` @@ -208,6 +207,8 @@ If you use it (outright or for inspiration), please consider donating. Many projects were born from first solving a need within `renderling`. Some of these solutions were then spun off into their own projects. +- [`cargo-gpu`](https://githu.com/rust-gpu/cargo-gpu) + A shader compilation cli tool. - [`crabslab`](https://github.com/schell/crabslab) A slab allocator for working across CPU/GPU boundaries. - [`loading-bytes`](crates/loading-bytes) diff --git a/crates/renderling/Cargo.toml b/crates/renderling/Cargo.toml index f937b9de..9cf273a6 100644 --- a/crates/renderling/Cargo.toml +++ b/crates/renderling/Cargo.toml @@ -8,6 +8,7 @@ license = "MIT OR Apache-2.0" keywords = ["game", "graphics", "shader", "rendering"] categories = ["rendering", "game-development", "graphics"] readme = "../../README.md" +build = "src/build.rs" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html @@ -87,8 +88,12 @@ tutorial_slabbed_renderlet = [] wasm = ["wgpu/fragile-send-sync-non-atomic-wasm"] -[patch.crates-io] -spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu" } +[build-dependencies] +naga = {workspace = true} +pathdiff = "0.2.2" +quote = "1.0" +serde = {version = "1.0", features = ["derive"]} +serde_json = {workspace = true} # dependencies for CPU and GPU code [dependencies] @@ -134,8 +139,3 @@ winit.workspace = true [target.'cfg(not(target_arch = "spirv"))'.dev-dependencies] glam = { workspace = true, features = ["std", "debug-glam-assert"] } - - -# [[bench]] -# name = "benchmarks" -# harness = false diff --git a/crates/renderling/src/linkage/bloom-bloom_downsample_fragment.spv b/crates/renderling/shaders/bloom-bloom_downsample_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/bloom-bloom_downsample_fragment.spv rename to crates/renderling/shaders/bloom-bloom_downsample_fragment.spv 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/src/linkage/bloom-bloom_mix_fragment.spv b/crates/renderling/shaders/bloom-bloom_mix_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/bloom-bloom_mix_fragment.spv rename to crates/renderling/shaders/bloom-bloom_mix_fragment.spv 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/src/linkage/bloom-bloom_upsample_fragment.spv b/crates/renderling/shaders/bloom-bloom_upsample_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/bloom-bloom_upsample_fragment.spv rename to crates/renderling/shaders/bloom-bloom_upsample_fragment.spv diff --git a/crates/renderling/shaders/bloom-bloom_upsample_fragment.wgsl b/crates/renderling/shaders/bloom-bloom_upsample_fragment.wgsl new file mode 100644 index 00000000..65f9b7f2 --- /dev/null +++ b/crates/renderling/shaders/bloom-bloom_upsample_fragment.wgsl @@ -0,0 +1,60 @@ +struct type_8 { + member: array, +} + +@group(0) @binding(0) +var global: type_8; +var global_1: vec2; +@group(0) @binding(2) +var global_2: sampler; +@group(0) @binding(1) +var global_3: texture_2d; +var global_4: u32; +var global_5: vec4; + +fn function() { + var phi_235_: bool; + var phi_108_: vec2; + + let _e17 = arrayLength((&global.member)); + let _e18 = global_1; + let _e19 = global_4; + if (_e17 >= 2u) { + phi_235_ = (_e19 <= (_e17 - 2u)); + } else { + phi_235_ = false; + } + let _e24 = phi_235_; + if _e24 { + let _e27 = global.member[_e19]; + let _e32 = global.member[(_e19 + 1u)]; + phi_108_ = vec2(bitcast(_e27), bitcast(_e32)); + } else { + phi_108_ = vec2(0f, 0f); + } + let _e36 = phi_108_; + let _e40 = (_e18.x - _e36.x); + let _e42 = (_e18.y + _e36.y); + let _e44 = textureSample(global_3, global_2, vec2(_e40, _e42)); + let _e49 = textureSample(global_3, global_2, vec2(_e18.x, _e42)); + let _e54 = textureSample(global_3, global_2, (_e18 + _e36)); + let _e59 = textureSample(global_3, global_2, vec2(_e40, _e18.y)); + let _e63 = textureSample(global_3, global_2, _e18); + let _e67 = (_e18.x + _e36.x); + let _e69 = textureSample(global_3, global_2, vec2(_e67, _e18.y)); + let _e74 = textureSample(global_3, global_2, (_e18 - _e36)); + let _e78 = (_e18.y - _e36.y); + let _e80 = textureSample(global_3, global_2, vec2(_e18.x, _e78)); + let _e85 = textureSample(global_3, global_2, vec2(_e67, _e78)); + global_5 = vec4(((fma(_e63.x, 4f, ((((_e49.x + _e59.x) + _e69.x) + _e80.x) * 2f)) + (((_e44.x + _e54.x) + _e74.x) + _e85.x)) * 0.0625f), ((fma(_e63.y, 4f, ((((_e49.y + _e59.y) + _e69.y) + _e80.y) * 2f)) + (((_e44.y + _e54.y) + _e74.y) + _e85.y)) * 0.0625f), ((fma(_e63.z, 4f, ((((_e49.z + _e59.z) + _e69.z) + _e80.z) * 2f)) + (((_e44.z + _e54.z) + _e74.z) + _e85.z)) * 0.0625f), 0.5f); + return; +} + +@fragment +fn bloombloom_upsample_fragment(@location(0) param: vec2, @location(1) @interpolate(flat) param_1: u32) -> @location(0) vec4 { + global_1 = param; + global_4 = param_1; + function(); + let _e5 = global_5; + return _e5; +} diff --git a/crates/renderling/shaders/bloom-bloom_vertex.spv b/crates/renderling/shaders/bloom-bloom_vertex.spv new file mode 100644 index 00000000..34d11cda Binary files /dev/null and b/crates/renderling/shaders/bloom-bloom_vertex.spv differ diff --git a/crates/renderling/shaders/bloom-bloom_vertex.wgsl b/crates/renderling/shaders/bloom-bloom_vertex.wgsl new file mode 100644 index 00000000..08fba408 --- /dev/null +++ b/crates/renderling/shaders/bloom-bloom_vertex.wgsl @@ -0,0 +1,55 @@ +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>; + + switch bitcast(0u) { + default: { + let _e24 = global; + let _e25 = global_1; + let _e26 = (_e24 % 6u); + local = array, 6>(vec2(0f, 1f), vec2(1f, 1f), vec2(1f, 0f), vec2(1f, 0f), vec2(0f, 0f), vec2(0f, 1f)); + let _e27 = (_e26 < 6u); + if _e27 { + } else { + break; + } + let _e29 = local[_e26]; + global_2 = _e29; + 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 _e27 { + } else { + break; + } + let _e31 = local_1[_e26]; + global_3 = _e31; + global_4 = _e25; + break; + } + } + return; +} + +@vertex +fn bloombloom_vertex(@builtin(vertex_index) param: u32, @builtin(instance_index) param_1: u32) -> VertexOutput { + global = param; + global_1 = param_1; + function(); + let _e8 = global_3.y; + global_3.y = -(_e8); + let _e10 = global_2; + let _e11 = global_4; + let _e12 = global_3; + return VertexOutput(_e10, _e11, _e12); +} diff --git a/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv new file mode 100644 index 00000000..1e418faf Binary files /dev/null and b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.spv differ diff --git a/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.wgsl b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.wgsl new file mode 100644 index 00000000..99b2a287 --- /dev/null +++ b/crates/renderling/shaders/convolution-brdf_lut_convolution_fragment.wgsl @@ -0,0 +1,165 @@ +struct type_6 { + member: u32, + member_1: u32, +} + +var global: vec2; +var global_1: vec2; + +fn function() { + var phi_415_: type_6; + var phi_416_: f32; + var phi_417_: f32; + var phi_430_: type_6; + var phi_431_: type_6; + var phi_680_: vec3; + var phi_715_: vec3; + var phi_750_: vec3; + var phi_792_: f32; + var phi_805_: f32; + var phi_488_: f32; + var phi_489_: f32; + var phi_491_: f32; + var phi_492_: f32; + var phi_493_: bool; + var local: f32; + var local_1: f32; + + let _e37 = global; + let _e40 = max(_e37.x, 0.00000011920929f); + let _e41 = -(_e40); + let _e43 = sqrt(fma(_e41, _e40, 1f)); + phi_415_ = type_6(1u, 1024u); + phi_416_ = 0f; + phi_417_ = 0f; + loop { + let _e45 = phi_415_; + let _e47 = phi_416_; + let _e49 = phi_417_; + local = _e49; + local_1 = _e47; + if (_e45.member < _e45.member_1) { + phi_430_ = type_6((_e45.member + 1u), _e45.member_1); + phi_431_ = type_6(1u, _e45.member); + } else { + phi_430_ = _e45; + phi_431_ = type_6(0u, type_6().member_1); + } + let _e62 = phi_430_; + let _e64 = phi_431_; + switch bitcast(_e64.member) { + case 0: { + phi_491_ = f32(); + phi_492_ = f32(); + phi_493_ = false; + break; + } + case 1: { + let _e73 = ((_e64.member_1 << bitcast(16u)) | (_e64.member_1 >> bitcast(16u))); + let _e80 = (((_e73 & 1431655765u) << bitcast(1u)) | ((_e73 & 2863311530u) >> bitcast(1u))); + let _e87 = (((_e80 & 858993459u) << bitcast(2u)) | ((_e80 & 3435973836u) >> bitcast(2u))); + let _e94 = (((_e87 & 252645135u) << bitcast(4u)) | ((_e87 & 4042322160u) >> bitcast(4u))); + let _e102 = f32((((_e94 & 16711935u) << bitcast(8u)) | ((_e94 & 4278255360u) >> bitcast(8u)))); + let _e104 = (_e37.y * _e37.y); + let _e105 = (f32(_e64.member_1) * 0.0061359233f); + let _e111 = sqrt((fma(-(_e102), 0.00000000023283064f, 1f) / fma(fma(_e104, _e104, -1f), (_e102 * 0.00000000023283064f), 1f))); + let _e114 = sqrt(fma(-(_e111), _e111, 1f)); + let _e116 = (cos(_e105) * _e114); + let _e118 = (sin(_e105) * _e114); + let _e122 = select(vec3(1f, 0f, 0f), vec3(0f, 0f, 1f), vec3((abs(1f) < 0.999f))); + let _e125 = -(_e122.x); + let _e129 = sqrt(fma(_e122.y, _e122.y, (_e125 * _e125))); + if (_e129 == 0f) { + phi_680_ = vec3(0f, 0f, 0f); + } else { + phi_680_ = (vec3(_e122.y, _e125, 0f) * (1f / _e129)); + } + let _e134 = phi_680_; + let _e141 = fma(_e134.x, _e116, (-(_e134.y) * _e118)); + let _e142 = fma(_e134.y, _e116, (_e134.x * _e118)); + let _e143 = fma(_e134.z, _e116, _e111); + let _e148 = sqrt(fma(_e143, _e143, fma(_e141, _e141, (_e142 * _e142)))); + if (_e148 == 0f) { + phi_715_ = vec3(0f, 0f, 0f); + } else { + phi_715_ = (vec3(_e141, _e142, _e143) * (1f / _e148)); + } + let _e153 = phi_715_; + let _e158 = fma(_e43, _e153.x, (_e40 * _e153.z)); + let _e159 = (2f * _e158); + let _e160 = (_e159 * _e153.y); + let _e162 = fma(_e159, _e153.x, -(_e43)); + let _e163 = fma(_e159, _e153.z, _e41); + let _e168 = sqrt(fma(_e163, _e163, fma(_e162, _e162, (_e160 * _e160)))); + if (_e168 == 0f) { + phi_750_ = vec3(0f, 0f, 0f); + } else { + phi_750_ = (vec3(_e162, _e160, _e163) * (1f / _e168)); + } + let _e173 = phi_750_; + let _e175 = max(_e173.z, 0f); + let _e177 = max(_e158, 0f); + if (_e175 > 0f) { + let _e179 = max(_e40, 0f); + let _e180 = (_e104 * 0.5f); + let _e182 = fma(-(_e104), 0.5f, 1f); + let _e183 = fma(_e179, _e182, _e180); + if (_e183 == 0f) { + phi_792_ = 0f; + } else { + phi_792_ = (_e179 / _e183); + } + let _e187 = phi_792_; + let _e188 = fma(_e175, _e182, _e180); + if (_e188 == 0f) { + phi_805_ = 0f; + } else { + phi_805_ = (_e175 / _e188); + } + let _e192 = phi_805_; + let _e196 = (((_e187 * _e192) * _e177) / (max(_e153.z, 0f) * _e40)); + let _e198 = pow((1f - _e177), 5f); + phi_488_ = fma(_e198, _e196, _e47); + phi_489_ = fma((1f - _e198), _e196, _e49); + } else { + phi_488_ = _e47; + phi_489_ = _e49; + } + let _e203 = phi_488_; + let _e205 = phi_489_; + phi_491_ = _e203; + phi_492_ = _e205; + phi_493_ = true; + break; + } + default: { + phi_491_ = f32(); + phi_492_ = f32(); + phi_493_ = bool(); + break; + } + } + let _e207 = phi_491_; + let _e209 = phi_492_; + let _e211 = phi_493_; + continue; + continuing { + phi_415_ = _e62; + phi_416_ = _e207; + phi_417_ = _e209; + break if !(_e211); + } + } + let _e214 = local; + let _e217 = local_1; + global_1 = vec2((_e214 * 0.0009765625f), (_e217 * 0.0009765625f)); + 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/src/linkage/convolution-brdf_lut_convolution_vertex.spv b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv similarity index 75% rename from crates/renderling/src/linkage/convolution-brdf_lut_convolution_vertex.spv rename to crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv index 23afd6dd..80ed1bc4 100644 Binary files a/crates/renderling/src/linkage/convolution-brdf_lut_convolution_vertex.spv and b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.spv differ diff --git a/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.wgsl b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.wgsl new file mode 100644 index 00000000..b2cdaae9 --- /dev/null +++ b/crates/renderling/shaders/convolution-brdf_lut_convolution_vertex.wgsl @@ -0,0 +1,45 @@ +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; + + switch bitcast(0u) { + default: { + let _e26 = 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 (_e26 < 6u) { + } else { + break; + } + let _e30 = local[_e26].member; + let _e33 = local[_e26].member_1; + global = vec2(_e33[0], _e33[1]); + global_2 = vec4(_e30[0], _e30[1], _e30[2], 1f); + break; + } + } + 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/src/linkage/convolution-generate_mipmap_fragment.spv b/crates/renderling/shaders/convolution-generate_mipmap_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/convolution-generate_mipmap_fragment.spv rename to crates/renderling/shaders/convolution-generate_mipmap_fragment.spv 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/src/linkage/convolution-generate_mipmap_vertex.spv b/crates/renderling/shaders/convolution-generate_mipmap_vertex.spv similarity index 60% rename from crates/renderling/src/linkage/convolution-generate_mipmap_vertex.spv rename to crates/renderling/shaders/convolution-generate_mipmap_vertex.spv index 49223d8c..9920cd37 100644 Binary files a/crates/renderling/src/linkage/convolution-generate_mipmap_vertex.spv and b/crates/renderling/shaders/convolution-generate_mipmap_vertex.spv differ diff --git a/crates/renderling/shaders/convolution-generate_mipmap_vertex.wgsl b/crates/renderling/shaders/convolution-generate_mipmap_vertex.wgsl new file mode 100644 index 00000000..4df4b270 --- /dev/null +++ b/crates/renderling/shaders/convolution-generate_mipmap_vertex.wgsl @@ -0,0 +1,47 @@ +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>; + + switch bitcast(0u) { + default: { + let _e22 = global_1; + local = array, 6>(vec2(0f, 1f), vec2(1f, 1f), vec2(1f, 0f), vec2(1f, 0f), vec2(0f, 0f), vec2(0f, 1f)); + let _e23 = (_e22 < 6u); + if _e23 { + } else { + break; + } + let _e25 = local[_e22]; + global = _e25; + 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 _e23 { + } else { + break; + } + let _e27 = local_1[_e22]; + global_2 = _e27; + break; + } + } + return; +} + +@vertex +fn convolutiongenerate_mipmap_vertex(@builtin(vertex_index) param: u32) -> VertexOutput { + global_1 = param; + function(); + let _e5 = global_2.y; + global_2.y = -(_e5); + let _e7 = global; + let _e8 = global_2; + return VertexOutput(_e7, _e8); +} diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv new file mode 100644 index 00000000..14d02e93 Binary files /dev/null and b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.spv differ diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.wgsl b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.wgsl new file mode 100644 index 00000000..29e5c0d7 --- /dev/null +++ b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_fragment.wgsl @@ -0,0 +1,177 @@ +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_104_: type_7; + var phi_107_: vec3; + var phi_109_: f32; + var phi_105_: type_7; + var phi_124_: type_7; + var phi_627_: vec3; + var phi_662_: vec3; + var phi_697_: vec3; + var phi_178_: f32; + var phi_197_: vec3; + var phi_198_: f32; + var phi_108_: vec3; + var phi_110_: f32; + var phi_199_: bool; + var local: vec3; + var local_1: f32; + var local_2: vec3; + var local_3: f32; + var local_4: vec3; + var local_5: f32; + + let _e42 = global_2; + let _e43 = global_3; + let _e50 = sqrt(fma(_e42.z, _e42.z, fma(_e42.x, _e42.x, (_e42.y * _e42.y)))); + if (_e50 == 0f) { + phi_446_ = vec3(0f, 0f, 0f); + } else { + phi_446_ = (_e42 * (1f / _e50)); + } + let _e55 = phi_446_; + let _e57 = (_e55.y * -1f); + phi_104_ = type_7(0u, 1024u); + phi_107_ = vec3(0f, 0f, 0f); + phi_109_ = 0f; + loop { + let _e59 = phi_104_; + let _e61 = phi_107_; + let _e63 = phi_109_; + local = _e61; + local_1 = _e63; + local_2 = _e61; + local_3 = _e63; + local_4 = _e61; + local_5 = _e63; + if (_e59.member < _e59.member_1) { + phi_105_ = type_7((_e59.member + 1u), _e59.member_1); + phi_124_ = type_7(1u, _e59.member); + } else { + phi_105_ = _e59; + phi_124_ = type_7(0u, type_7().member_1); + } + let _e76 = phi_105_; + let _e78 = phi_124_; + switch bitcast(_e78.member) { + case 0: { + phi_108_ = vec3(); + phi_110_ = f32(); + phi_199_ = false; + break; + } + case 1: { + let _e87 = ((_e78.member_1 << bitcast(16u)) | (_e78.member_1 >> bitcast(16u))); + let _e94 = (((_e87 & 1431655765u) << bitcast(1u)) | ((_e87 & 2863311530u) >> bitcast(1u))); + let _e101 = (((_e94 & 858993459u) << bitcast(2u)) | ((_e94 & 3435973836u) >> bitcast(2u))); + let _e108 = (((_e101 & 252645135u) << bitcast(4u)) | ((_e101 & 4042322160u) >> bitcast(4u))); + let _e116 = f32((((_e108 & 16711935u) << bitcast(8u)) | ((_e108 & 4278255360u) >> bitcast(8u)))); + let _e118 = (_e43 * _e43); + let _e119 = (f32(_e78.member_1) * 0.0061359233f); + let _e125 = sqrt((fma(-(_e116), 0.00000000023283064f, 1f) / fma(fma(_e118, _e118, -1f), (_e116 * 0.00000000023283064f), 1f))); + let _e128 = sqrt(fma(-(_e125), _e125, 1f)); + let _e130 = (cos(_e119) * _e128); + let _e132 = (sin(_e119) * _e128); + let _e137 = select(vec3(1f, 0f, 0f), vec3(0f, 0f, 1f), vec3((abs(_e55.z) < 0.999f))); + let _e142 = fma(_e137.y, _e55.z, -((_e57 * _e137.z))); + let _e147 = fma(_e137.z, _e55.x, -((_e55.z * _e137.x))); + let _e150 = fma(_e137.x, _e57, -((_e55.x * _e137.y))); + let _e155 = sqrt(fma(_e150, _e150, fma(_e142, _e142, (_e147 * _e147)))); + if (_e155 == 0f) { + phi_627_ = vec3(0f, 0f, 0f); + } else { + phi_627_ = (vec3(_e142, _e147, _e150) * (1f / _e155)); + } + let _e160 = phi_627_; + let _e179 = fma(_e55.x, _e125, fma(_e160.x, _e130, (fma(_e57, _e160.z, -((_e160.y * _e55.z))) * _e132))); + let _e180 = fma(_e57, _e125, fma(_e160.y, _e130, (fma(_e55.z, _e160.x, -((_e160.z * _e55.x))) * _e132))); + let _e181 = fma(_e55.z, _e125, fma(_e160.z, _e130, (fma(_e55.x, _e160.y, -((_e160.x * _e57))) * _e132))); + let _e186 = sqrt(fma(_e181, _e181, fma(_e179, _e179, (_e180 * _e180)))); + if (_e186 == 0f) { + phi_662_ = vec3(0f, 0f, 0f); + } else { + phi_662_ = (vec3(_e179, _e180, _e181) * (1f / _e186)); + } + let _e191 = phi_662_; + let _e198 = (2f * fma(_e55.z, _e191.z, fma(_e55.x, _e191.x, (_e57 * _e191.y)))); + let _e200 = fma(_e198, _e191.x, -(_e55.x)); + let _e201 = fma(_e198, _e191.y, _e55.y); + let _e203 = fma(_e198, _e191.z, -(_e55.z)); + let _e208 = sqrt(fma(_e203, _e203, fma(_e200, _e200, (_e201 * _e201)))); + if (_e208 == 0f) { + phi_697_ = vec3(0f, 0f, 0f); + } else { + phi_697_ = (vec3(_e200, _e201, _e203) * (1f / _e208)); + } + let _e213 = phi_697_; + let _e220 = max(fma(_e55.z, _e213.z, fma(_e55.x, _e213.x, (_e57 * _e213.y))), 0f); + if (_e220 > 0f) { + if (_e43 == 0f) { + phi_178_ = 0f; + } else { + phi_178_ = (0.5f * log2((1572864f / max((1024f * max((_e220 * 0.31830987f), 0f)), 0.00000011920929f)))); + } + let _e231 = phi_178_; + let _e232 = textureSampleLevel(global_4, global, _e213, _e231); + phi_197_ = vec3(fma(_e232.x, _e220, _e61.x), fma(_e232.y, _e220, _e61.y), fma(_e232.z, _e220, _e61.z)); + phi_198_ = (_e63 + _e220); + } else { + phi_197_ = _e61; + phi_198_ = _e63; + } + let _e245 = phi_197_; + let _e247 = phi_198_; + phi_108_ = _e245; + phi_110_ = _e247; + phi_199_ = true; + break; + } + default: { + phi_108_ = vec3(); + phi_110_ = f32(); + phi_199_ = bool(); + break; + } + } + let _e249 = phi_108_; + let _e251 = phi_110_; + let _e253 = phi_199_; + continue; + continuing { + phi_104_ = _e76; + phi_107_ = _e249; + phi_109_ = _e251; + break if !(_e253); + } + } + let _e256 = local; + let _e259 = local_1; + let _e262 = local_2; + let _e265 = local_3; + let _e268 = local_4; + let _e271 = local_5; + global_1 = vec4((_e256.x / _e259), (_e262.y / _e265), (_e268.z / _e271), 1f); + return; +} + +@fragment +fn convolutionprefilter_environment_cubemap_fragment(@location(0) param: vec3, @location(1) param_1: f32) -> @location(0) vec4 { + global_2 = param; + global_3 = param_1; + function(); + let _e5 = global_1; + return _e5; +} diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv new file mode 100644 index 00000000..7b350164 Binary files /dev/null and b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.spv differ diff --git a/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.wgsl b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.wgsl new file mode 100644 index 00000000..98c2226a --- /dev/null +++ b/crates/renderling/shaders/convolution-prefilter_environment_cubemap_vertex.wgsl @@ -0,0 +1,248 @@ +struct type_10 { + member: array, +} + +struct type_20 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_21 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_22 { + member: type_20, + member_1: type_20, + member_2: type_21, + member_3: vec3, +} + +struct type_24 { + member: u32, + member_1: u32, +} + +struct VertexOutput { + @location(0) member: vec3, + @location(1) member_1: f32, + @builtin(position) member_2: vec4, +} + +@group(0) @binding(0) +var global: type_10; +var global_1: u32; +var global_2: u32; +var global_3: f32; +var global_4: vec3; +var global_5: vec4 = vec4(0f, 0f, 0f, 1f); + +fn function() { + var local: array, 8>; + var local_1: array, 6>; + var local_2: array, 36>; + var phi_767_: bool; + var phi_165_: type_24; + var phi_795_: bool; + var phi_326_: type_24; + var phi_327_: type_24; + var phi_342_: type_24; + var phi_369_: bool; + var phi_375_: type_24; + var phi_376_: type_24; + var phi_391_: type_24; + var phi_414_: bool; + var phi_422_: type_22; + var phi_827_: bool; + var phi_430_: f32; + + switch bitcast(0u) { + default: { + let _e81 = global_1; + let _e82 = global_2; + let _e84 = 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 (_e82 < 36u) { + } else { + break; + } + let _e87 = local_2[_e82]; + if (_e84 >= 2u) { + phi_767_ = (_e81 <= (_e84 - 2u)); + } else { + phi_767_ = false; + } + let _e92 = phi_767_; + if _e92 { + let _e95 = global.member[_e81]; + let _e99 = global.member[(_e81 + 1u)]; + phi_165_ = type_24(_e95, _e99); + } else { + phi_165_ = type_24(4294967295u, 4294967295u); + } + let _e102 = phi_165_; + if (_e84 >= 83u) { + phi_795_ = (_e102.member <= (_e84 - 83u)); + } else { + phi_795_ = false; + } + let _e109 = phi_795_; + if _e109 { + let _e112 = global.member[_e102.member]; + let _e117 = global.member[(_e102.member + 1u)]; + let _e122 = global.member[(_e102.member + 2u)]; + let _e127 = global.member[(_e102.member + 3u)]; + let _e133 = global.member[(_e102.member + 4u)]; + let _e138 = global.member[(_e102.member + 5u)]; + let _e143 = global.member[(_e102.member + 6u)]; + let _e148 = global.member[(_e102.member + 7u)]; + let _e154 = global.member[(_e102.member + 8u)]; + let _e159 = global.member[(_e102.member + 9u)]; + let _e164 = global.member[(_e102.member + 10u)]; + let _e169 = global.member[(_e102.member + 11u)]; + let _e175 = global.member[(_e102.member + 12u)]; + let _e180 = global.member[(_e102.member + 13u)]; + let _e185 = global.member[(_e102.member + 14u)]; + let _e190 = global.member[(_e102.member + 15u)]; + let _e197 = global.member[(_e102.member + 16u)]; + let _e202 = global.member[(_e102.member + 17u)]; + let _e207 = global.member[(_e102.member + 18u)]; + let _e212 = global.member[(_e102.member + 19u)]; + let _e218 = global.member[(_e102.member + 20u)]; + let _e223 = global.member[(_e102.member + 21u)]; + let _e228 = global.member[(_e102.member + 22u)]; + let _e233 = global.member[(_e102.member + 23u)]; + let _e239 = global.member[(_e102.member + 24u)]; + let _e244 = global.member[(_e102.member + 25u)]; + let _e249 = global.member[(_e102.member + 26u)]; + let _e254 = global.member[(_e102.member + 27u)]; + let _e260 = global.member[(_e102.member + 28u)]; + let _e265 = global.member[(_e102.member + 29u)]; + let _e270 = global.member[(_e102.member + 30u)]; + let _e275 = global.member[(_e102.member + 31u)]; + let _e282 = global.member[(_e102.member + 32u)]; + let _e287 = global.member[(_e102.member + 33u)]; + let _e292 = global.member[(_e102.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 _e297 = phi_326_; + if (_e297.member < _e297.member_1) { + phi_327_ = type_24((_e297.member + 1u), _e297.member_1); + phi_342_ = type_24(1u, _e297.member); + } else { + phi_327_ = _e297; + phi_342_ = type_24(0u, type_24().member_1); + } + let _e310 = phi_327_; + let _e312 = phi_342_; + switch bitcast(_e312.member) { + case 0: { + phi_369_ = false; + break; + } + case 1: { + let _e317 = ((_e102.member + 35u) + (_e312.member_1 * 4u)); + let _e320 = global.member[_e317]; + let _e325 = global.member[(_e317 + 1u)]; + let _e330 = global.member[(_e317 + 2u)]; + let _e335 = global.member[(_e317 + 3u)]; + local_1[_e312.member_1] = vec4(bitcast(_e320), bitcast(_e325), bitcast(_e330), bitcast(_e335)); + phi_369_ = true; + break; + } + default: { + phi_369_ = bool(); + break; + } + } + let _e340 = phi_369_; + continue; + continuing { + phi_326_ = _e310; + break if !(_e340); + } + } + let _e342 = 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_375_ = type_24(0u, 8u); + loop { + let _e345 = phi_375_; + if (_e345.member < _e345.member_1) { + phi_376_ = type_24((_e345.member + 1u), _e345.member_1); + phi_391_ = type_24(1u, _e345.member); + } else { + phi_376_ = _e345; + phi_391_ = type_24(0u, type_24().member_1); + } + let _e358 = phi_376_; + let _e360 = phi_391_; + switch bitcast(_e360.member) { + case 0: { + phi_414_ = false; + break; + } + case 1: { + let _e365 = ((_e102.member + 59u) + (_e360.member_1 * 3u)); + let _e368 = global.member[_e365]; + let _e373 = global.member[(_e365 + 1u)]; + let _e378 = global.member[(_e365 + 2u)]; + local[_e360.member_1] = vec3(bitcast(_e368), bitcast(_e373), bitcast(_e378)); + phi_414_ = true; + break; + } + default: { + phi_414_ = bool(); + break; + } + } + let _e383 = phi_414_; + continue; + continuing { + phi_375_ = _e358; + break if !(_e383); + } + } + let _e385 = local; + phi_422_ = type_22(type_20(vec4(bitcast(_e112), bitcast(_e117), bitcast(_e122), bitcast(_e127)), vec4(bitcast(_e133), bitcast(_e138), bitcast(_e143), bitcast(_e148)), vec4(bitcast(_e154), bitcast(_e159), bitcast(_e164), bitcast(_e169)), vec4(bitcast(_e175), bitcast(_e180), bitcast(_e185), bitcast(_e190))), type_20(vec4(bitcast(_e197), bitcast(_e202), bitcast(_e207), bitcast(_e212)), vec4(bitcast(_e218), bitcast(_e223), bitcast(_e228), bitcast(_e233)), vec4(bitcast(_e239), bitcast(_e244), bitcast(_e249), bitcast(_e254)), vec4(bitcast(_e260), bitcast(_e265), bitcast(_e270), bitcast(_e275))), type_21(_e385, _e342), vec3(bitcast(_e282), bitcast(_e287), bitcast(_e292))); + } else { + phi_422_ = 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 _e389 = phi_422_; + if (_e84 >= 1u) { + phi_827_ = (_e102.member_1 <= (_e84 - 1u)); + } else { + phi_827_ = false; + } + let _e396 = phi_827_; + if _e396 { + let _e399 = global.member[_e102.member_1]; + phi_430_ = bitcast(_e399); + } else { + phi_430_ = 0f; + } + let _e402 = phi_430_; + global_3 = _e402; + global_4 = _e87; + global_5 = vec4((fma(fma(_e389.member.member_3.x, _e389.member_1.member_2.w, fma(_e389.member.member_2.x, _e389.member_1.member_2.z, fma(_e389.member.member.x, _e389.member_1.member_2.x, (_e389.member.member_1.x * _e389.member_1.member_2.y)))), _e87.z, fma(fma(_e389.member.member_3.x, _e389.member_1.member.w, fma(_e389.member.member_2.x, _e389.member_1.member.z, fma(_e389.member.member.x, _e389.member_1.member.x, (_e389.member.member_1.x * _e389.member_1.member.y)))), _e87.x, (fma(_e389.member.member_3.x, _e389.member_1.member_1.w, fma(_e389.member.member_2.x, _e389.member_1.member_1.z, fma(_e389.member.member.x, _e389.member_1.member_1.x, (_e389.member.member_1.x * _e389.member_1.member_1.y)))) * _e87.y))) + fma(_e389.member.member_3.x, _e389.member_1.member_3.w, fma(_e389.member.member_2.x, _e389.member_1.member_3.z, fma(_e389.member.member.x, _e389.member_1.member_3.x, (_e389.member.member_1.x * _e389.member_1.member_3.y))))), (fma(fma(_e389.member.member_3.y, _e389.member_1.member_2.w, fma(_e389.member.member_2.y, _e389.member_1.member_2.z, fma(_e389.member.member.y, _e389.member_1.member_2.x, (_e389.member.member_1.y * _e389.member_1.member_2.y)))), _e87.z, fma(fma(_e389.member.member_3.y, _e389.member_1.member.w, fma(_e389.member.member_2.y, _e389.member_1.member.z, fma(_e389.member.member.y, _e389.member_1.member.x, (_e389.member.member_1.y * _e389.member_1.member.y)))), _e87.x, (fma(_e389.member.member_3.y, _e389.member_1.member_1.w, fma(_e389.member.member_2.y, _e389.member_1.member_1.z, fma(_e389.member.member.y, _e389.member_1.member_1.x, (_e389.member.member_1.y * _e389.member_1.member_1.y)))) * _e87.y))) + fma(_e389.member.member_3.y, _e389.member_1.member_3.w, fma(_e389.member.member_2.y, _e389.member_1.member_3.z, fma(_e389.member.member.y, _e389.member_1.member_3.x, (_e389.member.member_1.y * _e389.member_1.member_3.y))))), (fma(fma(_e389.member.member_3.z, _e389.member_1.member_2.w, fma(_e389.member.member_2.z, _e389.member_1.member_2.z, fma(_e389.member.member.z, _e389.member_1.member_2.x, (_e389.member.member_1.z * _e389.member_1.member_2.y)))), _e87.z, fma(fma(_e389.member.member_3.z, _e389.member_1.member.w, fma(_e389.member.member_2.z, _e389.member_1.member.z, fma(_e389.member.member.z, _e389.member_1.member.x, (_e389.member.member_1.z * _e389.member_1.member.y)))), _e87.x, (fma(_e389.member.member_3.z, _e389.member_1.member_1.w, fma(_e389.member.member_2.z, _e389.member_1.member_1.z, fma(_e389.member.member.z, _e389.member_1.member_1.x, (_e389.member.member_1.z * _e389.member_1.member_1.y)))) * _e87.y))) + fma(_e389.member.member_3.z, _e389.member_1.member_3.w, fma(_e389.member.member_2.z, _e389.member_1.member_3.z, fma(_e389.member.member.z, _e389.member_1.member_3.x, (_e389.member.member_1.z * _e389.member_1.member_3.y))))), (fma(fma(_e389.member.member_3.w, _e389.member_1.member_2.w, fma(_e389.member.member_2.w, _e389.member_1.member_2.z, fma(_e389.member.member.w, _e389.member_1.member_2.x, (_e389.member.member_1.w * _e389.member_1.member_2.y)))), _e87.z, fma(fma(_e389.member.member_3.w, _e389.member_1.member.w, fma(_e389.member.member_2.w, _e389.member_1.member.z, fma(_e389.member.member.w, _e389.member_1.member.x, (_e389.member.member_1.w * _e389.member_1.member.y)))), _e87.x, (fma(_e389.member.member_3.w, _e389.member_1.member_1.w, fma(_e389.member.member_2.w, _e389.member_1.member_1.z, fma(_e389.member.member.w, _e389.member_1.member_1.x, (_e389.member.member_1.w * _e389.member_1.member_1.y)))) * _e87.y))) + fma(_e389.member.member_3.w, _e389.member_1.member_3.w, fma(_e389.member.member_2.w, _e389.member_1.member_3.z, fma(_e389.member.member.w, _e389.member_1.member_3.x, (_e389.member.member_1.w * _e389.member_1.member_3.y)))))); + break; + } + } + return; +} + +@vertex +fn convolutionprefilter_environment_cubemap_vertex(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_1 = param; + global_2 = param_1; + function(); + let _e8 = global_5.y; + global_5.y = -(_e8); + let _e10 = global_4; + let _e11 = global_3; + let _e12 = global_5; + return VertexOutput(_e10, _e11, _e12); +} diff --git a/crates/renderling/shaders/cull-compute_frustum_culling.spv b/crates/renderling/shaders/cull-compute_frustum_culling.spv new file mode 100644 index 00000000..eddf5824 Binary files /dev/null and b/crates/renderling/shaders/cull-compute_frustum_culling.spv differ diff --git a/crates/renderling/shaders/cull-compute_frustum_culling.wgsl b/crates/renderling/shaders/cull-compute_frustum_culling.wgsl new file mode 100644 index 00000000..34caf38b --- /dev/null +++ b/crates/renderling/shaders/cull-compute_frustum_culling.wgsl @@ -0,0 +1,667 @@ +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_1208_: bool; + var phi_460_: type_18; + var phi_461_: type_18; + var phi_476_: type_18; + var phi_503_: bool; + var phi_509_: type_18; + var phi_510_: type_18; + var phi_525_: type_18; + var phi_548_: bool; + var phi_556_: type_16; + var phi_1240_: bool; + var phi_607_: type_29; + var phi_739_: type_18; + var phi_740_: type_18; + var phi_755_: type_18; + var phi_799_: bool; + var phi_803_: bool; + var phi_804_: bool; + var phi_1415_: bool; + var phi_1154_: bool; + var phi_1438_: bool; + var phi_811_: type_18; + var phi_812_: type_18; + var phi_827_: type_18; + var phi_837_: type_18; + var phi_840_: i32; + var phi_838_: type_18; + var phi_855_: type_18; + var phi_896_: i32; + var phi_841_: i32; + var phi_897_: bool; + var phi_1433_: bool; + var local_8: i32; + var phi_904_: type_18; + var phi_907_: i32; + var phi_905_: type_18; + var phi_922_: type_18; + var phi_963_: i32; + var phi_908_: i32; + var phi_964_: bool; + var phi_1440_: bool; + var local_9: i32; + var phi_1447_: bool; + var phi_970_: bool; + var phi_971_: bool; + var phi_1446_: bool; + var phi_972_: bool; + var phi_973_: bool; + var phi_974_: bool; + var phi_975_: bool; + var phi_1445_: bool; + var phi_1157_: bool; + var phi_1156_: bool; + var phi_1155_: bool; + var phi_998_: type_30; + var phi_999_: type_30; + var local_10: u32; + var phi_1005_: type_30; + var phi_1006_: type_30; + + switch bitcast(0u) { + default: { + let _e82 = arrayLength((&global.member)); + let _e85 = global_2; + if (_e85.x >= arrayLength((&global_1.member))) { + } else { + let _e91 = global_1.member[_e85.x].member_3; + let _e94 = global.member[_e91]; + let _e99 = global.member[(_e91 + 2u)]; + let _e103 = global.member[(_e91 + 3u)]; + let _e104 = bitcast(_e103); + let _e108 = global.member[(_e91 + 4u)]; + let _e109 = bitcast(_e108); + let _e113 = global.member[(_e91 + 5u)]; + let _e114 = bitcast(_e113); + let _e118 = global.member[(_e91 + 6u)]; + let _e119 = bitcast(_e118); + let _e123 = global.member[(_e91 + 7u)]; + let _e127 = global.member[(_e91 + 8u)]; + let _e131 = global.member[(_e91 + 9u)]; + let _e135 = global.member[(_e91 + 10u)]; + global_1.member[_e85.x].member = select(_e127, _e99, (_e123 == 4294967295u)); + global_1.member[_e85.x].member_1 = select(0u, 1u, (_e94 == 1u)); + if (_e119 == 0f) { + } else { + if (_e82 >= 83u) { + phi_1208_ = (_e131 <= (_e82 - 83u)); + } else { + phi_1208_ = false; + } + let _e150 = phi_1208_; + if _e150 { + let _e153 = global.member[_e131]; + let _e158 = global.member[(_e131 + 1u)]; + let _e163 = global.member[(_e131 + 2u)]; + let _e168 = global.member[(_e131 + 3u)]; + let _e174 = global.member[(_e131 + 4u)]; + let _e179 = global.member[(_e131 + 5u)]; + let _e184 = global.member[(_e131 + 6u)]; + let _e189 = global.member[(_e131 + 7u)]; + let _e195 = global.member[(_e131 + 8u)]; + let _e200 = global.member[(_e131 + 9u)]; + let _e205 = global.member[(_e131 + 10u)]; + let _e210 = global.member[(_e131 + 11u)]; + let _e216 = global.member[(_e131 + 12u)]; + let _e221 = global.member[(_e131 + 13u)]; + let _e226 = global.member[(_e131 + 14u)]; + let _e231 = global.member[(_e131 + 15u)]; + let _e238 = global.member[(_e131 + 16u)]; + let _e243 = global.member[(_e131 + 17u)]; + let _e248 = global.member[(_e131 + 18u)]; + let _e253 = global.member[(_e131 + 19u)]; + let _e259 = global.member[(_e131 + 20u)]; + let _e264 = global.member[(_e131 + 21u)]; + let _e269 = global.member[(_e131 + 22u)]; + let _e274 = global.member[(_e131 + 23u)]; + let _e280 = global.member[(_e131 + 24u)]; + let _e285 = global.member[(_e131 + 25u)]; + let _e290 = global.member[(_e131 + 26u)]; + let _e295 = global.member[(_e131 + 27u)]; + let _e301 = global.member[(_e131 + 28u)]; + let _e306 = global.member[(_e131 + 29u)]; + let _e311 = global.member[(_e131 + 30u)]; + let _e316 = global.member[(_e131 + 31u)]; + let _e323 = global.member[(_e131 + 32u)]; + let _e328 = global.member[(_e131 + 33u)]; + let _e333 = global.member[(_e131 + 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_460_ = type_18(0u, 6u); + loop { + let _e338 = phi_460_; + if (_e338.member < _e338.member_1) { + phi_461_ = type_18((_e338.member + 1u), _e338.member_1); + phi_476_ = type_18(1u, _e338.member); + } else { + phi_461_ = _e338; + phi_476_ = type_18(0u, type_18().member_1); + } + let _e351 = phi_461_; + let _e353 = phi_476_; + switch bitcast(_e353.member) { + case 0: { + phi_503_ = false; + break; + } + case 1: { + let _e358 = ((_e131 + 35u) + (_e353.member_1 * 4u)); + let _e361 = global.member[_e358]; + let _e366 = global.member[(_e358 + 1u)]; + let _e371 = global.member[(_e358 + 2u)]; + let _e376 = global.member[(_e358 + 3u)]; + local_7[_e353.member_1] = vec4(bitcast(_e361), bitcast(_e366), bitcast(_e371), bitcast(_e376)); + phi_503_ = true; + break; + } + default: { + phi_503_ = bool(); + break; + } + } + let _e381 = phi_503_; + continue; + continuing { + phi_460_ = _e351; + break if !(_e381); + } + } + let _e383 = 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_509_ = type_18(0u, 8u); + loop { + let _e386 = phi_509_; + if (_e386.member < _e386.member_1) { + phi_510_ = type_18((_e386.member + 1u), _e386.member_1); + phi_525_ = type_18(1u, _e386.member); + } else { + phi_510_ = _e386; + phi_525_ = type_18(0u, type_18().member_1); + } + let _e399 = phi_510_; + let _e401 = phi_525_; + switch bitcast(_e401.member) { + case 0: { + phi_548_ = false; + break; + } + case 1: { + let _e406 = ((_e131 + 59u) + (_e401.member_1 * 3u)); + let _e409 = global.member[_e406]; + let _e414 = global.member[(_e406 + 1u)]; + let _e419 = global.member[(_e406 + 2u)]; + local_6[_e401.member_1] = vec3(bitcast(_e409), bitcast(_e414), bitcast(_e419)); + phi_548_ = true; + break; + } + default: { + phi_548_ = bool(); + break; + } + } + let _e424 = phi_548_; + continue; + continuing { + phi_509_ = _e399; + break if !(_e424); + } + } + let _e426 = local_6; + phi_556_ = type_16(type_14(vec4(bitcast(_e153), bitcast(_e158), bitcast(_e163), bitcast(_e168)), vec4(bitcast(_e174), bitcast(_e179), bitcast(_e184), bitcast(_e189)), vec4(bitcast(_e195), bitcast(_e200), bitcast(_e205), bitcast(_e210)), vec4(bitcast(_e216), bitcast(_e221), bitcast(_e226), bitcast(_e231))), type_14(vec4(bitcast(_e238), bitcast(_e243), bitcast(_e248), bitcast(_e253)), vec4(bitcast(_e259), bitcast(_e264), bitcast(_e269), bitcast(_e274)), vec4(bitcast(_e280), bitcast(_e285), bitcast(_e290), bitcast(_e295)), vec4(bitcast(_e301), bitcast(_e306), bitcast(_e311), bitcast(_e316))), type_15(_e426, _e383), vec3(bitcast(_e323), bitcast(_e328), bitcast(_e333))); + } else { + phi_556_ = 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 _e430 = phi_556_; + if (_e82 >= 10u) { + phi_1240_ = (_e135 <= (_e82 - 10u)); + } else { + phi_1240_ = false; + } + let _e436 = phi_1240_; + if _e436 { + let _e439 = global.member[_e135]; + let _e444 = global.member[(_e135 + 1u)]; + let _e449 = global.member[(_e135 + 2u)]; + let _e455 = global.member[(_e135 + 3u)]; + let _e460 = global.member[(_e135 + 4u)]; + let _e465 = global.member[(_e135 + 5u)]; + let _e470 = global.member[(_e135 + 6u)]; + let _e476 = global.member[(_e135 + 7u)]; + let _e481 = global.member[(_e135 + 8u)]; + let _e486 = global.member[(_e135 + 9u)]; + phi_607_ = type_29(vec3(bitcast(_e439), bitcast(_e444), bitcast(_e449)), vec4(bitcast(_e455), bitcast(_e460), bitcast(_e465), bitcast(_e470)), vec3(bitcast(_e476), bitcast(_e481), bitcast(_e486))); + } else { + phi_607_ = type_29(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e491 = phi_607_; + let _e499 = (_e491.member_1.x + _e491.member_1.x); + let _e500 = (_e491.member_1.y + _e491.member_1.y); + let _e501 = (_e491.member_1.z + _e491.member_1.z); + let _e503 = (_e491.member_1.z * _e501); + let _e504 = (_e491.member_1.w * _e499); + let _e505 = (_e491.member_1.w * _e500); + let _e506 = (_e491.member_1.w * _e501); + let _e526 = (vec4((1f - fma(_e491.member_1.y, _e500, _e503)), fma(_e491.member_1.x, _e500, _e506), fma(_e491.member_1.x, _e501, -(_e505)), 0f) * _e491.member_2.x); + let _e528 = (vec4(fma(_e491.member_1.x, _e500, -(_e506)), (1f - fma(_e491.member_1.x, _e499, _e503)), fma(_e491.member_1.y, _e501, _e504), 0f) * _e491.member_2.y); + let _e530 = (vec4(fma(_e491.member_1.x, _e501, _e505), fma(_e491.member_1.y, _e501, -(_e504)), (1f - fma(_e491.member_1.x, _e499, (_e491.member_1.y * _e500))), 0f) * _e491.member_2.z); + let _e552 = (_e491.member.x + fma(_e530.x, _e114, fma(_e528.x, _e109, (_e526.x * _e104)))); + let _e553 = (_e491.member.y + fma(_e530.y, _e114, fma(_e528.y, _e109, (_e526.y * _e104)))); + let _e554 = (_e491.member.z + fma(_e530.z, _e114, fma(_e528.z, _e109, (_e526.z * _e104)))); + let _e555 = vec3(_e552, _e553, _e554); + let _e558 = (max(_e491.member_2.x, max(_e491.member_2.y, _e491.member_2.z)) * _e119); + let _e560 = sqrt((_e558 * _e558)); + local_1 = _e430.member_2.member; + local = _e430.member_2.member_1; + let _e565 = local[0u][0u]; + let _e568 = local[0u][1u]; + let _e573 = local[0u][2u]; + let _e577 = local[0u][3u]; + let _e579 = -(_e560); + if ((fma(_e573, _e554, fma(_e565, _e552, (_e568 * _e553))) + _e577) < _e579) { + phi_1006_ = type_30(true, 0u); + } else { + phi_739_ = type_18(0u, 6u); + loop { + let _e582 = phi_739_; + if (_e582.member < _e582.member_1) { + phi_740_ = type_18((_e582.member + 1u), _e582.member_1); + phi_755_ = type_18(1u, _e582.member); + } else { + phi_740_ = _e582; + phi_755_ = type_18(0u, type_18().member_1); + } + let _e595 = phi_740_; + let _e597 = phi_755_; + local_10 = _e597.member_1; + switch bitcast(_e597.member) { + case 0: { + phi_803_ = false; + phi_804_ = true; + break; + } + case 1: { + if (_e597.member_1 != 0u) { + if (_e597.member_1 < 6u) { + } else { + phi_1415_ = true; + phi_1154_ = bool(); + break; + } + let _e605 = local[_e597.member_1][0u]; + let _e608 = local[_e597.member_1][1u]; + let _e613 = local[_e597.member_1][2u]; + let _e617 = local[_e597.member_1][3u]; + phi_799_ = select(true, false, ((fma(_e613, _e554, fma(_e605, _e552, (_e608 * _e553))) + _e617) < _e579)); + } else { + phi_799_ = true; + } + let _e622 = phi_799_; + phi_803_ = _e622; + phi_804_ = false; + break; + } + default: { + phi_803_ = bool(); + phi_804_ = bool(); + break; + } + } + let _e624 = phi_803_; + let _e626 = phi_804_; + continue; + continuing { + phi_739_ = _e595; + phi_1415_ = false; + phi_1154_ = _e626; + break if !(_e624); + } + } + let _e629 = phi_1415_; + let _e631 = phi_1154_; + if _e629 { + break; + } + if _e631 { + let _e632 = vec3(_e560); + let _e633 = (_e555 - _e632); + let _e634 = (_e555 + _e632); + phi_1438_ = _e629; + phi_811_ = type_18(0u, 3u); + loop { + let _e636 = phi_1438_; + let _e638 = phi_811_; + if (_e638.member < _e638.member_1) { + phi_812_ = type_18((_e638.member + 1u), _e638.member_1); + phi_827_ = type_18(1u, _e638.member); + } else { + phi_812_ = _e638; + phi_827_ = type_18(0u, type_18().member_1); + } + let _e651 = phi_812_; + let _e653 = phi_827_; + switch bitcast(_e653.member) { + case 0: { + phi_1446_ = _e636; + phi_972_ = false; + phi_973_ = true; + phi_974_ = false; + phi_975_ = false; + break; + } + case 1: { + phi_837_ = type_18(0u, 8u); + phi_840_ = 0i; + loop { + let _e658 = phi_837_; + let _e660 = phi_840_; + local_8 = _e660; + if (_e658.member < _e658.member_1) { + phi_838_ = type_18((_e658.member + 1u), _e658.member_1); + phi_855_ = type_18(1u, _e658.member); + } else { + phi_838_ = _e658; + phi_855_ = type_18(0u, type_18().member_1); + } + let _e673 = phi_838_; + let _e675 = phi_855_; + switch bitcast(_e675.member) { + case 0: { + phi_841_ = i32(); + phi_897_ = false; + break; + } + case 1: { + if (_e675.member_1 < 8u) { + } else { + phi_1433_ = true; + break; + } + let _e682 = local_1[_e675.member_1][0u]; + let _e685 = local_1[_e675.member_1][1u]; + let _e688 = local_1[_e675.member_1][2u]; + local_2 = array(_e682, _e685, _e688); + let _e690 = (_e653.member_1 < 3u); + if _e690 { + } else { + phi_1433_ = true; + break; + } + let _e692 = local_2[_e653.member_1]; + local_3 = array(_e633.x, _e633.y, _e633.z); + if _e690 { + } else { + phi_1433_ = true; + break; + } + let _e698 = local_3[_e653.member_1]; + if (_e692 < _e698) { + phi_896_ = (_e660 + 1i); + } else { + phi_896_ = _e660; + } + let _e702 = phi_896_; + phi_841_ = _e702; + phi_897_ = true; + break; + } + default: { + phi_841_ = i32(); + phi_897_ = bool(); + break; + } + } + let _e704 = phi_841_; + let _e706 = phi_897_; + continue; + continuing { + phi_837_ = _e673; + phi_840_ = _e704; + phi_1433_ = _e636; + break if !(_e706); + } + } + let _e709 = phi_1433_; + phi_1445_ = _e709; + phi_1157_ = bool(); + phi_1156_ = bool(); + phi_1155_ = bool(); + if _e709 { + break; + } + let _e711 = local_8; + let _e712 = (_e711 == 8i); + if _e712 { + phi_1447_ = _e709; + phi_970_ = false; + phi_971_ = false; + } else { + phi_904_ = type_18(0u, 8u); + phi_907_ = 0i; + loop { + let _e714 = phi_904_; + let _e716 = phi_907_; + local_9 = _e716; + if (_e714.member < _e714.member_1) { + phi_905_ = type_18((_e714.member + 1u), _e714.member_1); + phi_922_ = type_18(1u, _e714.member); + } else { + phi_905_ = _e714; + phi_922_ = type_18(0u, type_18().member_1); + } + let _e729 = phi_905_; + let _e731 = phi_922_; + switch bitcast(_e731.member) { + case 0: { + phi_908_ = i32(); + phi_964_ = false; + break; + } + case 1: { + if (_e731.member_1 < 8u) { + } else { + phi_1440_ = true; + break; + } + let _e738 = local_1[_e731.member_1][0u]; + let _e741 = local_1[_e731.member_1][1u]; + let _e744 = local_1[_e731.member_1][2u]; + local_4 = array(_e738, _e741, _e744); + let _e746 = (_e653.member_1 < 3u); + if _e746 { + } else { + phi_1440_ = true; + break; + } + let _e748 = local_4[_e653.member_1]; + local_5 = array(_e634.x, _e634.y, _e634.z); + if _e746 { + } else { + phi_1440_ = true; + break; + } + let _e754 = local_5[_e653.member_1]; + if (_e748 > _e754) { + phi_963_ = (_e716 + 1i); + } else { + phi_963_ = _e716; + } + let _e758 = phi_963_; + phi_908_ = _e758; + phi_964_ = true; + break; + } + default: { + phi_908_ = i32(); + phi_964_ = bool(); + break; + } + } + let _e760 = phi_908_; + let _e762 = phi_964_; + continue; + continuing { + phi_904_ = _e729; + phi_907_ = _e760; + phi_1440_ = _e709; + break if !(_e762); + } + } + let _e765 = phi_1440_; + phi_1445_ = _e765; + phi_1157_ = bool(); + phi_1156_ = bool(); + phi_1155_ = bool(); + if _e765 { + break; + } + let _e767 = local_9; + let _e768 = (_e767 == 8i); + phi_1447_ = _e765; + phi_970_ = select(true, false, _e768); + phi_971_ = _e768; + } + let _e771 = phi_1447_; + let _e773 = phi_970_; + let _e775 = phi_971_; + phi_1446_ = _e771; + phi_972_ = _e773; + phi_973_ = false; + phi_974_ = _e712; + phi_975_ = _e775; + break; + } + default: { + phi_1446_ = _e636; + phi_972_ = bool(); + phi_973_ = bool(); + phi_974_ = bool(); + phi_975_ = bool(); + break; + } + } + let _e777 = phi_1446_; + let _e779 = phi_972_; + let _e781 = phi_973_; + let _e783 = phi_974_; + let _e785 = phi_975_; + continue; + continuing { + phi_1438_ = _e777; + phi_811_ = _e651; + phi_1445_ = _e777; + phi_1157_ = _e785; + phi_1156_ = _e783; + phi_1155_ = _e781; + break if !(_e779); + } + } + let _e788 = phi_1445_; + let _e790 = phi_1157_; + let _e792 = phi_1156_; + let _e794 = phi_1155_; + if _e788 { + break; + } + let _e795 = select(_e792, false, _e794); + if select(true, false, select(_e795, true, select(select(_e790, false, _e794), false, _e795))) { + phi_998_ = type_30(false, 0u); + } else { + phi_998_ = type_30(true, 0u); + } + let _e801 = phi_998_; + phi_999_ = _e801; + } else { + phi_999_ = type_30(); + } + let _e803 = phi_999_; + if select(true, false, _e631) { + let _e806 = local_10; + phi_1005_ = type_30(true, _e806); + } else { + phi_1005_ = _e803; + } + let _e809 = phi_1005_; + phi_1006_ = _e809; + } + let _e811 = phi_1006_; + if (_e811.member != true) { + } else { + global_1.member[_e85.x].member_1 = 0u; + } + } + } + break; + } + } + 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/src/linkage/skybox-skybox_cubemap_fragment.spv b/crates/renderling/shaders/skybox-skybox_cubemap_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/skybox-skybox_cubemap_fragment.spv rename to crates/renderling/shaders/skybox-skybox_cubemap_fragment.spv diff --git a/crates/renderling/shaders/skybox-skybox_cubemap_fragment.wgsl b/crates/renderling/shaders/skybox-skybox_cubemap_fragment.wgsl new file mode 100644 index 00000000..777d4032 --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_cubemap_fragment.wgsl @@ -0,0 +1,30 @@ +@group(0) @binding(2) +var global: sampler; +var global_1: vec3; +@group(0) @binding(1) +var global_2: texture_cube; +var global_3: vec4; + +fn function() { + var phi_129_: vec3; + + let _e7 = global_1; + let _e14 = sqrt(fma(_e7.z, _e7.z, fma(_e7.x, _e7.x, (_e7.y * _e7.y)))); + if (_e14 == 0f) { + phi_129_ = vec3(0f, 0f, 0f); + } else { + phi_129_ = (_e7 * (1f / _e14)); + } + let _e19 = phi_129_; + let _e20 = textureSample(global_2, global, _e19); + global_3 = vec4(_e20.x, _e20.y, _e20.z, 1f); + return; +} + +@fragment +fn skyboxskybox_cubemap_fragment(@location(0) param: vec3) -> @location(0) vec4 { + global_1 = param; + function(); + let _e3 = global_3; + return _e3; +} diff --git a/crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv new file mode 100644 index 00000000..ef4a3cdf Binary files /dev/null and b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.spv differ diff --git a/crates/renderling/shaders/skybox-skybox_cubemap_vertex.wgsl b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.wgsl new file mode 100644 index 00000000..277f1a99 --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_cubemap_vertex.wgsl @@ -0,0 +1,213 @@ +struct type_10 { + member: array, +} + +struct type_19 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_20 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_21 { + member: type_19, + member_1: type_19, + member_2: type_20, + member_3: vec3, +} + +struct type_23 { + member: u32, + member_1: u32, +} + +struct VertexOutput { + @location(0) member: vec3, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_10; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); +var global_3: vec3; +var global_4: u32; + +fn function() { + var local: array, 8>; + var local_1: array, 6>; + var local_2: array, 36>; + var phi_689_: bool; + var phi_517_: type_23; + var phi_518_: type_23; + var phi_533_: type_23; + var phi_560_: bool; + var phi_566_: type_23; + var phi_567_: type_23; + var phi_582_: type_23; + var phi_605_: bool; + var phi_613_: type_21; + + switch bitcast(0u) { + default: { + let _e78 = global_4; + let _e79 = global; + let _e81 = arrayLength((&global_1.member)); + if (_e81 >= 83u) { + phi_689_ = (_e78 <= (_e81 - 83u)); + } else { + phi_689_ = false; + } + let _e86 = phi_689_; + if _e86 { + let _e89 = global_1.member[_e78]; + let _e94 = global_1.member[(_e78 + 1u)]; + let _e99 = global_1.member[(_e78 + 2u)]; + let _e104 = global_1.member[(_e78 + 3u)]; + let _e110 = global_1.member[(_e78 + 4u)]; + let _e115 = global_1.member[(_e78 + 5u)]; + let _e120 = global_1.member[(_e78 + 6u)]; + let _e125 = global_1.member[(_e78 + 7u)]; + let _e131 = global_1.member[(_e78 + 8u)]; + let _e136 = global_1.member[(_e78 + 9u)]; + let _e141 = global_1.member[(_e78 + 10u)]; + let _e146 = global_1.member[(_e78 + 11u)]; + let _e152 = global_1.member[(_e78 + 12u)]; + let _e157 = global_1.member[(_e78 + 13u)]; + let _e162 = global_1.member[(_e78 + 14u)]; + let _e167 = global_1.member[(_e78 + 15u)]; + let _e174 = global_1.member[(_e78 + 16u)]; + let _e179 = global_1.member[(_e78 + 17u)]; + let _e184 = global_1.member[(_e78 + 18u)]; + let _e189 = global_1.member[(_e78 + 19u)]; + let _e195 = global_1.member[(_e78 + 20u)]; + let _e200 = global_1.member[(_e78 + 21u)]; + let _e205 = global_1.member[(_e78 + 22u)]; + let _e210 = global_1.member[(_e78 + 23u)]; + let _e216 = global_1.member[(_e78 + 24u)]; + let _e221 = global_1.member[(_e78 + 25u)]; + let _e226 = global_1.member[(_e78 + 26u)]; + let _e231 = global_1.member[(_e78 + 27u)]; + let _e237 = global_1.member[(_e78 + 28u)]; + let _e242 = global_1.member[(_e78 + 29u)]; + let _e247 = global_1.member[(_e78 + 30u)]; + let _e252 = global_1.member[(_e78 + 31u)]; + let _e259 = global_1.member[(_e78 + 32u)]; + let _e264 = global_1.member[(_e78 + 33u)]; + let _e269 = global_1.member[(_e78 + 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 _e274 = phi_517_; + if (_e274.member < _e274.member_1) { + phi_518_ = type_23((_e274.member + 1u), _e274.member_1); + phi_533_ = type_23(1u, _e274.member); + } else { + phi_518_ = _e274; + phi_533_ = type_23(0u, type_23().member_1); + } + let _e287 = phi_518_; + let _e289 = phi_533_; + switch bitcast(_e289.member) { + case 0: { + phi_560_ = false; + break; + } + case 1: { + let _e294 = ((_e78 + 35u) + (_e289.member_1 * 4u)); + let _e297 = global_1.member[_e294]; + let _e302 = global_1.member[(_e294 + 1u)]; + let _e307 = global_1.member[(_e294 + 2u)]; + let _e312 = global_1.member[(_e294 + 3u)]; + local_1[_e289.member_1] = vec4(bitcast(_e297), bitcast(_e302), bitcast(_e307), bitcast(_e312)); + phi_560_ = true; + break; + } + default: { + phi_560_ = bool(); + break; + } + } + let _e317 = phi_560_; + continue; + continuing { + phi_517_ = _e287; + break if !(_e317); + } + } + let _e319 = 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_566_ = type_23(0u, 8u); + loop { + let _e322 = phi_566_; + if (_e322.member < _e322.member_1) { + phi_567_ = type_23((_e322.member + 1u), _e322.member_1); + phi_582_ = type_23(1u, _e322.member); + } else { + phi_567_ = _e322; + phi_582_ = type_23(0u, type_23().member_1); + } + let _e335 = phi_567_; + let _e337 = phi_582_; + switch bitcast(_e337.member) { + case 0: { + phi_605_ = false; + break; + } + case 1: { + let _e342 = ((_e78 + 59u) + (_e337.member_1 * 3u)); + let _e345 = global_1.member[_e342]; + let _e350 = global_1.member[(_e342 + 1u)]; + let _e355 = global_1.member[(_e342 + 2u)]; + local[_e337.member_1] = vec3(bitcast(_e345), bitcast(_e350), bitcast(_e355)); + phi_605_ = true; + break; + } + default: { + phi_605_ = bool(); + break; + } + } + let _e360 = phi_605_; + continue; + continuing { + phi_566_ = _e335; + break if !(_e360); + } + } + let _e362 = local; + phi_613_ = type_21(type_19(vec4(bitcast(_e89), bitcast(_e94), bitcast(_e99), bitcast(_e104)), vec4(bitcast(_e110), bitcast(_e115), bitcast(_e120), bitcast(_e125)), vec4(bitcast(_e131), bitcast(_e136), bitcast(_e141), bitcast(_e146)), vec4(bitcast(_e152), bitcast(_e157), bitcast(_e162), bitcast(_e167))), type_19(vec4(bitcast(_e174), bitcast(_e179), bitcast(_e184), bitcast(_e189)), vec4(bitcast(_e195), bitcast(_e200), bitcast(_e205), bitcast(_e210)), vec4(bitcast(_e216), bitcast(_e221), bitcast(_e226), bitcast(_e231)), vec4(bitcast(_e237), bitcast(_e242), bitcast(_e247), bitcast(_e252))), type_20(_e362, _e319), vec3(bitcast(_e259), bitcast(_e264), bitcast(_e269))); + } else { + phi_613_ = 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 _e366 = phi_613_; + 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 (_e79 < 36u) { + } else { + break; + } + let _e371 = local_2[_e79]; + global_3 = _e371; + global_2 = vec4((fma(fma(_e366.member.member_3.x, _e366.member_1.member_2.w, fma(_e366.member.member_2.x, _e366.member_1.member_2.z, fma(_e366.member.member.x, _e366.member_1.member_2.x, (_e366.member.member_1.x * _e366.member_1.member_2.y)))), _e371.z, fma(fma(_e366.member.member_3.x, _e366.member_1.member.w, fma(_e366.member.member_2.x, _e366.member_1.member.z, fma(_e366.member.member.x, _e366.member_1.member.x, (_e366.member.member_1.x * _e366.member_1.member.y)))), _e371.x, (fma(_e366.member.member_3.x, _e366.member_1.member_1.w, fma(_e366.member.member_2.x, _e366.member_1.member_1.z, fma(_e366.member.member.x, _e366.member_1.member_1.x, (_e366.member.member_1.x * _e366.member_1.member_1.y)))) * _e371.y))) + fma(_e366.member.member_3.x, _e366.member_1.member_3.w, fma(_e366.member.member_2.x, _e366.member_1.member_3.z, fma(_e366.member.member.x, _e366.member_1.member_3.x, (_e366.member.member_1.x * _e366.member_1.member_3.y))))), (fma(fma(_e366.member.member_3.y, _e366.member_1.member_2.w, fma(_e366.member.member_2.y, _e366.member_1.member_2.z, fma(_e366.member.member.y, _e366.member_1.member_2.x, (_e366.member.member_1.y * _e366.member_1.member_2.y)))), _e371.z, fma(fma(_e366.member.member_3.y, _e366.member_1.member.w, fma(_e366.member.member_2.y, _e366.member_1.member.z, fma(_e366.member.member.y, _e366.member_1.member.x, (_e366.member.member_1.y * _e366.member_1.member.y)))), _e371.x, (fma(_e366.member.member_3.y, _e366.member_1.member_1.w, fma(_e366.member.member_2.y, _e366.member_1.member_1.z, fma(_e366.member.member.y, _e366.member_1.member_1.x, (_e366.member.member_1.y * _e366.member_1.member_1.y)))) * _e371.y))) + fma(_e366.member.member_3.y, _e366.member_1.member_3.w, fma(_e366.member.member_2.y, _e366.member_1.member_3.z, fma(_e366.member.member.y, _e366.member_1.member_3.x, (_e366.member.member_1.y * _e366.member_1.member_3.y))))), (fma(fma(_e366.member.member_3.z, _e366.member_1.member_2.w, fma(_e366.member.member_2.z, _e366.member_1.member_2.z, fma(_e366.member.member.z, _e366.member_1.member_2.x, (_e366.member.member_1.z * _e366.member_1.member_2.y)))), _e371.z, fma(fma(_e366.member.member_3.z, _e366.member_1.member.w, fma(_e366.member.member_2.z, _e366.member_1.member.z, fma(_e366.member.member.z, _e366.member_1.member.x, (_e366.member.member_1.z * _e366.member_1.member.y)))), _e371.x, (fma(_e366.member.member_3.z, _e366.member_1.member_1.w, fma(_e366.member.member_2.z, _e366.member_1.member_1.z, fma(_e366.member.member.z, _e366.member_1.member_1.x, (_e366.member.member_1.z * _e366.member_1.member_1.y)))) * _e371.y))) + fma(_e366.member.member_3.z, _e366.member_1.member_3.w, fma(_e366.member.member_2.z, _e366.member_1.member_3.z, fma(_e366.member.member.z, _e366.member_1.member_3.x, (_e366.member.member_1.z * _e366.member_1.member_3.y))))), (fma(fma(_e366.member.member_3.w, _e366.member_1.member_2.w, fma(_e366.member.member_2.w, _e366.member_1.member_2.z, fma(_e366.member.member.w, _e366.member_1.member_2.x, (_e366.member.member_1.w * _e366.member_1.member_2.y)))), _e371.z, fma(fma(_e366.member.member_3.w, _e366.member_1.member.w, fma(_e366.member.member_2.w, _e366.member_1.member.z, fma(_e366.member.member.w, _e366.member_1.member.x, (_e366.member.member_1.w * _e366.member_1.member.y)))), _e371.x, (fma(_e366.member.member_3.w, _e366.member_1.member_1.w, fma(_e366.member.member_2.w, _e366.member_1.member_1.z, fma(_e366.member.member.w, _e366.member_1.member_1.x, (_e366.member.member_1.w * _e366.member_1.member_1.y)))) * _e371.y))) + fma(_e366.member.member_3.w, _e366.member_1.member_3.w, fma(_e366.member.member_2.w, _e366.member_1.member_3.z, fma(_e366.member.member.w, _e366.member_1.member_3.x, (_e366.member.member_1.w * _e366.member_1.member_3.y)))))); + break; + } + } + 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/src/linkage/skybox-skybox_equirectangular_fragment.spv b/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/skybox-skybox_equirectangular_fragment.spv rename to crates/renderling/shaders/skybox-skybox_equirectangular_fragment.spv diff --git a/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.wgsl b/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.wgsl new file mode 100644 index 00000000..8ab36b8c --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_equirectangular_fragment.wgsl @@ -0,0 +1,30 @@ +@group(0) @binding(2) +var global: sampler; +@group(0) @binding(1) +var global_1: texture_2d; +var global_2: vec3; +var global_3: vec4; + +fn function() { + var phi_153_: vec3; + + let _e10 = global_2; + let _e17 = sqrt(fma(_e10.z, _e10.z, fma(_e10.x, _e10.x, (_e10.y * _e10.y)))); + if (_e17 == 0f) { + phi_153_ = vec3(0f, 0f, 0f); + } else { + phi_153_ = (_e10 * (1f / _e17)); + } + let _e22 = phi_153_; + let _e31 = textureSample(global_1, global, vec2(fma(atan2(_e22.z, _e22.x), 0.1591f, 0.5f), fma(asin(_e22.y), 0.31830987f, 0.5f))); + global_3 = vec4(_e31.x, _e31.y, _e31.z, 1f); + return; +} + +@fragment +fn skyboxskybox_equirectangular_fragment(@location(0) param: vec3) -> @location(0) vec4 { + global_2 = param; + function(); + let _e3 = global_3; + return _e3; +} diff --git a/crates/renderling/shaders/skybox-skybox_vertex.spv b/crates/renderling/shaders/skybox-skybox_vertex.spv new file mode 100644 index 00000000..cc307f64 Binary files /dev/null and b/crates/renderling/shaders/skybox-skybox_vertex.spv differ diff --git a/crates/renderling/shaders/skybox-skybox_vertex.wgsl b/crates/renderling/shaders/skybox-skybox_vertex.wgsl new file mode 100644 index 00000000..67a569b0 --- /dev/null +++ b/crates/renderling/shaders/skybox-skybox_vertex.wgsl @@ -0,0 +1,214 @@ +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_725_: bool; + var phi_305_: type_23; + var phi_306_: type_23; + var phi_321_: type_23; + var phi_348_: bool; + var phi_354_: type_23; + var phi_355_: type_23; + var phi_370_: type_23; + var phi_393_: bool; + var phi_401_: type_21; + + switch bitcast(0u) { + default: { + let _e78 = global_2; + let _e79 = global; + let _e81 = arrayLength((&global_1.member)); + if (_e81 >= 83u) { + phi_725_ = (_e78 <= (_e81 - 83u)); + } else { + phi_725_ = false; + } + let _e86 = phi_725_; + if _e86 { + let _e89 = global_1.member[_e78]; + let _e94 = global_1.member[(_e78 + 1u)]; + let _e99 = global_1.member[(_e78 + 2u)]; + let _e104 = global_1.member[(_e78 + 3u)]; + let _e110 = global_1.member[(_e78 + 4u)]; + let _e115 = global_1.member[(_e78 + 5u)]; + let _e120 = global_1.member[(_e78 + 6u)]; + let _e125 = global_1.member[(_e78 + 7u)]; + let _e131 = global_1.member[(_e78 + 8u)]; + let _e136 = global_1.member[(_e78 + 9u)]; + let _e141 = global_1.member[(_e78 + 10u)]; + let _e146 = global_1.member[(_e78 + 11u)]; + let _e152 = global_1.member[(_e78 + 12u)]; + let _e157 = global_1.member[(_e78 + 13u)]; + let _e162 = global_1.member[(_e78 + 14u)]; + let _e167 = global_1.member[(_e78 + 15u)]; + let _e174 = global_1.member[(_e78 + 16u)]; + let _e179 = global_1.member[(_e78 + 17u)]; + let _e184 = global_1.member[(_e78 + 18u)]; + let _e189 = global_1.member[(_e78 + 19u)]; + let _e195 = global_1.member[(_e78 + 20u)]; + let _e200 = global_1.member[(_e78 + 21u)]; + let _e205 = global_1.member[(_e78 + 22u)]; + let _e210 = global_1.member[(_e78 + 23u)]; + let _e216 = global_1.member[(_e78 + 24u)]; + let _e221 = global_1.member[(_e78 + 25u)]; + let _e226 = global_1.member[(_e78 + 26u)]; + let _e231 = global_1.member[(_e78 + 27u)]; + let _e237 = global_1.member[(_e78 + 28u)]; + let _e242 = global_1.member[(_e78 + 29u)]; + let _e247 = global_1.member[(_e78 + 30u)]; + let _e252 = global_1.member[(_e78 + 31u)]; + let _e259 = global_1.member[(_e78 + 32u)]; + let _e264 = global_1.member[(_e78 + 33u)]; + let _e269 = global_1.member[(_e78 + 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 _e274 = phi_305_; + if (_e274.member < _e274.member_1) { + phi_306_ = type_23((_e274.member + 1u), _e274.member_1); + phi_321_ = type_23(1u, _e274.member); + } else { + phi_306_ = _e274; + phi_321_ = type_23(0u, type_23().member_1); + } + let _e287 = phi_306_; + let _e289 = phi_321_; + switch bitcast(_e289.member) { + case 0: { + phi_348_ = false; + break; + } + case 1: { + let _e294 = ((_e78 + 35u) + (_e289.member_1 * 4u)); + let _e297 = global_1.member[_e294]; + let _e302 = global_1.member[(_e294 + 1u)]; + let _e307 = global_1.member[(_e294 + 2u)]; + let _e312 = global_1.member[(_e294 + 3u)]; + local_1[_e289.member_1] = vec4(bitcast(_e297), bitcast(_e302), bitcast(_e307), bitcast(_e312)); + phi_348_ = true; + break; + } + default: { + phi_348_ = bool(); + break; + } + } + let _e317 = phi_348_; + continue; + continuing { + phi_305_ = _e287; + break if !(_e317); + } + } + let _e319 = 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_354_ = type_23(0u, 8u); + loop { + let _e322 = phi_354_; + if (_e322.member < _e322.member_1) { + phi_355_ = type_23((_e322.member + 1u), _e322.member_1); + phi_370_ = type_23(1u, _e322.member); + } else { + phi_355_ = _e322; + phi_370_ = type_23(0u, type_23().member_1); + } + let _e335 = phi_355_; + let _e337 = phi_370_; + switch bitcast(_e337.member) { + case 0: { + phi_393_ = false; + break; + } + case 1: { + let _e342 = ((_e78 + 59u) + (_e337.member_1 * 3u)); + let _e345 = global_1.member[_e342]; + let _e350 = global_1.member[(_e342 + 1u)]; + let _e355 = global_1.member[(_e342 + 2u)]; + local[_e337.member_1] = vec3(bitcast(_e345), bitcast(_e350), bitcast(_e355)); + phi_393_ = true; + break; + } + default: { + phi_393_ = bool(); + break; + } + } + let _e360 = phi_393_; + continue; + continuing { + phi_354_ = _e335; + break if !(_e360); + } + } + let _e362 = local; + phi_401_ = type_21(type_19(vec4(bitcast(_e89), bitcast(_e94), bitcast(_e99), bitcast(_e104)), vec4(bitcast(_e110), bitcast(_e115), bitcast(_e120), bitcast(_e125)), vec4(bitcast(_e131), bitcast(_e136), bitcast(_e141), bitcast(_e146)), vec4(bitcast(_e152), bitcast(_e157), bitcast(_e162), bitcast(_e167))), type_19(vec4(bitcast(_e174), bitcast(_e179), bitcast(_e184), bitcast(_e189)), vec4(bitcast(_e195), bitcast(_e200), bitcast(_e205), bitcast(_e210)), vec4(bitcast(_e216), bitcast(_e221), bitcast(_e226), bitcast(_e231)), vec4(bitcast(_e237), bitcast(_e242), bitcast(_e247), bitcast(_e252))), type_20(_e362, _e319), vec3(bitcast(_e259), bitcast(_e264), bitcast(_e269))); + } else { + phi_401_ = 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 _e366 = phi_401_; + 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 (_e79 < 36u) { + } else { + break; + } + let _e374 = local_2[_e79]; + global_3 = _e374; + let _e441 = (fma(fma(_e366.member.member_2.w, _e366.member_1.member_2.z, fma(_e366.member.member.w, _e366.member_1.member_2.x, (_e366.member.member_1.w * _e366.member_1.member_2.y))), _e374.z, fma(fma(_e366.member.member_2.w, _e366.member_1.member.z, fma(_e366.member.member.w, _e366.member_1.member.x, (_e366.member.member_1.w * _e366.member_1.member.y))), _e374.x, (fma(_e366.member.member_2.w, _e366.member_1.member_1.z, fma(_e366.member.member.w, _e366.member_1.member_1.x, (_e366.member.member_1.w * _e366.member_1.member_1.y))) * _e374.y))) + _e366.member.member_3.w); + global_4 = vec4((fma(fma(_e366.member.member_2.x, _e366.member_1.member_2.z, fma(_e366.member.member.x, _e366.member_1.member_2.x, (_e366.member.member_1.x * _e366.member_1.member_2.y))), _e374.z, fma(fma(_e366.member.member_2.x, _e366.member_1.member.z, fma(_e366.member.member.x, _e366.member_1.member.x, (_e366.member.member_1.x * _e366.member_1.member.y))), _e374.x, (fma(_e366.member.member_2.x, _e366.member_1.member_1.z, fma(_e366.member.member.x, _e366.member_1.member_1.x, (_e366.member.member_1.x * _e366.member_1.member_1.y))) * _e374.y))) + _e366.member.member_3.x), (fma(fma(_e366.member.member_2.y, _e366.member_1.member_2.z, fma(_e366.member.member.y, _e366.member_1.member_2.x, (_e366.member.member_1.y * _e366.member_1.member_2.y))), _e374.z, fma(fma(_e366.member.member_2.y, _e366.member_1.member.z, fma(_e366.member.member.y, _e366.member_1.member.x, (_e366.member.member_1.y * _e366.member_1.member.y))), _e374.x, (fma(_e366.member.member_2.y, _e366.member_1.member_1.z, fma(_e366.member.member.y, _e366.member_1.member_1.x, (_e366.member.member_1.y * _e366.member_1.member_1.y))) * _e374.y))) + _e366.member.member_3.y), _e441, _e441); + break; + } + } + return; +} + +@vertex +fn skyboxskybox_vertex(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_2 = param; + global = param_1; + function(); + let _e7 = global_4.y; + global_4.y = -(_e7); + let _e9 = global_3; + let _e10 = global_4; + return VertexOutput(_e9, _e10); +} diff --git a/crates/renderling/shaders/stage-renderlet_fragment.spv b/crates/renderling/shaders/stage-renderlet_fragment.spv new file mode 100644 index 00000000..1cd8a79d Binary files /dev/null and b/crates/renderling/shaders/stage-renderlet_fragment.spv differ diff --git a/crates/renderling/shaders/stage-renderlet_fragment.wgsl b/crates/renderling/shaders/stage-renderlet_fragment.wgsl new file mode 100644 index 00000000..422eb816 --- /dev/null +++ b/crates/renderling/shaders/stage-renderlet_fragment.wgsl @@ -0,0 +1,2228 @@ +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_3692_: bool; + var phi_500_: u32; + var phi_526_: type_30; + var phi_3743_: bool; + var phi_645_: type_32; + var phi_649_: type_32; + var phi_3776_: bool; + var phi_689_: u32; + var phi_698_: u32; + var phi_711_: type_33; + var phi_3832_: f32; + var phi_3814_: bool; + var phi_765_: f32; + var phi_760_: f32; + var phi_766_: f32; + var phi_3797_: bool; + var phi_731_: f32; + var phi_768_: f32; + var phi_3880_: f32; + var phi_3862_: bool; + var phi_823_: f32; + var phi_818_: f32; + var phi_824_: f32; + var phi_3845_: bool; + var phi_789_: f32; + var phi_826_: f32; + var phi_3912_: bool; + var phi_909_: u32; + var phi_918_: u32; + var phi_931_: type_33; + var phi_3967_: f32; + var phi_3949_: bool; + var phi_985_: f32; + var phi_980_: f32; + var phi_986_: f32; + var phi_3932_: bool; + var phi_951_: f32; + var phi_988_: f32; + var phi_4015_: f32; + var phi_3997_: bool; + var phi_1043_: f32; + var phi_1038_: f32; + var phi_1044_: f32; + var phi_3980_: bool; + var phi_1009_: f32; + var phi_1046_: f32; + var phi_4047_: bool; + var phi_1129_: u32; + var phi_1138_: u32; + var phi_1151_: type_33; + var phi_4102_: f32; + var phi_4084_: bool; + var phi_1205_: f32; + var phi_1200_: f32; + var phi_1206_: f32; + var phi_4067_: bool; + var phi_1171_: f32; + var phi_1208_: f32; + var phi_4150_: f32; + var phi_4132_: bool; + var phi_1263_: f32; + var phi_1258_: f32; + var phi_1264_: f32; + var phi_4115_: bool; + var phi_1229_: f32; + var phi_1266_: f32; + var phi_4182_: bool; + var phi_1349_: u32; + var phi_1358_: u32; + var phi_1371_: type_33; + var phi_4237_: f32; + var phi_4219_: bool; + var phi_1425_: f32; + var phi_1420_: f32; + var phi_1426_: f32; + var phi_4202_: bool; + var phi_1391_: f32; + var phi_1428_: f32; + var phi_4285_: f32; + var phi_4267_: bool; + var phi_1483_: f32; + var phi_1478_: f32; + var phi_1484_: f32; + var phi_4250_: bool; + var phi_1449_: f32; + var phi_1486_: f32; + var phi_4317_: bool; + var phi_1569_: u32; + var phi_1578_: u32; + var phi_1591_: type_33; + var phi_4372_: f32; + var phi_4354_: bool; + var phi_1645_: f32; + var phi_1640_: f32; + var phi_1646_: f32; + var phi_4337_: bool; + var phi_1611_: f32; + var phi_1648_: f32; + var phi_4420_: f32; + var phi_4402_: bool; + var phi_1703_: f32; + var phi_1698_: f32; + var phi_1704_: f32; + var phi_4385_: bool; + var phi_1669_: f32; + var phi_1706_: f32; + var phi_4474_: vec3; + var phi_4509_: vec3; + var phi_4544_: vec3; + var phi_4579_: vec3; + var phi_4614_: vec3; + var phi_1800_: vec3; + var phi_1801_: vec3; + var phi_4646_: bool; + var phi_2007_: type_24; + var phi_2008_: type_24; + var phi_2023_: type_24; + var phi_2050_: bool; + var phi_2056_: type_24; + var phi_2057_: type_24; + var phi_2072_: type_24; + var phi_2095_: bool; + var phi_2103_: type_22; + var phi_4718_: vec3; + var phi_4777_: vec3; + var phi_4851_: vec3; + var phi_5996_: vec3; + var phi_5947_: vec3; + var phi_5898_: vec3; + var phi_5849_: vec3; + var phi_5800_: vec3; + var phi_5751_: vec3; + var phi_5702_: vec3; + var phi_4901_: vec3; + var phi_4936_: vec3; + var phi_2143_: type_24; + var phi_2146_: vec3; + var phi_2144_: type_24; + var phi_2161_: type_24; + var phi_4953_: u32; + var phi_4972_: bool; + var phi_2178_: u32; + var phi_5004_: bool; + var phi_2195_: u32; + var phi_2205_: type_34; + var phi_5034_: bool; + var phi_2255_: type_28; + var phi_5463_: bool; + var phi_2753_: type_36; + var phi_5513_: vec3; + var phi_5548_: vec3; + var phi_5583_: vec3; + var phi_2999_: vec3; + var phi_5290_: bool; + var phi_2505_: type_35; + var phi_5336_: vec3; + var phi_5371_: vec3; + var phi_2690_: vec3; + var phi_5115_: bool; + var phi_2303_: type_35; + var phi_5163_: vec3; + var phi_5198_: vec3; + var phi_3001_: vec3; + var phi_3002_: bool; + var phi_3011_: vec3; + var phi_2147_: vec3; + var phi_3013_: bool; + var local_2: vec3; + var local_3: vec3; + var local_4: vec3; + var phi_3125_: vec4; + + let _e117 = arrayLength((&global.member)); + let _e118 = global_1; + let _e119 = global_2; + let _e120 = global_3; + let _e121 = global_4; + let _e122 = global_5; + let _e123 = global_6; + let _e124 = global_7; + let _e125 = global_8; + let _e126 = global_9; + let _e127 = global_10; + if (_e117 >= 9u) { + phi_3692_ = (_e120 <= (_e117 - 9u)); + } else { + phi_3692_ = false; + } + let _e132 = phi_3692_; + if _e132 { + let _e135 = global.member[_e120]; + let _e139 = global.member[(_e120 + 1u)]; + let _e144 = global.member[(_e120 + 2u)]; + let _e148 = global.member[(_e120 + 3u)]; + let _e153 = global.member[(_e120 + 4u)]; + switch bitcast(_e153) { + case 0: { + phi_500_ = 0u; + break; + } + case 1: { + phi_500_ = 1u; + break; + } + case 2: { + phi_500_ = 2u; + break; + } + case 3: { + phi_500_ = 3u; + break; + } + case 4: { + phi_500_ = 4u; + break; + } + case 5: { + phi_500_ = 5u; + break; + } + case 6: { + phi_500_ = 6u; + break; + } + case 7: { + phi_500_ = 7u; + break; + } + case 8: { + phi_500_ = 8u; + break; + } + case 9: { + phi_500_ = 9u; + break; + } + case 10: { + phi_500_ = 10u; + break; + } + case 11: { + phi_500_ = 11u; + break; + } + case 12: { + phi_500_ = 12u; + break; + } + case 13: { + phi_500_ = 13u; + break; + } + case 14: { + phi_500_ = 14u; + break; + } + case 15: { + phi_500_ = 15u; + break; + } + case 16: { + phi_500_ = 16u; + break; + } + case 17: { + phi_500_ = 17u; + break; + } + case 18: { + phi_500_ = 18u; + break; + } + case 19: { + phi_500_ = 19u; + break; + } + default: { + phi_500_ = 0u; + break; + } + } + let _e156 = phi_500_; + let _e160 = global.member[(_e120 + 5u)]; + let _e165 = global.member[(_e120 + 6u)]; + let _e170 = global.member[(_e120 + 7u)]; + let _e174 = global.member[(_e120 + 8u)]; + phi_526_ = type_30(vec2(_e135, _e139), vec2(_e144, _e148), type_24(_e170, _e174), _e156, (_e160 == 1u), (_e165 == 1u)); + } else { + phi_526_ = type_30(vec2(0u, 0u), vec2(1u, 1u), type_24(4294967295u, 0u), 0u, true, true); + } + let _e178 = phi_526_; + if (_e119 == 4294967295u) { + phi_649_ = 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 (_e117 >= 22u) { + phi_3743_ = (_e119 <= (_e117 - 22u)); + } else { + phi_3743_ = false; + } + let _e191 = phi_3743_; + if _e191 { + let _e194 = global.member[_e119]; + let _e199 = global.member[(_e119 + 1u)]; + let _e204 = global.member[(_e119 + 2u)]; + let _e210 = global.member[(_e119 + 3u)]; + let _e215 = global.member[(_e119 + 4u)]; + let _e220 = global.member[(_e119 + 5u)]; + let _e225 = global.member[(_e119 + 6u)]; + let _e230 = global.member[(_e119 + 7u)]; + let _e236 = global.member[(_e119 + 8u)]; + let _e241 = global.member[(_e119 + 9u)]; + let _e246 = global.member[(_e119 + 10u)]; + let _e250 = global.member[(_e119 + 11u)]; + let _e254 = global.member[(_e119 + 12u)]; + let _e258 = global.member[(_e119 + 13u)]; + let _e262 = global.member[(_e119 + 14u)]; + let _e266 = global.member[(_e119 + 15u)]; + let _e270 = global.member[(_e119 + 16u)]; + let _e274 = global.member[(_e119 + 17u)]; + let _e278 = global.member[(_e119 + 18u)]; + let _e282 = global.member[(_e119 + 19u)]; + let _e286 = global.member[(_e119 + 20u)]; + let _e291 = global.member[(_e119 + 21u)]; + phi_645_ = type_32(vec3(bitcast(_e194), bitcast(_e199), bitcast(_e204)), bitcast(_e210), vec4(bitcast(_e215), bitcast(_e220), bitcast(_e225), bitcast(_e230)), bitcast(_e236), bitcast(_e241), _e246, _e250, _e254, _e258, _e262, _e266, _e270, _e274, _e278, _e282, (_e286 == 1u), bitcast(_e291)); + } else { + phi_645_ = 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 _e295 = phi_645_; + phi_649_ = type_32(_e295.member, _e295.member_1, _e295.member_2, _e295.member_3, _e295.member_4, _e295.member_5, _e295.member_6, _e295.member_7, _e295.member_8, _e295.member_9, _e295.member_10, _e295.member_11, _e295.member_12, _e295.member_13, _e295.member_14, (_e295.member_15 && _e178.member_4), _e295.member_16); + } + let _e317 = phi_649_; + let _e321 = select(_e123, _e122, vec2((_e317.member_10 == 0u))); + let _e323 = (_e117 >= 8u); + if _e323 { + phi_3776_ = (_e317.member_5 <= (_e117 - 8u)); + } else { + phi_3776_ = false; + } + let _e327 = phi_3776_; + if _e327 { + let _e330 = global.member[_e317.member_5]; + let _e334 = global.member[(_e317.member_5 + 1u)]; + let _e339 = global.member[(_e317.member_5 + 2u)]; + let _e343 = global.member[(_e317.member_5 + 3u)]; + let _e348 = global.member[(_e317.member_5 + 4u)]; + let _e352 = global.member[(_e317.member_5 + 5u)]; + let _e356 = global.member[(_e317.member_5 + 6u)]; + switch bitcast(_e356) { + case 0: { + phi_689_ = 0u; + break; + } + case 1: { + phi_689_ = 1u; + break; + } + case 2: { + phi_689_ = 2u; + break; + } + default: { + phi_689_ = 0u; + break; + } + } + let _e359 = phi_689_; + let _e363 = global.member[(_e317.member_5 + 7u)]; + switch bitcast(_e363) { + case 0: { + phi_698_ = 0u; + break; + } + case 1: { + phi_698_ = 1u; + break; + } + case 2: { + phi_698_ = 2u; + break; + } + default: { + phi_698_ = 0u; + break; + } + } + let _e366 = phi_698_; + phi_711_ = type_33(type_24(_e359, _e366), vec2(_e330, _e334), vec2(_e339, _e343), _e348, _e352); + } else { + phi_711_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e370 = phi_711_; + switch bitcast(_e370.member.member) { + case 1: { + let _e408 = abs(_e321.x); + let _e410 = (_e408 % 1f); + if (_e408 >= 1f) { + phi_3797_ = select(true, false, (_e410 == 0f)); + } else { + phi_3797_ = true; + } + let _e414 = phi_3797_; + let _e415 = select(1f, _e410, _e414); + if (select(-1f, 1f, (_e321.x >= 0f)) > 0f) { + phi_731_ = _e415; + } else { + phi_731_ = (1f - _e415); + } + let _e419 = phi_731_; + phi_768_ = _e419; + break; + } + case 2: { + let _e382 = abs(_e321.x); + let _e389 = ((select(select(u32(_e382), 0u, (_e382 < 0f)), 4294967295u, (_e382 > 4294967000f)) % 2u) == 0u); + let _e391 = (_e382 % 1f); + if (_e382 >= 1f) { + phi_3814_ = select(true, false, (_e391 == 0f)); + } else { + phi_3814_ = true; + } + let _e395 = phi_3814_; + let _e396 = select(1f, _e391, _e395); + if (select(-1f, 1f, (_e321.x >= 0f)) > 0f) { + if _e389 { + phi_760_ = _e396; + } else { + phi_760_ = (1f - _e396); + } + let _e403 = phi_760_; + phi_766_ = _e403; + } else { + if _e389 { + phi_765_ = (1f - _e396); + } else { + phi_765_ = _e396; + } + let _e400 = phi_765_; + phi_766_ = _e400; + } + let _e405 = phi_766_; + phi_768_ = _e405; + break; + } + case 0: { + if (_e321.x > 1f) { + phi_3832_ = 0.9999999f; + } else { + phi_3832_ = select(_e321.x, 0.00000011920929f, (_e321.x < 0f)); + } + let _e379 = phi_3832_; + phi_768_ = _e379; + break; + } + default: { + phi_768_ = f32(); + break; + } + } + let _e421 = phi_768_; + switch bitcast(_e370.member.member_1) { + case 1: { + let _e459 = abs(_e321.y); + let _e461 = (_e459 % 1f); + if (_e459 >= 1f) { + phi_3845_ = select(true, false, (_e461 == 0f)); + } else { + phi_3845_ = true; + } + let _e465 = phi_3845_; + let _e466 = select(1f, _e461, _e465); + if (select(-1f, 1f, (_e321.y >= 0f)) > 0f) { + phi_789_ = _e466; + } else { + phi_789_ = (1f - _e466); + } + let _e470 = phi_789_; + phi_826_ = _e470; + break; + } + case 2: { + let _e433 = abs(_e321.y); + let _e440 = ((select(select(u32(_e433), 0u, (_e433 < 0f)), 4294967295u, (_e433 > 4294967000f)) % 2u) == 0u); + let _e442 = (_e433 % 1f); + if (_e433 >= 1f) { + phi_3862_ = select(true, false, (_e442 == 0f)); + } else { + phi_3862_ = true; + } + let _e446 = phi_3862_; + let _e447 = select(1f, _e442, _e446); + if (select(-1f, 1f, (_e321.y >= 0f)) > 0f) { + if _e440 { + phi_818_ = _e447; + } else { + phi_818_ = (1f - _e447); + } + let _e454 = phi_818_; + phi_824_ = _e454; + } else { + if _e440 { + phi_823_ = (1f - _e447); + } else { + phi_823_ = _e447; + } + let _e451 = phi_823_; + phi_824_ = _e451; + } + let _e456 = phi_824_; + phi_826_ = _e456; + break; + } + case 0: { + if (_e321.y > 1f) { + phi_3880_ = 0.9999999f; + } else { + phi_3880_ = select(_e321.y, 0.00000011920929f, (_e321.y < 0f)); + } + let _e430 = phi_3880_; + phi_826_ = _e430; + break; + } + default: { + phi_826_ = f32(); + break; + } + } + let _e472 = phi_826_; + let _e476 = (_e421 * f32(_e370.member_2.x)); + let _e485 = (_e472 * f32(_e370.member_2.y)); + let _e498 = f32(_e178.member.x); + let _e500 = f32(_e178.member.y); + let _e507 = vec3((f32((select(select(u32(_e476), 0u, (_e476 < 0f)), 4294967295u, (_e476 > 4294967000f)) + _e370.member_1.x)) / _e498), (f32((select(select(u32(_e485), 0u, (_e485 < 0f)), 4294967295u, (_e485 > 4294967000f)) + _e370.member_1.y)) / _e500), f32(_e370.member_3)); + let _e513 = textureSampleLevel(global_12, global_11, vec2(_e507.x, _e507.y), i32(_e507.z), 0f); + let _e516 = select(_e513, vec4(1f, 1f, 1f, 1f), vec4((_e317.member_5 == 4294967295u))); + let _e520 = select(_e123, _e122, vec2((_e317.member_11 == 0u))); + if _e323 { + phi_3912_ = (_e317.member_6 <= (_e117 - 8u)); + } else { + phi_3912_ = false; + } + let _e525 = phi_3912_; + if _e525 { + let _e528 = global.member[_e317.member_6]; + let _e532 = global.member[(_e317.member_6 + 1u)]; + let _e537 = global.member[(_e317.member_6 + 2u)]; + let _e541 = global.member[(_e317.member_6 + 3u)]; + let _e546 = global.member[(_e317.member_6 + 4u)]; + let _e550 = global.member[(_e317.member_6 + 5u)]; + let _e554 = global.member[(_e317.member_6 + 6u)]; + switch bitcast(_e554) { + case 0: { + phi_909_ = 0u; + break; + } + case 1: { + phi_909_ = 1u; + break; + } + case 2: { + phi_909_ = 2u; + break; + } + default: { + phi_909_ = 0u; + break; + } + } + let _e557 = phi_909_; + let _e561 = global.member[(_e317.member_6 + 7u)]; + switch bitcast(_e561) { + case 0: { + phi_918_ = 0u; + break; + } + case 1: { + phi_918_ = 1u; + break; + } + case 2: { + phi_918_ = 2u; + break; + } + default: { + phi_918_ = 0u; + break; + } + } + let _e564 = phi_918_; + phi_931_ = type_33(type_24(_e557, _e564), vec2(_e528, _e532), vec2(_e537, _e541), _e546, _e550); + } else { + phi_931_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e568 = phi_931_; + switch bitcast(_e568.member.member) { + case 1: { + let _e606 = abs(_e520.x); + let _e608 = (_e606 % 1f); + if (_e606 >= 1f) { + phi_3932_ = select(true, false, (_e608 == 0f)); + } else { + phi_3932_ = true; + } + let _e612 = phi_3932_; + let _e613 = select(1f, _e608, _e612); + if (select(-1f, 1f, (_e520.x >= 0f)) > 0f) { + phi_951_ = _e613; + } else { + phi_951_ = (1f - _e613); + } + let _e617 = phi_951_; + phi_988_ = _e617; + break; + } + case 2: { + let _e580 = abs(_e520.x); + let _e587 = ((select(select(u32(_e580), 0u, (_e580 < 0f)), 4294967295u, (_e580 > 4294967000f)) % 2u) == 0u); + let _e589 = (_e580 % 1f); + if (_e580 >= 1f) { + phi_3949_ = select(true, false, (_e589 == 0f)); + } else { + phi_3949_ = true; + } + let _e593 = phi_3949_; + let _e594 = select(1f, _e589, _e593); + if (select(-1f, 1f, (_e520.x >= 0f)) > 0f) { + if _e587 { + phi_980_ = _e594; + } else { + phi_980_ = (1f - _e594); + } + let _e601 = phi_980_; + phi_986_ = _e601; + } else { + if _e587 { + phi_985_ = (1f - _e594); + } else { + phi_985_ = _e594; + } + let _e598 = phi_985_; + phi_986_ = _e598; + } + let _e603 = phi_986_; + phi_988_ = _e603; + break; + } + case 0: { + if (_e520.x > 1f) { + phi_3967_ = 0.9999999f; + } else { + phi_3967_ = select(_e520.x, 0.00000011920929f, (_e520.x < 0f)); + } + let _e577 = phi_3967_; + phi_988_ = _e577; + break; + } + default: { + phi_988_ = f32(); + break; + } + } + let _e619 = phi_988_; + switch bitcast(_e568.member.member_1) { + case 1: { + let _e657 = abs(_e520.y); + let _e659 = (_e657 % 1f); + if (_e657 >= 1f) { + phi_3980_ = select(true, false, (_e659 == 0f)); + } else { + phi_3980_ = true; + } + let _e663 = phi_3980_; + let _e664 = select(1f, _e659, _e663); + if (select(-1f, 1f, (_e520.y >= 0f)) > 0f) { + phi_1009_ = _e664; + } else { + phi_1009_ = (1f - _e664); + } + let _e668 = phi_1009_; + phi_1046_ = _e668; + break; + } + case 2: { + let _e631 = abs(_e520.y); + let _e638 = ((select(select(u32(_e631), 0u, (_e631 < 0f)), 4294967295u, (_e631 > 4294967000f)) % 2u) == 0u); + let _e640 = (_e631 % 1f); + if (_e631 >= 1f) { + phi_3997_ = select(true, false, (_e640 == 0f)); + } else { + phi_3997_ = true; + } + let _e644 = phi_3997_; + let _e645 = select(1f, _e640, _e644); + if (select(-1f, 1f, (_e520.y >= 0f)) > 0f) { + if _e638 { + phi_1038_ = _e645; + } else { + phi_1038_ = (1f - _e645); + } + let _e652 = phi_1038_; + phi_1044_ = _e652; + } else { + if _e638 { + phi_1043_ = (1f - _e645); + } else { + phi_1043_ = _e645; + } + let _e649 = phi_1043_; + phi_1044_ = _e649; + } + let _e654 = phi_1044_; + phi_1046_ = _e654; + break; + } + case 0: { + if (_e520.y > 1f) { + phi_4015_ = 0.9999999f; + } else { + phi_4015_ = select(_e520.y, 0.00000011920929f, (_e520.y < 0f)); + } + let _e628 = phi_4015_; + phi_1046_ = _e628; + break; + } + default: { + phi_1046_ = f32(); + break; + } + } + let _e670 = phi_1046_; + let _e674 = (_e619 * f32(_e568.member_2.x)); + let _e683 = (_e670 * f32(_e568.member_2.y)); + let _e701 = vec3((f32((select(select(u32(_e674), 0u, (_e674 < 0f)), 4294967295u, (_e674 > 4294967000f)) + _e568.member_1.x)) / _e498), (f32((select(select(u32(_e683), 0u, (_e683 < 0f)), 4294967295u, (_e683 > 4294967000f)) + _e568.member_1.y)) / _e500), f32(_e568.member_3)); + let _e707 = textureSampleLevel(global_12, global_11, vec2(_e701.x, _e701.y), i32(_e701.z), 0f); + let _e710 = select(_e707, vec4(1f, 1f, 1f, 1f), vec4((_e317.member_6 == 4294967295u))); + let _e714 = select(_e123, _e122, vec2((_e317.member_12 == 0u))); + if _e323 { + phi_4047_ = (_e317.member_7 <= (_e117 - 8u)); + } else { + phi_4047_ = false; + } + let _e719 = phi_4047_; + if _e719 { + let _e722 = global.member[_e317.member_7]; + let _e726 = global.member[(_e317.member_7 + 1u)]; + let _e731 = global.member[(_e317.member_7 + 2u)]; + let _e735 = global.member[(_e317.member_7 + 3u)]; + let _e740 = global.member[(_e317.member_7 + 4u)]; + let _e744 = global.member[(_e317.member_7 + 5u)]; + let _e748 = global.member[(_e317.member_7 + 6u)]; + switch bitcast(_e748) { + case 0: { + phi_1129_ = 0u; + break; + } + case 1: { + phi_1129_ = 1u; + break; + } + case 2: { + phi_1129_ = 2u; + break; + } + default: { + phi_1129_ = 0u; + break; + } + } + let _e751 = phi_1129_; + let _e755 = global.member[(_e317.member_7 + 7u)]; + switch bitcast(_e755) { + case 0: { + phi_1138_ = 0u; + break; + } + case 1: { + phi_1138_ = 1u; + break; + } + case 2: { + phi_1138_ = 2u; + break; + } + default: { + phi_1138_ = 0u; + break; + } + } + let _e758 = phi_1138_; + phi_1151_ = type_33(type_24(_e751, _e758), vec2(_e722, _e726), vec2(_e731, _e735), _e740, _e744); + } else { + phi_1151_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e762 = phi_1151_; + switch bitcast(_e762.member.member) { + case 1: { + let _e800 = abs(_e714.x); + let _e802 = (_e800 % 1f); + if (_e800 >= 1f) { + phi_4067_ = select(true, false, (_e802 == 0f)); + } else { + phi_4067_ = true; + } + let _e806 = phi_4067_; + let _e807 = select(1f, _e802, _e806); + if (select(-1f, 1f, (_e714.x >= 0f)) > 0f) { + phi_1171_ = _e807; + } else { + phi_1171_ = (1f - _e807); + } + let _e811 = phi_1171_; + phi_1208_ = _e811; + break; + } + case 2: { + let _e774 = abs(_e714.x); + let _e781 = ((select(select(u32(_e774), 0u, (_e774 < 0f)), 4294967295u, (_e774 > 4294967000f)) % 2u) == 0u); + let _e783 = (_e774 % 1f); + if (_e774 >= 1f) { + phi_4084_ = select(true, false, (_e783 == 0f)); + } else { + phi_4084_ = true; + } + let _e787 = phi_4084_; + let _e788 = select(1f, _e783, _e787); + if (select(-1f, 1f, (_e714.x >= 0f)) > 0f) { + if _e781 { + phi_1200_ = _e788; + } else { + phi_1200_ = (1f - _e788); + } + let _e795 = phi_1200_; + phi_1206_ = _e795; + } else { + if _e781 { + phi_1205_ = (1f - _e788); + } else { + phi_1205_ = _e788; + } + let _e792 = phi_1205_; + phi_1206_ = _e792; + } + let _e797 = phi_1206_; + phi_1208_ = _e797; + break; + } + case 0: { + if (_e714.x > 1f) { + phi_4102_ = 0.9999999f; + } else { + phi_4102_ = select(_e714.x, 0.00000011920929f, (_e714.x < 0f)); + } + let _e771 = phi_4102_; + phi_1208_ = _e771; + break; + } + default: { + phi_1208_ = f32(); + break; + } + } + let _e813 = phi_1208_; + switch bitcast(_e762.member.member_1) { + case 1: { + let _e851 = abs(_e714.y); + let _e853 = (_e851 % 1f); + if (_e851 >= 1f) { + phi_4115_ = select(true, false, (_e853 == 0f)); + } else { + phi_4115_ = true; + } + let _e857 = phi_4115_; + let _e858 = select(1f, _e853, _e857); + if (select(-1f, 1f, (_e714.y >= 0f)) > 0f) { + phi_1229_ = _e858; + } else { + phi_1229_ = (1f - _e858); + } + let _e862 = phi_1229_; + phi_1266_ = _e862; + break; + } + case 2: { + let _e825 = abs(_e714.y); + let _e832 = ((select(select(u32(_e825), 0u, (_e825 < 0f)), 4294967295u, (_e825 > 4294967000f)) % 2u) == 0u); + let _e834 = (_e825 % 1f); + if (_e825 >= 1f) { + phi_4132_ = select(true, false, (_e834 == 0f)); + } else { + phi_4132_ = true; + } + let _e838 = phi_4132_; + let _e839 = select(1f, _e834, _e838); + if (select(-1f, 1f, (_e714.y >= 0f)) > 0f) { + if _e832 { + phi_1258_ = _e839; + } else { + phi_1258_ = (1f - _e839); + } + let _e846 = phi_1258_; + phi_1264_ = _e846; + } else { + if _e832 { + phi_1263_ = (1f - _e839); + } else { + phi_1263_ = _e839; + } + let _e843 = phi_1263_; + phi_1264_ = _e843; + } + let _e848 = phi_1264_; + phi_1266_ = _e848; + break; + } + case 0: { + if (_e714.y > 1f) { + phi_4150_ = 0.9999999f; + } else { + phi_4150_ = select(_e714.y, 0.00000011920929f, (_e714.y < 0f)); + } + let _e822 = phi_4150_; + phi_1266_ = _e822; + break; + } + default: { + phi_1266_ = f32(); + break; + } + } + let _e864 = phi_1266_; + let _e868 = (_e813 * f32(_e762.member_2.x)); + let _e877 = (_e864 * f32(_e762.member_2.y)); + let _e895 = vec3((f32((select(select(u32(_e868), 0u, (_e868 < 0f)), 4294967295u, (_e868 > 4294967000f)) + _e762.member_1.x)) / _e498), (f32((select(select(u32(_e877), 0u, (_e877 < 0f)), 4294967295u, (_e877 > 4294967000f)) + _e762.member_1.y)) / _e500), f32(_e762.member_3)); + let _e901 = textureSampleLevel(global_12, global_11, vec2(_e895.x, _e895.y), i32(_e895.z), 0f); + let _e902 = (_e317.member_7 == 4294967295u); + let _e904 = select(_e901, vec4(1f, 1f, 1f, 1f), vec4(_e902)); + let _e908 = select(_e123, _e122, vec2((_e317.member_13 == 0u))); + if _e323 { + phi_4182_ = (_e317.member_8 <= (_e117 - 8u)); + } else { + phi_4182_ = false; + } + let _e913 = phi_4182_; + if _e913 { + let _e916 = global.member[_e317.member_8]; + let _e920 = global.member[(_e317.member_8 + 1u)]; + let _e925 = global.member[(_e317.member_8 + 2u)]; + let _e929 = global.member[(_e317.member_8 + 3u)]; + let _e934 = global.member[(_e317.member_8 + 4u)]; + let _e938 = global.member[(_e317.member_8 + 5u)]; + let _e942 = global.member[(_e317.member_8 + 6u)]; + switch bitcast(_e942) { + case 0: { + phi_1349_ = 0u; + break; + } + case 1: { + phi_1349_ = 1u; + break; + } + case 2: { + phi_1349_ = 2u; + break; + } + default: { + phi_1349_ = 0u; + break; + } + } + let _e945 = phi_1349_; + let _e949 = global.member[(_e317.member_8 + 7u)]; + switch bitcast(_e949) { + case 0: { + phi_1358_ = 0u; + break; + } + case 1: { + phi_1358_ = 1u; + break; + } + case 2: { + phi_1358_ = 2u; + break; + } + default: { + phi_1358_ = 0u; + break; + } + } + let _e952 = phi_1358_; + phi_1371_ = type_33(type_24(_e945, _e952), vec2(_e916, _e920), vec2(_e925, _e929), _e934, _e938); + } else { + phi_1371_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e956 = phi_1371_; + switch bitcast(_e956.member.member) { + case 1: { + let _e994 = abs(_e908.x); + let _e996 = (_e994 % 1f); + if (_e994 >= 1f) { + phi_4202_ = select(true, false, (_e996 == 0f)); + } else { + phi_4202_ = true; + } + let _e1000 = phi_4202_; + let _e1001 = select(1f, _e996, _e1000); + if (select(-1f, 1f, (_e908.x >= 0f)) > 0f) { + phi_1391_ = _e1001; + } else { + phi_1391_ = (1f - _e1001); + } + let _e1005 = phi_1391_; + phi_1428_ = _e1005; + break; + } + case 2: { + let _e968 = abs(_e908.x); + let _e975 = ((select(select(u32(_e968), 0u, (_e968 < 0f)), 4294967295u, (_e968 > 4294967000f)) % 2u) == 0u); + let _e977 = (_e968 % 1f); + if (_e968 >= 1f) { + phi_4219_ = select(true, false, (_e977 == 0f)); + } else { + phi_4219_ = true; + } + let _e981 = phi_4219_; + let _e982 = select(1f, _e977, _e981); + if (select(-1f, 1f, (_e908.x >= 0f)) > 0f) { + if _e975 { + phi_1420_ = _e982; + } else { + phi_1420_ = (1f - _e982); + } + let _e989 = phi_1420_; + phi_1426_ = _e989; + } else { + if _e975 { + phi_1425_ = (1f - _e982); + } else { + phi_1425_ = _e982; + } + let _e986 = phi_1425_; + phi_1426_ = _e986; + } + let _e991 = phi_1426_; + phi_1428_ = _e991; + break; + } + case 0: { + if (_e908.x > 1f) { + phi_4237_ = 0.9999999f; + } else { + phi_4237_ = select(_e908.x, 0.00000011920929f, (_e908.x < 0f)); + } + let _e965 = phi_4237_; + phi_1428_ = _e965; + break; + } + default: { + phi_1428_ = f32(); + break; + } + } + let _e1007 = phi_1428_; + switch bitcast(_e956.member.member_1) { + case 1: { + let _e1045 = abs(_e908.y); + let _e1047 = (_e1045 % 1f); + if (_e1045 >= 1f) { + phi_4250_ = select(true, false, (_e1047 == 0f)); + } else { + phi_4250_ = true; + } + let _e1051 = phi_4250_; + let _e1052 = select(1f, _e1047, _e1051); + if (select(-1f, 1f, (_e908.y >= 0f)) > 0f) { + phi_1449_ = _e1052; + } else { + phi_1449_ = (1f - _e1052); + } + let _e1056 = phi_1449_; + phi_1486_ = _e1056; + break; + } + case 2: { + let _e1019 = abs(_e908.y); + let _e1026 = ((select(select(u32(_e1019), 0u, (_e1019 < 0f)), 4294967295u, (_e1019 > 4294967000f)) % 2u) == 0u); + let _e1028 = (_e1019 % 1f); + if (_e1019 >= 1f) { + phi_4267_ = select(true, false, (_e1028 == 0f)); + } else { + phi_4267_ = true; + } + let _e1032 = phi_4267_; + let _e1033 = select(1f, _e1028, _e1032); + if (select(-1f, 1f, (_e908.y >= 0f)) > 0f) { + if _e1026 { + phi_1478_ = _e1033; + } else { + phi_1478_ = (1f - _e1033); + } + let _e1040 = phi_1478_; + phi_1484_ = _e1040; + } else { + if _e1026 { + phi_1483_ = (1f - _e1033); + } else { + phi_1483_ = _e1033; + } + let _e1037 = phi_1483_; + phi_1484_ = _e1037; + } + let _e1042 = phi_1484_; + phi_1486_ = _e1042; + break; + } + case 0: { + if (_e908.y > 1f) { + phi_4285_ = 0.9999999f; + } else { + phi_4285_ = select(_e908.y, 0.00000011920929f, (_e908.y < 0f)); + } + let _e1016 = phi_4285_; + phi_1486_ = _e1016; + break; + } + default: { + phi_1486_ = f32(); + break; + } + } + let _e1058 = phi_1486_; + let _e1062 = (_e1007 * f32(_e956.member_2.x)); + let _e1071 = (_e1058 * f32(_e956.member_2.y)); + let _e1089 = vec3((f32((select(select(u32(_e1062), 0u, (_e1062 < 0f)), 4294967295u, (_e1062 > 4294967000f)) + _e956.member_1.x)) / _e498), (f32((select(select(u32(_e1071), 0u, (_e1071 < 0f)), 4294967295u, (_e1071 > 4294967000f)) + _e956.member_1.y)) / _e500), f32(_e956.member_3)); + let _e1095 = textureSampleLevel(global_12, global_11, vec2(_e1089.x, _e1089.y), i32(_e1089.z), 0f); + let _e1102 = select(_e123, _e122, vec2((_e317.member_14 == 0u))); + if _e323 { + phi_4317_ = (_e317.member_9 <= (_e117 - 8u)); + } else { + phi_4317_ = false; + } + let _e1107 = phi_4317_; + if _e1107 { + let _e1110 = global.member[_e317.member_9]; + let _e1114 = global.member[(_e317.member_9 + 1u)]; + let _e1119 = global.member[(_e317.member_9 + 2u)]; + let _e1123 = global.member[(_e317.member_9 + 3u)]; + let _e1128 = global.member[(_e317.member_9 + 4u)]; + let _e1132 = global.member[(_e317.member_9 + 5u)]; + let _e1136 = global.member[(_e317.member_9 + 6u)]; + switch bitcast(_e1136) { + case 0: { + phi_1569_ = 0u; + break; + } + case 1: { + phi_1569_ = 1u; + break; + } + case 2: { + phi_1569_ = 2u; + break; + } + default: { + phi_1569_ = 0u; + break; + } + } + let _e1139 = phi_1569_; + let _e1143 = global.member[(_e317.member_9 + 7u)]; + switch bitcast(_e1143) { + case 0: { + phi_1578_ = 0u; + break; + } + case 1: { + phi_1578_ = 1u; + break; + } + case 2: { + phi_1578_ = 2u; + break; + } + default: { + phi_1578_ = 0u; + break; + } + } + let _e1146 = phi_1578_; + phi_1591_ = type_33(type_24(_e1139, _e1146), vec2(_e1110, _e1114), vec2(_e1119, _e1123), _e1128, _e1132); + } else { + phi_1591_ = type_33(type_24(0u, 0u), vec2(0u, 0u), vec2(0u, 0u), 0u, 0u); + } + let _e1150 = phi_1591_; + switch bitcast(_e1150.member.member) { + case 1: { + let _e1188 = abs(_e1102.x); + let _e1190 = (_e1188 % 1f); + if (_e1188 >= 1f) { + phi_4337_ = select(true, false, (_e1190 == 0f)); + } else { + phi_4337_ = true; + } + let _e1194 = phi_4337_; + let _e1195 = select(1f, _e1190, _e1194); + if (select(-1f, 1f, (_e1102.x >= 0f)) > 0f) { + phi_1611_ = _e1195; + } else { + phi_1611_ = (1f - _e1195); + } + let _e1199 = phi_1611_; + phi_1648_ = _e1199; + break; + } + case 2: { + let _e1162 = abs(_e1102.x); + let _e1169 = ((select(select(u32(_e1162), 0u, (_e1162 < 0f)), 4294967295u, (_e1162 > 4294967000f)) % 2u) == 0u); + let _e1171 = (_e1162 % 1f); + if (_e1162 >= 1f) { + phi_4354_ = select(true, false, (_e1171 == 0f)); + } else { + phi_4354_ = true; + } + let _e1175 = phi_4354_; + let _e1176 = select(1f, _e1171, _e1175); + if (select(-1f, 1f, (_e1102.x >= 0f)) > 0f) { + if _e1169 { + phi_1640_ = _e1176; + } else { + phi_1640_ = (1f - _e1176); + } + let _e1183 = phi_1640_; + phi_1646_ = _e1183; + } else { + if _e1169 { + phi_1645_ = (1f - _e1176); + } else { + phi_1645_ = _e1176; + } + let _e1180 = phi_1645_; + phi_1646_ = _e1180; + } + let _e1185 = phi_1646_; + phi_1648_ = _e1185; + break; + } + case 0: { + if (_e1102.x > 1f) { + phi_4372_ = 0.9999999f; + } else { + phi_4372_ = select(_e1102.x, 0.00000011920929f, (_e1102.x < 0f)); + } + let _e1159 = phi_4372_; + phi_1648_ = _e1159; + break; + } + default: { + phi_1648_ = f32(); + break; + } + } + let _e1201 = phi_1648_; + switch bitcast(_e1150.member.member_1) { + case 1: { + let _e1239 = abs(_e1102.y); + let _e1241 = (_e1239 % 1f); + if (_e1239 >= 1f) { + phi_4385_ = select(true, false, (_e1241 == 0f)); + } else { + phi_4385_ = true; + } + let _e1245 = phi_4385_; + let _e1246 = select(1f, _e1241, _e1245); + if (select(-1f, 1f, (_e1102.y >= 0f)) > 0f) { + phi_1669_ = _e1246; + } else { + phi_1669_ = (1f - _e1246); + } + let _e1250 = phi_1669_; + phi_1706_ = _e1250; + break; + } + case 2: { + let _e1213 = abs(_e1102.y); + let _e1220 = ((select(select(u32(_e1213), 0u, (_e1213 < 0f)), 4294967295u, (_e1213 > 4294967000f)) % 2u) == 0u); + let _e1222 = (_e1213 % 1f); + if (_e1213 >= 1f) { + phi_4402_ = select(true, false, (_e1222 == 0f)); + } else { + phi_4402_ = true; + } + let _e1226 = phi_4402_; + let _e1227 = select(1f, _e1222, _e1226); + if (select(-1f, 1f, (_e1102.y >= 0f)) > 0f) { + if _e1220 { + phi_1698_ = _e1227; + } else { + phi_1698_ = (1f - _e1227); + } + let _e1234 = phi_1698_; + phi_1704_ = _e1234; + } else { + if _e1220 { + phi_1703_ = (1f - _e1227); + } else { + phi_1703_ = _e1227; + } + let _e1231 = phi_1703_; + phi_1704_ = _e1231; + } + let _e1236 = phi_1704_; + phi_1706_ = _e1236; + break; + } + case 0: { + if (_e1102.y > 1f) { + phi_4420_ = 0.9999999f; + } else { + phi_4420_ = select(_e1102.y, 0.00000011920929f, (_e1102.y < 0f)); + } + let _e1210 = phi_4420_; + phi_1706_ = _e1210; + break; + } + default: { + phi_1706_ = f32(); + break; + } + } + let _e1252 = phi_1706_; + let _e1256 = (_e1201 * f32(_e1150.member_2.x)); + let _e1265 = (_e1252 * f32(_e1150.member_2.y)); + let _e1283 = vec3((f32((select(select(u32(_e1256), 0u, (_e1256 < 0f)), 4294967295u, (_e1256 > 4294967000f)) + _e1150.member_1.x)) / _e498), (f32((select(select(u32(_e1265), 0u, (_e1265 < 0f)), 4294967295u, (_e1265 > 4294967000f)) + _e1150.member_1.y)) / _e500), f32(_e1150.member_3)); + let _e1289 = textureSampleLevel(global_12, global_11, vec2(_e1283.x, _e1283.y), i32(_e1283.z), 0f); + let _e1292 = select(_e1289, vec4(1f, 1f, 1f, 1f), vec4((_e317.member_9 == 4294967295u))); + if _e902 { + phi_1800_ = vec3(0f, 0f, 0f); + phi_1801_ = _e124; + } else { + let _e1296 = fma(_e904.x, 2f, -1f); + let _e1297 = fma(_e904.y, 2f, -1f); + let _e1298 = fma(_e904.z, 2f, -1f); + let _e1303 = sqrt(fma(_e1298, _e1298, fma(_e1296, _e1296, (_e1297 * _e1297)))); + if (_e1303 == 0f) { + phi_4474_ = vec3(0f, 0f, 0f); + } else { + phi_4474_ = (vec3(_e1296, _e1297, _e1298) * (1f / _e1303)); + } + let _e1308 = phi_4474_; + let _e1315 = sqrt(fma(_e125.z, _e125.z, fma(_e125.x, _e125.x, (_e125.y * _e125.y)))); + if (_e1315 == 0f) { + phi_4509_ = vec3(0f, 0f, 0f); + } else { + phi_4509_ = (_e125 * (1f / _e1315)); + } + let _e1320 = phi_4509_; + let _e1327 = sqrt(fma(_e126.z, _e126.z, fma(_e126.x, _e126.x, (_e126.y * _e126.y)))); + if (_e1327 == 0f) { + phi_4544_ = vec3(0f, 0f, 0f); + } else { + phi_4544_ = (_e126 * (1f / _e1327)); + } + let _e1332 = phi_4544_; + let _e1339 = sqrt(fma(_e124.z, _e124.z, fma(_e124.x, _e124.x, (_e124.y * _e124.y)))); + if (_e1339 == 0f) { + phi_4579_ = vec3(0f, 0f, 0f); + } else { + phi_4579_ = (_e124 * (1f / _e1339)); + } + let _e1344 = phi_4579_; + let _e1363 = fma(_e1344.x, _e1308.z, fma(_e1320.x, _e1308.x, (_e1332.x * _e1308.y))); + let _e1364 = fma(_e1344.y, _e1308.z, fma(_e1320.y, _e1308.x, (_e1332.y * _e1308.y))); + let _e1365 = fma(_e1344.z, _e1308.z, fma(_e1320.z, _e1308.x, (_e1332.z * _e1308.y))); + let _e1370 = sqrt(fma(_e1365, _e1365, fma(_e1363, _e1363, (_e1364 * _e1364)))); + if (_e1370 == 0f) { + phi_4614_ = vec3(0f, 0f, 0f); + } else { + phi_4614_ = (vec3(_e1363, _e1364, _e1365) * (1f / _e1370)); + } + let _e1375 = phi_4614_; + phi_1800_ = _e1308; + phi_1801_ = _e1375; + } + let _e1377 = phi_1800_; + let _e1379 = phi_1801_; + let _e1383 = (_e516.x * _e317.member_2.x); + let _e1386 = (_e516.y * _e317.member_2.y); + let _e1389 = (_e516.z * _e317.member_2.z); + let _e1394 = (_e1383 * _e121.x); + let _e1396 = (_e1386 * _e121.y); + let _e1398 = (_e1389 * _e121.z); + let _e1403 = (_e710.y * _e317.member_4); + let _e1406 = (_e710.z * _e317.member_3); + let _e1410 = fma(_e317.member_16, (select(_e1095, vec4(1f, 1f, 1f, 1f), vec4((_e317.member_8 == 4294967295u))).x - 1f), 1f); + let _e1416 = (_e1292.x * _e317.member.x); + let _e1418 = (_e1292.y * _e317.member.y); + let _e1420 = (_e1292.z * _e317.member.z); + let _e1425 = textureSampleLevel(global_13, global_14, _e1379, 0f); + if (_e117 >= 83u) { + phi_4646_ = (_e118 <= (_e117 - 83u)); + } else { + phi_4646_ = false; + } + let _e1433 = phi_4646_; + if _e1433 { + let _e1436 = global.member[_e118]; + let _e1441 = global.member[(_e118 + 1u)]; + let _e1446 = global.member[(_e118 + 2u)]; + let _e1451 = global.member[(_e118 + 3u)]; + let _e1457 = global.member[(_e118 + 4u)]; + let _e1462 = global.member[(_e118 + 5u)]; + let _e1467 = global.member[(_e118 + 6u)]; + let _e1472 = global.member[(_e118 + 7u)]; + let _e1478 = global.member[(_e118 + 8u)]; + let _e1483 = global.member[(_e118 + 9u)]; + let _e1488 = global.member[(_e118 + 10u)]; + let _e1493 = global.member[(_e118 + 11u)]; + let _e1499 = global.member[(_e118 + 12u)]; + let _e1504 = global.member[(_e118 + 13u)]; + let _e1509 = global.member[(_e118 + 14u)]; + let _e1514 = global.member[(_e118 + 15u)]; + let _e1521 = global.member[(_e118 + 16u)]; + let _e1526 = global.member[(_e118 + 17u)]; + let _e1531 = global.member[(_e118 + 18u)]; + let _e1536 = global.member[(_e118 + 19u)]; + let _e1542 = global.member[(_e118 + 20u)]; + let _e1547 = global.member[(_e118 + 21u)]; + let _e1552 = global.member[(_e118 + 22u)]; + let _e1557 = global.member[(_e118 + 23u)]; + let _e1563 = global.member[(_e118 + 24u)]; + let _e1568 = global.member[(_e118 + 25u)]; + let _e1573 = global.member[(_e118 + 26u)]; + let _e1578 = global.member[(_e118 + 27u)]; + let _e1584 = global.member[(_e118 + 28u)]; + let _e1589 = global.member[(_e118 + 29u)]; + let _e1594 = global.member[(_e118 + 30u)]; + let _e1599 = global.member[(_e118 + 31u)]; + let _e1606 = global.member[(_e118 + 32u)]; + let _e1611 = global.member[(_e118 + 33u)]; + let _e1616 = global.member[(_e118 + 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_2007_ = type_24(0u, 6u); + loop { + let _e1621 = phi_2007_; + if (_e1621.member < _e1621.member_1) { + phi_2008_ = type_24((_e1621.member + 1u), _e1621.member_1); + phi_2023_ = type_24(1u, _e1621.member); + } else { + phi_2008_ = _e1621; + phi_2023_ = type_24(0u, type_24().member_1); + } + let _e1634 = phi_2008_; + let _e1636 = phi_2023_; + switch bitcast(_e1636.member) { + case 0: { + phi_2050_ = false; + break; + } + case 1: { + let _e1641 = ((_e118 + 35u) + (_e1636.member_1 * 4u)); + let _e1644 = global.member[_e1641]; + let _e1649 = global.member[(_e1641 + 1u)]; + let _e1654 = global.member[(_e1641 + 2u)]; + let _e1659 = global.member[(_e1641 + 3u)]; + local_1[_e1636.member_1] = vec4(bitcast(_e1644), bitcast(_e1649), bitcast(_e1654), bitcast(_e1659)); + phi_2050_ = true; + break; + } + default: { + phi_2050_ = bool(); + break; + } + } + let _e1664 = phi_2050_; + continue; + continuing { + phi_2007_ = _e1634; + break if !(_e1664); + } + } + let _e1666 = 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_2056_ = type_24(0u, 8u); + loop { + let _e1669 = phi_2056_; + if (_e1669.member < _e1669.member_1) { + phi_2057_ = type_24((_e1669.member + 1u), _e1669.member_1); + phi_2072_ = type_24(1u, _e1669.member); + } else { + phi_2057_ = _e1669; + phi_2072_ = type_24(0u, type_24().member_1); + } + let _e1682 = phi_2057_; + let _e1684 = phi_2072_; + switch bitcast(_e1684.member) { + case 0: { + phi_2095_ = false; + break; + } + case 1: { + let _e1689 = ((_e118 + 59u) + (_e1684.member_1 * 3u)); + let _e1692 = global.member[_e1689]; + let _e1697 = global.member[(_e1689 + 1u)]; + let _e1702 = global.member[(_e1689 + 2u)]; + local[_e1684.member_1] = vec3(bitcast(_e1692), bitcast(_e1697), bitcast(_e1702)); + phi_2095_ = true; + break; + } + default: { + phi_2095_ = bool(); + break; + } + } + let _e1707 = phi_2095_; + continue; + continuing { + phi_2056_ = _e1682; + break if !(_e1707); + } + } + let _e1709 = local; + phi_2103_ = type_22(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_20(vec4(bitcast(_e1521), bitcast(_e1526), bitcast(_e1531), bitcast(_e1536)), vec4(bitcast(_e1542), bitcast(_e1547), bitcast(_e1552), bitcast(_e1557)), vec4(bitcast(_e1563), bitcast(_e1568), bitcast(_e1573), bitcast(_e1578)), vec4(bitcast(_e1584), bitcast(_e1589), bitcast(_e1594), bitcast(_e1599))), type_21(_e1709, _e1666), vec3(bitcast(_e1606), bitcast(_e1611), bitcast(_e1616))); + } else { + phi_2103_ = 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 _e1713 = phi_2103_; + let _e1715 = (_e1713.member_3 - _e127); + let _e1722 = sqrt(fma(_e1715.z, _e1715.z, fma(_e1715.x, _e1715.x, (_e1715.y * _e1715.y)))); + let _e1723 = (_e1722 == 0f); + if _e1723 { + phi_4718_ = vec3(0f, 0f, 0f); + } else { + phi_4718_ = (_e1715 * (1f / _e1722)); + } + let _e1727 = phi_4718_; + let _e1728 = -(_e1727); + let _e1735 = sqrt(fma(_e1379.z, _e1379.z, fma(_e1379.x, _e1379.x, (_e1379.y * _e1379.y)))); + let _e1736 = (_e1735 == 0f); + if _e1736 { + phi_4777_ = vec3(0f, 0f, 0f); + } else { + phi_4777_ = (_e1379 * (1f / _e1735)); + } + let _e1740 = phi_4777_; + let _e1750 = (2f * fma(_e1740.z, _e1728.z, fma(_e1740.x, _e1728.x, (_e1740.y * _e1728.y)))); + let _e1757 = textureSampleLevel(global_15, global_16, (_e1728 - vec3((_e1750 * _e1740.x), (_e1750 * _e1740.y), (_e1750 * _e1740.z))), (_e1403 * 4f)); + if _e1723 { + phi_4851_ = vec3(0f, 0f, 0f); + } else { + phi_4851_ = (_e1715 * (1f / _e1722)); + } + let _e1764 = phi_4851_; + let _e1773 = textureSampleLevel(global_17, global_18, vec2(max(fma(_e1379.z, _e1764.z, fma(_e1379.x, _e1764.x, (_e1379.y * _e1764.y))), 0f), _e1403), 0f); + switch bitcast(_e178.member_3) { + case 0: { + if _e317.member_15 { + if _e1736 { + phi_4901_ = vec3(0f, 0f, 0f); + } else { + phi_4901_ = (_e1379 * (1f / _e1735)); + } + let _e1942 = phi_4901_; + if _e1723 { + phi_4936_ = vec3(0f, 0f, 0f); + } else { + phi_4936_ = (_e1715 * (1f / _e1722)); + } + let _e1946 = phi_4936_; + phi_2143_ = type_24(0u, _e178.member_2.member_1); + phi_2146_ = vec3(0f, 0f, 0f); + loop { + let _e1949 = phi_2143_; + let _e1951 = phi_2146_; + local_2 = _e1951; + local_3 = _e1951; + local_4 = _e1951; + if (_e1949.member < _e1949.member_1) { + phi_2144_ = type_24((_e1949.member + 1u), _e1949.member_1); + phi_2161_ = type_24(1u, _e1949.member); + } else { + phi_2144_ = _e1949; + phi_2161_ = type_24(0u, type_24().member_1); + } + let _e1964 = phi_2144_; + let _e1966 = phi_2161_; + switch bitcast(_e1966.member) { + case 0: { + phi_2147_ = vec3(); + phi_3013_ = false; + break; + } + case 1: { + if (_e1966.member_1 >= _e178.member_2.member_1) { + phi_4953_ = 4294967295u; + } else { + phi_4953_ = (_e178.member_2.member + _e1966.member_1); + } + let _e1973 = phi_4953_; + if (_e117 >= 1u) { + phi_4972_ = (_e1973 <= (_e117 - 1u)); + } else { + phi_4972_ = false; + } + let _e1978 = phi_4972_; + if _e1978 { + let _e1981 = global.member[_e1973]; + phi_2178_ = _e1981; + } else { + phi_2178_ = 4294967295u; + } + let _e1983 = phi_2178_; + let _e1984 = (_e1983 == 4294967295u); + if _e1984 { + phi_3011_ = vec3(); + } else { + if (_e117 >= 3u) { + phi_5004_ = (_e1983 <= (_e117 - 3u)); + } else { + phi_5004_ = false; + } + let _e1989 = phi_5004_; + if _e1989 { + let _e1992 = global.member[_e1983]; + switch bitcast(_e1992) { + case 0: { + phi_2195_ = 0u; + break; + } + case 1: { + phi_2195_ = 1u; + break; + } + case 2: { + phi_2195_ = 2u; + break; + } + default: { + phi_2195_ = 0u; + break; + } + } + let _e1995 = phi_2195_; + let _e1999 = global.member[(_e1983 + 1u)]; + let _e2003 = global.member[(_e1983 + 2u)]; + phi_2205_ = type_34(_e1995, _e1999, _e2003); + } else { + phi_2205_ = type_34(0u, 4294967295u, 4294967295u); + } + let _e2006 = phi_2205_; + if (_e117 >= 10u) { + phi_5034_ = (_e2006.member_2 <= (_e117 - 10u)); + } else { + phi_5034_ = false; + } + let _e2012 = phi_5034_; + if _e2012 { + let _e2015 = global.member[_e2006.member_2]; + let _e2020 = global.member[(_e2006.member_2 + 1u)]; + let _e2025 = global.member[(_e2006.member_2 + 2u)]; + let _e2031 = global.member[(_e2006.member_2 + 3u)]; + let _e2036 = global.member[(_e2006.member_2 + 4u)]; + let _e2041 = global.member[(_e2006.member_2 + 5u)]; + let _e2046 = global.member[(_e2006.member_2 + 6u)]; + let _e2052 = global.member[(_e2006.member_2 + 7u)]; + let _e2057 = global.member[(_e2006.member_2 + 8u)]; + let _e2062 = global.member[(_e2006.member_2 + 9u)]; + phi_2255_ = type_28(vec3(bitcast(_e2015), bitcast(_e2020), bitcast(_e2025)), vec4(bitcast(_e2031), bitcast(_e2036), bitcast(_e2041), bitcast(_e2046)), vec3(bitcast(_e2052), bitcast(_e2057), bitcast(_e2062))); + } else { + phi_2255_ = type_28(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e2067 = phi_2255_; + let _e2075 = (_e2067.member_1.x + _e2067.member_1.x); + let _e2076 = (_e2067.member_1.y + _e2067.member_1.y); + let _e2077 = (_e2067.member_1.z + _e2067.member_1.z); + let _e2079 = (_e2067.member_1.z * _e2077); + let _e2080 = (_e2067.member_1.w * _e2075); + let _e2081 = (_e2067.member_1.w * _e2076); + let _e2082 = (_e2067.member_1.w * _e2077); + let _e2102 = (vec4((1f - fma(_e2067.member_1.y, _e2076, _e2079)), fma(_e2067.member_1.x, _e2076, _e2082), fma(_e2067.member_1.x, _e2077, -(_e2081)), 0f) * _e2067.member_2.x); + let _e2104 = (vec4(fma(_e2067.member_1.x, _e2076, -(_e2082)), (1f - fma(_e2067.member_1.x, _e2075, _e2079)), fma(_e2067.member_1.y, _e2077, _e2080), 0f) * _e2067.member_2.y); + let _e2106 = (vec4(fma(_e2067.member_1.x, _e2077, _e2081), fma(_e2067.member_1.y, _e2077, -(_e2080)), (1f - fma(_e2067.member_1.x, _e2075, (_e2067.member_1.y * _e2076))), 0f) * _e2067.member_2.z); + switch bitcast(_e2006.member) { + case 0: { + if _e323 { + phi_5115_ = (_e2006.member_1 <= (_e117 - 8u)); + } else { + phi_5115_ = false; + } + let _e2602 = phi_5115_; + if _e2602 { + let _e2605 = global.member[_e2006.member_1]; + let _e2610 = global.member[(_e2006.member_1 + 1u)]; + let _e2615 = global.member[(_e2006.member_1 + 2u)]; + let _e2621 = global.member[(_e2006.member_1 + 3u)]; + let _e2626 = global.member[(_e2006.member_1 + 4u)]; + let _e2631 = global.member[(_e2006.member_1 + 5u)]; + let _e2636 = global.member[(_e2006.member_1 + 6u)]; + let _e2642 = global.member[(_e2006.member_1 + 7u)]; + phi_2303_ = type_35(vec3(bitcast(_e2605), bitcast(_e2610), bitcast(_e2615)), vec4(bitcast(_e2621), bitcast(_e2626), bitcast(_e2631), bitcast(_e2636)), bitcast(_e2642)); + } else { + phi_2303_ = type_35(vec3(0f, -1f, 0f), vec4(1f, 1f, 1f, 1f), 1f); + } + let _e2646 = phi_2303_; + let _e2668 = fma(_e2106.x, _e2646.member.z, fma(_e2104.x, _e2646.member.y, (_e2102.x * _e2646.member.x))); + let _e2669 = fma(_e2106.y, _e2646.member.z, fma(_e2104.y, _e2646.member.y, (_e2102.y * _e2646.member.x))); + let _e2670 = fma(_e2106.z, _e2646.member.z, fma(_e2104.z, _e2646.member.y, (_e2102.z * _e2646.member.x))); + let _e2675 = sqrt(fma(_e2670, _e2670, fma(_e2668, _e2668, (_e2669 * _e2669)))); + if (_e2675 == 0f) { + phi_5163_ = vec3(0f, 0f, 0f); + } else { + phi_5163_ = (vec3(_e2668, _e2669, _e2670) * (1f / _e2675)); + } + let _e2680 = phi_5163_; + let _e2682 = -(_e2680.x); + let _e2684 = -(_e2680.y); + let _e2686 = -(_e2680.z); + let _e2687 = -(_e2680); + let _e2691 = fma(fma(_e1383, _e121.x, -0.4f), _e1406, 0.4f); + let _e2692 = fma(fma(_e1386, _e121.y, -0.4f), _e1406, 0.4f); + let _e2693 = fma(fma(_e1389, _e121.z, -0.4f), _e1406, 0.4f); + let _e2701 = (_e1946 + vec3(_e2682, _e2684, _e2686)); + let _e2708 = sqrt(fma(_e2701.z, _e2701.z, fma(_e2701.x, _e2701.x, (_e2701.y * _e2701.y)))); + if (_e2708 == 0f) { + phi_5198_ = vec3(0f, 0f, 0f); + } else { + phi_5198_ = (_e2701 * (1f / _e2708)); + } + let _e2713 = phi_5198_; + let _e2714 = (_e1403 * _e1403); + let _e2725 = max(fma(_e1942.z, _e2713.z, fma(_e1942.x, _e2713.x, (_e1942.y * _e2713.y))), 0f); + let _e2738 = max(fma(_e1942.z, _e1946.z, fma(_e1942.x, _e1946.x, (_e1942.y * _e1946.y))), 0f); + let _e2745 = max(fma(_e1942.z, _e2687.z, fma(_e1942.x, _e2687.x, (_e1942.y * _e2687.y))), 0f); + let _e2746 = fma(_e710.y, _e317.member_4, 1f); + let _e2747 = (_e2746 * _e2746); + let _e2748 = (_e2747 * 0.125f); + let _e2750 = fma(-(_e2747), 0.125f, 1f); + let _e2763 = (1f - max(fma(_e2713.z, _e1946.z, fma(_e2713.x, _e1946.x, (_e2713.y * _e1946.y))), 0f)); + let _e2765 = select(_e2763, 0f, (_e2763 < 0f)); + let _e2768 = pow(select(_e2765, 1f, (_e2765 > 1f)), 5f); + let _e2769 = fma((1f - _e2691), _e2768, _e2691); + let _e2770 = fma((1f - _e2692), _e2768, _e2692); + let _e2771 = fma((1f - _e2693), _e2768, _e2693); + let _e2776 = fma(-(_e710.z), _e317.member_3, 1f); + let _e2780 = (((_e2714 * _e2714) / (pow(fma((_e2725 * _e2725), fma(_e2714, _e2714, -1f), 1f), 2f) * 3.1415927f)) * ((_e2738 / fma(_e2738, _e2750, _e2748)) * (_e2745 / fma(_e2745, _e2750, _e2748)))); + let _e2787 = max(fma(_e1942.z, _e2686, fma(_e1942.x, _e2682, (_e1942.y * _e2684))), 0f); + let _e2789 = fma((4f * _e2738), _e2787, 0.0001f); + phi_3001_ = vec3(fma((fma((((1f - _e2769) * _e2776) * _e1394), 0.31830987f, ((_e2780 * _e2769) / _e2789)) * (_e2646.member_1.x * _e2646.member_2)), _e2787, _e1951.x), fma((fma((((1f - _e2770) * _e2776) * _e1396), 0.31830987f, ((_e2780 * _e2770) / _e2789)) * (_e2646.member_1.y * _e2646.member_2)), _e2787, _e1951.y), fma((fma((((1f - _e2771) * _e2776) * _e1398), 0.31830987f, ((_e2780 * _e2771) / _e2789)) * (_e2646.member_1.z * _e2646.member_2)), _e2787, _e1951.z)); + phi_3002_ = true; + break; + } + case 1: { + if _e323 { + phi_5290_ = (_e2006.member_1 <= (_e117 - 8u)); + } else { + phi_5290_ = false; + } + let _e2391 = phi_5290_; + if _e2391 { + let _e2394 = global.member[_e2006.member_1]; + let _e2399 = global.member[(_e2006.member_1 + 1u)]; + let _e2404 = global.member[(_e2006.member_1 + 2u)]; + let _e2410 = global.member[(_e2006.member_1 + 3u)]; + let _e2415 = global.member[(_e2006.member_1 + 4u)]; + let _e2420 = global.member[(_e2006.member_1 + 5u)]; + let _e2425 = global.member[(_e2006.member_1 + 6u)]; + let _e2431 = global.member[(_e2006.member_1 + 7u)]; + phi_2505_ = type_35(vec3(bitcast(_e2394), bitcast(_e2399), bitcast(_e2404)), vec4(bitcast(_e2410), bitcast(_e2415), bitcast(_e2420), bitcast(_e2425)), bitcast(_e2431)); + } else { + phi_2505_ = type_35(vec3(0f, 0f, 0f), vec4(1f, 1f, 1f, 1f), 1f); + } + let _e2435 = phi_2505_; + let _e2464 = (vec3((_e2067.member.x + fma(_e2106.x, _e2435.member.z, fma(_e2104.x, _e2435.member.y, (_e2102.x * _e2435.member.x)))), (_e2067.member.y + fma(_e2106.y, _e2435.member.z, fma(_e2104.y, _e2435.member.y, (_e2102.y * _e2435.member.x)))), (_e2067.member.z + fma(_e2106.z, _e2435.member.z, fma(_e2104.z, _e2435.member.y, (_e2102.z * _e2435.member.x))))) - _e127); + let _e2471 = sqrt(fma(_e2464.z, _e2464.z, fma(_e2464.x, _e2464.x, (_e2464.y * _e2464.y)))); + let _e2472 = (_e2471 == 0f); + if _e2472 { + phi_2690_ = vec3(); + } else { + if _e2472 { + phi_5336_ = vec3(0f, 0f, 0f); + } else { + phi_5336_ = (_e2464 * (1f / _e2471)); + } + let _e2476 = phi_5336_; + let _e2478 = (_e2435.member_2 / (_e2471 * _e2471)); + let _e2482 = fma(fma(_e1383, _e121.x, -0.4f), _e1406, 0.4f); + let _e2483 = fma(fma(_e1386, _e121.y, -0.4f), _e1406, 0.4f); + let _e2484 = fma(fma(_e1389, _e121.z, -0.4f), _e1406, 0.4f); + let _e2491 = (_e1946 + _e2476); + let _e2498 = sqrt(fma(_e2491.z, _e2491.z, fma(_e2491.x, _e2491.x, (_e2491.y * _e2491.y)))); + if (_e2498 == 0f) { + phi_5371_ = vec3(0f, 0f, 0f); + } else { + phi_5371_ = (_e2491 * (1f / _e2498)); + } + let _e2503 = phi_5371_; + let _e2504 = (_e1403 * _e1403); + let _e2515 = max(fma(_e1942.z, _e2503.z, fma(_e1942.x, _e2503.x, (_e1942.y * _e2503.y))), 0f); + let _e2528 = max(fma(_e1942.z, _e1946.z, fma(_e1942.x, _e1946.x, (_e1942.y * _e1946.y))), 0f); + let _e2535 = max(fma(_e1942.z, _e2476.z, fma(_e1942.x, _e2476.x, (_e1942.y * _e2476.y))), 0f); + let _e2536 = fma(_e710.y, _e317.member_4, 1f); + let _e2537 = (_e2536 * _e2536); + let _e2538 = (_e2537 * 0.125f); + let _e2540 = fma(-(_e2537), 0.125f, 1f); + let _e2553 = (1f - max(fma(_e2503.z, _e1946.z, fma(_e2503.x, _e1946.x, (_e2503.y * _e1946.y))), 0f)); + let _e2555 = select(_e2553, 0f, (_e2553 < 0f)); + let _e2558 = pow(select(_e2555, 1f, (_e2555 > 1f)), 5f); + let _e2559 = fma((1f - _e2482), _e2558, _e2482); + let _e2560 = fma((1f - _e2483), _e2558, _e2483); + let _e2561 = fma((1f - _e2484), _e2558, _e2484); + let _e2566 = fma(-(_e710.z), _e317.member_3, 1f); + let _e2570 = (((_e2504 * _e2504) / (pow(fma((_e2515 * _e2515), fma(_e2504, _e2504, -1f), 1f), 2f) * 3.1415927f)) * ((_e2528 / fma(_e2528, _e2540, _e2538)) * (_e2535 / fma(_e2535, _e2540, _e2538)))); + let _e2575 = fma((4f * _e2528), _e2535, 0.0001f); + phi_2690_ = vec3(fma((fma((((1f - _e2559) * _e2566) * _e1394), 0.31830987f, ((_e2570 * _e2559) / _e2575)) * (_e2435.member_1.x * _e2478)), _e2535, _e1951.x), fma((fma((((1f - _e2560) * _e2566) * _e1396), 0.31830987f, ((_e2570 * _e2560) / _e2575)) * (_e2435.member_1.y * _e2478)), _e2535, _e1951.y), fma((fma((((1f - _e2561) * _e2566) * _e1398), 0.31830987f, ((_e2570 * _e2561) / _e2575)) * (_e2435.member_1.z * _e2478)), _e2535, _e1951.z)); + } + let _e2596 = phi_2690_; + phi_3001_ = _e2596; + phi_3002_ = select(true, false, _e2472); + break; + } + case 2: { + if (_e117 >= 13u) { + phi_5463_ = (_e2006.member_1 <= (_e117 - 13u)); + } else { + phi_5463_ = false; + } + let _e2117 = phi_5463_; + if _e2117 { + let _e2120 = global.member[_e2006.member_1]; + let _e2125 = global.member[(_e2006.member_1 + 1u)]; + let _e2130 = global.member[(_e2006.member_1 + 2u)]; + let _e2136 = global.member[(_e2006.member_1 + 3u)]; + let _e2141 = global.member[(_e2006.member_1 + 4u)]; + let _e2146 = global.member[(_e2006.member_1 + 5u)]; + let _e2152 = global.member[(_e2006.member_1 + 6u)]; + let _e2157 = global.member[(_e2006.member_1 + 7u)]; + let _e2162 = global.member[(_e2006.member_1 + 8u)]; + let _e2167 = global.member[(_e2006.member_1 + 9u)]; + let _e2172 = global.member[(_e2006.member_1 + 10u)]; + let _e2177 = global.member[(_e2006.member_1 + 11u)]; + let _e2183 = global.member[(_e2006.member_1 + 12u)]; + phi_2753_ = type_36(vec3(bitcast(_e2120), bitcast(_e2125), bitcast(_e2130)), vec3(bitcast(_e2136), bitcast(_e2141), bitcast(_e2146)), bitcast(_e2152), bitcast(_e2157), vec4(bitcast(_e2162), bitcast(_e2167), bitcast(_e2172), bitcast(_e2177)), bitcast(_e2183)); + } else { + phi_2753_ = type_36(vec3(0f, 0f, 0f), vec3(0f, -1f, 0f), 1.0471976f, 1.5707964f, vec4(1f, 1f, 1f, 1f), 1f); + } + let _e2187 = phi_2753_; + let _e2219 = (vec3((_e2067.member.x + fma(_e2106.x, _e2187.member.z, fma(_e2104.x, _e2187.member.y, (_e2102.x * _e2187.member.x)))), (_e2067.member.y + fma(_e2106.y, _e2187.member.z, fma(_e2104.y, _e2187.member.y, (_e2102.y * _e2187.member.x)))), (_e2067.member.z + fma(_e2106.z, _e2187.member.z, fma(_e2104.z, _e2187.member.y, (_e2102.z * _e2187.member.x))))) - _e127); + let _e2226 = sqrt(fma(_e2219.z, _e2219.z, fma(_e2219.x, _e2219.x, (_e2219.y * _e2219.y)))); + let _e2227 = (_e2226 == 0f); + if _e2227 { + phi_2999_ = vec3(); + } else { + if _e2227 { + phi_5513_ = vec3(0f, 0f, 0f); + } else { + phi_5513_ = (_e2219 * (1f / _e2226)); + } + let _e2231 = phi_5513_; + let _e2241 = fma(_e2106.x, _e2187.member_1.z, fma(_e2104.x, _e2187.member_1.y, (_e2102.x * _e2187.member_1.x))); + let _e2242 = fma(_e2106.y, _e2187.member_1.z, fma(_e2104.y, _e2187.member_1.y, (_e2102.y * _e2187.member_1.x))); + let _e2243 = fma(_e2106.z, _e2187.member_1.z, fma(_e2104.z, _e2187.member_1.y, (_e2102.z * _e2187.member_1.x))); + let _e2248 = sqrt(fma(_e2243, _e2243, fma(_e2241, _e2241, (_e2242 * _e2242)))); + if (_e2248 == 0f) { + phi_5548_ = vec3(0f, 0f, 0f); + } else { + phi_5548_ = (vec3(_e2241, _e2242, _e2243) * (1f / _e2248)); + } + let _e2253 = phi_5548_; + let _e2265 = ((fma(_e2231.z, _e2253.z, fma(_e2231.x, _e2253.x, (_e2231.y * _e2253.y))) - _e2187.member_3) / (_e2187.member_2 - _e2187.member_3)); + let _e2267 = select(_e2265, 0f, (_e2265 < 0f)); + let _e2270 = (_e2187.member_5 * select(_e2267, 1f, (_e2267 > 1f))); + let _e2274 = fma(fma(_e1383, _e121.x, -0.4f), _e1406, 0.4f); + let _e2275 = fma(fma(_e1386, _e121.y, -0.4f), _e1406, 0.4f); + let _e2276 = fma(fma(_e1389, _e121.z, -0.4f), _e1406, 0.4f); + let _e2283 = (_e1946 + _e2231); + let _e2290 = sqrt(fma(_e2283.z, _e2283.z, fma(_e2283.x, _e2283.x, (_e2283.y * _e2283.y)))); + if (_e2290 == 0f) { + phi_5583_ = vec3(0f, 0f, 0f); + } else { + phi_5583_ = (_e2283 * (1f / _e2290)); + } + let _e2295 = phi_5583_; + let _e2296 = (_e1403 * _e1403); + let _e2307 = max(fma(_e1942.z, _e2295.z, fma(_e1942.x, _e2295.x, (_e1942.y * _e2295.y))), 0f); + let _e2320 = max(fma(_e1942.z, _e1946.z, fma(_e1942.x, _e1946.x, (_e1942.y * _e1946.y))), 0f); + let _e2324 = max(fma(_e1942.z, _e2231.z, fma(_e1942.x, _e2231.x, (_e1942.y * _e2231.y))), 0f); + let _e2325 = fma(_e710.y, _e317.member_4, 1f); + let _e2326 = (_e2325 * _e2325); + let _e2327 = (_e2326 * 0.125f); + let _e2329 = fma(-(_e2326), 0.125f, 1f); + let _e2342 = (1f - max(fma(_e2295.z, _e1946.z, fma(_e2295.x, _e1946.x, (_e2295.y * _e1946.y))), 0f)); + let _e2344 = select(_e2342, 0f, (_e2342 < 0f)); + let _e2347 = pow(select(_e2344, 1f, (_e2344 > 1f)), 5f); + let _e2348 = fma((1f - _e2274), _e2347, _e2274); + let _e2349 = fma((1f - _e2275), _e2347, _e2275); + let _e2350 = fma((1f - _e2276), _e2347, _e2276); + let _e2355 = fma(-(_e710.z), _e317.member_3, 1f); + let _e2359 = (((_e2296 * _e2296) / (pow(fma((_e2307 * _e2307), fma(_e2296, _e2296, -1f), 1f), 2f) * 3.1415927f)) * ((_e2320 / fma(_e2320, _e2329, _e2327)) * (_e2324 / fma(_e2324, _e2329, _e2327)))); + let _e2364 = fma((4f * _e2320), _e2324, 0.0001f); + phi_2999_ = vec3(fma((fma((((1f - _e2348) * _e2355) * _e1394), 0.31830987f, ((_e2359 * _e2348) / _e2364)) * (_e2187.member_4.x * _e2270)), _e2324, _e1951.x), fma((fma((((1f - _e2349) * _e2355) * _e1396), 0.31830987f, ((_e2359 * _e2349) / _e2364)) * (_e2187.member_4.y * _e2270)), _e2324, _e1951.y), fma((fma((((1f - _e2350) * _e2355) * _e1398), 0.31830987f, ((_e2359 * _e2350) / _e2364)) * (_e2187.member_4.z * _e2270)), _e2324, _e1951.z)); + } + let _e2385 = phi_2999_; + phi_3001_ = _e2385; + phi_3002_ = select(true, false, _e2227); + break; + } + default: { + phi_3001_ = vec3(); + phi_3002_ = bool(); + break; + } + } + let _e2810 = phi_3001_; + let _e2812 = phi_3002_; + phi_3011_ = select(_e2810, _e1951, vec3(select(true, false, _e2812))); + } + let _e2817 = phi_3011_; + phi_2147_ = _e2817; + phi_3013_ = select(true, false, _e1984); + break; + } + default: { + phi_2147_ = vec3(); + phi_3013_ = bool(); + break; + } + } + let _e2820 = phi_2147_; + let _e2822 = phi_3013_; + continue; + continuing { + phi_2143_ = _e1964; + phi_2146_ = _e2820; + break if !(_e2822); + } + } + let _e2827 = fma(fma(_e1383, _e121.x, -0.04f), _e1406, 0.04f); + let _e2828 = fma(fma(_e1386, _e121.y, -0.04f), _e1406, 0.04f); + let _e2829 = fma(fma(_e1389, _e121.z, -0.04f), _e1406, 0.04f); + let _e2841 = fma(-(_e710.y), _e317.member_4, 1f); + let _e2848 = (1f - max(fma(_e1942.z, _e1946.z, fma(_e1942.x, _e1946.x, (_e1942.y * _e1946.y))), 0f)); + let _e2850 = select(_e2848, 0f, (_e2848 < 0f)); + let _e2853 = pow(select(_e2850, 1f, (_e2850 > 1f)), 5f); + let _e2854 = fma((max(_e2841, _e2827) - _e2827), _e2853, _e2827); + let _e2855 = fma((max(_e2841, _e2828) - _e2828), _e2853, _e2828); + let _e2856 = fma((max(_e2841, _e2829) - _e2829), _e2853, _e2829); + let _e2861 = fma(-(_e710.z), _e317.member_3, 1f); + let _e2878 = local_2; + let _e2882 = local_3; + let _e2886 = local_4; + phi_3125_ = vec4(fma(_e1416, _e317.member_1, fma(fma(((1f - _e2854) * _e2861), (_e1425.x * _e1394), (_e1757.x * fma(_e2854, _e1773.x, _e1773.y))), _e1410, _e2878.x)), fma(_e1418, _e317.member_1, fma(fma(((1f - _e2855) * _e2861), (_e1425.y * _e1396), (_e1757.y * fma(_e2855, _e1773.x, _e1773.y))), _e1410, _e2882.y)), fma(_e1420, _e317.member_1, fma(fma(((1f - _e2856) * _e2861), (_e1425.z * _e1398), (_e1757.z * fma(_e2856, _e1773.x, _e1773.y))), _e1410, _e2886.z)), 1f); + } else { + phi_3125_ = (vec4((_e121.x * _e516.x), (_e121.y * _e516.y), (_e121.z * _e516.z), (_e121.w * _e516.w)) * _e317.member_2); + } + let _e2894 = phi_3125_; + global_19 = _e2894; + break; + } + case 1: { + let _e1915 = sqrt(fma(_e122.x, _e122.x, (_e122.y * _e122.y))); + if (_e1915 == 0f) { + phi_5702_ = vec3(0f, 0f, 0f); + } else { + phi_5702_ = (vec3(_e122.x, _e122.y, 0f) * (1f / _e1915)); + } + let _e1920 = phi_5702_; + global_19 = vec4(((_e1920.x + 1f) * 0.5f), ((_e1920.y + 1f) * 0.5f), ((_e1920.z + 1f) * 0.5f), 1f); + break; + } + case 2: { + let _e1894 = sqrt(fma(_e123.x, _e123.x, (_e123.y * _e123.y))); + if (_e1894 == 0f) { + phi_5751_ = vec3(0f, 0f, 0f); + } else { + phi_5751_ = (vec3(_e123.x, _e123.y, 0f) * (1f / _e1894)); + } + let _e1899 = phi_5751_; + global_19 = vec4(((_e1899.x + 1f) * 0.5f), ((_e1899.y + 1f) * 0.5f), ((_e1899.z + 1f) * 0.5f), 1f); + break; + } + case 3: { + if _e1736 { + phi_5800_ = vec3(0f, 0f, 0f); + } else { + phi_5800_ = (_e1379 * (1f / _e1735)); + } + let _e1878 = phi_5800_; + global_19 = vec4(((_e1878.x + 1f) * 0.5f), ((_e1878.y + 1f) * 0.5f), ((_e1878.z + 1f) * 0.5f), 1f); + break; + } + case 4: { + global_19 = _e121; + break; + } + case 5: { + let _e1859 = sqrt(fma(_e124.z, _e124.z, fma(_e124.x, _e124.x, (_e124.y * _e124.y)))); + if (_e1859 == 0f) { + phi_5849_ = vec3(0f, 0f, 0f); + } else { + phi_5849_ = (_e124 * (1f / _e1859)); + } + let _e1864 = phi_5849_; + global_19 = vec4(((_e1864.x + 1f) * 0.5f), ((_e1864.y + 1f) * 0.5f), ((_e1864.z + 1f) * 0.5f), 1f); + break; + } + case 6: { + let _e1837 = sqrt(fma(_e1377.z, _e1377.z, fma(_e1377.x, _e1377.x, (_e1377.y * _e1377.y)))); + if (_e1837 == 0f) { + phi_5898_ = vec3(0f, 0f, 0f); + } else { + phi_5898_ = (_e1377 * (1f / _e1837)); + } + let _e1842 = phi_5898_; + global_19 = vec4(((_e1842.x + 1f) * 0.5f), ((_e1842.y + 1f) * 0.5f), ((_e1842.z + 1f) * 0.5f), 1f); + break; + } + case 7: { + let _e1815 = sqrt(fma(_e125.z, _e125.z, fma(_e125.x, _e125.x, (_e125.y * _e125.y)))); + if (_e1815 == 0f) { + phi_5947_ = vec3(0f, 0f, 0f); + } else { + phi_5947_ = (_e125 * (1f / _e1815)); + } + let _e1820 = phi_5947_; + global_19 = vec4(((_e1820.x + 1f) * 0.5f), ((_e1820.y + 1f) * 0.5f), ((_e1820.z + 1f) * 0.5f), 1f); + break; + } + case 8: { + let _e1793 = sqrt(fma(_e126.z, _e126.z, fma(_e126.x, _e126.x, (_e126.y * _e126.y)))); + if (_e1793 == 0f) { + phi_5996_ = vec3(0f, 0f, 0f); + } else { + phi_5996_ = (_e126 * (1f / _e1793)); + } + let _e1798 = phi_5996_; + global_19 = vec4(((_e1798.x + 1f) * 0.5f), ((_e1798.y + 1f) * 0.5f), ((_e1798.z + 1f) * 0.5f), 1f); + break; + } + case 9: { + global_19 = vec4(_e1425.x, _e1425.y, _e1425.z, 1f); + break; + } + case 10: { + global_19 = vec4(_e1757.x, _e1757.y, _e1757.z, 1f); + break; + } + case 11: { + global_19 = vec4(_e1773.x, _e1773.y, 1f, 1f); + break; + } + case 12: { + global_19 = (vec4(_e1383, _e1386, _e1389, (_e516.w * _e317.member_2.w)) * _e121); + break; + } + case 13: { + global_19 = vec4(_e1403, _e1403, _e1403, 1f); + break; + } + case 14: { + global_19 = vec4(_e1406, _e1406, _e1406, 1f); + break; + } + case 15: { + global_19 = vec4(_e1410, _e1410, _e1410, 1f); + break; + } + case 16: { + global_19 = vec4((_e1416 * _e317.member_1), (_e1418 * _e317.member_1), (_e1420 * _e317.member_1), 1f); + break; + } + case 17: { + global_19 = vec4(_e1292.x, _e1292.y, _e1292.z, 1f); + break; + } + case 18: { + global_19 = vec4(_e317.member.x, _e317.member.y, _e317.member.z, 1f); + break; + } + case 19: { + global_19 = vec4(_e317.member_1, _e317.member_1, _e317.member_1, 1f); + break; + } + default: { + break; + } + } + return; +} + +@fragment +fn stagerenderlet_fragment(@location(0) @interpolate(flat) param: u32, @location(1) @interpolate(flat) param_1: u32, @location(2) @interpolate(flat) param_2: u32, @location(3) param_3: vec4, @location(4) param_4: vec2, @location(5) param_5: vec2, @location(6) param_6: vec3, @location(7) param_7: vec3, @location(8) param_8: vec3, @location(9) param_9: vec3) -> @location(0) vec4 { + global_1 = param; + global_2 = param_1; + global_3 = param_2; + global_4 = param_3; + global_5 = param_4; + global_6 = param_5; + global_7 = param_6; + global_8 = param_7; + global_9 = param_8; + global_10 = param_9; + function(); + let _e21 = global_19; + return _e21; +} diff --git a/crates/renderling/shaders/stage-renderlet_vertex.spv b/crates/renderling/shaders/stage-renderlet_vertex.spv new file mode 100644 index 00000000..23ffd2d9 Binary files /dev/null and b/crates/renderling/shaders/stage-renderlet_vertex.spv differ diff --git a/crates/renderling/shaders/stage-renderlet_vertex.wgsl b/crates/renderling/shaders/stage-renderlet_vertex.wgsl new file mode 100644 index 00000000..a410eb01 --- /dev/null +++ b/crates/renderling/shaders/stage-renderlet_vertex.wgsl @@ -0,0 +1,1179 @@ +struct type_12 { + member: array, +} + +struct type_20 { + member: vec4, + member_1: vec4, + member_2: vec4, + member_3: vec4, +} + +struct type_21 { + member: array, 8>, + member_1: array, 6>, +} + +struct type_22 { + member: type_20, + member_1: type_20, + member_2: type_21, + member_3: vec3, +} + +struct type_24 { + member: u32, + member_1: u32, +} + +struct type_27 { + member: vec3, + member_1: vec4, + member_2: vec3, +} + +struct type_28 { + member: vec3, + member_1: vec3, + member_2: vec3, +} + +struct type_31 { + member: vec3, + member_1: vec4, + member_2: vec3, + member_3: vec4, + member_4: array, + member_5: array, + member_6: vec2, + member_7: vec2, +} + +struct type_34 { + member: type_24, + member_1: type_24, +} + +struct VertexOutput { + @location(0) @interpolate(flat) member: u32, + @location(1) @interpolate(flat) member_1: u32, + @location(2) @interpolate(flat) member_2: u32, + @location(3) member_3: vec4, + @location(4) member_4: vec2, + @location(5) member_5: vec2, + @location(6) member_6: vec3, + @location(7) member_7: vec3, + @location(8) member_8: vec3, + @location(9) member_9: vec3, + @builtin(position) member_10: vec4, +} + +var global: u32; +var global_1: vec4 = vec4(0f, 0f, 0f, 1f); +@group(0) @binding(0) +var global_2: type_12; +var global_3: u32; +var global_4: u32; +var global_5: u32; +var global_6: u32; +var global_7: vec4; +var global_8: vec2; +var global_9: vec2; +var global_10: type_20 = type_20(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)); +var global_11: vec3; +var global_12: vec3; +var global_13: vec3; +var global_14: vec3; + +fn function() { + var local: array; + var local_1: array; + var local_2: array, 8>; + var local_3: array, 6>; + var local_4: array; + var local_5: array; + var phi_741_: u32; + var phi_2842_: bool; + var phi_748_: u32; + var phi_749_: u32; + var phi_759_: u32; + var phi_841_: type_24; + var phi_842_: type_24; + var phi_857_: type_24; + var phi_870_: bool; + var phi_876_: type_24; + var phi_877_: type_24; + var phi_892_: type_24; + var phi_906_: bool; + var phi_912_: type_24; + var phi_915_: type_31; + var phi_913_: type_24; + var phi_930_: type_24; + var phi_947_: u32; + var phi_2872_: bool; + var phi_965_: type_24; + var phi_2898_: u32; + var phi_2917_: bool; + var phi_1015_: type_28; + var phi_1025_: u32; + var phi_2939_: bool; + var phi_1033_: f32; + var phi_916_: type_31; + var phi_1086_: bool; + var local_6: type_31; + var local_7: type_31; + var local_8: type_31; + var phi_2962_: bool; + var phi_1200_: type_34; + var local_9: type_31; + var phi_1203_: type_24; + var phi_1206_: type_20; + var phi_1204_: type_24; + var phi_1221_: type_24; + var local_10: type_31; + var phi_1245_: u32; + var phi_2996_: bool; + var phi_1254_: u32; + var phi_3020_: bool; + var phi_1303_: type_27; + var phi_1313_: u32; + var phi_3046_: bool; + var phi_1386_: type_20; + var phi_1207_: type_20; + var phi_1623_: bool; + var phi_3863_: bool; + var local_11: type_20; + var local_12: type_20; + var local_13: type_20; + var local_14: type_20; + var phi_1650_: bool; + var phi_1652_: bool; + var phi_1653_: bool; + var phi_1654_: bool; + var phi_1655_: bool; + var local_15: type_20; + var local_16: type_20; + var local_17: type_20; + var local_18: type_20; + var phi_1689_: bool; + var phi_1691_: bool; + var phi_1692_: bool; + var phi_1693_: bool; + var phi_1694_: bool; + var local_19: type_20; + var local_20: type_20; + var local_21: type_20; + var local_22: type_20; + var phi_1728_: bool; + var phi_1730_: bool; + var phi_1731_: bool; + var phi_1732_: bool; + var phi_1733_: bool; + var local_23: type_20; + var local_24: type_20; + var local_25: type_20; + var local_26: type_20; + var phi_1767_: bool; + var phi_1769_: bool; + var phi_1770_: bool; + var phi_1771_: bool; + var phi_1772_: bool; + var phi_1777_: bool; + var phi_1779_: bool; + var phi_1780_: bool; + var phi_1781_: bool; + var phi_1782_: bool; + var phi_1790_: type_20; + var phi_3183_: bool; + var phi_3246_: vec4; + var phi_3276_: vec4; + var phi_3278_: vec4; + var phi_3289_: type_27; + var phi_3290_: type_27; + var phi_3293_: type_27; + var phi_3294_: type_27; + var phi_3295_: bool; + var phi_3299_: type_27; + var phi_1792_: type_27; + var phi_1794_: type_27; + var phi_1795_: bool; + var phi_3393_: bool; + var phi_1848_: type_27; + var phi_1849_: type_27; + var local_27: type_31; + var phi_1893_: vec3; + var local_28: type_31; + var phi_3438_: vec3; + var phi_3520_: vec3; + var phi_3555_: vec3; + var local_29: type_31; + var local_30: type_31; + var phi_3568_: bool; + var phi_2217_: type_24; + var phi_2218_: type_24; + var phi_2233_: type_24; + var phi_2260_: bool; + var phi_2266_: type_24; + var phi_2267_: type_24; + var phi_2282_: type_24; + var phi_2305_: bool; + var phi_2313_: type_22; + var local_31: type_20; + + switch bitcast(0u) { + default: { + 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_749_ = _e98; + } else { + if (_e98 >= _e120) { + phi_741_ = 4294967295u; + } else { + phi_741_ = (_e116 + _e98); + } + let _e161 = phi_741_; + if (_e100 >= 1u) { + phi_2842_ = (_e161 <= (_e100 - 1u)); + } else { + phi_2842_ = false; + } + let _e166 = phi_2842_; + if _e166 { + let _e169 = global_2.member[_e161]; + phi_748_ = _e169; + } else { + phi_748_ = 0u; + } + let _e171 = phi_748_; + phi_749_ = _e171; + } + let _e173 = phi_749_; + if (_e173 >= _e112) { + phi_759_ = 4294967295u; + } else { + phi_759_ = (_e108 + (26u * _e173)); + } + let _e178 = phi_759_; + 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_841_ = type_24(0u, 4u); + loop { + let _e276 = phi_841_; + if (_e276.member < _e276.member_1) { + phi_842_ = type_24((_e276.member + 1u), _e276.member_1); + phi_857_ = type_24(1u, _e276.member); + } else { + phi_842_ = _e276; + phi_857_ = type_24(0u, type_24().member_1); + } + let _e289 = phi_842_; + let _e291 = phi_857_; + switch bitcast(_e291.member) { + case 0: { + phi_870_ = false; + break; + } + case 1: { + let _e298 = global_2.member[((_e178 + 18u) + _e291.member_1)]; + local_5[_e291.member_1] = _e298; + phi_870_ = true; + break; + } + default: { + phi_870_ = bool(); + break; + } + } + let _e301 = phi_870_; + continue; + continuing { + phi_841_ = _e289; + break if !(_e301); + } + } + let _e303 = local_5; + local_4 = array(0f, 0f, 0f, 0f); + phi_876_ = type_24(0u, 4u); + loop { + let _e306 = phi_876_; + if (_e306.member < _e306.member_1) { + phi_877_ = type_24((_e306.member + 1u), _e306.member_1); + phi_892_ = type_24(1u, _e306.member); + } else { + phi_877_ = _e306; + phi_892_ = type_24(0u, type_24().member_1); + } + let _e319 = phi_877_; + let _e321 = phi_892_; + switch bitcast(_e321.member) { + case 0: { + phi_906_ = false; + break; + } + case 1: { + let _e328 = global_2.member[((_e178 + 22u) + _e321.member_1)]; + local_4[_e321.member_1] = bitcast(_e328); + phi_906_ = true; + break; + } + default: { + phi_906_ = bool(); + break; + } + } + let _e332 = phi_906_; + continue; + continuing { + phi_876_ = _e319; + break if !(_e332); + } + } + let _e334 = local_4; + phi_912_ = type_24(0u, _e144); + phi_915_ = 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)), _e303, _e334, vec2(bitcast(_e218), bitcast(_e223)), vec2(bitcast(_e229), bitcast(_e234))); + loop { + let _e338 = phi_912_; + let _e340 = phi_915_; + local_6 = _e340; + local_7 = _e340; + local_8 = _e340; + local_9 = _e340; + local_10 = _e340; + local_27 = _e340; + local_28 = _e340; + local_29 = _e340; + local_30 = _e340; + if (_e338.member < _e338.member_1) { + phi_913_ = type_24((_e338.member + 1u), _e338.member_1); + phi_930_ = type_24(1u, _e338.member); + } else { + phi_913_ = _e338; + phi_930_ = type_24(0u, type_24().member_1); + } + let _e353 = phi_913_; + let _e355 = phi_930_; + switch bitcast(_e355.member) { + case 0: { + phi_916_ = type_31(); + phi_1086_ = false; + break; + } + case 1: { + if (_e355.member_1 >= _e144) { + phi_947_ = 4294967295u; + } else { + phi_947_ = (_e140 + (2u * _e355.member_1)); + } + let _e363 = phi_947_; + if (_e100 >= 2u) { + phi_2872_ = (_e363 <= (_e100 - 2u)); + } else { + phi_2872_ = false; + } + let _e368 = phi_2872_; + if _e368 { + let _e371 = global_2.member[_e363]; + let _e375 = global_2.member[(_e363 + 1u)]; + phi_965_ = type_24(_e371, _e375); + } else { + phi_965_ = type_24(4294967295u, 0u); + } + let _e378 = phi_965_; + if (_e173 >= _e378.member_1) { + phi_2898_ = 4294967295u; + } else { + phi_2898_ = (_e378.member + (9u * _e173)); + } + let _e385 = phi_2898_; + if (_e100 >= 9u) { + phi_2917_ = (_e385 <= (_e100 - 9u)); + } else { + phi_2917_ = false; + } + let _e390 = phi_2917_; + if _e390 { + let _e393 = global_2.member[_e385]; + let _e398 = global_2.member[(_e385 + 1u)]; + let _e403 = global_2.member[(_e385 + 2u)]; + let _e409 = global_2.member[(_e385 + 3u)]; + let _e414 = global_2.member[(_e385 + 4u)]; + let _e419 = global_2.member[(_e385 + 5u)]; + let _e425 = global_2.member[(_e385 + 6u)]; + let _e430 = global_2.member[(_e385 + 7u)]; + let _e435 = global_2.member[(_e385 + 8u)]; + phi_1015_ = type_28(vec3(bitcast(_e393), bitcast(_e398), bitcast(_e403)), vec3(bitcast(_e409), bitcast(_e414), bitcast(_e419)), vec3(bitcast(_e425), bitcast(_e430), bitcast(_e435))); + } else { + phi_1015_ = type_28(vec3(0f, 0f, 0f), vec3(0f, 0f, 0f), vec3(0f, 0f, 0f)); + } + let _e440 = phi_1015_; + if (_e355.member_1 >= _e152) { + phi_1025_ = 4294967295u; + } else { + phi_1025_ = (_e148 + _e355.member_1); + } + let _e444 = phi_1025_; + if (_e100 >= 1u) { + phi_2939_ = (_e444 <= (_e100 - 1u)); + } else { + phi_2939_ = false; + } + let _e449 = phi_2939_; + if _e449 { + let _e452 = global_2.member[_e444]; + phi_1033_ = bitcast(_e452); + } else { + phi_1033_ = 0f; + } + let _e455 = phi_1033_; + let _e478 = type_31(vec3(fma(_e455, _e440.member.x, _e340.member.x), fma(_e455, _e440.member.y, _e340.member.y), fma(_e455, _e440.member.z, _e340.member.z)), _e340.member_1, _e340.member_2, _e340.member_3, _e340.member_4, _e340.member_5, _e340.member_6, _e340.member_7); + let _e501 = type_31(_e478.member, _e478.member_1, vec3(fma(_e455, _e440.member_1.x, _e340.member_2.x), fma(_e455, _e440.member_1.y, _e340.member_2.y), fma(_e455, _e440.member_1.z, _e340.member_2.z)), _e478.member_3, _e478.member_4, _e478.member_5, _e478.member_6, _e478.member_7); + phi_916_ = type_31(_e501.member, _e501.member_1, _e501.member_2, vec4(fma(_e455, _e440.member_2.x, _e340.member_3.x), fma(_e455, _e440.member_2.y, _e340.member_3.y), fma(_e455, _e440.member_2.z, _e340.member_3.z), _e340.member_3.w), _e501.member_4, _e501.member_5, _e501.member_6, _e501.member_7); + phi_1086_ = true; + break; + } + default: { + phi_916_ = type_31(); + phi_1086_ = bool(); + break; + } + } + let _e528 = phi_916_; + let _e530 = phi_1086_; + continue; + continuing { + phi_912_ = _e353; + phi_915_ = _e528; + break if !(_e530); + } + } + let _e533 = local_6; + global_7 = _e533.member_1; + let _e536 = local_7; + global_8 = _e536.member_6; + let _e539 = local_8; + global_9 = _e539.member_7; + let _e544 = global_2.member[(_e156 + 6u)]; + if (_e544 == 1u) { + let _e547 = ((_e136 == 4294967295u) != true); + if _e547 { + if (_e100 >= 4u) { + phi_2962_ = (_e136 <= (_e100 - 4u)); + } else { + phi_2962_ = false; + } + let _e552 = phi_2962_; + if _e552 { + let _e555 = global_2.member[_e136]; + let _e559 = global_2.member[(_e136 + 1u)]; + let _e563 = global_2.member[(_e136 + 2u)]; + let _e567 = global_2.member[(_e136 + 3u)]; + phi_1200_ = type_34(type_24(_e555, _e559), type_24(_e563, _e567)); + } else { + phi_1200_ = type_34(type_24(4294967295u, 0u), type_24(4294967295u, 0u)); + } + let _e572 = phi_1200_; + let _e574 = local_9; + local = _e574.member_5; + phi_1203_ = type_24(0u, 4u); + phi_1206_ = type_20(vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f), vec4(0f, 0f, 0f, 0f)); + loop { + let _e577 = phi_1203_; + let _e579 = phi_1206_; + local_11 = _e579; + local_12 = _e579; + local_13 = _e579; + local_14 = _e579; + local_15 = _e579; + local_16 = _e579; + local_17 = _e579; + local_18 = _e579; + local_19 = _e579; + local_20 = _e579; + local_21 = _e579; + local_22 = _e579; + local_23 = _e579; + local_24 = _e579; + local_25 = _e579; + local_26 = _e579; + local_31 = _e579; + if (_e577.member < _e577.member_1) { + phi_1204_ = type_24((_e577.member + 1u), _e577.member_1); + phi_1221_ = type_24(1u, _e577.member); + } else { + phi_1204_ = _e577; + phi_1221_ = type_24(0u, type_24().member_1); + } + let _e592 = phi_1204_; + let _e594 = phi_1221_; + switch bitcast(_e594.member) { + case 0: { + phi_1207_ = type_20(); + phi_1623_ = false; + break; + } + case 1: { + let _e599 = local_10; + local_1 = _e599.member_4; + let _e601 = (_e594.member_1 < 4u); + if _e601 { + } else { + phi_3863_ = true; + break; + } + let _e603 = local_1[_e594.member_1]; + if (_e603 >= _e572.member.member_1) { + phi_1245_ = 4294967295u; + } else { + phi_1245_ = (_e572.member.member + _e603); + } + let _e611 = phi_1245_; + if (_e100 >= 1u) { + phi_2996_ = (_e611 <= (_e100 - 1u)); + } else { + phi_2996_ = false; + } + let _e616 = phi_2996_; + if _e616 { + let _e619 = global_2.member[_e611]; + phi_1254_ = _e619; + } else { + phi_1254_ = 4294967295u; + } + let _e621 = phi_1254_; + if (_e100 >= 10u) { + phi_3020_ = (_e621 <= (_e100 - 10u)); + } else { + phi_3020_ = false; + } + let _e626 = phi_3020_; + if _e626 { + let _e629 = global_2.member[_e621]; + let _e634 = global_2.member[(_e621 + 1u)]; + let _e639 = global_2.member[(_e621 + 2u)]; + let _e645 = global_2.member[(_e621 + 3u)]; + let _e650 = global_2.member[(_e621 + 4u)]; + let _e655 = global_2.member[(_e621 + 5u)]; + let _e660 = global_2.member[(_e621 + 6u)]; + let _e666 = global_2.member[(_e621 + 7u)]; + let _e671 = global_2.member[(_e621 + 8u)]; + let _e676 = global_2.member[(_e621 + 9u)]; + phi_1303_ = type_27(vec3(bitcast(_e629), bitcast(_e634), bitcast(_e639)), vec4(bitcast(_e645), bitcast(_e650), bitcast(_e655), bitcast(_e660)), vec3(bitcast(_e666), bitcast(_e671), bitcast(_e676))); + } else { + phi_1303_ = type_27(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e681 = phi_1303_; + if (_e603 >= _e572.member_1.member_1) { + phi_1313_ = 4294967295u; + } else { + phi_1313_ = (_e572.member_1.member + (16u * _e603)); + } + let _e690 = phi_1313_; + if (_e100 >= 16u) { + phi_3046_ = (_e690 <= (_e100 - 16u)); + } else { + phi_3046_ = false; + } + let _e695 = phi_3046_; + if _e695 { + let _e698 = global_2.member[_e690]; + let _e703 = global_2.member[(_e690 + 1u)]; + let _e708 = global_2.member[(_e690 + 2u)]; + let _e713 = global_2.member[(_e690 + 3u)]; + let _e719 = global_2.member[(_e690 + 4u)]; + let _e724 = global_2.member[(_e690 + 5u)]; + let _e729 = global_2.member[(_e690 + 6u)]; + let _e734 = global_2.member[(_e690 + 7u)]; + let _e740 = global_2.member[(_e690 + 8u)]; + let _e745 = global_2.member[(_e690 + 9u)]; + let _e750 = global_2.member[(_e690 + 10u)]; + let _e755 = global_2.member[(_e690 + 11u)]; + let _e761 = global_2.member[(_e690 + 12u)]; + let _e766 = global_2.member[(_e690 + 13u)]; + let _e771 = global_2.member[(_e690 + 14u)]; + let _e776 = global_2.member[(_e690 + 15u)]; + phi_1386_ = type_20(vec4(bitcast(_e698), bitcast(_e703), bitcast(_e708), bitcast(_e713)), vec4(bitcast(_e719), bitcast(_e724), bitcast(_e729), bitcast(_e734)), vec4(bitcast(_e740), bitcast(_e745), bitcast(_e750), bitcast(_e755)), vec4(bitcast(_e761), bitcast(_e766), bitcast(_e771), bitcast(_e776))); + } else { + phi_1386_ = type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)); + } + let _e781 = phi_1386_; + let _e789 = (_e681.member_1.x + _e681.member_1.x); + let _e790 = (_e681.member_1.y + _e681.member_1.y); + let _e791 = (_e681.member_1.z + _e681.member_1.z); + let _e793 = (_e681.member_1.z * _e791); + let _e794 = (_e681.member_1.w * _e789); + let _e795 = (_e681.member_1.w * _e790); + let _e796 = (_e681.member_1.w * _e791); + let _e816 = (vec4((1f - fma(_e681.member_1.y, _e790, _e793)), fma(_e681.member_1.x, _e790, _e796), fma(_e681.member_1.x, _e791, -(_e795)), 0f) * _e681.member_2.x); + let _e818 = (vec4(fma(_e681.member_1.x, _e790, -(_e796)), (1f - fma(_e681.member_1.x, _e789, _e793)), fma(_e681.member_1.y, _e791, _e794), 0f) * _e681.member_2.y); + let _e820 = (vec4(fma(_e681.member_1.x, _e791, _e795), fma(_e681.member_1.y, _e791, -(_e794)), (1f - fma(_e681.member_1.x, _e789, (_e681.member_1.y * _e790))), 0f) * _e681.member_2.z); + if _e601 { + } else { + phi_3863_ = true; + break; + } + let _e925 = local[_e594.member_1]; + phi_1207_ = type_20((_e579.member + (vec4(fma(_e681.member.x, _e781.member.w, fma(_e820.x, _e781.member.z, fma(_e816.x, _e781.member.x, (_e818.x * _e781.member.y)))), fma(_e681.member.y, _e781.member.w, fma(_e820.y, _e781.member.z, fma(_e816.y, _e781.member.x, (_e818.y * _e781.member.y)))), fma(_e681.member.z, _e781.member.w, fma(_e820.z, _e781.member.z, fma(_e816.z, _e781.member.x, (_e818.z * _e781.member.y)))), (fma(_e820.w, _e781.member.z, fma(_e816.w, _e781.member.x, (_e818.w * _e781.member.y))) + _e781.member.w)) * _e925)), (_e579.member_1 + (vec4(fma(_e681.member.x, _e781.member_1.w, fma(_e820.x, _e781.member_1.z, fma(_e816.x, _e781.member_1.x, (_e818.x * _e781.member_1.y)))), fma(_e681.member.y, _e781.member_1.w, fma(_e820.y, _e781.member_1.z, fma(_e816.y, _e781.member_1.x, (_e818.y * _e781.member_1.y)))), fma(_e681.member.z, _e781.member_1.w, fma(_e820.z, _e781.member_1.z, fma(_e816.z, _e781.member_1.x, (_e818.z * _e781.member_1.y)))), (fma(_e820.w, _e781.member_1.z, fma(_e816.w, _e781.member_1.x, (_e818.w * _e781.member_1.y))) + _e781.member_1.w)) * _e925)), (_e579.member_2 + (vec4(fma(_e681.member.x, _e781.member_2.w, fma(_e820.x, _e781.member_2.z, fma(_e816.x, _e781.member_2.x, (_e818.x * _e781.member_2.y)))), fma(_e681.member.y, _e781.member_2.w, fma(_e820.y, _e781.member_2.z, fma(_e816.y, _e781.member_2.x, (_e818.y * _e781.member_2.y)))), fma(_e681.member.z, _e781.member_2.w, fma(_e820.z, _e781.member_2.z, fma(_e816.z, _e781.member_2.x, (_e818.z * _e781.member_2.y)))), (fma(_e820.w, _e781.member_2.z, fma(_e816.w, _e781.member_2.x, (_e818.w * _e781.member_2.y))) + _e781.member_2.w)) * _e925)), (_e579.member_3 + (vec4(fma(_e681.member.x, _e781.member_3.w, fma(_e820.x, _e781.member_3.z, fma(_e816.x, _e781.member_3.x, (_e818.x * _e781.member_3.y)))), fma(_e681.member.y, _e781.member_3.w, fma(_e820.y, _e781.member_3.z, fma(_e816.y, _e781.member_3.x, (_e818.y * _e781.member_3.y)))), fma(_e681.member.z, _e781.member_3.w, fma(_e820.z, _e781.member_3.z, fma(_e816.z, _e781.member_3.x, (_e818.z * _e781.member_3.y)))), (fma(_e820.w, _e781.member_3.z, fma(_e816.w, _e781.member_3.x, (_e818.w * _e781.member_3.y))) + _e781.member_3.w)) * _e925))); + phi_1623_ = true; + break; + } + default: { + phi_1207_ = type_20(); + phi_1623_ = bool(); + break; + } + } + let _e940 = phi_1207_; + let _e942 = phi_1623_; + continue; + continuing { + phi_1203_ = _e592; + phi_1206_ = _e940; + phi_3863_ = false; + break if !(_e942); + } + } + let _e945 = phi_3863_; + if _e945 { + break; + } + let _e947 = local_11; + let _e952 = global_10.member[0u]; + if (_e947.member.x == _e952) { + let _e955 = local_12; + let _e960 = global_10.member[1u]; + if (_e955.member.y == _e960) { + let _e963 = local_13; + let _e968 = global_10.member[2u]; + let _e969 = (_e963.member.z == _e968); + if _e969 { + let _e971 = local_14; + let _e976 = global_10.member[3u]; + phi_1650_ = (_e971.member.w == _e976); + } else { + phi_1650_ = bool(); + } + let _e979 = phi_1650_; + phi_1652_ = _e979; + phi_1653_ = select(true, false, _e969); + } else { + phi_1652_ = bool(); + phi_1653_ = true; + } + let _e982 = phi_1652_; + let _e984 = phi_1653_; + phi_1654_ = _e982; + phi_1655_ = _e984; + } else { + phi_1654_ = bool(); + phi_1655_ = true; + } + let _e986 = phi_1654_; + let _e988 = phi_1655_; + if select(_e986, false, _e988) { + let _e991 = local_15; + let _e996 = global_10.member_1[0u]; + if (_e991.member_1.x == _e996) { + let _e999 = local_16; + let _e1004 = global_10.member_1[1u]; + if (_e999.member_1.y == _e1004) { + let _e1007 = local_17; + let _e1012 = global_10.member_1[2u]; + let _e1013 = (_e1007.member_1.z == _e1012); + if _e1013 { + let _e1015 = local_18; + let _e1020 = global_10.member_1[3u]; + phi_1689_ = (_e1015.member_1.w == _e1020); + } else { + phi_1689_ = bool(); + } + let _e1023 = phi_1689_; + phi_1691_ = _e1023; + phi_1692_ = select(true, false, _e1013); + } else { + phi_1691_ = bool(); + phi_1692_ = true; + } + let _e1026 = phi_1691_; + let _e1028 = phi_1692_; + phi_1693_ = _e1026; + phi_1694_ = _e1028; + } else { + phi_1693_ = bool(); + phi_1694_ = true; + } + let _e1030 = phi_1693_; + let _e1032 = phi_1694_; + if select(_e1030, false, _e1032) { + let _e1035 = local_19; + let _e1040 = global_10.member_2[0u]; + if (_e1035.member_2.x == _e1040) { + let _e1043 = local_20; + let _e1048 = global_10.member_2[1u]; + if (_e1043.member_2.y == _e1048) { + let _e1051 = local_21; + let _e1056 = global_10.member_2[2u]; + let _e1057 = (_e1051.member_2.z == _e1056); + if _e1057 { + let _e1059 = local_22; + let _e1064 = global_10.member_2[3u]; + phi_1728_ = (_e1059.member_2.w == _e1064); + } else { + phi_1728_ = bool(); + } + let _e1067 = phi_1728_; + phi_1730_ = _e1067; + phi_1731_ = select(true, false, _e1057); + } else { + phi_1730_ = bool(); + phi_1731_ = true; + } + let _e1070 = phi_1730_; + let _e1072 = phi_1731_; + phi_1732_ = _e1070; + phi_1733_ = _e1072; + } else { + phi_1732_ = bool(); + phi_1733_ = true; + } + let _e1074 = phi_1732_; + let _e1076 = phi_1733_; + let _e1077 = select(_e1074, false, _e1076); + if _e1077 { + let _e1079 = local_23; + let _e1084 = global_10.member_3[0u]; + if (_e1079.member_3.x == _e1084) { + let _e1087 = local_24; + let _e1092 = global_10.member_3[1u]; + if (_e1087.member_3.y == _e1092) { + let _e1095 = local_25; + let _e1100 = global_10.member_3[2u]; + let _e1101 = (_e1095.member_3.z == _e1100); + if _e1101 { + let _e1103 = local_26; + let _e1108 = global_10.member_3[3u]; + phi_1767_ = (_e1103.member_3.w == _e1108); + } else { + phi_1767_ = bool(); + } + let _e1111 = phi_1767_; + phi_1769_ = _e1111; + phi_1770_ = select(true, false, _e1101); + } else { + phi_1769_ = bool(); + phi_1770_ = true; + } + let _e1114 = phi_1769_; + let _e1116 = phi_1770_; + phi_1771_ = _e1114; + phi_1772_ = _e1116; + } else { + phi_1771_ = bool(); + phi_1772_ = true; + } + let _e1118 = phi_1771_; + let _e1120 = phi_1772_; + phi_1777_ = select(_e1118, false, _e1120); + } else { + phi_1777_ = bool(); + } + let _e1123 = phi_1777_; + phi_1779_ = _e1123; + phi_1780_ = select(true, false, _e1077); + } else { + phi_1779_ = bool(); + phi_1780_ = true; + } + let _e1126 = phi_1779_; + let _e1128 = phi_1780_; + phi_1781_ = _e1126; + phi_1782_ = _e1128; + } else { + phi_1781_ = bool(); + phi_1782_ = true; + } + let _e1130 = phi_1781_; + let _e1132 = phi_1782_; + if select(_e1130, false, _e1132) { + phi_1790_ = type_20(vec4(1f, 0f, 0f, 0f), vec4(0f, 1f, 0f, 0f), vec4(0f, 0f, 1f, 0f), vec4(0f, 0f, 0f, 1f)); + } else { + let _e2062 = local_31; + phi_1790_ = _e2062; + } + let _e1135 = phi_1790_; + let _e1158 = fma(_e1135.member_2.z, _e1135.member_3.w, -((_e1135.member_2.w * _e1135.member_3.z))); + let _e1161 = fma(_e1135.member_2.y, _e1135.member_3.w, -((_e1135.member_2.w * _e1135.member_3.y))); + let _e1164 = fma(_e1135.member_2.y, _e1135.member_3.z, -((_e1135.member_2.z * _e1135.member_3.y))); + let _e1167 = fma(_e1135.member_2.x, _e1135.member_3.w, -((_e1135.member_2.w * _e1135.member_3.x))); + let _e1170 = fma(_e1135.member_2.x, _e1135.member_3.z, -((_e1135.member_2.z * _e1135.member_3.x))); + let _e1173 = fma(_e1135.member_2.x, _e1135.member_3.y, -((_e1135.member_2.y * _e1135.member_3.x))); + let _e1195 = fma(-(_e1135.member.w), fma(_e1135.member_1.z, _e1173, fma(_e1135.member_1.x, _e1164, -((_e1135.member_1.y * _e1170)))), fma(_e1135.member.z, fma(_e1135.member_1.w, _e1173, fma(_e1135.member_1.x, _e1161, -((_e1135.member_1.y * _e1167)))), fma(_e1135.member.x, fma(_e1135.member_1.w, _e1164, fma(_e1135.member_1.y, _e1158, -((_e1135.member_1.z * _e1161)))), -((_e1135.member.y * fma(_e1135.member_1.w, _e1170, fma(_e1135.member_1.x, _e1158, -((_e1135.member_1.z * _e1167))))))))); + if (_e1195 == 0f) { + phi_3293_ = type_27(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); + phi_3294_ = type_27(); + phi_3295_ = true; + } else { + let _e1204 = (sqrt(fma(_e1135.member.w, _e1135.member.w, fma(_e1135.member.z, _e1135.member.z, fma(_e1135.member.x, _e1135.member.x, (_e1135.member.y * _e1135.member.y))))) * select(-1f, 1f, (_e1195 >= 0f))); + let _e1209 = sqrt(fma(_e1135.member_1.w, _e1135.member_1.w, fma(_e1135.member_1.z, _e1135.member_1.z, fma(_e1135.member_1.x, _e1135.member_1.x, (_e1135.member_1.y * _e1135.member_1.y))))); + let _e1214 = sqrt(fma(_e1135.member_2.w, _e1135.member_2.w, fma(_e1135.member_2.z, _e1135.member_2.z, fma(_e1135.member_2.x, _e1135.member_2.x, (_e1135.member_2.y * _e1135.member_2.y))))); + if (_e1204 != 0f) { + phi_3183_ = select(true, false, (_e1209 != 0f)); + } else { + phi_3183_ = true; + } + let _e1221 = phi_3183_; + let _e1222 = select((_e1214 != 0f), false, _e1221); + if _e1222 { + let _e1223 = (1f / _e1204); + let _e1224 = (1f / _e1209); + let _e1225 = (1f / _e1214); + let _e1226 = (_e1135.member.x * _e1223); + let _e1227 = (_e1135.member.z * _e1223); + let _e1228 = (_e1135.member_1.x * _e1224); + let _e1229 = (_e1135.member_2.x * _e1225); + let _e1230 = (_e1135.member_2.y * _e1225); + if ((_e1135.member_2.z * _e1225) <= 0f) { + let _e1234 = fma(_e1135.member_1.y, _e1224, -(_e1226)); + let _e1236 = fma(-(_e1135.member_2.z), _e1225, 1f); + if (_e1234 <= 0f) { + let _e1238 = (_e1236 - _e1234); + let _e1240 = (0.5f / sqrt(_e1238)); + phi_3246_ = vec4((_e1238 * _e1240), (fma(_e1135.member.y, _e1223, _e1228) * _e1240), (fma(_e1135.member.z, _e1223, _e1229) * _e1240), (fma(_e1135.member_1.z, _e1224, -(_e1230)) * _e1240)); + } else { + let _e1250 = (_e1236 + _e1234); + let _e1252 = (0.5f / sqrt(_e1250)); + phi_3246_ = vec4((fma(_e1135.member.y, _e1223, _e1228) * _e1252), (_e1250 * _e1252), (fma(_e1135.member_1.z, _e1224, _e1230) * _e1252), (fma(_e1135.member_2.x, _e1225, -(_e1227)) * _e1252)); + } + let _e1263 = phi_3246_; + phi_3278_ = _e1263; + } else { + let _e1264 = fma(_e1135.member_1.y, _e1224, _e1226); + let _e1265 = fma(_e1135.member_2.z, _e1225, 1f); + if (_e1264 <= 0f) { + let _e1267 = (_e1265 - _e1264); + let _e1269 = (0.5f / sqrt(_e1267)); + phi_3276_ = vec4((fma(_e1135.member.z, _e1223, _e1229) * _e1269), (fma(_e1135.member_1.z, _e1224, _e1230) * _e1269), (_e1267 * _e1269), (fma(_e1135.member.y, _e1223, -(_e1228)) * _e1269)); + } else { + let _e1279 = (_e1265 + _e1264); + let _e1281 = (0.5f / sqrt(_e1279)); + phi_3276_ = vec4((fma(_e1135.member_1.z, _e1224, -(_e1230)) * _e1281), (fma(_e1135.member_2.x, _e1225, -(_e1227)) * _e1281), (fma(_e1135.member.y, _e1223, -(_e1228)) * _e1281), (_e1279 * _e1281)); + } + let _e1294 = phi_3276_; + phi_3278_ = _e1294; + } + let _e1296 = phi_3278_; + phi_3289_ = type_27(vec3(_e1204, _e1209, _e1214), _e1296, vec3(_e1135.member_3.x, _e1135.member_3.y, _e1135.member_3.z)); + phi_3290_ = type_27(); + } else { + phi_3289_ = type_27(); + phi_3290_ = type_27(vec3(1f, 1f, 1f), vec4(0f, 0f, 0f, 1f), vec3(0f, 0f, 0f)); + } + let _e1300 = phi_3289_; + let _e1302 = phi_3290_; + phi_3293_ = _e1302; + phi_3294_ = _e1300; + phi_3295_ = select(true, false, _e1222); + } + let _e1305 = phi_3293_; + let _e1307 = phi_3294_; + let _e1309 = phi_3295_; + if _e1309 { + phi_3299_ = _e1305; + } else { + phi_3299_ = _e1307; + } + let _e1311 = phi_3299_; + phi_1792_ = type_27(_e1311.member_2, _e1311.member_1, _e1311.member); + } else { + phi_1792_ = type_27(); + } + let _e1317 = phi_1792_; + phi_1794_ = _e1317; + phi_1795_ = select(true, false, _e547); + } else { + phi_1794_ = type_27(); + phi_1795_ = true; + } + let _e1320 = phi_1794_; + let _e1322 = phi_1795_; + if _e1322 { + if (_e100 >= 10u) { + phi_3393_ = (_e128 <= (_e100 - 10u)); + } else { + phi_3393_ = false; + } + let _e1327 = phi_3393_; + if _e1327 { + let _e1330 = global_2.member[_e128]; + let _e1335 = global_2.member[(_e128 + 1u)]; + let _e1340 = global_2.member[(_e128 + 2u)]; + let _e1346 = global_2.member[(_e128 + 3u)]; + let _e1351 = global_2.member[(_e128 + 4u)]; + let _e1356 = global_2.member[(_e128 + 5u)]; + let _e1361 = global_2.member[(_e128 + 6u)]; + let _e1367 = global_2.member[(_e128 + 7u)]; + let _e1372 = global_2.member[(_e128 + 8u)]; + let _e1377 = global_2.member[(_e128 + 9u)]; + phi_1848_ = type_27(vec3(bitcast(_e1330), bitcast(_e1335), bitcast(_e1340)), vec4(bitcast(_e1346), bitcast(_e1351), bitcast(_e1356), bitcast(_e1361)), vec3(bitcast(_e1367), bitcast(_e1372), bitcast(_e1377))); + } else { + phi_1848_ = type_27(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e1382 = phi_1848_; + phi_1849_ = _e1382; + } else { + phi_1849_ = _e1320; + } + let _e1384 = phi_1849_; + let _e1393 = local_27; + let _e1401 = sqrt(fma(_e1393.member_2.z, _e1393.member_2.z, fma(_e1393.member_2.x, _e1393.member_2.x, (_e1393.member_2.y * _e1393.member_2.y)))); + if (_e1401 == 0f) { + phi_1893_ = vec3(0f, 0f, 0f); + } else { + phi_1893_ = (_e1393.member_2 * (1f / _e1401)); + } + let _e1406 = phi_1893_; + let _e1408 = local_28; + let _e1417 = sqrt(fma(_e1408.member_3.z, _e1408.member_3.z, fma(_e1408.member_3.x, _e1408.member_3.x, (_e1408.member_3.y * _e1408.member_3.y)))); + if (_e1417 == 0f) { + phi_3438_ = vec3(0f, 0f, 0f); + } else { + phi_3438_ = (vec3(_e1408.member_3.x, _e1408.member_3.y, _e1408.member_3.z) * (1f / _e1417)); + } + let _e1422 = phi_3438_; + let _e1429 = (_e1384.member_1.x + _e1384.member_1.x); + let _e1430 = (_e1384.member_1.y + _e1384.member_1.y); + let _e1431 = (_e1384.member_1.z + _e1384.member_1.z); + let _e1433 = (_e1384.member_1.z * _e1431); + let _e1434 = (_e1384.member_1.w * _e1429); + let _e1435 = (_e1384.member_1.w * _e1430); + let _e1436 = (_e1384.member_1.w * _e1431); + let _e1455 = (vec4((1f - fma(_e1384.member_1.y, _e1430, _e1433)), fma(_e1384.member_1.x, _e1430, _e1436), fma(_e1384.member_1.x, _e1431, -(_e1435)), 0f) * _e1384.member_2.x); + let _e1456 = (vec4(fma(_e1384.member_1.x, _e1430, -(_e1436)), (1f - fma(_e1384.member_1.x, _e1429, _e1433)), fma(_e1384.member_1.y, _e1431, _e1434), 0f) * _e1384.member_2.y); + let _e1457 = (vec4(fma(_e1384.member_1.x, _e1431, _e1435), fma(_e1384.member_1.y, _e1431, -(_e1434)), (1f - fma(_e1384.member_1.x, _e1429, (_e1384.member_1.y * _e1430))), 0f) * _e1384.member_2.z); + let _e1462 = (_e1406.x / (_e1384.member_2.x * _e1384.member_2.x)); + let _e1464 = (_e1406.y / (_e1384.member_2.y * _e1384.member_2.y)); + let _e1466 = (_e1406.z / (_e1384.member_2.z * _e1384.member_2.z)); + let _e1482 = fma(_e1457.x, _e1466, fma(_e1455.x, _e1462, (_e1456.x * _e1464))); + let _e1483 = fma(_e1457.y, _e1466, fma(_e1455.y, _e1462, (_e1456.y * _e1464))); + let _e1484 = fma(_e1457.z, _e1466, fma(_e1455.z, _e1462, (_e1456.z * _e1464))); + let _e1489 = sqrt(fma(_e1484, _e1484, fma(_e1482, _e1482, (_e1483 * _e1483)))); + if (_e1489 == 0f) { + phi_3520_ = vec3(0f, 0f, 0f); + } else { + phi_3520_ = (vec3(_e1482, _e1483, _e1484) * (1f / _e1489)); + } + let _e1494 = phi_3520_; + global_11 = _e1494; + let _e1504 = fma(_e1457.x, _e1422.z, fma(_e1455.x, _e1422.x, (_e1456.x * _e1422.y))); + let _e1505 = fma(_e1457.y, _e1422.z, fma(_e1455.y, _e1422.x, (_e1456.y * _e1422.y))); + let _e1506 = fma(_e1457.z, _e1422.z, fma(_e1455.z, _e1422.x, (_e1456.z * _e1422.y))); + let _e1511 = sqrt(fma(_e1506, _e1506, fma(_e1504, _e1504, (_e1505 * _e1505)))); + if (_e1511 == 0f) { + phi_3555_ = vec3(0f, 0f, 0f); + } else { + phi_3555_ = (vec3(_e1504, _e1505, _e1506) * (1f / _e1511)); + } + let _e1516 = phi_3555_; + global_12 = _e1516; + let _e1533 = local_29; + let _e1537 = select(-1f, 1f, (_e1533.member_3.w >= 0f)); + global_13 = vec3((fma(_e1494.y, _e1516.z, -((_e1516.y * _e1494.z))) * _e1537), (fma(_e1494.z, _e1516.x, -((_e1516.z * _e1494.x))) * _e1537), (fma(_e1494.x, _e1516.y, -((_e1516.x * _e1494.y))) * _e1537)); + let _e1543 = local_30; + let _e1557 = (_e1384.member.x + fma(_e1457.x, _e1543.member.z, fma(_e1456.x, _e1543.member.y, (_e1455.x * _e1543.member.x)))); + let _e1558 = (_e1384.member.y + fma(_e1457.y, _e1543.member.z, fma(_e1456.y, _e1543.member.y, (_e1455.y * _e1543.member.x)))); + let _e1559 = (_e1384.member.z + fma(_e1457.z, _e1543.member.z, fma(_e1456.z, _e1543.member.y, (_e1455.z * _e1543.member.x)))); + global_14 = vec3(_e1557, _e1558, _e1559); + if (_e100 >= 83u) { + phi_3568_ = (_e124 <= (_e100 - 83u)); + } else { + phi_3568_ = false; + } + let _e1565 = phi_3568_; + if _e1565 { + let _e1568 = global_2.member[_e124]; + let _e1573 = global_2.member[(_e124 + 1u)]; + let _e1578 = global_2.member[(_e124 + 2u)]; + let _e1583 = global_2.member[(_e124 + 3u)]; + let _e1589 = global_2.member[(_e124 + 4u)]; + let _e1594 = global_2.member[(_e124 + 5u)]; + let _e1599 = global_2.member[(_e124 + 6u)]; + let _e1604 = global_2.member[(_e124 + 7u)]; + let _e1610 = global_2.member[(_e124 + 8u)]; + let _e1615 = global_2.member[(_e124 + 9u)]; + let _e1620 = global_2.member[(_e124 + 10u)]; + let _e1625 = global_2.member[(_e124 + 11u)]; + let _e1631 = global_2.member[(_e124 + 12u)]; + let _e1636 = global_2.member[(_e124 + 13u)]; + let _e1641 = global_2.member[(_e124 + 14u)]; + let _e1646 = global_2.member[(_e124 + 15u)]; + let _e1653 = global_2.member[(_e124 + 16u)]; + let _e1658 = global_2.member[(_e124 + 17u)]; + let _e1663 = global_2.member[(_e124 + 18u)]; + let _e1668 = global_2.member[(_e124 + 19u)]; + let _e1674 = global_2.member[(_e124 + 20u)]; + let _e1679 = global_2.member[(_e124 + 21u)]; + let _e1684 = global_2.member[(_e124 + 22u)]; + let _e1689 = global_2.member[(_e124 + 23u)]; + let _e1695 = global_2.member[(_e124 + 24u)]; + let _e1700 = global_2.member[(_e124 + 25u)]; + let _e1705 = global_2.member[(_e124 + 26u)]; + let _e1710 = global_2.member[(_e124 + 27u)]; + let _e1716 = global_2.member[(_e124 + 28u)]; + let _e1721 = global_2.member[(_e124 + 29u)]; + let _e1726 = global_2.member[(_e124 + 30u)]; + let _e1731 = global_2.member[(_e124 + 31u)]; + let _e1738 = global_2.member[(_e124 + 32u)]; + let _e1743 = global_2.member[(_e124 + 33u)]; + let _e1748 = 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_2217_ = type_24(0u, 6u); + loop { + let _e1753 = phi_2217_; + if (_e1753.member < _e1753.member_1) { + phi_2218_ = type_24((_e1753.member + 1u), _e1753.member_1); + phi_2233_ = type_24(1u, _e1753.member); + } else { + phi_2218_ = _e1753; + phi_2233_ = type_24(0u, type_24().member_1); + } + let _e1766 = phi_2218_; + let _e1768 = phi_2233_; + switch bitcast(_e1768.member) { + case 0: { + phi_2260_ = false; + break; + } + case 1: { + let _e1773 = ((_e124 + 35u) + (_e1768.member_1 * 4u)); + let _e1776 = global_2.member[_e1773]; + let _e1781 = global_2.member[(_e1773 + 1u)]; + let _e1786 = global_2.member[(_e1773 + 2u)]; + let _e1791 = global_2.member[(_e1773 + 3u)]; + local_3[_e1768.member_1] = vec4(bitcast(_e1776), bitcast(_e1781), bitcast(_e1786), bitcast(_e1791)); + phi_2260_ = true; + break; + } + default: { + phi_2260_ = bool(); + break; + } + } + let _e1796 = phi_2260_; + continue; + continuing { + phi_2217_ = _e1766; + break if !(_e1796); + } + } + let _e1798 = 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_2266_ = type_24(0u, 8u); + loop { + let _e1801 = phi_2266_; + if (_e1801.member < _e1801.member_1) { + phi_2267_ = type_24((_e1801.member + 1u), _e1801.member_1); + phi_2282_ = type_24(1u, _e1801.member); + } else { + phi_2267_ = _e1801; + phi_2282_ = type_24(0u, type_24().member_1); + } + let _e1814 = phi_2267_; + let _e1816 = phi_2282_; + switch bitcast(_e1816.member) { + case 0: { + phi_2305_ = false; + break; + } + case 1: { + let _e1821 = ((_e124 + 59u) + (_e1816.member_1 * 3u)); + let _e1824 = global_2.member[_e1821]; + let _e1829 = global_2.member[(_e1821 + 1u)]; + let _e1834 = global_2.member[(_e1821 + 2u)]; + local_2[_e1816.member_1] = vec3(bitcast(_e1824), bitcast(_e1829), bitcast(_e1834)); + phi_2305_ = true; + break; + } + default: { + phi_2305_ = bool(); + break; + } + } + let _e1839 = phi_2305_; + continue; + continuing { + phi_2266_ = _e1814; + break if !(_e1839); + } + } + let _e1841 = local_2; + phi_2313_ = type_22(type_20(vec4(bitcast(_e1568), bitcast(_e1573), bitcast(_e1578), bitcast(_e1583)), vec4(bitcast(_e1589), bitcast(_e1594), bitcast(_e1599), bitcast(_e1604)), vec4(bitcast(_e1610), bitcast(_e1615), bitcast(_e1620), bitcast(_e1625)), vec4(bitcast(_e1631), bitcast(_e1636), bitcast(_e1641), bitcast(_e1646))), type_20(vec4(bitcast(_e1653), bitcast(_e1658), bitcast(_e1663), bitcast(_e1668)), vec4(bitcast(_e1674), bitcast(_e1679), bitcast(_e1684), bitcast(_e1689)), vec4(bitcast(_e1695), bitcast(_e1700), bitcast(_e1705), bitcast(_e1710)), vec4(bitcast(_e1716), bitcast(_e1721), bitcast(_e1726), bitcast(_e1731))), type_21(_e1841, _e1798), vec3(bitcast(_e1738), bitcast(_e1743), bitcast(_e1748))); + } else { + phi_2313_ = 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 _e1845 = phi_2313_; + global_1 = vec4((fma(fma(_e1845.member.member_3.x, _e1845.member_1.member_2.w, fma(_e1845.member.member_2.x, _e1845.member_1.member_2.z, fma(_e1845.member.member.x, _e1845.member_1.member_2.x, (_e1845.member.member_1.x * _e1845.member_1.member_2.y)))), _e1559, fma(fma(_e1845.member.member_3.x, _e1845.member_1.member.w, fma(_e1845.member.member_2.x, _e1845.member_1.member.z, fma(_e1845.member.member.x, _e1845.member_1.member.x, (_e1845.member.member_1.x * _e1845.member_1.member.y)))), _e1557, (fma(_e1845.member.member_3.x, _e1845.member_1.member_1.w, fma(_e1845.member.member_2.x, _e1845.member_1.member_1.z, fma(_e1845.member.member.x, _e1845.member_1.member_1.x, (_e1845.member.member_1.x * _e1845.member_1.member_1.y)))) * _e1558))) + fma(_e1845.member.member_3.x, _e1845.member_1.member_3.w, fma(_e1845.member.member_2.x, _e1845.member_1.member_3.z, fma(_e1845.member.member.x, _e1845.member_1.member_3.x, (_e1845.member.member_1.x * _e1845.member_1.member_3.y))))), (fma(fma(_e1845.member.member_3.y, _e1845.member_1.member_2.w, fma(_e1845.member.member_2.y, _e1845.member_1.member_2.z, fma(_e1845.member.member.y, _e1845.member_1.member_2.x, (_e1845.member.member_1.y * _e1845.member_1.member_2.y)))), _e1559, fma(fma(_e1845.member.member_3.y, _e1845.member_1.member.w, fma(_e1845.member.member_2.y, _e1845.member_1.member.z, fma(_e1845.member.member.y, _e1845.member_1.member.x, (_e1845.member.member_1.y * _e1845.member_1.member.y)))), _e1557, (fma(_e1845.member.member_3.y, _e1845.member_1.member_1.w, fma(_e1845.member.member_2.y, _e1845.member_1.member_1.z, fma(_e1845.member.member.y, _e1845.member_1.member_1.x, (_e1845.member.member_1.y * _e1845.member_1.member_1.y)))) * _e1558))) + fma(_e1845.member.member_3.y, _e1845.member_1.member_3.w, fma(_e1845.member.member_2.y, _e1845.member_1.member_3.z, fma(_e1845.member.member.y, _e1845.member_1.member_3.x, (_e1845.member.member_1.y * _e1845.member_1.member_3.y))))), (fma(fma(_e1845.member.member_3.z, _e1845.member_1.member_2.w, fma(_e1845.member.member_2.z, _e1845.member_1.member_2.z, fma(_e1845.member.member.z, _e1845.member_1.member_2.x, (_e1845.member.member_1.z * _e1845.member_1.member_2.y)))), _e1559, fma(fma(_e1845.member.member_3.z, _e1845.member_1.member.w, fma(_e1845.member.member_2.z, _e1845.member_1.member.z, fma(_e1845.member.member.z, _e1845.member_1.member.x, (_e1845.member.member_1.z * _e1845.member_1.member.y)))), _e1557, (fma(_e1845.member.member_3.z, _e1845.member_1.member_1.w, fma(_e1845.member.member_2.z, _e1845.member_1.member_1.z, fma(_e1845.member.member.z, _e1845.member_1.member_1.x, (_e1845.member.member_1.z * _e1845.member_1.member_1.y)))) * _e1558))) + fma(_e1845.member.member_3.z, _e1845.member_1.member_3.w, fma(_e1845.member.member_2.z, _e1845.member_1.member_3.z, fma(_e1845.member.member.z, _e1845.member_1.member_3.x, (_e1845.member.member_1.z * _e1845.member_1.member_3.y))))), (fma(fma(_e1845.member.member_3.w, _e1845.member_1.member_2.w, fma(_e1845.member.member_2.w, _e1845.member_1.member_2.z, fma(_e1845.member.member.w, _e1845.member_1.member_2.x, (_e1845.member.member_1.w * _e1845.member_1.member_2.y)))), _e1559, fma(fma(_e1845.member.member_3.w, _e1845.member_1.member.w, fma(_e1845.member.member_2.w, _e1845.member_1.member.z, fma(_e1845.member.member.w, _e1845.member_1.member.x, (_e1845.member.member_1.w * _e1845.member_1.member.y)))), _e1557, (fma(_e1845.member.member_3.w, _e1845.member_1.member_1.w, fma(_e1845.member.member_2.w, _e1845.member_1.member_1.z, fma(_e1845.member.member.w, _e1845.member_1.member_1.x, (_e1845.member.member_1.w * _e1845.member_1.member_1.y)))) * _e1558))) + fma(_e1845.member.member_3.w, _e1845.member_1.member_3.w, fma(_e1845.member.member_2.w, _e1845.member_1.member_3.z, fma(_e1845.member.member.w, _e1845.member_1.member_3.x, (_e1845.member.member_1.w * _e1845.member_1.member_3.y)))))); + } else { + global_1 = vec4(10f, 10f, 10f, 1f); + } + break; + } + } + 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/src/linkage/tonemapping-tonemapping_fragment.spv b/crates/renderling/shaders/tonemapping-tonemapping_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/tonemapping-tonemapping_fragment.spv rename to crates/renderling/shaders/tonemapping-tonemapping_fragment.spv 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/src/linkage/tonemapping-tonemapping_vertex.spv b/crates/renderling/shaders/tonemapping-tonemapping_vertex.spv similarity index 72% rename from crates/renderling/src/linkage/tonemapping-tonemapping_vertex.spv rename to crates/renderling/shaders/tonemapping-tonemapping_vertex.spv index cd32400d..a43d96ca 100644 Binary files a/crates/renderling/src/linkage/tonemapping-tonemapping_vertex.spv and b/crates/renderling/shaders/tonemapping-tonemapping_vertex.spv differ diff --git a/crates/renderling/shaders/tonemapping-tonemapping_vertex.wgsl b/crates/renderling/shaders/tonemapping-tonemapping_vertex.wgsl new file mode 100644 index 00000000..a6309c0c --- /dev/null +++ b/crates/renderling/shaders/tonemapping-tonemapping_vertex.wgsl @@ -0,0 +1,45 @@ +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; + + switch bitcast(0u) { + default: { + let _e23 = 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 (_e23 < 6u) { + } else { + break; + } + let _e27 = local[_e23].member; + let _e30 = local[_e23].member_1; + global = _e30; + global_2 = vec4(_e27.x, _e27.y, 0f, 1f); + break; + } + } + 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/src/linkage/tutorial-tutorial_implicit_isosceles_vertex.spv b/crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.spv similarity index 100% rename from crates/renderling/src/linkage/tutorial-tutorial_implicit_isosceles_vertex.spv rename to crates/renderling/shaders/tutorial-tutorial_implicit_isosceles_vertex.spv 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/src/linkage/tutorial-tutorial_passthru_fragment.spv b/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.spv similarity index 100% rename from crates/renderling/src/linkage/tutorial-tutorial_passthru_fragment.spv rename to crates/renderling/shaders/tutorial-tutorial_passthru_fragment.spv diff --git a/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.wgsl b/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.wgsl new file mode 100644 index 00000000..96ad6c46 --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_passthru_fragment.wgsl @@ -0,0 +1,16 @@ +var global: vec4; +var global_1: vec4; + +fn function() { + let _e2 = global_1; + global = _e2; + return; +} + +@fragment +fn tutorialtutorial_passthru_fragment(@location(0) param: vec4) -> @location(0) vec4 { + global_1 = param; + function(); + let _e3 = global; + return _e3; +} diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv new file mode 100644 index 00000000..cd614e1e Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.wgsl b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.wgsl new file mode 100644 index 00000000..c399ba81 --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_slabbed_renderlet.wgsl @@ -0,0 +1,395 @@ +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_613_: u32; + var phi_1381_: bool; + var phi_699_: type_22; + var phi_700_: type_22; + var phi_715_: type_22; + var phi_728_: bool; + var phi_734_: type_22; + var phi_735_: type_22; + var phi_750_: type_22; + var phi_764_: bool; + var phi_768_: type_28; + var phi_1412_: bool; + var phi_819_: type_25; + var phi_1483_: bool; + var phi_980_: type_22; + var phi_981_: type_22; + var phi_996_: type_22; + var phi_1023_: bool; + var phi_1029_: type_22; + var phi_1030_: type_22; + var phi_1045_: type_22; + var phi_1068_: bool; + var phi_1076_: type_20; + + let _e76 = global_4; + let _e77 = global; + let _e79 = arrayLength((&global_1.member)); + let _e83 = global_1.member[(_e76 + 1u)]; + let _e87 = global_1.member[(_e76 + 2u)]; + let _e91 = global_1.member[(_e76 + 9u)]; + let _e95 = global_1.member[(_e76 + 10u)]; + if (_e77 >= _e87) { + phi_613_ = 4294967295u; + } else { + phi_613_ = (_e83 + (26u * _e77)); + } + let _e100 = phi_613_; + if (_e79 >= 26u) { + phi_1381_ = (_e100 <= (_e79 - 26u)); + } else { + phi_1381_ = false; + } + let _e105 = phi_1381_; + if _e105 { + let _e108 = global_1.member[_e100]; + let _e113 = global_1.member[(_e100 + 1u)]; + let _e118 = global_1.member[(_e100 + 2u)]; + let _e124 = global_1.member[(_e100 + 3u)]; + let _e129 = global_1.member[(_e100 + 4u)]; + let _e134 = global_1.member[(_e100 + 5u)]; + let _e139 = global_1.member[(_e100 + 6u)]; + let _e145 = global_1.member[(_e100 + 7u)]; + let _e150 = global_1.member[(_e100 + 8u)]; + let _e156 = global_1.member[(_e100 + 9u)]; + let _e161 = global_1.member[(_e100 + 10u)]; + let _e167 = global_1.member[(_e100 + 11u)]; + let _e172 = global_1.member[(_e100 + 12u)]; + let _e177 = global_1.member[(_e100 + 13u)]; + let _e183 = global_1.member[(_e100 + 14u)]; + let _e188 = global_1.member[(_e100 + 15u)]; + let _e193 = global_1.member[(_e100 + 16u)]; + let _e198 = global_1.member[(_e100 + 17u)]; + local_3 = array(0u, 0u, 0u, 0u); + phi_699_ = type_22(0u, 4u); + loop { + let _e203 = phi_699_; + if (_e203.member < _e203.member_1) { + phi_700_ = type_22((_e203.member + 1u), _e203.member_1); + phi_715_ = type_22(1u, _e203.member); + } else { + phi_700_ = _e203; + phi_715_ = type_22(0u, type_22().member_1); + } + let _e216 = phi_700_; + let _e218 = phi_715_; + switch bitcast(_e218.member) { + case 0: { + phi_728_ = false; + break; + } + case 1: { + let _e225 = global_1.member[((_e100 + 18u) + _e218.member_1)]; + local_3[_e218.member_1] = _e225; + phi_728_ = true; + break; + } + default: { + phi_728_ = bool(); + break; + } + } + let _e228 = phi_728_; + continue; + continuing { + phi_699_ = _e216; + break if !(_e228); + } + } + let _e230 = local_3; + local_2 = array(0f, 0f, 0f, 0f); + phi_734_ = type_22(0u, 4u); + loop { + let _e233 = phi_734_; + if (_e233.member < _e233.member_1) { + phi_735_ = type_22((_e233.member + 1u), _e233.member_1); + phi_750_ = type_22(1u, _e233.member); + } else { + phi_735_ = _e233; + phi_750_ = type_22(0u, type_22().member_1); + } + let _e246 = phi_735_; + let _e248 = phi_750_; + switch bitcast(_e248.member) { + case 0: { + phi_764_ = false; + break; + } + case 1: { + let _e255 = global_1.member[((_e100 + 22u) + _e248.member_1)]; + local_2[_e248.member_1] = bitcast(_e255); + phi_764_ = true; + break; + } + default: { + phi_764_ = bool(); + break; + } + } + let _e259 = phi_764_; + continue; + continuing { + phi_734_ = _e246; + break if !(_e259); + } + } + let _e261 = local_2; + phi_768_ = type_28(vec3(bitcast(_e108), bitcast(_e113), bitcast(_e118)), vec4(bitcast(_e124), bitcast(_e129), bitcast(_e134), bitcast(_e139)), vec3(bitcast(_e167), bitcast(_e172), bitcast(_e177)), vec4(bitcast(_e183), bitcast(_e188), bitcast(_e193), bitcast(_e198)), _e230, _e261, vec2(bitcast(_e145), bitcast(_e150)), vec2(bitcast(_e156), bitcast(_e161))); + } else { + phi_768_ = 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 _e264 = phi_768_; + global_3 = _e264.member_1; + if (_e79 >= 10u) { + phi_1412_ = (_e95 <= (_e79 - 10u)); + } else { + phi_1412_ = false; + } + let _e270 = phi_1412_; + if _e270 { + let _e273 = global_1.member[_e95]; + let _e278 = global_1.member[(_e95 + 1u)]; + let _e283 = global_1.member[(_e95 + 2u)]; + let _e289 = global_1.member[(_e95 + 3u)]; + let _e294 = global_1.member[(_e95 + 4u)]; + let _e299 = global_1.member[(_e95 + 5u)]; + let _e304 = global_1.member[(_e95 + 6u)]; + let _e310 = global_1.member[(_e95 + 7u)]; + let _e315 = global_1.member[(_e95 + 8u)]; + let _e320 = global_1.member[(_e95 + 9u)]; + phi_819_ = type_25(vec3(bitcast(_e273), bitcast(_e278), bitcast(_e283)), vec4(bitcast(_e289), bitcast(_e294), bitcast(_e299), bitcast(_e304)), vec3(bitcast(_e310), bitcast(_e315), bitcast(_e320))); + } else { + phi_819_ = type_25(vec3(0f, 0f, 0f), vec4(0f, 0f, 0f, 1f), vec3(1f, 1f, 1f)); + } + let _e325 = phi_819_; + let _e333 = (_e325.member_1.x + _e325.member_1.x); + let _e334 = (_e325.member_1.y + _e325.member_1.y); + let _e335 = (_e325.member_1.z + _e325.member_1.z); + let _e337 = (_e325.member_1.z * _e335); + let _e338 = (_e325.member_1.w * _e333); + let _e339 = (_e325.member_1.w * _e334); + let _e340 = (_e325.member_1.w * _e335); + let _e360 = (vec4((1f - fma(_e325.member_1.y, _e334, _e337)), fma(_e325.member_1.x, _e334, _e340), fma(_e325.member_1.x, _e335, -(_e339)), 0f) * _e325.member_2.x); + let _e362 = (vec4(fma(_e325.member_1.x, _e334, -(_e340)), (1f - fma(_e325.member_1.x, _e333, _e337)), fma(_e325.member_1.y, _e335, _e338), 0f) * _e325.member_2.y); + let _e364 = (vec4(fma(_e325.member_1.x, _e335, _e339), fma(_e325.member_1.y, _e335, -(_e338)), (1f - fma(_e325.member_1.x, _e333, (_e325.member_1.y * _e334))), 0f) * _e325.member_2.z); + if (_e79 >= 83u) { + phi_1483_ = (_e91 <= (_e79 - 83u)); + } else { + phi_1483_ = false; + } + let _e372 = phi_1483_; + if _e372 { + let _e375 = global_1.member[_e91]; + let _e380 = global_1.member[(_e91 + 1u)]; + let _e385 = global_1.member[(_e91 + 2u)]; + let _e390 = global_1.member[(_e91 + 3u)]; + let _e396 = global_1.member[(_e91 + 4u)]; + let _e401 = global_1.member[(_e91 + 5u)]; + let _e406 = global_1.member[(_e91 + 6u)]; + let _e411 = global_1.member[(_e91 + 7u)]; + let _e417 = global_1.member[(_e91 + 8u)]; + let _e422 = global_1.member[(_e91 + 9u)]; + let _e427 = global_1.member[(_e91 + 10u)]; + let _e432 = global_1.member[(_e91 + 11u)]; + let _e438 = global_1.member[(_e91 + 12u)]; + let _e443 = global_1.member[(_e91 + 13u)]; + let _e448 = global_1.member[(_e91 + 14u)]; + let _e453 = global_1.member[(_e91 + 15u)]; + let _e460 = global_1.member[(_e91 + 16u)]; + let _e465 = global_1.member[(_e91 + 17u)]; + let _e470 = global_1.member[(_e91 + 18u)]; + let _e475 = global_1.member[(_e91 + 19u)]; + let _e481 = global_1.member[(_e91 + 20u)]; + let _e486 = global_1.member[(_e91 + 21u)]; + let _e491 = global_1.member[(_e91 + 22u)]; + let _e496 = global_1.member[(_e91 + 23u)]; + let _e502 = global_1.member[(_e91 + 24u)]; + let _e507 = global_1.member[(_e91 + 25u)]; + let _e512 = global_1.member[(_e91 + 26u)]; + let _e517 = global_1.member[(_e91 + 27u)]; + let _e523 = global_1.member[(_e91 + 28u)]; + let _e528 = global_1.member[(_e91 + 29u)]; + let _e533 = global_1.member[(_e91 + 30u)]; + let _e538 = global_1.member[(_e91 + 31u)]; + let _e545 = global_1.member[(_e91 + 32u)]; + let _e550 = global_1.member[(_e91 + 33u)]; + let _e555 = global_1.member[(_e91 + 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_980_ = type_22(0u, 6u); + loop { + let _e560 = phi_980_; + if (_e560.member < _e560.member_1) { + phi_981_ = type_22((_e560.member + 1u), _e560.member_1); + phi_996_ = type_22(1u, _e560.member); + } else { + phi_981_ = _e560; + phi_996_ = type_22(0u, type_22().member_1); + } + let _e573 = phi_981_; + let _e575 = phi_996_; + switch bitcast(_e575.member) { + case 0: { + phi_1023_ = false; + break; + } + case 1: { + let _e580 = ((_e91 + 35u) + (_e575.member_1 * 4u)); + let _e583 = global_1.member[_e580]; + let _e588 = global_1.member[(_e580 + 1u)]; + let _e593 = global_1.member[(_e580 + 2u)]; + let _e598 = global_1.member[(_e580 + 3u)]; + local_1[_e575.member_1] = vec4(bitcast(_e583), bitcast(_e588), bitcast(_e593), bitcast(_e598)); + phi_1023_ = true; + break; + } + default: { + phi_1023_ = bool(); + break; + } + } + let _e603 = phi_1023_; + continue; + continuing { + phi_980_ = _e573; + break if !(_e603); + } + } + let _e605 = 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_1029_ = type_22(0u, 8u); + loop { + let _e608 = phi_1029_; + if (_e608.member < _e608.member_1) { + phi_1030_ = type_22((_e608.member + 1u), _e608.member_1); + phi_1045_ = type_22(1u, _e608.member); + } else { + phi_1030_ = _e608; + phi_1045_ = type_22(0u, type_22().member_1); + } + let _e621 = phi_1030_; + let _e623 = phi_1045_; + switch bitcast(_e623.member) { + case 0: { + phi_1068_ = false; + break; + } + case 1: { + let _e628 = ((_e91 + 59u) + (_e623.member_1 * 3u)); + let _e631 = global_1.member[_e628]; + let _e636 = global_1.member[(_e628 + 1u)]; + let _e641 = global_1.member[(_e628 + 2u)]; + local[_e623.member_1] = vec3(bitcast(_e631), bitcast(_e636), bitcast(_e641)); + phi_1068_ = true; + break; + } + default: { + phi_1068_ = bool(); + break; + } + } + let _e646 = phi_1068_; + continue; + continuing { + phi_1029_ = _e621; + break if !(_e646); + } + } + let _e648 = local; + phi_1076_ = type_20(type_18(vec4(bitcast(_e375), bitcast(_e380), bitcast(_e385), bitcast(_e390)), vec4(bitcast(_e396), bitcast(_e401), bitcast(_e406), bitcast(_e411)), vec4(bitcast(_e417), bitcast(_e422), bitcast(_e427), bitcast(_e432)), vec4(bitcast(_e438), bitcast(_e443), bitcast(_e448), bitcast(_e453))), type_18(vec4(bitcast(_e460), bitcast(_e465), bitcast(_e470), bitcast(_e475)), vec4(bitcast(_e481), bitcast(_e486), bitcast(_e491), bitcast(_e496)), vec4(bitcast(_e502), bitcast(_e507), bitcast(_e512), bitcast(_e517)), vec4(bitcast(_e523), bitcast(_e528), bitcast(_e533), bitcast(_e538))), type_19(_e648, _e605), vec3(bitcast(_e545), bitcast(_e550), bitcast(_e555))); + } else { + phi_1076_ = 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 _e652 = phi_1076_; + let _e692 = fma(_e652.member.member_3.x, _e652.member_1.member.w, fma(_e652.member.member_2.x, _e652.member_1.member.z, fma(_e652.member.member.x, _e652.member_1.member.x, (_e652.member.member_1.x * _e652.member_1.member.y)))); + let _e693 = fma(_e652.member.member_3.y, _e652.member_1.member.w, fma(_e652.member.member_2.y, _e652.member_1.member.z, fma(_e652.member.member.y, _e652.member_1.member.x, (_e652.member.member_1.y * _e652.member_1.member.y)))); + let _e694 = fma(_e652.member.member_3.z, _e652.member_1.member.w, fma(_e652.member.member_2.z, _e652.member_1.member.z, fma(_e652.member.member.z, _e652.member_1.member.x, (_e652.member.member_1.z * _e652.member_1.member.y)))); + let _e695 = fma(_e652.member.member_3.w, _e652.member_1.member.w, fma(_e652.member.member_2.w, _e652.member_1.member.z, fma(_e652.member.member.w, _e652.member_1.member.x, (_e652.member.member_1.w * _e652.member_1.member.y)))); + let _e713 = fma(_e652.member.member_3.x, _e652.member_1.member_1.w, fma(_e652.member.member_2.x, _e652.member_1.member_1.z, fma(_e652.member.member.x, _e652.member_1.member_1.x, (_e652.member.member_1.x * _e652.member_1.member_1.y)))); + let _e714 = fma(_e652.member.member_3.y, _e652.member_1.member_1.w, fma(_e652.member.member_2.y, _e652.member_1.member_1.z, fma(_e652.member.member.y, _e652.member_1.member_1.x, (_e652.member.member_1.y * _e652.member_1.member_1.y)))); + let _e715 = fma(_e652.member.member_3.z, _e652.member_1.member_1.w, fma(_e652.member.member_2.z, _e652.member_1.member_1.z, fma(_e652.member.member.z, _e652.member_1.member_1.x, (_e652.member.member_1.z * _e652.member_1.member_1.y)))); + let _e716 = fma(_e652.member.member_3.w, _e652.member_1.member_1.w, fma(_e652.member.member_2.w, _e652.member_1.member_1.z, fma(_e652.member.member.w, _e652.member_1.member_1.x, (_e652.member.member_1.w * _e652.member_1.member_1.y)))); + let _e734 = fma(_e652.member.member_3.x, _e652.member_1.member_2.w, fma(_e652.member.member_2.x, _e652.member_1.member_2.z, fma(_e652.member.member.x, _e652.member_1.member_2.x, (_e652.member.member_1.x * _e652.member_1.member_2.y)))); + let _e735 = fma(_e652.member.member_3.y, _e652.member_1.member_2.w, fma(_e652.member.member_2.y, _e652.member_1.member_2.z, fma(_e652.member.member.y, _e652.member_1.member_2.x, (_e652.member.member_1.y * _e652.member_1.member_2.y)))); + let _e736 = fma(_e652.member.member_3.z, _e652.member_1.member_2.w, fma(_e652.member.member_2.z, _e652.member_1.member_2.z, fma(_e652.member.member.z, _e652.member_1.member_2.x, (_e652.member.member_1.z * _e652.member_1.member_2.y)))); + let _e737 = fma(_e652.member.member_3.w, _e652.member_1.member_2.w, fma(_e652.member.member_2.w, _e652.member_1.member_2.z, fma(_e652.member.member.w, _e652.member_1.member_2.x, (_e652.member.member_1.w * _e652.member_1.member_2.y)))); + let _e755 = fma(_e652.member.member_3.x, _e652.member_1.member_3.w, fma(_e652.member.member_2.x, _e652.member_1.member_3.z, fma(_e652.member.member.x, _e652.member_1.member_3.x, (_e652.member.member_1.x * _e652.member_1.member_3.y)))); + let _e756 = fma(_e652.member.member_3.y, _e652.member_1.member_3.w, fma(_e652.member.member_2.y, _e652.member_1.member_3.z, fma(_e652.member.member.y, _e652.member_1.member_3.x, (_e652.member.member_1.y * _e652.member_1.member_3.y)))); + let _e757 = fma(_e652.member.member_3.z, _e652.member_1.member_3.w, fma(_e652.member.member_2.z, _e652.member_1.member_3.z, fma(_e652.member.member.z, _e652.member_1.member_3.x, (_e652.member.member_1.z * _e652.member_1.member_3.y)))); + let _e758 = fma(_e652.member.member_3.w, _e652.member_1.member_3.w, fma(_e652.member.member_2.w, _e652.member_1.member_3.z, fma(_e652.member.member.w, _e652.member_1.member_3.x, (_e652.member.member_1.w * _e652.member_1.member_3.y)))); + global_2 = vec4((fma(fma(_e755, _e364.w, fma(_e734, _e364.z, fma(_e692, _e364.x, (_e713 * _e364.y)))), _e264.member.z, fma(fma(_e755, _e360.w, fma(_e734, _e360.z, fma(_e692, _e360.x, (_e713 * _e360.y)))), _e264.member.x, (fma(_e755, _e362.w, fma(_e734, _e362.z, fma(_e692, _e362.x, (_e713 * _e362.y)))) * _e264.member.y))) + (fma(_e734, _e325.member.z, fma(_e692, _e325.member.x, (_e713 * _e325.member.y))) + _e755)), (fma(fma(_e756, _e364.w, fma(_e735, _e364.z, fma(_e693, _e364.x, (_e714 * _e364.y)))), _e264.member.z, fma(fma(_e756, _e360.w, fma(_e735, _e360.z, fma(_e693, _e360.x, (_e714 * _e360.y)))), _e264.member.x, (fma(_e756, _e362.w, fma(_e735, _e362.z, fma(_e693, _e362.x, (_e714 * _e362.y)))) * _e264.member.y))) + (fma(_e735, _e325.member.z, fma(_e693, _e325.member.x, (_e714 * _e325.member.y))) + _e756)), (fma(fma(_e757, _e364.w, fma(_e736, _e364.z, fma(_e694, _e364.x, (_e715 * _e364.y)))), _e264.member.z, fma(fma(_e757, _e360.w, fma(_e736, _e360.z, fma(_e694, _e360.x, (_e715 * _e360.y)))), _e264.member.x, (fma(_e757, _e362.w, fma(_e736, _e362.z, fma(_e694, _e362.x, (_e715 * _e362.y)))) * _e264.member.y))) + (fma(_e736, _e325.member.z, fma(_e694, _e325.member.x, (_e715 * _e325.member.y))) + _e757)), (fma(fma(_e758, _e364.w, fma(_e737, _e364.z, fma(_e695, _e364.x, (_e716 * _e364.y)))), _e264.member.z, fma(fma(_e758, _e360.w, fma(_e737, _e360.z, fma(_e695, _e360.x, (_e716 * _e360.y)))), _e264.member.x, (fma(_e758, _e362.w, fma(_e737, _e362.z, fma(_e695, _e362.x, (_e716 * _e362.y)))) * _e264.member.y))) + (fma(_e737, _e325.member.z, fma(_e695, _e325.member.x, (_e716 * _e325.member.y))) + _e758))); + return; +} + +@vertex +fn tutorialtutorial_slabbed_renderlet(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_4 = param; + global = param_1; + function(); + let _e7 = global_2.y; + global_2.y = -(_e7); + let _e9 = global_3; + let _e10 = global_2; + return VertexOutput(_e9, _e10); +} diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv new file mode 100644 index 00000000..cdd8bffd Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.wgsl b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.wgsl new file mode 100644 index 00000000..0582f04a --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices.wgsl @@ -0,0 +1,192 @@ +struct type_8 { + member: array, +} + +struct type_13 { + member: u32, + member_1: u32, +} + +struct type_18 { + member: vec3, + member_1: vec4, + member_2: vec3, + member_3: vec4, + member_4: array, + member_5: array, + member_6: vec2, + member_7: vec2, +} + +struct VertexOutput { + @location(0) member: vec4, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_8; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); +var global_3: vec4; +var global_4: u32; + +fn function() { + var local: array; + var local_1: array; + var phi_365_: bool; + var phi_148_: type_13; + var phi_391_: u32; + var phi_410_: bool; + var phi_239_: type_13; + var phi_240_: type_13; + var phi_255_: type_13; + var phi_268_: bool; + var phi_274_: type_13; + var phi_275_: type_13; + var phi_290_: type_13; + var phi_304_: bool; + var phi_308_: type_18; + + let _e45 = global_4; + let _e46 = global; + let _e48 = arrayLength((&global_1.member)); + if (_e48 >= 2u) { + phi_365_ = (_e45 <= (_e48 - 2u)); + } else { + phi_365_ = false; + } + let _e53 = phi_365_; + 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_391_ = 4294967295u; + } else { + phi_391_ = (_e63.member + (26u * _e46)); + } + let _e70 = phi_391_; + if (_e48 >= 26u) { + phi_410_ = (_e70 <= (_e48 - 26u)); + } else { + phi_410_ = false; + } + let _e75 = phi_410_; + 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_240_ = type_13((_e173.member + 1u), _e173.member_1); + phi_255_ = type_13(1u, _e173.member); + } else { + phi_240_ = _e173; + phi_255_ = type_13(0u, type_13().member_1); + } + let _e186 = phi_240_; + let _e188 = phi_255_; + switch bitcast(_e188.member) { + case 0: { + phi_268_ = false; + break; + } + case 1: { + let _e195 = global_1.member[((_e70 + 18u) + _e188.member_1)]; + local_1[_e188.member_1] = _e195; + phi_268_ = true; + break; + } + default: { + phi_268_ = bool(); + break; + } + } + let _e198 = phi_268_; + continue; + continuing { + phi_239_ = _e186; + break if !(_e198); + } + } + let _e200 = local_1; + local = array(0f, 0f, 0f, 0f); + phi_274_ = type_13(0u, 4u); + loop { + let _e203 = phi_274_; + if (_e203.member < _e203.member_1) { + phi_275_ = type_13((_e203.member + 1u), _e203.member_1); + phi_290_ = type_13(1u, _e203.member); + } else { + phi_275_ = _e203; + phi_290_ = type_13(0u, type_13().member_1); + } + let _e216 = phi_275_; + let _e218 = phi_290_; + switch bitcast(_e218.member) { + case 0: { + phi_304_ = false; + break; + } + case 1: { + let _e225 = global_1.member[((_e70 + 22u) + _e218.member_1)]; + local[_e218.member_1] = bitcast(_e225); + phi_304_ = true; + break; + } + default: { + phi_304_ = bool(); + break; + } + } + let _e229 = phi_304_; + continue; + continuing { + phi_274_ = _e216; + break if !(_e229); + } + } + let _e231 = local; + phi_308_ = 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)), _e200, _e231, vec2(bitcast(_e115), bitcast(_e120)), vec2(bitcast(_e126), bitcast(_e131))); + } else { + phi_308_ = 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 _e234 = phi_308_; + global_2 = vec4(_e234.member.x, _e234.member.y, _e234.member.z, 1f); + global_3 = _e234.member_1; + return; +} + +@vertex +fn tutorialtutorial_slabbed_vertices(@builtin(instance_index) param: u32, @builtin(vertex_index) param_1: u32) -> VertexOutput { + global_4 = param; + global = param_1; + function(); + let _e7 = global_2.y; + global_2.y = -(_e7); + let _e9 = global_3; + let _e10 = global_2; + return VertexOutput(_e9, _e10); +} diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv new file mode 100644 index 00000000..60ad158b Binary files /dev/null and b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv differ diff --git a/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl new file mode 100644 index 00000000..fa14608c --- /dev/null +++ b/crates/renderling/shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl @@ -0,0 +1,167 @@ +struct type_8 { + member: array, +} + +struct type_13 { + member: u32, + member_1: u32, +} + +struct type_18 { + member: vec3, + member_1: vec4, + member_2: vec3, + member_3: vec4, + member_4: array, + member_5: array, + member_6: vec2, + member_7: vec2, +} + +struct VertexOutput { + @location(0) member: vec4, + @builtin(position) member_1: vec4, +} + +var global: u32; +@group(0) @binding(0) +var global_1: type_8; +var global_2: vec4 = vec4(0f, 0f, 0f, 1f); +var global_3: vec4; + +fn function() { + var local: array; + var local_1: array; + var phi_296_: bool; + var phi_179_: type_13; + var phi_180_: type_13; + var phi_195_: type_13; + var phi_208_: bool; + var phi_214_: type_13; + var phi_215_: type_13; + var phi_230_: type_13; + var phi_244_: bool; + var phi_248_: type_18; + + let _e42 = global; + let _e44 = arrayLength((&global_1.member)); + let _e45 = (_e42 * 26u); + if (_e44 >= 26u) { + phi_296_ = (_e45 <= (_e44 - 26u)); + } else { + phi_296_ = false; + } + let _e50 = phi_296_; + 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_180_ = type_13((_e148.member + 1u), _e148.member_1); + phi_195_ = type_13(1u, _e148.member); + } else { + phi_180_ = _e148; + phi_195_ = type_13(0u, type_13().member_1); + } + let _e161 = phi_180_; + let _e163 = phi_195_; + switch bitcast(_e163.member) { + case 0: { + phi_208_ = false; + break; + } + case 1: { + let _e170 = global_1.member[((_e45 + 18u) + _e163.member_1)]; + local_1[_e163.member_1] = _e170; + phi_208_ = true; + break; + } + default: { + phi_208_ = bool(); + break; + } + } + let _e173 = phi_208_; + continue; + continuing { + phi_179_ = _e161; + break if !(_e173); + } + } + let _e175 = local_1; + local = array(0f, 0f, 0f, 0f); + phi_214_ = type_13(0u, 4u); + loop { + let _e178 = phi_214_; + if (_e178.member < _e178.member_1) { + phi_215_ = type_13((_e178.member + 1u), _e178.member_1); + phi_230_ = type_13(1u, _e178.member); + } else { + phi_215_ = _e178; + phi_230_ = type_13(0u, type_13().member_1); + } + let _e191 = phi_215_; + let _e193 = phi_230_; + switch bitcast(_e193.member) { + case 0: { + phi_244_ = false; + break; + } + case 1: { + let _e200 = global_1.member[((_e45 + 22u) + _e193.member_1)]; + local[_e193.member_1] = bitcast(_e200); + phi_244_ = true; + break; + } + default: { + phi_244_ = bool(); + break; + } + } + let _e204 = phi_244_; + continue; + continuing { + phi_214_ = _e191; + break if !(_e204); + } + } + let _e206 = local; + phi_248_ = 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)), _e175, _e206, vec2(bitcast(_e90), bitcast(_e95)), vec2(bitcast(_e101), bitcast(_e106))); + } else { + phi_248_ = 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 _e209 = phi_248_; + global_2 = vec4(_e209.member.x, _e209.member.y, _e209.member.z, 1f); + global_3 = _e209.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..c11bbd31 --- /dev/null +++ b/crates/renderling/src/build.rs @@ -0,0 +1,163 @@ +//! 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 fn_name = self.fn_name(); + + let quote = quote! { + use crate::linkage::ShaderLinkage; + + #[cfg(not(target_arch = "wasm32"))] + mod target { + 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 { + log::info!("creating native linkage for {}", #fn_name); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into() + } + } + } + #[cfg(target_arch = "wasm32")] + mod target { + pub const ENTRY_POINT: &str = #wgsl_entry_point; + + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!(#wgsl_include_source_path) + } + + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", #fn_name); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into() + } + } + } + + pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::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(); + } +} diff --git a/crates/renderling/src/lib.rs b/crates/renderling/src/lib.rs index 852dc7f3..2dd550fa 100644 --- a/crates/renderling/src/lib.rs +++ b/crates/renderling/src/lib.rs @@ -167,7 +167,7 @@ pub mod pbr; pub mod skybox; pub mod slab; pub mod stage; -#[cfg(not(target_arch = "spirv"))] +#[cfg(not(target_arch = "spirv"))] pub mod texture; pub mod tonemapping; pub mod transform; diff --git a/crates/renderling/src/linkage/bloom-bloom_vertex.spv b/crates/renderling/src/linkage/bloom-bloom_vertex.spv deleted file mode 100644 index 0d08a095..00000000 Binary files a/crates/renderling/src/linkage/bloom-bloom_vertex.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/bloom_downsample_fragment.rs b/crates/renderling/src/linkage/bloom_downsample_fragment.rs index ae23eb0b..2b09fdae 100644 --- a/crates/renderling/src/linkage/bloom_downsample_fragment.rs +++ b/crates/renderling/src/linkage/bloom_downsample_fragment.rs @@ -1,23 +1,37 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [bloom::bloom_downsample_fragment](crate::bloom::bloom_downsample_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/bloom-bloom_downsample_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "bloom::bloom_downsample_fragment"; +mod target { + pub const ENTRY_POINT: &str = "bloom::bloom_downsample_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/bloom-bloom_downsample_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "bloom_downsample_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "bloombloom_downsample_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device - .create_shader_module(wgpu::include_spirv!("bloom-bloom_downsample_fragment.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "bloombloom_downsample_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/bloom-bloom_downsample_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "bloom_downsample_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/bloom_mix_fragment.rs b/crates/renderling/src/linkage/bloom_mix_fragment.rs index 4a3ea315..a1691afe 100644 --- a/crates/renderling/src/linkage/bloom_mix_fragment.rs +++ b/crates/renderling/src/linkage/bloom_mix_fragment.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [bloom::bloom_mix_fragment](crate::bloom::bloom_mix_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/bloom-bloom_mix_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "bloom::bloom_mix_fragment"; +mod target { + pub const ENTRY_POINT: &str = "bloom::bloom_mix_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/bloom-bloom_mix_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "bloom_mix_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "bloombloom_mix_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("bloom-bloom_mix_fragment.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "bloombloom_mix_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/bloom-bloom_mix_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "bloom_mix_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/bloom_upsample_fragment.rs b/crates/renderling/src/linkage/bloom_upsample_fragment.rs index aefaaba8..b564d3ab 100644 --- a/crates/renderling/src/linkage/bloom_upsample_fragment.rs +++ b/crates/renderling/src/linkage/bloom_upsample_fragment.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [bloom::bloom_upsample_fragment](crate::bloom::bloom_upsample_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/bloom-bloom_upsample_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "bloom::bloom_upsample_fragment"; +mod target { + pub const ENTRY_POINT: &str = "bloom::bloom_upsample_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/bloom-bloom_upsample_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "bloom_upsample_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "bloombloom_upsample_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("bloom-bloom_upsample_fragment.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "bloombloom_upsample_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/bloom-bloom_upsample_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "bloom_upsample_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/bloom_vertex.rs b/crates/renderling/src/linkage/bloom_vertex.rs index 66a7896c..788c68d7 100644 --- a/crates/renderling/src/linkage/bloom_vertex.rs +++ b/crates/renderling/src/linkage/bloom_vertex.rs @@ -1,21 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [bloom::bloom_vertex](crate::bloom::bloom_vertex). -//! -//! **source path**: `crates/renderling/src/linkage/bloom-bloom_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "bloom::bloom_vertex"; +mod target { + pub const ENTRY_POINT: &str = "bloom::bloom_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/bloom-bloom_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "bloom_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "bloombloom_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("bloom-bloom_vertex.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "bloombloom_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/bloom-bloom_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "bloom_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/brdf_lut_convolution_fragment.rs b/crates/renderling/src/linkage/brdf_lut_convolution_fragment.rs index d7213047..70616eda 100644 --- a/crates/renderling/src/linkage/brdf_lut_convolution_fragment.rs +++ b/crates/renderling/src/linkage/brdf_lut_convolution_fragment.rs @@ -1,23 +1,40 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [convolution::brdf_lut_convolution_fragment](crate::convolution::brdf_lut_convolution_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/convolution-brdf_lut_convolution_fragment. -//! spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "convolution::brdf_lut_convolution_fragment"; +mod target { + pub const ENTRY_POINT: &str = "convolution::brdf_lut_convolution_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/convolution-brdf_lut_convolution_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "brdf_lut_convolution_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "convolutionbrdf_lut_convolution_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "convolution-brdf_lut_convolution_fragment.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "convolutionbrdf_lut_convolution_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/convolution-brdf_lut_convolution_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating web linkage for {}", + "brdf_lut_convolution_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/brdf_lut_convolution_vertex.rs b/crates/renderling/src/linkage/brdf_lut_convolution_vertex.rs index 485ca607..9b568294 100644 --- a/crates/renderling/src/linkage/brdf_lut_convolution_vertex.rs +++ b/crates/renderling/src/linkage/brdf_lut_convolution_vertex.rs @@ -1,22 +1,37 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [convolution::brdf_lut_convolution_vertex](crate::convolution::brdf_lut_convolution_vertex). -//! -//! **source path**: -//! `crates/renderling/src/linkage/convolution-brdf_lut_convolution_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "convolution::brdf_lut_convolution_vertex"; +mod target { + pub const ENTRY_POINT: &str = "convolution::brdf_lut_convolution_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/convolution-brdf_lut_convolution_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "brdf_lut_convolution_vertex" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "convolutionbrdf_lut_convolution_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "convolution-brdf_lut_convolution_vertex.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "convolutionbrdf_lut_convolution_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/convolution-brdf_lut_convolution_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "brdf_lut_convolution_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/compute_frustum_culling.rs b/crates/renderling/src/linkage/compute_frustum_culling.rs index d704051f..9ef46a9a 100644 --- a/crates/renderling/src/linkage/compute_frustum_culling.rs +++ b/crates/renderling/src/linkage/compute_frustum_culling.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [cull::compute_frustum_culling](crate::cull::compute_frustum_culling). -//! -//! **source path**: -//! `crates/renderling/src/linkage/cull-compute_frustum_culling.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "cull::compute_frustum_culling"; +mod target { + pub const ENTRY_POINT: &str = "cull::compute_frustum_culling"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/cull-compute_frustum_culling.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "compute_frustum_culling"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "cullcompute_frustum_culling"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("cull-compute_frustum_culling.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "cullcompute_frustum_culling"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/cull-compute_frustum_culling.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "compute_frustum_culling"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/convolution-brdf_lut_convolution_fragment.spv b/crates/renderling/src/linkage/convolution-brdf_lut_convolution_fragment.spv deleted file mode 100644 index 4dbda372..00000000 Binary files a/crates/renderling/src/linkage/convolution-brdf_lut_convolution_fragment.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/convolution-prefilter_environment_cubemap_fragment.spv b/crates/renderling/src/linkage/convolution-prefilter_environment_cubemap_fragment.spv deleted file mode 100644 index efcb42aa..00000000 Binary files a/crates/renderling/src/linkage/convolution-prefilter_environment_cubemap_fragment.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/convolution-prefilter_environment_cubemap_vertex.spv b/crates/renderling/src/linkage/convolution-prefilter_environment_cubemap_vertex.spv deleted file mode 100644 index 8d2ee732..00000000 Binary files a/crates/renderling/src/linkage/convolution-prefilter_environment_cubemap_vertex.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/cull-compute_frustum_culling.spv b/crates/renderling/src/linkage/cull-compute_frustum_culling.spv deleted file mode 100644 index 3dc27c52..00000000 Binary files a/crates/renderling/src/linkage/cull-compute_frustum_culling.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/generate_mipmap_fragment.rs b/crates/renderling/src/linkage/generate_mipmap_fragment.rs index d82a32ca..339c5ccd 100644 --- a/crates/renderling/src/linkage/generate_mipmap_fragment.rs +++ b/crates/renderling/src/linkage/generate_mipmap_fragment.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [convolution::generate_mipmap_fragment](crate::convolution::generate_mipmap_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/convolution-generate_mipmap_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "convolution::generate_mipmap_fragment"; +mod target { + pub const ENTRY_POINT: &str = "convolution::generate_mipmap_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/convolution-generate_mipmap_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "generate_mipmap_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "convolutiongenerate_mipmap_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "convolution-generate_mipmap_fragment.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "convolutiongenerate_mipmap_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/convolution-generate_mipmap_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "generate_mipmap_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/generate_mipmap_vertex.rs b/crates/renderling/src/linkage/generate_mipmap_vertex.rs index ca323a1c..355550d8 100644 --- a/crates/renderling/src/linkage/generate_mipmap_vertex.rs +++ b/crates/renderling/src/linkage/generate_mipmap_vertex.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [convolution::generate_mipmap_vertex](crate::convolution::generate_mipmap_vertex). -//! -//! **source path**: -//! `crates/renderling/src/linkage/convolution-generate_mipmap_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "convolution::generate_mipmap_vertex"; +mod target { + pub const ENTRY_POINT: &str = "convolution::generate_mipmap_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/convolution-generate_mipmap_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "generate_mipmap_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "convolutiongenerate_mipmap_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "convolution-generate_mipmap_vertex.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "convolutiongenerate_mipmap_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/convolution-generate_mipmap_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "generate_mipmap_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/prefilter_environment_cubemap_fragment.rs b/crates/renderling/src/linkage/prefilter_environment_cubemap_fragment.rs index 950283aa..e91964ec 100644 --- a/crates/renderling/src/linkage/prefilter_environment_cubemap_fragment.rs +++ b/crates/renderling/src/linkage/prefilter_environment_cubemap_fragment.rs @@ -1,23 +1,40 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [convolution::prefilter_environment_cubemap_fragment](crate::convolution::prefilter_environment_cubemap_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/ -//! convolution-prefilter_environment_cubemap_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "convolution::prefilter_environment_cubemap_fragment"; +mod target { + pub const ENTRY_POINT: &str = "convolution::prefilter_environment_cubemap_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/convolution-prefilter_environment_cubemap_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "prefilter_environment_cubemap_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "convolutionprefilter_environment_cubemap_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "convolution-prefilter_environment_cubemap_fragment.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "convolutionprefilter_environment_cubemap_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/convolution-prefilter_environment_cubemap_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating web linkage for {}", + "prefilter_environment_cubemap_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/prefilter_environment_cubemap_vertex.rs b/crates/renderling/src/linkage/prefilter_environment_cubemap_vertex.rs index 21714481..f5bd22ca 100644 --- a/crates/renderling/src/linkage/prefilter_environment_cubemap_vertex.rs +++ b/crates/renderling/src/linkage/prefilter_environment_cubemap_vertex.rs @@ -1,23 +1,40 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [convolution::prefilter_environment_cubemap_vertex](crate::convolution::prefilter_environment_cubemap_vertex). -//! -//! **source path**: -//! `crates/renderling/src/linkage/ -//! convolution-prefilter_environment_cubemap_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "convolution::prefilter_environment_cubemap_vertex"; +mod target { + pub const ENTRY_POINT: &str = "convolution::prefilter_environment_cubemap_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/convolution-prefilter_environment_cubemap_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "prefilter_environment_cubemap_vertex" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "convolutionprefilter_environment_cubemap_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "convolution-prefilter_environment_cubemap_vertex.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "convolutionprefilter_environment_cubemap_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/convolution-prefilter_environment_cubemap_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating web linkage for {}", + "prefilter_environment_cubemap_vertex" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/renderlet_fragment.rs b/crates/renderling/src/linkage/renderlet_fragment.rs index a68b04c6..9f261f3e 100644 --- a/crates/renderling/src/linkage/renderlet_fragment.rs +++ b/crates/renderling/src/linkage/renderlet_fragment.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [stage::renderlet_fragment](crate::stage::renderlet_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/stage-renderlet_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "stage::renderlet_fragment"; +mod target { + pub const ENTRY_POINT: &str = "stage::renderlet_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/stage-renderlet_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "renderlet_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "stagerenderlet_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("stage-renderlet_fragment.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "stagerenderlet_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/stage-renderlet_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "renderlet_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/renderlet_vertex.rs b/crates/renderling/src/linkage/renderlet_vertex.rs index 6e6013ed..e0715022 100644 --- a/crates/renderling/src/linkage/renderlet_vertex.rs +++ b/crates/renderling/src/linkage/renderlet_vertex.rs @@ -1,21 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [stage::renderlet_vertex](crate::stage::renderlet_vertex). -//! -//! **source path**: `crates/renderling/src/linkage/stage-renderlet_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "stage::renderlet_vertex"; +mod target { + pub const ENTRY_POINT: &str = "stage::renderlet_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/stage-renderlet_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "renderlet_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "stagerenderlet_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("stage-renderlet_vertex.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "stagerenderlet_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/stage-renderlet_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "renderlet_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/skybox-skybox_cubemap_vertex.spv b/crates/renderling/src/linkage/skybox-skybox_cubemap_vertex.spv deleted file mode 100644 index 4cd01e1e..00000000 Binary files a/crates/renderling/src/linkage/skybox-skybox_cubemap_vertex.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/skybox-skybox_vertex.spv b/crates/renderling/src/linkage/skybox-skybox_vertex.spv deleted file mode 100644 index 550db981..00000000 Binary files a/crates/renderling/src/linkage/skybox-skybox_vertex.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/skybox_cubemap_fragment.rs b/crates/renderling/src/linkage/skybox_cubemap_fragment.rs index 48e78a25..1ecf4602 100644 --- a/crates/renderling/src/linkage/skybox_cubemap_fragment.rs +++ b/crates/renderling/src/linkage/skybox_cubemap_fragment.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [skybox::skybox_cubemap_fragment](crate::skybox::skybox_cubemap_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/skybox-skybox_cubemap_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "skybox::skybox_cubemap_fragment"; +mod target { + pub const ENTRY_POINT: &str = "skybox::skybox_cubemap_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/skybox-skybox_cubemap_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "skybox_cubemap_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "skyboxskybox_cubemap_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("skybox-skybox_cubemap_fragment.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "skyboxskybox_cubemap_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/skybox-skybox_cubemap_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "skybox_cubemap_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/skybox_cubemap_vertex.rs b/crates/renderling/src/linkage/skybox_cubemap_vertex.rs index 77067641..2f792fe2 100644 --- a/crates/renderling/src/linkage/skybox_cubemap_vertex.rs +++ b/crates/renderling/src/linkage/skybox_cubemap_vertex.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [skybox::skybox_cubemap_vertex](crate::skybox::skybox_cubemap_vertex). -//! -//! **source path**: -//! `crates/renderling/src/linkage/skybox-skybox_cubemap_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "skybox::skybox_cubemap_vertex"; +mod target { + pub const ENTRY_POINT: &str = "skybox::skybox_cubemap_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/skybox-skybox_cubemap_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "skybox_cubemap_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "skyboxskybox_cubemap_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("skybox-skybox_cubemap_vertex.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "skyboxskybox_cubemap_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/skybox-skybox_cubemap_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "skybox_cubemap_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/skybox_equirectangular_fragment.rs b/crates/renderling/src/linkage/skybox_equirectangular_fragment.rs index c993c51c..9ef6fc56 100644 --- a/crates/renderling/src/linkage/skybox_equirectangular_fragment.rs +++ b/crates/renderling/src/linkage/skybox_equirectangular_fragment.rs @@ -1,22 +1,40 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [skybox::skybox_equirectangular_fragment](crate::skybox::skybox_equirectangular_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/skybox-skybox_equirectangular_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "skybox::skybox_equirectangular_fragment"; +mod target { + pub const ENTRY_POINT: &str = "skybox::skybox_equirectangular_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/skybox-skybox_equirectangular_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "skybox_equirectangular_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "skyboxskybox_equirectangular_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "skybox-skybox_equirectangular_fragment.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "skyboxskybox_equirectangular_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/skybox-skybox_equirectangular_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating web linkage for {}", + "skybox_equirectangular_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/skybox_vertex.rs b/crates/renderling/src/linkage/skybox_vertex.rs index a5ce4286..a7acf011 100644 --- a/crates/renderling/src/linkage/skybox_vertex.rs +++ b/crates/renderling/src/linkage/skybox_vertex.rs @@ -1,21 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [skybox::skybox_vertex](crate::skybox::skybox_vertex). -//! -//! **source path**: `crates/renderling/src/linkage/skybox-skybox_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "skybox::skybox_vertex"; +mod target { + pub const ENTRY_POINT: &str = "skybox::skybox_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/skybox-skybox_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "skybox_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "skyboxskybox_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("skybox-skybox_vertex.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "skyboxskybox_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/skybox-skybox_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "skybox_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/stage-renderlet_fragment.spv b/crates/renderling/src/linkage/stage-renderlet_fragment.spv deleted file mode 100644 index 5fcbcf48..00000000 Binary files a/crates/renderling/src/linkage/stage-renderlet_fragment.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/stage-renderlet_vertex.spv b/crates/renderling/src/linkage/stage-renderlet_vertex.spv deleted file mode 100644 index a1b8d4e7..00000000 Binary files a/crates/renderling/src/linkage/stage-renderlet_vertex.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/tonemapping_fragment.rs b/crates/renderling/src/linkage/tonemapping_fragment.rs index 2e359b33..29ae25d4 100644 --- a/crates/renderling/src/linkage/tonemapping_fragment.rs +++ b/crates/renderling/src/linkage/tonemapping_fragment.rs @@ -1,23 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [tonemapping::tonemapping_fragment](crate::tonemapping::tonemapping_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/tonemapping-tonemapping_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "tonemapping::tonemapping_fragment"; +mod target { + pub const ENTRY_POINT: &str = "tonemapping::tonemapping_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/tonemapping-tonemapping_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "tonemapping_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "tonemappingtonemapping_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device - .create_shader_module(wgpu::include_spirv!("tonemapping-tonemapping_fragment.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "tonemappingtonemapping_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/tonemapping-tonemapping_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "tonemapping_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/tonemapping_vertex.rs b/crates/renderling/src/linkage/tonemapping_vertex.rs index 9d8dc862..dad930fc 100644 --- a/crates/renderling/src/linkage/tonemapping_vertex.rs +++ b/crates/renderling/src/linkage/tonemapping_vertex.rs @@ -1,22 +1,34 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [tonemapping::tonemapping_vertex](crate::tonemapping::tonemapping_vertex). -//! -//! **source path**: -//! `crates/renderling/src/linkage/tonemapping-tonemapping_vertex.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "tonemapping::tonemapping_vertex"; +mod target { + pub const ENTRY_POINT: &str = "tonemapping::tonemapping_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/tonemapping-tonemapping_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating native linkage for {}", "tonemapping_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "tonemappingtonemapping_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new( - device.create_shader_module(wgpu::include_spirv!("tonemapping-tonemapping_vertex.spv")), - ), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "tonemappingtonemapping_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/tonemapping-tonemapping_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "tonemapping_vertex"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/tutorial-tutorial_slabbed_renderlet.spv b/crates/renderling/src/linkage/tutorial-tutorial_slabbed_renderlet.spv deleted file mode 100644 index 1f0d74b8..00000000 Binary files a/crates/renderling/src/linkage/tutorial-tutorial_slabbed_renderlet.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/tutorial-tutorial_slabbed_vertices.spv b/crates/renderling/src/linkage/tutorial-tutorial_slabbed_vertices.spv deleted file mode 100644 index 66dd7164..00000000 Binary files a/crates/renderling/src/linkage/tutorial-tutorial_slabbed_vertices.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/tutorial-tutorial_slabbed_vertices_no_instance.spv b/crates/renderling/src/linkage/tutorial-tutorial_slabbed_vertices_no_instance.spv deleted file mode 100644 index 1ab9440d..00000000 Binary files a/crates/renderling/src/linkage/tutorial-tutorial_slabbed_vertices_no_instance.spv and /dev/null differ diff --git a/crates/renderling/src/linkage/tutorial_implicit_isosceles_vertex.rs b/crates/renderling/src/linkage/tutorial_implicit_isosceles_vertex.rs index aaa8059a..cc679ff2 100644 --- a/crates/renderling/src/linkage/tutorial_implicit_isosceles_vertex.rs +++ b/crates/renderling/src/linkage/tutorial_implicit_isosceles_vertex.rs @@ -1,23 +1,40 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [tutorial::tutorial_implicit_isosceles_vertex](crate::tutorial::tutorial_implicit_isosceles_vertex). -//! -//! **source path**: -//! `crates/renderling/src/linkage/tutorial-tutorial_implicit_isosceles_vertex. -//! spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "tutorial::tutorial_implicit_isosceles_vertex"; +mod target { + pub const ENTRY_POINT: &str = "tutorial::tutorial_implicit_isosceles_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/tutorial-tutorial_implicit_isosceles_vertex.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "tutorial_implicit_isosceles_vertex" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "tutorialtutorial_implicit_isosceles_vertex"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "tutorial-tutorial_implicit_isosceles_vertex.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "tutorialtutorial_implicit_isosceles_vertex"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/tutorial-tutorial_implicit_isosceles_vertex.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating web linkage for {}", + "tutorial_implicit_isosceles_vertex" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/tutorial_passthru_fragment.rs b/crates/renderling/src/linkage/tutorial_passthru_fragment.rs index c3fd9c77..30e6172a 100644 --- a/crates/renderling/src/linkage/tutorial_passthru_fragment.rs +++ b/crates/renderling/src/linkage/tutorial_passthru_fragment.rs @@ -1,22 +1,37 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [tutorial::tutorial_passthru_fragment](crate::tutorial::tutorial_passthru_fragment). -//! -//! **source path**: -//! `crates/renderling/src/linkage/tutorial-tutorial_passthru_fragment.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "tutorial::tutorial_passthru_fragment"; +mod target { + pub const ENTRY_POINT: &str = "tutorial::tutorial_passthru_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/tutorial-tutorial_passthru_fragment.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "tutorial_passthru_fragment" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "tutorialtutorial_passthru_fragment"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "tutorial-tutorial_passthru_fragment.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "tutorialtutorial_passthru_fragment"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/tutorial-tutorial_passthru_fragment.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "tutorial_passthru_fragment"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/tutorial_slabbed_renderlet.rs b/crates/renderling/src/linkage/tutorial_slabbed_renderlet.rs index 83b5de16..a2cf0d9f 100644 --- a/crates/renderling/src/linkage/tutorial_slabbed_renderlet.rs +++ b/crates/renderling/src/linkage/tutorial_slabbed_renderlet.rs @@ -1,22 +1,37 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [tutorial::tutorial_slabbed_renderlet](crate::tutorial::tutorial_slabbed_renderlet). -//! -//! **source path**: -//! `crates/renderling/src/linkage/tutorial-tutorial_slabbed_renderlet.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "tutorial::tutorial_slabbed_renderlet"; +mod target { + pub const ENTRY_POINT: &str = "tutorial::tutorial_slabbed_renderlet"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/tutorial-tutorial_slabbed_renderlet.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "tutorial_slabbed_renderlet" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "tutorialtutorial_slabbed_renderlet"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "tutorial-tutorial_slabbed_renderlet.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "tutorialtutorial_slabbed_renderlet"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/tutorial-tutorial_slabbed_renderlet.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "tutorial_slabbed_renderlet"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/tutorial_slabbed_vertices.rs b/crates/renderling/src/linkage/tutorial_slabbed_vertices.rs index ab52f4c9..a1a9f95a 100644 --- a/crates/renderling/src/linkage/tutorial_slabbed_vertices.rs +++ b/crates/renderling/src/linkage/tutorial_slabbed_vertices.rs @@ -1,22 +1,37 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [tutorial::tutorial_slabbed_vertices](crate::tutorial::tutorial_slabbed_vertices). -//! -//! **source path**: -//! `crates/renderling/src/linkage/tutorial-tutorial_slabbed_vertices.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "tutorial::tutorial_slabbed_vertices"; +mod target { + pub const ENTRY_POINT: &str = "tutorial::tutorial_slabbed_vertices"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/tutorial-tutorial_slabbed_vertices.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "tutorial_slabbed_vertices" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "tutorialtutorial_slabbed_vertices"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "tutorial-tutorial_slabbed_vertices.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "tutorialtutorial_slabbed_vertices"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/tutorial-tutorial_slabbed_vertices.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!("creating web linkage for {}", "tutorial_slabbed_vertices"); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/crates/renderling/src/linkage/tutorial_slabbed_vertices_no_instance.rs b/crates/renderling/src/linkage/tutorial_slabbed_vertices_no_instance.rs index bd4e75ff..b6e0d949 100644 --- a/crates/renderling/src/linkage/tutorial_slabbed_vertices_no_instance.rs +++ b/crates/renderling/src/linkage/tutorial_slabbed_vertices_no_instance.rs @@ -1,23 +1,40 @@ #![allow(dead_code)] -//! Automatically generated with `cd shaders && cargo run --release`. -//! -//! Provides the shader linkage for -//! [tutorial::tutorial_slabbed_vertices_no_instance](crate::tutorial::tutorial_slabbed_vertices_no_instance). -//! -//! **source path**: -//! `crates/renderling/src/linkage/ -//! tutorial-tutorial_slabbed_vertices_no_instance.spv` -use super::ShaderLinkage; -use std::sync::Arc; +//! Automatically generated by Renderling's `build.rs`. +use crate::linkage::ShaderLinkage; #[cfg(not(target_arch = "wasm32"))] -pub const ENTRY_POINT: &str = "tutorial::tutorial_slabbed_vertices_no_instance"; +mod target { + pub const ENTRY_POINT: &str = "tutorial::tutorial_slabbed_vertices_no_instance"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_spirv!("../../shaders/tutorial-tutorial_slabbed_vertices_no_instance.spv") + } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating native linkage for {}", + "tutorial_slabbed_vertices_no_instance" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} #[cfg(target_arch = "wasm32")] -pub const ENTRY_POINT: &str = "tutorialtutorial_slabbed_vertices_no_instance"; -pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: Arc::new(device.create_shader_module(wgpu::include_spirv!( - "tutorial-tutorial_slabbed_vertices_no_instance.spv" - ))), - entry_point: ENTRY_POINT, +mod target { + pub const ENTRY_POINT: &str = "tutorialtutorial_slabbed_vertices_no_instance"; + pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> { + wgpu::include_wgsl!("../../shaders/tutorial-tutorial_slabbed_vertices_no_instance.wgsl") } + pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage { + log::info!( + "creating web linkage for {}", + "tutorial_slabbed_vertices_no_instance" + ); + super::ShaderLinkage { + entry_point: ENTRY_POINT, + module: device.create_shader_module(descriptor()).into(), + } + } +} +pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { + target::linkage(device) } diff --git a/shaders/Cargo.lock b/shaders/Cargo.lock deleted file mode 100644 index 07d0f1d7..00000000 --- a/shaders/Cargo.lock +++ /dev/null @@ -1,966 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "ahash" -version = "0.7.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" -dependencies = [ - "getrandom", - "once_cell", - "version_check", -] - -[[package]] -name = "aho-corasick" -version = "0.7.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac" -dependencies = [ - "memchr", -] - -[[package]] -name = "anstream" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ab91ebe16eb252986481c5b62f6098f3b698a45e34b5b98200cf20dd2484a44" -dependencies = [ - "anstyle", - "anstyle-parse", - "anstyle-query", - "anstyle-wincon", - "colorchoice", - "utf8parse", -] - -[[package]] -name = "anstyle" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87" - -[[package]] -name = "anstyle-parse" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "317b9a89c1868f5ea6ff1d9539a69f45dffc21ce321ac1fd1160dfa48c8e2140" -dependencies = [ - "utf8parse", -] - -[[package]] -name = "anstyle-query" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b" -dependencies = [ - "windows-sys", -] - -[[package]] -name = "anstyle-wincon" -version = "3.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0699d10d2f4d628a98ee7b57b289abbc98ff3bad977cb3152709d4bf2330628" -dependencies = [ - "anstyle", - "windows-sys", -] - -[[package]] -name = "ar" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d67af77d68a931ecd5cbd8a3b5987d63a1d1d1278f7f6a60ae33db485cdebb69" - -[[package]] -name = "arrayvec" -version = "0.7.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6" - -[[package]] -name = "autocfg" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" - -[[package]] -name = "bit-set" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" -dependencies = [ - "bit-vec", -] - -[[package]] -name = "bit-vec" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" - -[[package]] -name = "bitflags" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bitflags" -version = "2.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" - -[[package]] -name = "bytemuck" -version = "1.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c041d3eab048880cb0b86b256447da3f18859a163c3b8d8893f4e6368abe6393" - -[[package]] -name = "byteorder" -version = "1.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" - -[[package]] -name = "cc" -version = "1.0.79" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f" -dependencies = [ - "jobserver", -] - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "clap" -version = "4.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2275f18819641850fa26c89acc84d465c1bf91ce57bc2748b28c420473352f64" -dependencies = [ - "clap_builder", - "clap_derive", -] - -[[package]] -name = "clap_builder" -version = "4.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07cdf1b148b25c1e1f7a42225e30a0d99a615cd4637eae7365548dd4529b95bc" -dependencies = [ - "anstream", - "anstyle", - "clap_lex", - "strsim", -] - -[[package]] -name = "clap_derive" -version = "4.4.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442" -dependencies = [ - "heck", - "proc-macro2", - "quote", - "syn 2.0.48", -] - -[[package]] -name = "clap_lex" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1" - -[[package]] -name = "codespan-reporting" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e" -dependencies = [ - "termcolor", - "unicode-width", -] - -[[package]] -name = "colorchoice" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7" - -[[package]] -name = "convert_case" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" - -[[package]] -name = "derive_more" -version = "0.99.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" -dependencies = [ - "convert_case", - "proc-macro2", - "quote", - "rustc_version", - "syn 1.0.107", -] - -[[package]] -name = "either" -version = "1.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91" - -[[package]] -name = "elsa" -version = "1.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b4b5d23ed6b6948d68240aafa4ac98e568c9a020efd9d4201a6288bc3006e09" -dependencies = [ - "indexmap 1.9.2", - "stable_deref_trait", -] - -[[package]] -name = "env_logger" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0" -dependencies = [ - "humantime", - "is-terminal", - "log", - "regex", - "termcolor", -] - -[[package]] -name = "equivalent" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" - -[[package]] -name = "errno" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a" -dependencies = [ - "errno-dragonfly", - "libc", - "windows-sys", -] - -[[package]] -name = "errno-dragonfly" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf" -dependencies = [ - "cc", - "libc", -] - -[[package]] -name = "fixedbitset" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" - -[[package]] -name = "fxhash" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" -dependencies = [ - "byteorder", -] - -[[package]] -name = "getrandom" -version = "0.2.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31" -dependencies = [ - "cfg-if", - "libc", - "wasi", -] - -[[package]] -name = "hashbrown" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" -dependencies = [ - "ahash", -] - -[[package]] -name = "hashbrown" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" - -[[package]] -name = "hashbrown" -version = "0.14.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" - -[[package]] -name = "heck" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" - -[[package]] -name = "hermit-abi" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286" - -[[package]] -name = "hexf-parse" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df" - -[[package]] -name = "humantime" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" - -[[package]] -name = "indexmap" -version = "1.9.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399" -dependencies = [ - "autocfg", - "hashbrown 0.12.3", -] - -[[package]] -name = "indexmap" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5" -dependencies = [ - "equivalent", - "hashbrown 0.14.5", -] - -[[package]] -name = "internal-iterator" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a668ef46056a63366da9d74f48062da9ece1a27958f2f3704aa6f7421c4433f5" - -[[package]] -name = "io-lifetimes" -version = "1.0.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220" -dependencies = [ - "hermit-abi", - "libc", - "windows-sys", -] - -[[package]] -name = "is-terminal" -version = "0.4.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adcf93614601c8129ddf72e2d5633df827ba6551541c6d8c59520a371475be1f" -dependencies = [ - "hermit-abi", - "io-lifetimes", - "rustix", - "windows-sys", -] - -[[package]] -name = "itertools" -version = "0.10.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" -dependencies = [ - "either", -] - -[[package]] -name = "itoa" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440" - -[[package]] -name = "jobserver" -version = "0.1.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "068b1ee6743e4d11fb9c6a1e6064b3693a1b600e7f5f5988047d98b3dc9fb90b" -dependencies = [ - "libc", -] - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "libc" -version = "0.2.153" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" - -[[package]] -name = "linux-raw-sys" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519" - -[[package]] -name = "log" -version = "0.4.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "longest-increasing-subsequence" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3bd0dd2cd90571056fdb71f6275fada10131182f84899f4b2a916e565d81d86" - -[[package]] -name = "memchr" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" - -[[package]] -name = "naga" -version = "0.19.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50e3524642f53d9af419ab5e8dd29d3ba155708267667c2f3f06c88c9e130843" -dependencies = [ - "bit-set", - "bitflags 2.6.0", - "codespan-reporting", - "hexf-parse", - "indexmap 2.5.0", - "log", - "num-traits", - "petgraph", - "rustc-hash", - "spirv 0.3.0+sdk-1.3.268.0", - "termcolor", - "thiserror", - "unicode-xid", -] - -[[package]] -name = "num-traits" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" -dependencies = [ - "autocfg", -] - -[[package]] -name = "once_cell" -version = "1.17.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66" - -[[package]] -name = "petgraph" -version = "0.6.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db" -dependencies = [ - "fixedbitset", - "indexmap 2.5.0", -] - -[[package]] -name = "proc-macro2" -version = "1.0.78" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quote" -version = "1.0.35" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "raw-string" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0501e134c6905fee1f10fed25b0a7e1261bf676cffac9543a7d0730dec01af2" - -[[package]] -name = "regex" -version = "1.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax", -] - -[[package]] -name = "regex-syntax" -version = "0.6.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848" - -[[package]] -name = "rspirv" -version = "0.11.0+1.5.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1503993b59ca9ae4127365c3293517576d7ce56be9f3d8abb1625c85ddc583ba" -dependencies = [ - "fxhash", - "num-traits", - "spirv 0.2.0+1.5.4", -] - -[[package]] -name = "rustc-demangle" -version = "0.1.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342" - -[[package]] -name = "rustc-hash" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" - -[[package]] -name = "rustc_codegen_spirv" -version = "0.9.0" -source = "git+https://github.com/Rust-GPU/rust-gpu#529aaf4f3fd1f40cb7dea4fbfd484d544b7b60ed" -dependencies = [ - "ar", - "either", - "hashbrown 0.11.2", - "indexmap 1.9.2", - "itertools", - "lazy_static", - "libc", - "num-traits", - "once_cell", - "regex", - "rspirv", - "rustc-demangle", - "rustc_codegen_spirv-types", - "sanitize-filename", - "smallvec", - "spirt", - "spirv-tools", - "syn 1.0.107", -] - -[[package]] -name = "rustc_codegen_spirv-types" -version = "0.9.0" -source = "git+https://github.com/Rust-GPU/rust-gpu#529aaf4f3fd1f40cb7dea4fbfd484d544b7b60ed" -dependencies = [ - "rspirv", - "serde", - "serde_json", -] - -[[package]] -name = "rustc_version" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" -dependencies = [ - "semver", -] - -[[package]] -name = "rustix" -version = "0.37.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fea8ca367a3a01fe35e6943c400addf443c0f57670e6ec51196f71a4b8762dd2" -dependencies = [ - "bitflags 1.3.2", - "errno", - "io-lifetimes", - "libc", - "linux-raw-sys", - "windows-sys", -] - -[[package]] -name = "ryu" -version = "1.0.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde" - -[[package]] -name = "sanitize-filename" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08c502bdb638f1396509467cb0580ef3b29aa2a45c5d43e5d84928241280296c" -dependencies = [ - "lazy_static", - "regex", -] - -[[package]] -name = "semver" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0293b4b29daaf487284529cc2f5675b8e57c61f70167ba415a463651fd6a918" - -[[package]] -name = "serde" -version = "1.0.152" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_derive" -version = "1.0.152" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.107", -] - -[[package]] -name = "serde_json" -version = "1.0.93" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cad406b69c91885b5107daf2c29572f6c8cdb3c66826821e286c533490c0bc76" -dependencies = [ - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "shaders" -version = "0.1.0" -dependencies = [ - "clap", - "env_logger", - "log", - "naga", - "quote", - "spirv-builder", -] - -[[package]] -name = "smallvec" -version = "1.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0" -dependencies = [ - "serde", -] - -[[package]] -name = "spirt" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64e1f7903720ff818d6da824edf2c4082c6e7a029a99317fd10c39dd7c40c7ff" -dependencies = [ - "arrayvec", - "bytemuck", - "derive_more", - "elsa", - "indexmap 1.9.2", - "internal-iterator", - "itertools", - "lazy_static", - "longest-increasing-subsequence", - "rustc-hash", - "serde", - "serde_json", - "smallvec", -] - -[[package]] -name = "spirv" -version = "0.2.0+1.5.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "246bfa38fe3db3f1dfc8ca5a2cdeb7348c78be2112740cc0ec8ef18b6d94f830" -dependencies = [ - "bitflags 1.3.2", - "num-traits", -] - -[[package]] -name = "spirv" -version = "0.3.0+sdk-1.3.268.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844" -dependencies = [ - "bitflags 2.6.0", -] - -[[package]] -name = "spirv-builder" -version = "0.9.0" -source = "git+https://github.com/Rust-GPU/rust-gpu#529aaf4f3fd1f40cb7dea4fbfd484d544b7b60ed" -dependencies = [ - "memchr", - "raw-string", - "rustc_codegen_spirv", - "rustc_codegen_spirv-types", - "serde", - "serde_json", -] - -[[package]] -name = "spirv-tools" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bcb3b0832881834994b7ec82b709ec5491043ceb4bf8101e27da6b5234b24261" -dependencies = [ - "spirv-tools-sys", -] - -[[package]] -name = "spirv-tools-sys" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48e68b55a97aa6856e010a6f2477425875a97873e147bb0232160e73c45bdae7" -dependencies = [ - "cc", -] - -[[package]] -name = "stable_deref_trait" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" - -[[package]] -name = "strsim" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" - -[[package]] -name = "syn" -version = "1.0.107" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "syn" -version = "2.0.48" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "termcolor" -version = "1.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "thiserror" -version = "1.0.64" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84" -dependencies = [ - "thiserror-impl", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.64" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.48", -] - -[[package]] -name = "unicode-ident" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc" - -[[package]] -name = "unicode-width" -version = "0.1.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" - -[[package]] -name = "unicode-xid" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" - -[[package]] -name = "utf8parse" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a" - -[[package]] -name = "version_check" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" - -[[package]] -name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-util" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" -dependencies = [ - "winapi", -] - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows-sys" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" -dependencies = [ - "windows-targets", -] - -[[package]] -name = "windows-targets" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5" -dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3" - -[[package]] -name = "windows_i686_gnu" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241" - -[[package]] -name = "windows_i686_msvc" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a" diff --git a/shaders/Cargo.toml b/shaders/Cargo.toml deleted file mode 100644 index 97b15a5d..00000000 --- a/shaders/Cargo.toml +++ /dev/null @@ -1,30 +0,0 @@ -[package] -name = "shaders" -version = "0.1.0" -edition = "2021" -description = "Generates shader .spv files from rust-gpu shader crates" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[dependencies] -clap = { version = "4.4.8", features = ["derive"] } -env_logger = "^0.10" -log = "^0.4" -naga = { version = "0.19", features = ["spv-in", "wgsl-out", "wgsl-in", "msl-out"] } -quote = "1.0" -spirv-builder = { git = "https://github.com/Rust-GPU/rust-gpu" } - -# Enable incremental by default in release mode. -[profile.release] -incremental = true -# HACK(eddyb) this is the default but without explicitly specifying it, Cargo -# will treat the identical settings in `[profile.release.build-override]` below -# as different sets of `rustc` flags and will not reuse artifacts between them. -codegen-units = 256 - -# Compile build-dependencies in release mode with the same settings -# as regular dependencies (including the incremental enabled above). -[profile.release.build-override] -opt-level = 3 -incremental = true -codegen-units = 256 diff --git a/shaders/rust-toolchain.toml b/shaders/rust-toolchain.toml deleted file mode 100644 index 92ae5010..00000000 --- a/shaders/rust-toolchain.toml +++ /dev/null @@ -1,12 +0,0 @@ -# If you see this, run `rustup self update` to get rustup 1.23 or newer. - -# NOTE: above comment is for older `rustup` (before TOML support was added), -# which will treat the first line as the toolchain name, and therefore show it -# to the user in the error, instead of "error: invalid channel name '[toolchain]'". - -[toolchain] -channel = "nightly-2024-04-24" -components = ["rust-src", "rustc-dev", "llvm-tools"] - -# Whenever changing the nightly channel, update the commit hash above, and make -# sure to change REQUIRED_TOOLCHAIN in crates/rustc_codegen_spirv/src/build.rs also. diff --git a/shaders/src/main.rs b/shaders/src/main.rs deleted file mode 100644 index 9d8ecd95..00000000 --- a/shaders/src/main.rs +++ /dev/null @@ -1,196 +0,0 @@ -//! This program builds the rust-gpu shaders and writes the spv files into the -//! main source repo. -use clap::Parser; -use spirv_builder::{CompileResult, MetadataPrintout, ModuleResult, SpirvBuilder}; - -mod shader; - -#[derive(Clone, Copy, Default)] -pub enum ShaderLang { - #[default] - Spv, - Wgsl, -} - -impl core::str::FromStr for ShaderLang { - type Err = String; - - fn from_str(s: &str) -> Result { - match s { - "spv" => Ok(ShaderLang::Spv), - "wgsl" => Ok(ShaderLang::Wgsl), - s => Err(format!("not a valid option '{s}'")), - } - } -} - -#[derive(Parser)] -#[clap(author, version, about)] -struct Cli { - /// Sets the verbosity level - #[clap(short, action = clap::ArgAction::Count)] - verbosity: u8, - - /// Directory containing the shader crate to compile. - #[clap(long, short, default_value = "renderling")] - shader_crate: std::path::PathBuf, - - /// Whether to write the spv or wgsl - #[clap(long, default_value = "spv")] - shader_lang: ShaderLang, - - /// Set cargo default-features. - #[clap(long)] - no_default_features: bool, - - /// Set cargo features. - #[clap(long)] - features: Vec, - - /// Path to the output directory for the compiled shaders. - #[clap(long, short, default_value = "../crates/renderling/src/linkage")] - output_dir: std::path::PathBuf, - - /// If set the shaders will be compiled but not put into place. - #[clap(long, short)] - dry_run: bool, -} - -fn wgsl(spv_filepath: impl AsRef, destination: impl AsRef) { - let bytes = std::fs::read(spv_filepath).unwrap(); - 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(); -} - -fn main() -> Result<(), Box> { - let Cli { - verbosity, - shader_crate, - shader_lang, - no_default_features, - features, - output_dir, - dry_run, - } = Cli::parse(); - let level = match verbosity { - 0 => log::LevelFilter::Warn, - 1 => log::LevelFilter::Info, - 2 => log::LevelFilter::Debug, - _ => log::LevelFilter::Trace, - }; - env_logger::builder() - .filter_level(level) - .try_init() - .unwrap(); - - std::fs::create_dir_all(&output_dir).unwrap(); - - let shader_crate = std::path::Path::new("../crates/").join(shader_crate); - assert!( - shader_crate.exists(), - "shader crate '{}' does not exist. Current dir is {}", - shader_crate.display(), - std::env::current_dir().unwrap().display() - ); - - let start = std::time::Instant::now(); - - let CompileResult { - entry_points, - module, - } = { - let mut builder = SpirvBuilder::new(shader_crate, "spirv-unknown-vulkan1.2") - //.shader_panic_strategy(spirv_builder::ShaderPanicStrategy::UNSOUND_DO_NOT_USE_UndefinedBehaviorViaUnreachable) - .print_metadata(MetadataPrintout::None) - .multimodule(true); - - if no_default_features { - println!("setting cargo --no-default-features"); - builder = builder.shader_crate_default_features(false); - } - if !features.is_empty() { - println!("setting --features {features:?}"); - builder = builder.shader_crate_features(features); - } - - builder.build()? - }; - - let dir = output_dir; - let mut shaders = vec![]; - match module { - ModuleResult::MultiModule(modules) => { - assert!(!modules.is_empty(), "No shader modules to compile"); - for (entry, filepath) in modules.into_iter() { - let path = dir.join(filepath.file_name().unwrap()); - if !dry_run { - match shader_lang { - ShaderLang::Spv => { - std::fs::copy(filepath, &path).unwrap(); - } - ShaderLang::Wgsl => { - wgsl(filepath, &path); - } - } - } - shaders.push(shader::Linkage { - entry_point: entry, - source_path: path, - }); - } - } - ModuleResult::SingleModule(filepath) => { - let path = dir.join(filepath.file_name().unwrap()); - if !dry_run { - std::fs::copy(filepath, &path).unwrap(); - } - for entry in entry_points { - shaders.push(shader::Linkage { - entry_point: entry, - source_path: path.clone(), - }); - } - } - } - - if dry_run { - println!("\nNot writing shaders.rs because --dry-run was set.\n"); - } else { - println!("\nWriting shaders..."); - }; - - let mut set = std::collections::HashSet::<&str>::default(); - - for linkage in shaders.iter() { - 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); - - let filepath = dir.join(fn_name).with_extension("rs"); - let contents = linkage.to_string(shader_lang); - if !dry_run { - std::fs::write(&filepath, contents).unwrap(); - std::process::Command::new("rustfmt") - .args([&format!("{}", filepath.display())]) - .output() - .expect("could not format generated code"); - println!(" {}", filepath.display()); - } - } - - let end = std::time::Instant::now(); - println!("Finished in {:?}", (end - start)); - - Ok(()) -} diff --git a/shaders/src/shader.rs b/shaders/src/shader.rs deleted file mode 100644 index 4d018820..00000000 --- a/shaders/src/shader.rs +++ /dev/null @@ -1,68 +0,0 @@ -//! A shader source and entry point that can be used to create renderling -//! shader linkage. -use super::ShaderLang; -use quote::quote; - -pub struct Linkage { - pub source_path: std::path::PathBuf, - pub entry_point: String, -} - -impl Linkage { - pub fn fn_name(&self) -> &str { - self.entry_point.split("::").last().unwrap() - } - - pub fn to_string(&self, lang: ShaderLang) -> String { - let source_path = match lang { - ShaderLang::Spv => self.source_path.clone(), - ShaderLang::Wgsl => self.source_path.with_extension("wgsl"), - }; - - let source_path = source_path.file_name().unwrap().to_str().unwrap(); - let entry_point = self.entry_point.clone(); - - let wgsl_entry_point = entry_point.replace("::", ""); - let entry_point = match lang { - ShaderLang::Spv => entry_point, - ShaderLang::Wgsl => entry_point.replace("::", ""), - }; - - let create_module = match lang { - ShaderLang::Spv => quote! { - Arc::new(device.create_shader_module(wgpu::include_spirv!(#source_path))) - }, - ShaderLang::Wgsl => quote! { - Arc::new(device.create_shader_module(wgpu::include_wgsl!(#source_path))) - }, - }; - let quote = quote! { - use std::sync::Arc; - - use super::ShaderLinkage; - - #[cfg(not(target_arch = "wasm32"))] - pub const ENTRY_POINT: &str = #entry_point; - #[cfg(target_arch = "wasm32")] - pub const ENTRY_POINT: &str = #wgsl_entry_point; - - pub fn linkage(device: &wgpu::Device) -> ShaderLinkage { - ShaderLinkage { - module: #create_module, - entry_point: ENTRY_POINT, - } - } - }; - format!( - r#"#![allow(dead_code)] - //! Automatically generated with `cd shaders && cargo run --release`. - //! - //! Provides the shader linkage for - //! [{entry_point}](crate::{entry_point}). - //! - //! **source path**: `crates/renderling/src/linkage/{source_path}` - {quote} - "#, - ) - } -}