From 7895e7f036debe59f5f35e2d5be9e1598d28393e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Capucho?= Date: Fri, 17 Sep 2021 22:03:54 +0100 Subject: [PATCH] Don't output identifiers starting with _ --- src/back/wgsl/mod.rs | 2 + src/back/wgsl/writer.rs | 6 +- src/proc/namer.rs | 2 +- tests/out/wgsl/210-bevy-2d-shader-frag.wgsl | 12 +- tests/out/wgsl/210-bevy-2d-shader-vert.wgsl | 24 +- tests/out/wgsl/210-bevy-shader-vert.wgsl | 38 +- tests/out/wgsl/246-collatz-comp.wgsl | 40 +- tests/out/wgsl/280-matrix-cast-vert.wgsl | 2 +- .../wgsl/800-out-of-bounds-panic-vert.wgsl | 24 +- tests/out/wgsl/932-for-loop-if-vert.wgsl | 8 +- tests/out/wgsl/access.wgsl | 32 +- tests/out/wgsl/bevy-pbr-frag.wgsl | 1042 ++++++++--------- tests/out/wgsl/bevy-pbr-vert.wgsl | 46 +- tests/out/wgsl/binop-frag.wgsl | 232 ++-- tests/out/wgsl/boids.wgsl | 160 +-- tests/out/wgsl/bool-select-frag.wgsl | 30 +- tests/out/wgsl/clamp-splat-vert.wgsl | 8 +- tests/out/wgsl/collatz.wgsl | 30 +- tests/out/wgsl/constant-array-size-vert.wgsl | 20 +- tests/out/wgsl/control-flow.wgsl | 8 +- tests/out/wgsl/fma-frag.wgsl | 36 +- .../out/wgsl/global-constant-array-vert.wgsl | 2 +- tests/out/wgsl/interpolate.wgsl | 4 +- .../wgsl/inv-hyperbolic-trig-functions.wgsl | 12 +- tests/out/wgsl/long-form-matrix-vert.wgsl | 28 +- tests/out/wgsl/math-functions-vert.wgsl | 202 ++-- tests/out/wgsl/operators.wgsl | 12 +- tests/out/wgsl/prepostfix-frag.wgsl | 48 +- tests/out/wgsl/quad-vert.wgsl | 14 +- tests/out/wgsl/quad_glsl-frag.wgsl | 4 +- tests/out/wgsl/quad_glsl-vert.wgsl | 14 +- tests/out/wgsl/samplers-frag.wgsl | 892 +++++++------- tests/out/wgsl/shadow.wgsl | 30 +- tests/out/wgsl/skybox.wgsl | 22 +- tests/out/wgsl/swizzle_write-frag.wgsl | 18 +- tests/out/wgsl/texture-arg.wgsl | 8 +- 36 files changed, 1557 insertions(+), 1555 deletions(-) diff --git a/src/back/wgsl/mod.rs b/src/back/wgsl/mod.rs index c99df6d811..3198e65b61 100644 --- a/src/back/wgsl/mod.rs +++ b/src/back/wgsl/mod.rs @@ -5,6 +5,8 @@ use thiserror::Error; pub use writer::Writer; +const BAKE_PREFIX: &str = "e"; + #[derive(Error, Debug)] pub enum Error { #[error(transparent)] diff --git a/src/back/wgsl/writer.rs b/src/back/wgsl/writer.rs index bed97fa7df..7f05d7915b 100644 --- a/src/back/wgsl/writer.rs +++ b/src/back/wgsl/writer.rs @@ -701,7 +701,7 @@ impl Writer { } } - Some(format!("{}{}", back::BAKE_PREFIX, handle.index())) + Some(format!("{}{}", super::BAKE_PREFIX, handle.index())) } else { None } @@ -804,7 +804,7 @@ impl Writer { } => { write!(self.out, "{}", level)?; if let Some(expr) = result { - let name = format!("{}{}", back::BAKE_PREFIX, expr.index()); + let name = format!("{}{}", super::BAKE_PREFIX, expr.index()); self.start_named_expr(module, expr, func_ctx, &name)?; self.named_expressions.insert(expr, name); } @@ -827,7 +827,7 @@ impl Writer { result, } => { write!(self.out, "{}", level)?; - let res_name = format!("{}{}", back::BAKE_PREFIX, result.index()); + let res_name = format!("{}{}", super::BAKE_PREFIX, result.index()); self.start_named_expr(module, result, func_ctx, &res_name)?; self.named_expressions.insert(result, res_name); diff --git a/src/proc/namer.rs b/src/proc/namer.rs index b8f03b25ce..f250fc1f60 100644 --- a/src/proc/namer.rs +++ b/src/proc/namer.rs @@ -32,7 +32,7 @@ impl Namer { fn sanitize(&self, string: &str) -> String { let mut base = string .chars() - .skip_while(|c| c.is_numeric()) + .skip_while(|&c| c.is_numeric() || c == '_') .filter(|&c| c.is_ascii_alphanumeric() || c == '_') .collect::(); // close the name by '_' if the re is a number, so that diff --git a/tests/out/wgsl/210-bevy-2d-shader-frag.wgsl b/tests/out/wgsl/210-bevy-2d-shader-frag.wgsl index 950979fdd8..30cd002911 100644 --- a/tests/out/wgsl/210-bevy-2d-shader-frag.wgsl +++ b/tests/out/wgsl/210-bevy-2d-shader-frag.wgsl @@ -15,10 +15,10 @@ var global: ColorMaterial_color; fn main1() { var color: vec4; - let _e4: vec4 = global.Color; - color = _e4; - let _e6: vec4 = color; - o_Target = _e6; + let e4: vec4 = global.Color; + color = e4; + let e6: vec4 = color; + o_Target = e6; return; } @@ -26,6 +26,6 @@ fn main1() { fn main([[location(0)]] v_Uv: vec2) -> FragmentOutput { v_Uv1 = v_Uv; main1(); - let _e9: vec4 = o_Target; - return FragmentOutput(_e9); + let e9: vec4 = o_Target; + return FragmentOutput(e9); } diff --git a/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl b/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl index c495a72323..0d0de959ae 100644 --- a/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl +++ b/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl @@ -33,15 +33,15 @@ var gl_Position: vec4; fn main1() { var position: vec3; - let _e10: vec2 = Vertex_Uv1; - v_Uv = _e10; - let _e11: vec3 = Vertex_Position1; - let _e12: vec2 = global2.size; - position = (_e11 * vec3(_e12, 1.0)); - let _e18: mat4x4 = global.ViewProj; - let _e19: mat4x4 = global1.Model; - let _e21: vec3 = position; - gl_Position = ((_e18 * _e19) * vec4(_e21, 1.0)); + let e10: vec2 = Vertex_Uv1; + v_Uv = e10; + let e11: vec3 = Vertex_Position1; + let e12: vec2 = global2.size; + position = (e11 * vec3(e12, 1.0)); + let e18: mat4x4 = global.ViewProj; + let e19: mat4x4 = global1.Model; + let e21: vec3 = position; + gl_Position = ((e18 * e19) * vec4(e21, 1.0)); return; } @@ -51,7 +51,7 @@ fn main([[location(0)]] Vertex_Position: vec3, [[location(1)]] Vertex_Norma Vertex_Normal1 = Vertex_Normal; Vertex_Uv1 = Vertex_Uv; main1(); - let _e21: vec2 = v_Uv; - let _e23: vec4 = gl_Position; - return VertexOutput(_e21, _e23); + let e21: vec2 = v_Uv; + let e23: vec4 = gl_Position; + return VertexOutput(e21, e23); } diff --git a/tests/out/wgsl/210-bevy-shader-vert.wgsl b/tests/out/wgsl/210-bevy-shader-vert.wgsl index 7c94a048f0..83495e2ae8 100644 --- a/tests/out/wgsl/210-bevy-shader-vert.wgsl +++ b/tests/out/wgsl/210-bevy-shader-vert.wgsl @@ -28,20 +28,20 @@ var global1: Transform; var gl_Position: vec4; fn main1() { - let _e10: mat4x4 = global1.Model; - let _e11: vec3 = Vertex_Normal1; - v_Normal = (_e10 * vec4(_e11, 1.0)).xyz; - let _e16: mat4x4 = global1.Model; - let _e24: vec3 = Vertex_Normal1; - v_Normal = (mat3x3(_e16[0].xyz, _e16[1].xyz, _e16[2].xyz) * _e24); - let _e26: mat4x4 = global1.Model; - let _e27: vec3 = Vertex_Position1; - v_Position = (_e26 * vec4(_e27, 1.0)).xyz; - let _e32: vec2 = Vertex_Uv1; - v_Uv = _e32; - let _e34: mat4x4 = global.ViewProj; - let _e35: vec3 = v_Position; - gl_Position = (_e34 * vec4(_e35, 1.0)); + let e10: mat4x4 = global1.Model; + let e11: vec3 = Vertex_Normal1; + v_Normal = (e10 * vec4(e11, 1.0)).xyz; + let e16: mat4x4 = global1.Model; + let e24: vec3 = Vertex_Normal1; + v_Normal = (mat3x3(e16[0].xyz, e16[1].xyz, e16[2].xyz) * e24); + let e26: mat4x4 = global1.Model; + let e27: vec3 = Vertex_Position1; + v_Position = (e26 * vec4(e27, 1.0)).xyz; + let e32: vec2 = Vertex_Uv1; + v_Uv = e32; + let e34: mat4x4 = global.ViewProj; + let e35: vec3 = v_Position; + gl_Position = (e34 * vec4(e35, 1.0)); return; } @@ -51,9 +51,9 @@ fn main([[location(0)]] Vertex_Position: vec3, [[location(1)]] Vertex_Norma Vertex_Normal1 = Vertex_Normal; Vertex_Uv1 = Vertex_Uv; main1(); - let _e23: vec3 = v_Position; - let _e25: vec3 = v_Normal; - let _e27: vec2 = v_Uv; - let _e29: vec4 = gl_Position; - return VertexOutput(_e23, _e25, _e27, _e29); + let e23: vec3 = v_Position; + let e25: vec3 = v_Normal; + let e27: vec2 = v_Uv; + let e29: vec4 = gl_Position; + return VertexOutput(e23, e25, e27, e29); } diff --git a/tests/out/wgsl/246-collatz-comp.wgsl b/tests/out/wgsl/246-collatz-comp.wgsl index fe75c08fb9..993ec7ff85 100644 --- a/tests/out/wgsl/246-collatz-comp.wgsl +++ b/tests/out/wgsl/246-collatz-comp.wgsl @@ -13,42 +13,42 @@ fn collatz_iterations(n: u32) -> u32 { n1 = n; loop { - let _e7: u32 = n1; - if (!((_e7 != u32(1)))) { + let e7: u32 = n1; + if (!((e7 != u32(1)))) { break; } { - let _e14: u32 = n1; - if (((f32(_e14) % f32(2)) == f32(0))) { + let e14: u32 = n1; + if (((f32(e14) % f32(2)) == f32(0))) { { - let _e22: u32 = n1; - n1 = (_e22 / u32(2)); + let e22: u32 = n1; + n1 = (e22 / u32(2)); } } else { { - let _e27: u32 = n1; - n1 = ((u32(3) * _e27) + u32(1)); + let e27: u32 = n1; + n1 = ((u32(3) * e27) + u32(1)); } } - let _e33: u32 = i; - i = (_e33 + 1u); + let e33: u32 = i; + i = (e33 + 1u); } } - let _e36: u32 = i; - return _e36; + let e36: u32 = i; + return e36; } fn main1() { var index: u32; - let _e3: vec3 = gl_GlobalInvocationID; - index = _e3.x; - let _e6: u32 = index; - let _e8: u32 = index; - let _e11: u32 = index; - let _e13: u32 = global.indices[_e11]; - let _e14: u32 = collatz_iterations(_e13); - global.indices[_e6] = _e14; + let e3: vec3 = gl_GlobalInvocationID; + index = e3.x; + let e6: u32 = index; + let e8: u32 = index; + let e11: u32 = index; + let e13: u32 = global.indices[e11]; + let e14: u32 = collatz_iterations(e13); + global.indices[e6] = e14; return; } diff --git a/tests/out/wgsl/280-matrix-cast-vert.wgsl b/tests/out/wgsl/280-matrix-cast-vert.wgsl index c5676cd288..d3a55eb8eb 100644 --- a/tests/out/wgsl/280-matrix-cast-vert.wgsl +++ b/tests/out/wgsl/280-matrix-cast-vert.wgsl @@ -1,7 +1,7 @@ fn main1() { var a: mat4x4 = mat4x4(vec4(1.0, 0.0, 0.0, 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0)); - let _e1: f32 = f32(1); + let e1: f32 = f32(1); } [[stage(vertex)]] diff --git a/tests/out/wgsl/800-out-of-bounds-panic-vert.wgsl b/tests/out/wgsl/800-out-of-bounds-panic-vert.wgsl index 6046dc3f4e..10ae39b3b5 100644 --- a/tests/out/wgsl/800-out-of-bounds-panic-vert.wgsl +++ b/tests/out/wgsl/800-out-of-bounds-panic-vert.wgsl @@ -22,15 +22,15 @@ var frag_color: vec4; var gl_Position: vec4; fn main1() { - let _e7: vec4 = color1; - frag_color = _e7; - let _e9: mat4x4 = global.view_matrix; - let _e10: mat4x4 = global1.world_matrix; - let _e12: vec2 = position1; - gl_Position = ((_e9 * _e10) * vec4(_e12, 0.0, 1.0)); - let _e18: vec4 = gl_Position; - let _e20: vec4 = gl_Position; - gl_Position.z = ((_e18.z + _e20.w) / 2.0); + let e7: vec4 = color1; + frag_color = e7; + let e9: mat4x4 = global.view_matrix; + let e10: mat4x4 = global1.world_matrix; + let e12: vec2 = position1; + gl_Position = ((e9 * e10) * vec4(e12, 0.0, 1.0)); + let e18: vec4 = gl_Position; + let e20: vec4 = gl_Position; + gl_Position.z = ((e18.z + e20.w) / 2.0); return; } @@ -39,7 +39,7 @@ fn main([[location(0)]] position: vec2, [[location(1)]] color: vec4) - position1 = position; color1 = color; main1(); - let _e15: vec4 = frag_color; - let _e17: vec4 = gl_Position; - return VertexOutput(_e15, _e17); + let e15: vec4 = frag_color; + let e17: vec4 = gl_Position; + return VertexOutput(e15, e17); } diff --git a/tests/out/wgsl/932-for-loop-if-vert.wgsl b/tests/out/wgsl/932-for-loop-if-vert.wgsl index a9fc14ab31..a66020fd8d 100644 --- a/tests/out/wgsl/932-for-loop-if-vert.wgsl +++ b/tests/out/wgsl/932-for-loop-if-vert.wgsl @@ -2,15 +2,15 @@ fn main1() { var i: i32 = 0; loop { - let _e2: i32 = i; - if (!((_e2 < 1))) { + let e2: i32 = i; + if (!((e2 < 1))) { break; } { } continuing { - let _e6: i32 = i; - i = (_e6 + 1); + let e6: i32 = i; + i = (e6 + 1); } } return; diff --git a/tests/out/wgsl/access.wgsl b/tests/out/wgsl/access.wgsl index dd0d9b65e1..1439604190 100644 --- a/tests/out/wgsl/access.wgsl +++ b/tests/out/wgsl/access.wgsl @@ -34,22 +34,22 @@ fn atomics() { var tmp: i32; let value: i32 = atomicLoad((&bar.atom)); - let _e6: i32 = atomicAdd((&bar.atom), 5); - tmp = _e6; - let _e9: i32 = atomicSub((&bar.atom), 5); - tmp = _e9; - let _e12: i32 = atomicAnd((&bar.atom), 5); - tmp = _e12; - let _e15: i32 = atomicOr((&bar.atom), 5); - tmp = _e15; - let _e18: i32 = atomicXor((&bar.atom), 5); - tmp = _e18; - let _e21: i32 = atomicMin((&bar.atom), 5); - tmp = _e21; - let _e24: i32 = atomicMax((&bar.atom), 5); - tmp = _e24; - let _e27: i32 = atomicExchange((&bar.atom), 5); - tmp = _e27; + let e6: i32 = atomicAdd((&bar.atom), 5); + tmp = e6; + let e9: i32 = atomicSub((&bar.atom), 5); + tmp = e9; + let e12: i32 = atomicAnd((&bar.atom), 5); + tmp = e12; + let e15: i32 = atomicOr((&bar.atom), 5); + tmp = e15; + let e18: i32 = atomicXor((&bar.atom), 5); + tmp = e18; + let e21: i32 = atomicMin((&bar.atom), 5); + tmp = e21; + let e24: i32 = atomicMax((&bar.atom), 5); + tmp = e24; + let e27: i32 = atomicExchange((&bar.atom), 5); + tmp = e27; atomicStore((&bar.atom), value); return; } diff --git a/tests/out/wgsl/bevy-pbr-frag.wgsl b/tests/out/wgsl/bevy-pbr-frag.wgsl index 8ff5b88233..23ca8a5f1e 100644 --- a/tests/out/wgsl/bevy-pbr-frag.wgsl +++ b/tests/out/wgsl/bevy-pbr-frag.wgsl @@ -104,13 +104,13 @@ fn pow5_(x: f32) -> f32 { var x2_: f32; x1 = x; - let _e42: f32 = x1; - let _e43: f32 = x1; - x2_ = (_e42 * _e43); - let _e46: f32 = x2_; - let _e47: f32 = x2_; - let _e49: f32 = x1; - return ((_e46 * _e47) * _e49); + let e42: f32 = x1; + let e43: f32 = x1; + x2_ = (e42 * e43); + let e46: f32 = x2_; + let e47: f32 = x2_; + let e49: f32 = x1; + return ((e46 * e47) * e49); } fn getDistanceAttenuation(distanceSquare: f32, inverseRangeSquared: f32) -> f32 { @@ -122,20 +122,20 @@ fn getDistanceAttenuation(distanceSquare: f32, inverseRangeSquared: f32) -> f32 distanceSquare1 = distanceSquare; inverseRangeSquared1 = inverseRangeSquared; - let _e44: f32 = distanceSquare1; - let _e45: f32 = inverseRangeSquared1; - factor = (_e44 * _e45); - let _e49: f32 = factor; - let _e50: f32 = factor; - let _e56: f32 = factor; - let _e57: f32 = factor; - smoothFactor = clamp((1.0 - (_e56 * _e57)), 0.0, 1.0); - let _e64: f32 = smoothFactor; - let _e65: f32 = smoothFactor; - attenuation = (_e64 * _e65); - let _e68: f32 = attenuation; - let _e73: f32 = distanceSquare1; - return ((_e68 * 1.0) / max(_e73, 0.00009999999747378752)); + let e44: f32 = distanceSquare1; + let e45: f32 = inverseRangeSquared1; + factor = (e44 * e45); + let e49: f32 = factor; + let e50: f32 = factor; + let e56: f32 = factor; + let e57: f32 = factor; + smoothFactor = clamp((1.0 - (e56 * e57)), 0.0, 1.0); + let e64: f32 = smoothFactor; + let e65: f32 = smoothFactor; + attenuation = (e64 * e65); + let e68: f32 = attenuation; + let e73: f32 = distanceSquare1; + return ((e68 * 1.0) / max(e73, 0.00009999999747378752)); } fn D_GGX(roughness: f32, NoH: f32, h: vec3) -> f32 { @@ -148,22 +148,22 @@ fn D_GGX(roughness: f32, NoH: f32, h: vec3) -> f32 { roughness1 = roughness; NoH1 = NoH; - let _e46: f32 = NoH1; - let _e47: f32 = NoH1; - oneMinusNoHSquared = (1.0 - (_e46 * _e47)); - let _e51: f32 = NoH1; - let _e52: f32 = roughness1; - a = (_e51 * _e52); - let _e55: f32 = roughness1; - let _e56: f32 = oneMinusNoHSquared; - let _e57: f32 = a; - let _e58: f32 = a; - k = (_e55 / (_e56 + (_e57 * _e58))); - let _e63: f32 = k; - let _e64: f32 = k; - d = ((_e63 * _e64) * (1.0 / 3.1415927410125732)); - let _e70: f32 = d; - return _e70; + let e46: f32 = NoH1; + let e47: f32 = NoH1; + oneMinusNoHSquared = (1.0 - (e46 * e47)); + let e51: f32 = NoH1; + let e52: f32 = roughness1; + a = (e51 * e52); + let e55: f32 = roughness1; + let e56: f32 = oneMinusNoHSquared; + let e57: f32 = a; + let e58: f32 = a; + k = (e55 / (e56 + (e57 * e58))); + let e63: f32 = k; + let e64: f32 = k; + d = ((e63 * e64) * (1.0 / 3.1415927410125732)); + let e70: f32 = d; + return e70; } fn V_SmithGGXCorrelated(roughness2: f32, NoV: f32, NoL: f32) -> f32 { @@ -178,38 +178,38 @@ fn V_SmithGGXCorrelated(roughness2: f32, NoV: f32, NoL: f32) -> f32 { roughness3 = roughness2; NoV1 = NoV; NoL1 = NoL; - let _e46: f32 = roughness3; - let _e47: f32 = roughness3; - a2_ = (_e46 * _e47); - let _e50: f32 = NoL1; - let _e51: f32 = NoV1; - let _e52: f32 = a2_; - let _e53: f32 = NoV1; - let _e56: f32 = NoV1; - let _e58: f32 = a2_; - let _e60: f32 = NoV1; - let _e61: f32 = a2_; - let _e62: f32 = NoV1; - let _e65: f32 = NoV1; - let _e67: f32 = a2_; - lambdaV = (_e50 * sqrt((((_e60 - (_e61 * _e62)) * _e65) + _e67))); - let _e72: f32 = NoV1; - let _e73: f32 = NoL1; - let _e74: f32 = a2_; - let _e75: f32 = NoL1; - let _e78: f32 = NoL1; - let _e80: f32 = a2_; - let _e82: f32 = NoL1; - let _e83: f32 = a2_; - let _e84: f32 = NoL1; - let _e87: f32 = NoL1; - let _e89: f32 = a2_; - lambdaL = (_e72 * sqrt((((_e82 - (_e83 * _e84)) * _e87) + _e89))); - let _e95: f32 = lambdaV; - let _e96: f32 = lambdaL; - v = (0.5 / (_e95 + _e96)); - let _e100: f32 = v; - return _e100; + let e46: f32 = roughness3; + let e47: f32 = roughness3; + a2_ = (e46 * e47); + let e50: f32 = NoL1; + let e51: f32 = NoV1; + let e52: f32 = a2_; + let e53: f32 = NoV1; + let e56: f32 = NoV1; + let e58: f32 = a2_; + let e60: f32 = NoV1; + let e61: f32 = a2_; + let e62: f32 = NoV1; + let e65: f32 = NoV1; + let e67: f32 = a2_; + lambdaV = (e50 * sqrt((((e60 - (e61 * e62)) * e65) + e67))); + let e72: f32 = NoV1; + let e73: f32 = NoL1; + let e74: f32 = a2_; + let e75: f32 = NoL1; + let e78: f32 = NoL1; + let e80: f32 = a2_; + let e82: f32 = NoL1; + let e83: f32 = a2_; + let e84: f32 = NoL1; + let e87: f32 = NoL1; + let e89: f32 = a2_; + lambdaL = (e72 * sqrt((((e82 - (e83 * e84)) * e87) + e89))); + let e95: f32 = lambdaV; + let e96: f32 = lambdaL; + v = (0.5 / (e95 + e96)); + let e100: f32 = v; + return e100; } fn F_Schlick(f0_: vec3, f90_: f32, VoH: f32) -> vec3 { @@ -218,11 +218,11 @@ fn F_Schlick(f0_: vec3, f90_: f32, VoH: f32) -> vec3 { f90_1 = f90_; VoH1 = VoH; - let _e45: f32 = f90_1; - let _e49: f32 = VoH1; - let _e52: f32 = VoH1; - let _e54: f32 = pow5_((1.0 - _e52)); - return (f0_ + ((vec3(_e45) - f0_) * _e54)); + let e45: f32 = f90_1; + let e49: f32 = VoH1; + let e52: f32 = VoH1; + let e54: f32 = pow5_((1.0 - e52)); + return (f0_ + ((vec3(e45) - f0_) * e54)); } fn F_Schlick1(f0_1: f32, f90_2: f32, VoH2: f32) -> f32 { @@ -233,13 +233,13 @@ fn F_Schlick1(f0_1: f32, f90_2: f32, VoH2: f32) -> f32 { f0_2 = f0_1; f90_3 = f90_2; VoH3 = VoH2; - let _e46: f32 = f0_2; - let _e47: f32 = f90_3; - let _e48: f32 = f0_2; - let _e51: f32 = VoH3; - let _e54: f32 = VoH3; - let _e56: f32 = pow5_((1.0 - _e54)); - return (_e46 + ((_e47 - _e48) * _e56)); + let e46: f32 = f0_2; + let e47: f32 = f90_3; + let e48: f32 = f0_2; + let e51: f32 = VoH3; + let e54: f32 = VoH3; + let e56: f32 = pow5_((1.0 - e54)); + return (e46 + ((e47 - e48) * e56)); } fn fresnel(f0_3: vec3, LoH: f32) -> vec3 { @@ -249,14 +249,14 @@ fn fresnel(f0_3: vec3, LoH: f32) -> vec3 { f0_4 = f0_3; LoH1 = LoH; - let _e49: vec3 = f0_4; - let _e62: vec3 = f0_4; - f90_4 = clamp(dot(_e62, vec3((50.0 * 0.33000001311302185))), 0.0, 1.0); - let _e75: vec3 = f0_4; - let _e76: f32 = f90_4; - let _e77: f32 = LoH1; - let _e78: vec3 = F_Schlick(_e75, _e76, _e77); - return _e78; + let e49: vec3 = f0_4; + let e62: vec3 = f0_4; + f90_4 = clamp(dot(e62, vec3((50.0 * 0.33000001311302185))), 0.0, 1.0); + let e75: vec3 = f0_4; + let e76: f32 = f90_4; + let e77: f32 = LoH1; + let e78: vec3 = F_Schlick(e75, e76, e77); + return e78; } fn specular(f0_5: vec3, roughness4: f32, h1: vec3, NoV2: f32, NoL2: f32, NoH2: f32, LoH2: f32, specularIntensity: f32) -> vec3 { @@ -278,24 +278,24 @@ fn specular(f0_5: vec3, roughness4: f32, h1: vec3, NoV2: f32, NoL2: f3 NoH3 = NoH2; LoH3 = LoH2; specularIntensity1 = specularIntensity; - let _e57: f32 = roughness5; - let _e58: f32 = NoH3; - let _e59: f32 = D_GGX(_e57, _e58, h1); - D = _e59; - let _e64: f32 = roughness5; - let _e65: f32 = NoV3; - let _e66: f32 = NoL3; - let _e67: f32 = V_SmithGGXCorrelated(_e64, _e65, _e66); - V = _e67; - let _e71: vec3 = f0_6; - let _e72: f32 = LoH3; - let _e73: vec3 = fresnel(_e71, _e72); - F = _e73; - let _e75: f32 = specularIntensity1; - let _e76: f32 = D; - let _e78: f32 = V; - let _e80: vec3 = F; - return (((_e75 * _e76) * _e78) * _e80); + let e57: f32 = roughness5; + let e58: f32 = NoH3; + let e59: f32 = D_GGX(e57, e58, h1); + D = e59; + let e64: f32 = roughness5; + let e65: f32 = NoV3; + let e66: f32 = NoL3; + let e67: f32 = V_SmithGGXCorrelated(e64, e65, e66); + V = e67; + let e71: vec3 = f0_6; + let e72: f32 = LoH3; + let e73: vec3 = fresnel(e71, e72); + F = e73; + let e75: f32 = specularIntensity1; + let e76: f32 = D; + let e78: f32 = V; + let e80: vec3 = F; + return (((e75 * e76) * e78) * e80); } fn Fd_Burley(roughness6: f32, NoV4: f32, NoL4: f32, LoH4: f32) -> f32 { @@ -311,21 +311,21 @@ fn Fd_Burley(roughness6: f32, NoV4: f32, NoL4: f32, LoH4: f32) -> f32 { NoV5 = NoV4; NoL5 = NoL4; LoH5 = LoH4; - let _e50: f32 = roughness7; - let _e52: f32 = LoH5; - let _e54: f32 = LoH5; - f90_5 = (0.5 + (((2.0 * _e50) * _e52) * _e54)); - let _e62: f32 = f90_5; - let _e63: f32 = NoL5; - let _e64: f32 = F_Schlick1(1.0, _e62, _e63); - lightScatter = _e64; - let _e70: f32 = f90_5; - let _e71: f32 = NoV5; - let _e72: f32 = F_Schlick1(1.0, _e70, _e71); - viewScatter = _e72; - let _e74: f32 = lightScatter; - let _e75: f32 = viewScatter; - return ((_e74 * _e75) * (1.0 / 3.1415927410125732)); + let e50: f32 = roughness7; + let e52: f32 = LoH5; + let e54: f32 = LoH5; + f90_5 = (0.5 + (((2.0 * e50) * e52) * e54)); + let e62: f32 = f90_5; + let e63: f32 = NoL5; + let e64: f32 = F_Schlick1(1.0, e62, e63); + lightScatter = e64; + let e70: f32 = f90_5; + let e71: f32 = NoV5; + let e72: f32 = F_Schlick1(1.0, e70, e71); + viewScatter = e72; + let e74: f32 = lightScatter; + let e75: f32 = viewScatter; + return ((e74 * e75) * (1.0 / 3.1415927410125732)); } fn EnvBRDFApprox(f0_7: vec3, perceptual_roughness: f32, NoV6: f32) -> vec3 { @@ -341,28 +341,28 @@ fn EnvBRDFApprox(f0_7: vec3, perceptual_roughness: f32, NoV6: f32) -> vec3< f0_8 = f0_7; perceptual_roughness1 = perceptual_roughness; NoV7 = NoV6; - let _e62: f32 = perceptual_roughness1; - let _e64: vec4 = c0_; - let _e66: vec4 = c1_; - r = ((vec4(_e62) * _e64) + _e66); - let _e69: vec4 = r; - let _e71: vec4 = r; - let _e76: f32 = NoV7; - let _e80: f32 = NoV7; - let _e83: vec4 = r; - let _e85: vec4 = r; - let _e90: f32 = NoV7; - let _e94: f32 = NoV7; - let _e98: vec4 = r; - let _e101: vec4 = r; - a004_ = ((min((_e83.x * _e85.x), exp2((-(9.279999732971191) * _e94))) * _e98.x) + _e101.y); - let _e109: f32 = a004_; - let _e112: vec4 = r; - AB = ((vec2(-(1.0399999618530273), 1.0399999618530273) * vec2(_e109)) + _e112.zw); - let _e116: vec3 = f0_8; - let _e117: vec2 = AB; - let _e121: vec2 = AB; - return ((_e116 * vec3(_e117.x)) + vec3(_e121.y)); + let e62: f32 = perceptual_roughness1; + let e64: vec4 = c0_; + let e66: vec4 = c1_; + r = ((vec4(e62) * e64) + e66); + let e69: vec4 = r; + let e71: vec4 = r; + let e76: f32 = NoV7; + let e80: f32 = NoV7; + let e83: vec4 = r; + let e85: vec4 = r; + let e90: f32 = NoV7; + let e94: f32 = NoV7; + let e98: vec4 = r; + let e101: vec4 = r; + a004_ = ((min((e83.x * e85.x), exp2((-(9.279999732971191) * e94))) * e98.x) + e101.y); + let e109: f32 = a004_; + let e112: vec4 = r; + AB = ((vec2(-(1.0399999618530273), 1.0399999618530273) * vec2(e109)) + e112.zw); + let e116: vec3 = f0_8; + let e117: vec2 = AB; + let e121: vec2 = AB; + return ((e116 * vec3(e117.x)) + vec3(e121.y)); } fn perceptualRoughnessToRoughness(perceptualRoughness: f32) -> f32 { @@ -370,20 +370,20 @@ fn perceptualRoughnessToRoughness(perceptualRoughness: f32) -> f32 { var clampedPerceptualRoughness: f32; perceptualRoughness1 = perceptualRoughness; - let _e45: f32 = perceptualRoughness1; - clampedPerceptualRoughness = clamp(_e45, 0.08900000154972076, 1.0); - let _e50: f32 = clampedPerceptualRoughness; - let _e51: f32 = clampedPerceptualRoughness; - return (_e50 * _e51); + let e45: f32 = perceptualRoughness1; + clampedPerceptualRoughness = clamp(e45, 0.08900000154972076, 1.0); + let e50: f32 = clampedPerceptualRoughness; + let e51: f32 = clampedPerceptualRoughness; + return (e50 * e51); } fn reinhard(color: vec3) -> vec3 { var color1: vec3; color1 = color; - let _e42: vec3 = color1; - let _e45: vec3 = color1; - return (_e42 / (vec3(1.0) + _e45)); + let e42: vec3 = color1; + let e45: vec3 = color1; + return (e42 / (vec3(1.0) + e45)); } fn reinhard_extended(color2: vec3, max_white: f32) -> vec3 { @@ -393,22 +393,22 @@ fn reinhard_extended(color2: vec3, max_white: f32) -> vec3 { color3 = color2; max_white1 = max_white; - let _e44: vec3 = color3; - let _e47: vec3 = color3; - let _e48: f32 = max_white1; - let _e49: f32 = max_white1; - numerator = (_e44 * (vec3(1.0) + (_e47 / vec3((_e48 * _e49))))); - let _e56: vec3 = numerator; - let _e59: vec3 = color3; - return (_e56 / (vec3(1.0) + _e59)); + let e44: vec3 = color3; + let e47: vec3 = color3; + let e48: f32 = max_white1; + let e49: f32 = max_white1; + numerator = (e44 * (vec3(1.0) + (e47 / vec3((e48 * e49))))); + let e56: vec3 = numerator; + let e59: vec3 = color3; + return (e56 / (vec3(1.0) + e59)); } fn luminance(v1: vec3) -> f32 { var v2: vec3; v2 = v1; - let _e47: vec3 = v2; - return dot(_e47, vec3(0.2125999927520752, 0.7152000069618225, 0.0722000002861023)); + let e47: vec3 = v2; + return dot(e47, vec3(0.2125999927520752, 0.7152000069618225, 0.0722000002861023)); } fn change_luminance(c_in: vec3, l_out: f32) -> vec3 { @@ -418,13 +418,13 @@ fn change_luminance(c_in: vec3, l_out: f32) -> vec3 { c_in1 = c_in; l_out1 = l_out; - let _e45: vec3 = c_in1; - let _e46: f32 = luminance(_e45); - l_in = _e46; - let _e48: vec3 = c_in1; - let _e49: f32 = l_out1; - let _e50: f32 = l_in; - return (_e48 * (_e49 / _e50)); + let e45: vec3 = c_in1; + let e46: f32 = luminance(e45); + l_in = e46; + let e48: vec3 = c_in1; + let e49: f32 = l_out1; + let e50: f32 = l_in; + return (e48 * (e49 / e50)); } fn reinhard_luminance(color4: vec3) -> vec3 { @@ -433,16 +433,16 @@ fn reinhard_luminance(color4: vec3) -> vec3 { var l_new: f32; color5 = color4; - let _e43: vec3 = color5; - let _e44: f32 = luminance(_e43); - l_old = _e44; - let _e46: f32 = l_old; - let _e48: f32 = l_old; - l_new = (_e46 / (1.0 + _e48)); - let _e54: vec3 = color5; - let _e55: f32 = l_new; - let _e56: vec3 = change_luminance(_e54, _e55); - return _e56; + let e43: vec3 = color5; + let e44: f32 = luminance(e43); + l_old = e44; + let e46: f32 = l_old; + let e48: f32 = l_old; + l_new = (e46 / (1.0 + e48)); + let e54: vec3 = color5; + let e55: f32 = l_new; + let e56: vec3 = change_luminance(e54, e55); + return e56; } fn reinhard_extended_luminance(color6: vec3, max_white_l: f32) -> vec3 { @@ -454,21 +454,21 @@ fn reinhard_extended_luminance(color6: vec3, max_white_l: f32) -> vec3 color7 = color6; max_white_l1 = max_white_l; - let _e45: vec3 = color7; - let _e46: f32 = luminance(_e45); - l_old1 = _e46; - let _e48: f32 = l_old1; - let _e50: f32 = l_old1; - let _e51: f32 = max_white_l1; - let _e52: f32 = max_white_l1; - numerator1 = (_e48 * (1.0 + (_e50 / (_e51 * _e52)))); - let _e58: f32 = numerator1; - let _e60: f32 = l_old1; - l_new1 = (_e58 / (1.0 + _e60)); - let _e66: vec3 = color7; - let _e67: f32 = l_new1; - let _e68: vec3 = change_luminance(_e66, _e67); - return _e68; + let e45: vec3 = color7; + let e46: f32 = luminance(e45); + l_old1 = e46; + let e48: f32 = l_old1; + let e50: f32 = l_old1; + let e51: f32 = max_white_l1; + let e52: f32 = max_white_l1; + numerator1 = (e48 * (1.0 + (e50 / (e51 * e52)))); + let e58: f32 = numerator1; + let e60: f32 = l_old1; + l_new1 = (e58 / (1.0 + e60)); + let e66: vec3 = color7; + let e67: f32 = l_new1; + let e68: vec3 = change_luminance(e66, e67); + return e68; } fn point_light(light: PointLight, roughness8: f32, NdotV: f32, N: vec3, V1: vec3, R: vec3, F0_: vec3, diffuseColor: vec3) -> vec3 { @@ -506,123 +506,123 @@ fn point_light(light: PointLight, roughness8: f32, NdotV: f32, N: vec3, V1: R1 = R; F0_1 = F0_; diffuseColor1 = diffuseColor; - let _e56: PointLight = light1; - let _e59: vec3 = v_WorldPosition1; - light_to_frag = (_e56.pos.xyz - _e59.xyz); - let _e65: vec3 = light_to_frag; - let _e66: vec3 = light_to_frag; - distance_square = dot(_e65, _e66); - let _e70: PointLight = light1; - let _e73: f32 = distance_square; - let _e74: PointLight = light1; - let _e77: f32 = getDistanceAttenuation(_e73, _e74.lightParams.x); - rangeAttenuation = _e77; - let _e79: f32 = roughness9; - a1 = _e79; - let _e81: PointLight = light1; - radius = _e81.lightParams.y; - let _e87: vec3 = light_to_frag; - let _e88: vec3 = R1; - let _e90: vec3 = R1; - let _e92: vec3 = light_to_frag; - centerToRay = ((dot(_e87, _e88) * _e90) - _e92); - let _e95: vec3 = light_to_frag; - let _e96: vec3 = centerToRay; - let _e97: f32 = radius; - let _e100: vec3 = centerToRay; - let _e101: vec3 = centerToRay; - let _e105: vec3 = centerToRay; - let _e106: vec3 = centerToRay; - let _e112: f32 = radius; - let _e115: vec3 = centerToRay; - let _e116: vec3 = centerToRay; - let _e120: vec3 = centerToRay; - let _e121: vec3 = centerToRay; - closestPoint = (_e95 + (_e96 * clamp((_e112 * inverseSqrt(dot(_e120, _e121))), 0.0, 1.0))); - let _e133: vec3 = closestPoint; - let _e134: vec3 = closestPoint; - let _e138: vec3 = closestPoint; - let _e139: vec3 = closestPoint; - LspecLengthInverse = inverseSqrt(dot(_e138, _e139)); - let _e143: f32 = a1; - let _e144: f32 = a1; - let _e145: f32 = radius; - let _e148: f32 = LspecLengthInverse; - let _e153: f32 = a1; - let _e154: f32 = radius; - let _e157: f32 = LspecLengthInverse; - normalizationFactor = (_e143 / clamp((_e153 + ((_e154 * 0.5) * _e157)), 0.0, 1.0)); - let _e165: f32 = normalizationFactor; - let _e166: f32 = normalizationFactor; - specularIntensity2 = (_e165 * _e166); - let _e169: vec3 = closestPoint; - let _e170: f32 = LspecLengthInverse; - L = (_e169 * _e170); - let _e173: vec3 = L; - let _e174: vec3 = V2; - let _e176: vec3 = L; - let _e177: vec3 = V2; - H = normalize((_e176 + _e177)); - let _e183: vec3 = N1; - let _e184: vec3 = L; - let _e190: vec3 = N1; - let _e191: vec3 = L; - NoL6 = clamp(dot(_e190, _e191), 0.0, 1.0); - let _e199: vec3 = N1; - let _e200: vec3 = H; - let _e206: vec3 = N1; - let _e207: vec3 = H; - NoH4 = clamp(dot(_e206, _e207), 0.0, 1.0); - let _e215: vec3 = L; - let _e216: vec3 = H; - let _e222: vec3 = L; - let _e223: vec3 = H; - LoH6 = clamp(dot(_e222, _e223), 0.0, 1.0); - let _e237: vec3 = F0_1; - let _e238: f32 = roughness9; - let _e239: vec3 = H; - let _e240: f32 = NdotV1; - let _e241: f32 = NoL6; - let _e242: f32 = NoH4; - let _e243: f32 = LoH6; - let _e244: f32 = specularIntensity2; - let _e245: vec3 = specular(_e237, _e238, _e239, _e240, _e241, _e242, _e243, _e244); - specular1 = _e245; - let _e248: vec3 = light_to_frag; - L = normalize(_e248); - let _e250: vec3 = L; - let _e251: vec3 = V2; - let _e253: vec3 = L; - let _e254: vec3 = V2; - H = normalize((_e253 + _e254)); - let _e259: vec3 = N1; - let _e260: vec3 = L; - let _e266: vec3 = N1; - let _e267: vec3 = L; - NoL6 = clamp(dot(_e266, _e267), 0.0, 1.0); - let _e274: vec3 = N1; - let _e275: vec3 = H; - let _e281: vec3 = N1; - let _e282: vec3 = H; - NoH4 = clamp(dot(_e281, _e282), 0.0, 1.0); - let _e289: vec3 = L; - let _e290: vec3 = H; - let _e296: vec3 = L; - let _e297: vec3 = H; - LoH6 = clamp(dot(_e296, _e297), 0.0, 1.0); - let _e302: vec3 = diffuseColor1; - let _e307: f32 = roughness9; - let _e308: f32 = NdotV1; - let _e309: f32 = NoL6; - let _e310: f32 = LoH6; - let _e311: f32 = Fd_Burley(_e307, _e308, _e309, _e310); - diffuse = (_e302 * _e311); - let _e314: vec3 = diffuse; - let _e315: vec3 = specular1; - let _e317: PointLight = light1; - let _e321: f32 = rangeAttenuation; - let _e322: f32 = NoL6; - return (((_e314 + _e315) * _e317.color.xyz) * (_e321 * _e322)); + let e56: PointLight = light1; + let e59: vec3 = v_WorldPosition1; + light_to_frag = (e56.pos.xyz - e59.xyz); + let e65: vec3 = light_to_frag; + let e66: vec3 = light_to_frag; + distance_square = dot(e65, e66); + let e70: PointLight = light1; + let e73: f32 = distance_square; + let e74: PointLight = light1; + let e77: f32 = getDistanceAttenuation(e73, e74.lightParams.x); + rangeAttenuation = e77; + let e79: f32 = roughness9; + a1 = e79; + let e81: PointLight = light1; + radius = e81.lightParams.y; + let e87: vec3 = light_to_frag; + let e88: vec3 = R1; + let e90: vec3 = R1; + let e92: vec3 = light_to_frag; + centerToRay = ((dot(e87, e88) * e90) - e92); + let e95: vec3 = light_to_frag; + let e96: vec3 = centerToRay; + let e97: f32 = radius; + let e100: vec3 = centerToRay; + let e101: vec3 = centerToRay; + let e105: vec3 = centerToRay; + let e106: vec3 = centerToRay; + let e112: f32 = radius; + let e115: vec3 = centerToRay; + let e116: vec3 = centerToRay; + let e120: vec3 = centerToRay; + let e121: vec3 = centerToRay; + closestPoint = (e95 + (e96 * clamp((e112 * inverseSqrt(dot(e120, e121))), 0.0, 1.0))); + let e133: vec3 = closestPoint; + let e134: vec3 = closestPoint; + let e138: vec3 = closestPoint; + let e139: vec3 = closestPoint; + LspecLengthInverse = inverseSqrt(dot(e138, e139)); + let e143: f32 = a1; + let e144: f32 = a1; + let e145: f32 = radius; + let e148: f32 = LspecLengthInverse; + let e153: f32 = a1; + let e154: f32 = radius; + let e157: f32 = LspecLengthInverse; + normalizationFactor = (e143 / clamp((e153 + ((e154 * 0.5) * e157)), 0.0, 1.0)); + let e165: f32 = normalizationFactor; + let e166: f32 = normalizationFactor; + specularIntensity2 = (e165 * e166); + let e169: vec3 = closestPoint; + let e170: f32 = LspecLengthInverse; + L = (e169 * e170); + let e173: vec3 = L; + let e174: vec3 = V2; + let e176: vec3 = L; + let e177: vec3 = V2; + H = normalize((e176 + e177)); + let e183: vec3 = N1; + let e184: vec3 = L; + let e190: vec3 = N1; + let e191: vec3 = L; + NoL6 = clamp(dot(e190, e191), 0.0, 1.0); + let e199: vec3 = N1; + let e200: vec3 = H; + let e206: vec3 = N1; + let e207: vec3 = H; + NoH4 = clamp(dot(e206, e207), 0.0, 1.0); + let e215: vec3 = L; + let e216: vec3 = H; + let e222: vec3 = L; + let e223: vec3 = H; + LoH6 = clamp(dot(e222, e223), 0.0, 1.0); + let e237: vec3 = F0_1; + let e238: f32 = roughness9; + let e239: vec3 = H; + let e240: f32 = NdotV1; + let e241: f32 = NoL6; + let e242: f32 = NoH4; + let e243: f32 = LoH6; + let e244: f32 = specularIntensity2; + let e245: vec3 = specular(e237, e238, e239, e240, e241, e242, e243, e244); + specular1 = e245; + let e248: vec3 = light_to_frag; + L = normalize(e248); + let e250: vec3 = L; + let e251: vec3 = V2; + let e253: vec3 = L; + let e254: vec3 = V2; + H = normalize((e253 + e254)); + let e259: vec3 = N1; + let e260: vec3 = L; + let e266: vec3 = N1; + let e267: vec3 = L; + NoL6 = clamp(dot(e266, e267), 0.0, 1.0); + let e274: vec3 = N1; + let e275: vec3 = H; + let e281: vec3 = N1; + let e282: vec3 = H; + NoH4 = clamp(dot(e281, e282), 0.0, 1.0); + let e289: vec3 = L; + let e290: vec3 = H; + let e296: vec3 = L; + let e297: vec3 = H; + LoH6 = clamp(dot(e296, e297), 0.0, 1.0); + let e302: vec3 = diffuseColor1; + let e307: f32 = roughness9; + let e308: f32 = NdotV1; + let e309: f32 = NoL6; + let e310: f32 = LoH6; + let e311: f32 = Fd_Burley(e307, e308, e309, e310); + diffuse = (e302 * e311); + let e314: vec3 = diffuse; + let e315: vec3 = specular1; + let e317: PointLight = light1; + let e321: f32 = rangeAttenuation; + let e322: f32 = NoL6; + return (((e314 + e315) * e317.color.xyz) * (e321 * e322)); } fn dir_light(light2: DirectionalLight, roughness10: f32, NdotV2: f32, normal: vec3, view: vec3, R2: vec3, F0_2: vec3, diffuseColor2: vec3) -> vec3 { @@ -651,50 +651,50 @@ fn dir_light(light2: DirectionalLight, roughness10: f32, NdotV2: f32, normal: ve R3 = R2; F0_3 = F0_2; diffuseColor3 = diffuseColor2; - let _e56: DirectionalLight = light3; - incident_light = _e56.direction.xyz; - let _e60: vec3 = incident_light; - let _e61: vec3 = view1; - let _e63: vec3 = incident_light; - let _e64: vec3 = view1; - half_vector = normalize((_e63 + _e64)); - let _e70: vec3 = normal1; - let _e71: vec3 = incident_light; - let _e77: vec3 = normal1; - let _e78: vec3 = incident_light; - NoL7 = clamp(dot(_e77, _e78), 0.0, 1.0); - let _e86: vec3 = normal1; - let _e87: vec3 = half_vector; - let _e93: vec3 = normal1; - let _e94: vec3 = half_vector; - NoH5 = clamp(dot(_e93, _e94), 0.0, 1.0); - let _e102: vec3 = incident_light; - let _e103: vec3 = half_vector; - let _e109: vec3 = incident_light; - let _e110: vec3 = half_vector; - LoH7 = clamp(dot(_e109, _e110), 0.0, 1.0); - let _e116: vec3 = diffuseColor3; - let _e121: f32 = roughness11; - let _e122: f32 = NdotV3; - let _e123: f32 = NoL7; - let _e124: f32 = LoH7; - let _e125: f32 = Fd_Burley(_e121, _e122, _e123, _e124); - diffuse1 = (_e116 * _e125); - let _e138: vec3 = F0_3; - let _e139: f32 = roughness11; - let _e140: vec3 = half_vector; - let _e141: f32 = NdotV3; - let _e142: f32 = NoL7; - let _e143: f32 = NoH5; - let _e144: f32 = LoH7; - let _e145: f32 = specularIntensity3; - let _e146: vec3 = specular(_e138, _e139, _e140, _e141, _e142, _e143, _e144, _e145); - specular2 = _e146; - let _e148: vec3 = specular2; - let _e149: vec3 = diffuse1; - let _e151: DirectionalLight = light3; - let _e155: f32 = NoL7; - return (((_e148 + _e149) * _e151.color.xyz) * _e155); + let e56: DirectionalLight = light3; + incident_light = e56.direction.xyz; + let e60: vec3 = incident_light; + let e61: vec3 = view1; + let e63: vec3 = incident_light; + let e64: vec3 = view1; + half_vector = normalize((e63 + e64)); + let e70: vec3 = normal1; + let e71: vec3 = incident_light; + let e77: vec3 = normal1; + let e78: vec3 = incident_light; + NoL7 = clamp(dot(e77, e78), 0.0, 1.0); + let e86: vec3 = normal1; + let e87: vec3 = half_vector; + let e93: vec3 = normal1; + let e94: vec3 = half_vector; + NoH5 = clamp(dot(e93, e94), 0.0, 1.0); + let e102: vec3 = incident_light; + let e103: vec3 = half_vector; + let e109: vec3 = incident_light; + let e110: vec3 = half_vector; + LoH7 = clamp(dot(e109, e110), 0.0, 1.0); + let e116: vec3 = diffuseColor3; + let e121: f32 = roughness11; + let e122: f32 = NdotV3; + let e123: f32 = NoL7; + let e124: f32 = LoH7; + let e125: f32 = Fd_Burley(e121, e122, e123, e124); + diffuse1 = (e116 * e125); + let e138: vec3 = F0_3; + let e139: f32 = roughness11; + let e140: vec3 = half_vector; + let e141: f32 = NdotV3; + let e142: f32 = NoL7; + let e143: f32 = NoH5; + let e144: f32 = LoH7; + let e145: f32 = specularIntensity3; + let e146: vec3 = specular(e138, e139, e140, e141, e142, e143, e144, e145); + specular2 = e146; + let e148: vec3 = specular2; + let e149: vec3 = diffuse1; + let e151: DirectionalLight = light3; + let e155: f32 = NoL7; + return (((e148 + e149) * e151.color.xyz) * e155); } fn main1() { @@ -720,186 +720,186 @@ fn main1() { var diffuse_ambient: vec3; var specular_ambient: vec3; - let _e40: vec4 = global3.base_color; - output_color = _e40; - let _e42: vec4 = output_color; - let _e44: vec2 = v_Uv1; - let _e45: vec4 = textureSample(StandardMaterial_base_color_texture, StandardMaterial_base_color_texture_sampler, _e44); - output_color = (_e42 * _e45); - let _e48: vec2 = v_Uv1; - let _e49: vec4 = textureSample(StandardMaterial_metallic_roughness_texture, StandardMaterial_metallic_roughness_texture_sampler, _e48); - metallic_roughness = _e49; - let _e51: f32 = global5.metallic; - let _e52: vec4 = metallic_roughness; - metallic = (_e51 * _e52.z); - let _e56: f32 = global4.perceptual_roughness; - let _e57: vec4 = metallic_roughness; - perceptual_roughness2 = (_e56 * _e57.y); - let _e62: f32 = perceptual_roughness2; - let _e63: f32 = perceptualRoughnessToRoughness(_e62); - roughness12 = _e63; - let _e66: vec3 = v_WorldNormal1; - N2 = normalize(_e66); - let _e69: vec4 = v_WorldTangent1; - let _e71: vec4 = v_WorldTangent1; - T = normalize(_e71.xyz); - let _e77: vec3 = N2; - let _e78: vec3 = T; - let _e80: vec4 = v_WorldTangent1; - B = (cross(_e77, _e78) * _e80.w); - let _e85: bool = gl_FrontFacing; - let _e86: vec3 = N2; - let _e87: vec3 = N2; - N2 = select(-(_e87), _e86, _e85); - let _e90: bool = gl_FrontFacing; - let _e91: vec3 = T; - let _e92: vec3 = T; - T = select(-(_e92), _e91, _e90); - let _e95: bool = gl_FrontFacing; - let _e96: vec3 = B; - let _e97: vec3 = B; - B = select(-(_e97), _e96, _e95); - let _e100: vec3 = T; - let _e101: vec3 = B; - let _e102: vec3 = N2; - TBN = mat3x3(vec3(_e100.x, _e100.y, _e100.z), vec3(_e101.x, _e101.y, _e101.z), vec3(_e102.x, _e102.y, _e102.z)); - let _e117: mat3x3 = TBN; - let _e119: vec2 = v_Uv1; - let _e120: vec4 = textureSample(StandardMaterial_normal_map, StandardMaterial_normal_map_sampler, _e119); - let _e128: vec2 = v_Uv1; - let _e129: vec4 = textureSample(StandardMaterial_normal_map, StandardMaterial_normal_map_sampler, _e128); - N2 = (_e117 * normalize(((_e129.xyz * 2.0) - vec3(1.0)))); - let _e139: vec2 = v_Uv1; - let _e140: vec4 = textureSample(StandardMaterial_occlusion_texture, StandardMaterial_occlusion_texture_sampler, _e139); - occlusion = _e140.x; - let _e143: vec4 = global7.emissive; - emissive = _e143; - let _e145: vec4 = emissive; - let _e147: vec4 = emissive; - let _e150: vec2 = v_Uv1; - let _e151: vec4 = textureSample(StandardMaterial_emissive_texture, StandardMaterial_emissive_texture_sampler, _e150); - let _e153: vec3 = (_e147.xyz * _e151.xyz); - emissive.x = _e153.x; - emissive.y = _e153.y; - emissive.z = _e153.z; - let _e160: vec4 = global1.CameraPos; - let _e162: vec3 = v_WorldPosition1; - let _e165: vec4 = global1.CameraPos; - let _e167: vec3 = v_WorldPosition1; - V3 = normalize((_e165.xyz - _e167.xyz)); - let _e174: vec3 = N2; - let _e175: vec3 = V3; - let _e180: vec3 = N2; - let _e181: vec3 = V3; - NdotV4 = max(dot(_e180, _e181), 0.00009999999747378752); - let _e187: f32 = global6.reflectance; - let _e189: f32 = global6.reflectance; - let _e192: f32 = metallic; - let _e196: vec4 = output_color; - let _e198: f32 = metallic; - F0_4 = (vec3((((0.1599999964237213 * _e187) * _e189) * (1.0 - _e192))) + (_e196.xyz * vec3(_e198))); - let _e203: vec4 = output_color; - let _e206: f32 = metallic; - diffuseColor4 = (_e203.xyz * vec3((1.0 - _e206))); - let _e211: vec3 = V3; - let _e214: vec3 = V3; - let _e216: vec3 = N2; - R4 = reflect(-(_e214), _e216); + let e40: vec4 = global3.base_color; + output_color = e40; + let e42: vec4 = output_color; + let e44: vec2 = v_Uv1; + let e45: vec4 = textureSample(StandardMaterial_base_color_texture, StandardMaterial_base_color_texture_sampler, e44); + output_color = (e42 * e45); + let e48: vec2 = v_Uv1; + let e49: vec4 = textureSample(StandardMaterial_metallic_roughness_texture, StandardMaterial_metallic_roughness_texture_sampler, e48); + metallic_roughness = e49; + let e51: f32 = global5.metallic; + let e52: vec4 = metallic_roughness; + metallic = (e51 * e52.z); + let e56: f32 = global4.perceptual_roughness; + let e57: vec4 = metallic_roughness; + perceptual_roughness2 = (e56 * e57.y); + let e62: f32 = perceptual_roughness2; + let e63: f32 = perceptualRoughnessToRoughness(e62); + roughness12 = e63; + let e66: vec3 = v_WorldNormal1; + N2 = normalize(e66); + let e69: vec4 = v_WorldTangent1; + let e71: vec4 = v_WorldTangent1; + T = normalize(e71.xyz); + let e77: vec3 = N2; + let e78: vec3 = T; + let e80: vec4 = v_WorldTangent1; + B = (cross(e77, e78) * e80.w); + let e85: bool = gl_FrontFacing; + let e86: vec3 = N2; + let e87: vec3 = N2; + N2 = select(-(e87), e86, e85); + let e90: bool = gl_FrontFacing; + let e91: vec3 = T; + let e92: vec3 = T; + T = select(-(e92), e91, e90); + let e95: bool = gl_FrontFacing; + let e96: vec3 = B; + let e97: vec3 = B; + B = select(-(e97), e96, e95); + let e100: vec3 = T; + let e101: vec3 = B; + let e102: vec3 = N2; + TBN = mat3x3(vec3(e100.x, e100.y, e100.z), vec3(e101.x, e101.y, e101.z), vec3(e102.x, e102.y, e102.z)); + let e117: mat3x3 = TBN; + let e119: vec2 = v_Uv1; + let e120: vec4 = textureSample(StandardMaterial_normal_map, StandardMaterial_normal_map_sampler, e119); + let e128: vec2 = v_Uv1; + let e129: vec4 = textureSample(StandardMaterial_normal_map, StandardMaterial_normal_map_sampler, e128); + N2 = (e117 * normalize(((e129.xyz * 2.0) - vec3(1.0)))); + let e139: vec2 = v_Uv1; + let e140: vec4 = textureSample(StandardMaterial_occlusion_texture, StandardMaterial_occlusion_texture_sampler, e139); + occlusion = e140.x; + let e143: vec4 = global7.emissive; + emissive = e143; + let e145: vec4 = emissive; + let e147: vec4 = emissive; + let e150: vec2 = v_Uv1; + let e151: vec4 = textureSample(StandardMaterial_emissive_texture, StandardMaterial_emissive_texture_sampler, e150); + let e153: vec3 = (e147.xyz * e151.xyz); + emissive.x = e153.x; + emissive.y = e153.y; + emissive.z = e153.z; + let e160: vec4 = global1.CameraPos; + let e162: vec3 = v_WorldPosition1; + let e165: vec4 = global1.CameraPos; + let e167: vec3 = v_WorldPosition1; + V3 = normalize((e165.xyz - e167.xyz)); + let e174: vec3 = N2; + let e175: vec3 = V3; + let e180: vec3 = N2; + let e181: vec3 = V3; + NdotV4 = max(dot(e180, e181), 0.00009999999747378752); + let e187: f32 = global6.reflectance; + let e189: f32 = global6.reflectance; + let e192: f32 = metallic; + let e196: vec4 = output_color; + let e198: f32 = metallic; + F0_4 = (vec3((((0.1599999964237213 * e187) * e189) * (1.0 - e192))) + (e196.xyz * vec3(e198))); + let e203: vec4 = output_color; + let e206: f32 = metallic; + diffuseColor4 = (e203.xyz * vec3((1.0 - e206))); + let e211: vec3 = V3; + let e214: vec3 = V3; + let e216: vec3 = N2; + R4 = reflect(-(e214), e216); loop { - let _e224: i32 = i; - let _e225: vec4 = global2.NumLights; - let _e229: i32 = i; - if (!(((_e224 < i32(_e225.x)) && (_e229 < 10)))) { + let e224: i32 = i; + let e225: vec4 = global2.NumLights; + let e229: i32 = i; + if (!(((e224 < i32(e225.x)) && (e229 < 10)))) { break; } { - let _e236: vec3 = light_accum; - let _e237: i32 = i; - let _e247: i32 = i; - let _e249: PointLight = global2.PointLights[_e247]; - let _e250: f32 = roughness12; - let _e251: f32 = NdotV4; - let _e252: vec3 = N2; - let _e253: vec3 = V3; - let _e254: vec3 = R4; - let _e255: vec3 = F0_4; - let _e256: vec3 = diffuseColor4; - let _e257: vec3 = point_light(_e249, _e250, _e251, _e252, _e253, _e254, _e255, _e256); - light_accum = (_e236 + _e257); + let e236: vec3 = light_accum; + let e237: i32 = i; + let e247: i32 = i; + let e249: PointLight = global2.PointLights[e247]; + let e250: f32 = roughness12; + let e251: f32 = NdotV4; + let e252: vec3 = N2; + let e253: vec3 = V3; + let e254: vec3 = R4; + let e255: vec3 = F0_4; + let e256: vec3 = diffuseColor4; + let e257: vec3 = point_light(e249, e250, e251, e252, e253, e254, e255, e256); + light_accum = (e236 + e257); } continuing { - let _e233: i32 = i; - i = (_e233 + 1); + let e233: i32 = i; + i = (e233 + 1); } } loop { - let _e261: i32 = i1; - let _e262: vec4 = global2.NumLights; - let _e266: i32 = i1; - if (!(((_e261 < i32(_e262.y)) && (_e266 < 1)))) { + let e261: i32 = i1; + let e262: vec4 = global2.NumLights; + let e266: i32 = i1; + if (!(((e261 < i32(e262.y)) && (e266 < 1)))) { break; } { - let _e273: vec3 = light_accum; - let _e274: i32 = i1; - let _e284: i32 = i1; - let _e286: DirectionalLight = global2.DirectionalLights[_e284]; - let _e287: f32 = roughness12; - let _e288: f32 = NdotV4; - let _e289: vec3 = N2; - let _e290: vec3 = V3; - let _e291: vec3 = R4; - let _e292: vec3 = F0_4; - let _e293: vec3 = diffuseColor4; - let _e294: vec3 = dir_light(_e286, _e287, _e288, _e289, _e290, _e291, _e292, _e293); - light_accum = (_e273 + _e294); + let e273: vec3 = light_accum; + let e274: i32 = i1; + let e284: i32 = i1; + let e286: DirectionalLight = global2.DirectionalLights[e284]; + let e287: f32 = roughness12; + let e288: f32 = NdotV4; + let e289: vec3 = N2; + let e290: vec3 = V3; + let e291: vec3 = R4; + let e292: vec3 = F0_4; + let e293: vec3 = diffuseColor4; + let e294: vec3 = dir_light(e286, e287, e288, e289, e290, e291, e292, e293); + light_accum = (e273 + e294); } continuing { - let _e270: i32 = i1; - i1 = (_e270 + 1); + let e270: i32 = i1; + i1 = (e270 + 1); } } - let _e299: vec3 = diffuseColor4; - let _e301: f32 = NdotV4; - let _e302: vec3 = EnvBRDFApprox(_e299, 1.0, _e301); - diffuse_ambient = _e302; - let _e307: vec3 = F0_4; - let _e308: f32 = perceptual_roughness2; - let _e309: f32 = NdotV4; - let _e310: vec3 = EnvBRDFApprox(_e307, _e308, _e309); - specular_ambient = _e310; - let _e312: vec4 = output_color; - let _e314: vec3 = light_accum; - output_color.x = _e314.x; - output_color.y = _e314.y; - output_color.z = _e314.z; - let _e321: vec4 = output_color; - let _e323: vec4 = output_color; - let _e325: vec3 = diffuse_ambient; - let _e326: vec3 = specular_ambient; - let _e328: vec4 = global2.AmbientColor; - let _e331: f32 = occlusion; - let _e333: vec3 = (_e323.xyz + (((_e325 + _e326) * _e328.xyz) * _e331)); - output_color.x = _e333.x; - output_color.y = _e333.y; - output_color.z = _e333.z; - let _e340: vec4 = output_color; - let _e342: vec4 = output_color; - let _e344: vec4 = emissive; - let _e346: vec4 = output_color; - let _e349: vec3 = (_e342.xyz + (_e344.xyz * _e346.w)); - output_color.x = _e349.x; - output_color.y = _e349.y; - output_color.z = _e349.z; - let _e356: vec4 = output_color; - let _e358: vec4 = output_color; - let _e360: vec4 = output_color; - let _e362: vec3 = reinhard_luminance(_e360.xyz); - output_color.x = _e362.x; - output_color.y = _e362.y; - output_color.z = _e362.z; - let _e369: vec4 = output_color; - o_Target = _e369; + let e299: vec3 = diffuseColor4; + let e301: f32 = NdotV4; + let e302: vec3 = EnvBRDFApprox(e299, 1.0, e301); + diffuse_ambient = e302; + let e307: vec3 = F0_4; + let e308: f32 = perceptual_roughness2; + let e309: f32 = NdotV4; + let e310: vec3 = EnvBRDFApprox(e307, e308, e309); + specular_ambient = e310; + let e312: vec4 = output_color; + let e314: vec3 = light_accum; + output_color.x = e314.x; + output_color.y = e314.y; + output_color.z = e314.z; + let e321: vec4 = output_color; + let e323: vec4 = output_color; + let e325: vec3 = diffuse_ambient; + let e326: vec3 = specular_ambient; + let e328: vec4 = global2.AmbientColor; + let e331: f32 = occlusion; + let e333: vec3 = (e323.xyz + (((e325 + e326) * e328.xyz) * e331)); + output_color.x = e333.x; + output_color.y = e333.y; + output_color.z = e333.z; + let e340: vec4 = output_color; + let e342: vec4 = output_color; + let e344: vec4 = emissive; + let e346: vec4 = output_color; + let e349: vec3 = (e342.xyz + (e344.xyz * e346.w)); + output_color.x = e349.x; + output_color.y = e349.y; + output_color.z = e349.z; + let e356: vec4 = output_color; + let e358: vec4 = output_color; + let e360: vec4 = output_color; + let e362: vec3 = reinhard_luminance(e360.xyz); + output_color.x = e362.x; + output_color.y = e362.y; + output_color.z = e362.z; + let e369: vec4 = output_color; + o_Target = e369; return; } @@ -911,6 +911,6 @@ fn main([[location(0)]] v_WorldPosition: vec3, [[location(1)]] v_WorldNorma v_WorldTangent1 = v_WorldTangent; gl_FrontFacing = param; main1(); - let _e72: vec4 = o_Target; - return FragmentOutput(_e72); + let e72: vec4 = o_Target; + return FragmentOutput(e72); } diff --git a/tests/out/wgsl/bevy-pbr-vert.wgsl b/tests/out/wgsl/bevy-pbr-vert.wgsl index 5eb6dc8975..2f629ea89c 100644 --- a/tests/out/wgsl/bevy-pbr-vert.wgsl +++ b/tests/out/wgsl/bevy-pbr-vert.wgsl @@ -33,23 +33,23 @@ var gl_Position: vec4; fn main1() { var world_position: vec4; - let _e12: mat4x4 = global1.Model; - let _e13: vec3 = Vertex_Position1; - world_position = (_e12 * vec4(_e13, 1.0)); - let _e18: vec4 = world_position; - v_WorldPosition = _e18.xyz; - let _e20: mat4x4 = global1.Model; - let _e28: vec3 = Vertex_Normal1; - v_WorldNormal = (mat3x3(_e20[0].xyz, _e20[1].xyz, _e20[2].xyz) * _e28); - let _e30: vec2 = Vertex_Uv1; - v_Uv = _e30; - let _e31: mat4x4 = global1.Model; - let _e39: vec4 = Vertex_Tangent1; - let _e42: vec4 = Vertex_Tangent1; - v_WorldTangent = vec4((mat3x3(_e31[0].xyz, _e31[1].xyz, _e31[2].xyz) * _e39.xyz), _e42.w); - let _e46: mat4x4 = global.ViewProj; - let _e47: vec4 = world_position; - gl_Position = (_e46 * _e47); + let e12: mat4x4 = global1.Model; + let e13: vec3 = Vertex_Position1; + world_position = (e12 * vec4(e13, 1.0)); + let e18: vec4 = world_position; + v_WorldPosition = e18.xyz; + let e20: mat4x4 = global1.Model; + let e28: vec3 = Vertex_Normal1; + v_WorldNormal = (mat3x3(e20[0].xyz, e20[1].xyz, e20[2].xyz) * e28); + let e30: vec2 = Vertex_Uv1; + v_Uv = e30; + let e31: mat4x4 = global1.Model; + let e39: vec4 = Vertex_Tangent1; + let e42: vec4 = Vertex_Tangent1; + v_WorldTangent = vec4((mat3x3(e31[0].xyz, e31[1].xyz, e31[2].xyz) * e39.xyz), e42.w); + let e46: mat4x4 = global.ViewProj; + let e47: vec4 = world_position; + gl_Position = (e46 * e47); return; } @@ -60,10 +60,10 @@ fn main([[location(0)]] Vertex_Position: vec3, [[location(1)]] Vertex_Norma Vertex_Uv1 = Vertex_Uv; Vertex_Tangent1 = Vertex_Tangent; main1(); - let _e29: vec3 = v_WorldPosition; - let _e31: vec3 = v_WorldNormal; - let _e33: vec2 = v_Uv; - let _e35: vec4 = v_WorldTangent; - let _e37: vec4 = gl_Position; - return VertexOutput(_e29, _e31, _e33, _e35, _e37); + let e29: vec3 = v_WorldPosition; + let e31: vec3 = v_WorldNormal; + let e33: vec2 = v_Uv; + let e35: vec4 = v_WorldTangent; + let e37: vec4 = gl_Position; + return VertexOutput(e29, e31, e33, e35, e37); } diff --git a/tests/out/wgsl/binop-frag.wgsl b/tests/out/wgsl/binop-frag.wgsl index dd75aeb110..40e8c82162 100644 --- a/tests/out/wgsl/binop-frag.wgsl +++ b/tests/out/wgsl/binop-frag.wgsl @@ -7,14 +7,14 @@ fn testBinOpVecFloat(a: vec4, b: f32) { a1 = a; b1 = b; - let _e5: vec4 = a1; - v = (_e5 * 2.0); - let _e8: vec4 = a1; - v = (_e8 / vec4(2.0)); - let _e12: vec4 = a1; - v = (_e12 + vec4(2.0)); - let _e16: vec4 = a1; - v = (_e16 - vec4(2.0)); + let e5: vec4 = a1; + v = (e5 * 2.0); + let e8: vec4 = a1; + v = (e8 / vec4(2.0)); + let e12: vec4 = a1; + v = (e12 + vec4(2.0)); + let e16: vec4 = a1; + v = (e16 - vec4(2.0)); return; } @@ -25,18 +25,18 @@ fn testBinOpFloatVec(a2: vec4, b2: f32) { a3 = a2; b3 = b2; - let _e5: vec4 = a3; - let _e6: f32 = b3; - v1 = (_e5 * _e6); - let _e8: vec4 = a3; - let _e9: f32 = b3; - v1 = (_e8 / vec4(_e9)); - let _e12: vec4 = a3; - let _e13: f32 = b3; - v1 = (_e12 + vec4(_e13)); - let _e16: vec4 = a3; - let _e17: f32 = b3; - v1 = (_e16 - vec4(_e17)); + let e5: vec4 = a3; + let e6: f32 = b3; + v1 = (e5 * e6); + let e8: vec4 = a3; + let e9: f32 = b3; + v1 = (e8 / vec4(e9)); + let e12: vec4 = a3; + let e13: f32 = b3; + v1 = (e12 + vec4(e13)); + let e16: vec4 = a3; + let e17: f32 = b3; + v1 = (e16 - vec4(e17)); return; } @@ -47,33 +47,33 @@ fn testBinOpIVecInt(a4: vec4, b4: i32) { a5 = a4; b5 = b4; - let _e5: vec4 = a5; - let _e6: i32 = b5; - v2 = (_e5 * _e6); - let _e8: vec4 = a5; - let _e9: i32 = b5; - v2 = (_e8 / vec4(_e9)); - let _e12: vec4 = a5; - let _e13: i32 = b5; - v2 = (_e12 + vec4(_e13)); - let _e16: vec4 = a5; - let _e17: i32 = b5; - v2 = (_e16 - vec4(_e17)); - let _e20: vec4 = a5; - let _e21: i32 = b5; - v2 = (_e20 & vec4(_e21)); - let _e24: vec4 = a5; - let _e25: i32 = b5; - v2 = (_e24 | vec4(_e25)); - let _e28: vec4 = a5; - let _e29: i32 = b5; - v2 = (_e28 ^ vec4(_e29)); - let _e32: vec4 = a5; - let _e33: i32 = b5; - v2 = (_e32 >> vec4(u32(_e33))); - let _e37: vec4 = a5; - let _e38: i32 = b5; - v2 = (_e37 << vec4(u32(_e38))); + let e5: vec4 = a5; + let e6: i32 = b5; + v2 = (e5 * e6); + let e8: vec4 = a5; + let e9: i32 = b5; + v2 = (e8 / vec4(e9)); + let e12: vec4 = a5; + let e13: i32 = b5; + v2 = (e12 + vec4(e13)); + let e16: vec4 = a5; + let e17: i32 = b5; + v2 = (e16 - vec4(e17)); + let e20: vec4 = a5; + let e21: i32 = b5; + v2 = (e20 & vec4(e21)); + let e24: vec4 = a5; + let e25: i32 = b5; + v2 = (e24 | vec4(e25)); + let e28: vec4 = a5; + let e29: i32 = b5; + v2 = (e28 ^ vec4(e29)); + let e32: vec4 = a5; + let e33: i32 = b5; + v2 = (e32 >> vec4(u32(e33))); + let e37: vec4 = a5; + let e38: i32 = b5; + v2 = (e37 << vec4(u32(e38))); return; } @@ -84,24 +84,24 @@ fn testBinOpIntIVec(a6: i32, b6: vec4) { a7 = a6; b7 = b6; - let _e5: i32 = a7; - let _e6: vec4 = b7; - v3 = (_e5 * _e6); - let _e8: i32 = a7; - let _e9: vec4 = b7; - v3 = (vec4(_e8) + _e9); - let _e12: i32 = a7; - let _e13: vec4 = b7; - v3 = (vec4(_e12) - _e13); - let _e16: i32 = a7; - let _e17: vec4 = b7; - v3 = (vec4(_e16) & _e17); - let _e20: i32 = a7; - let _e21: vec4 = b7; - v3 = (vec4(_e20) | _e21); - let _e24: i32 = a7; - let _e25: vec4 = b7; - v3 = (vec4(_e24) ^ _e25); + let e5: i32 = a7; + let e6: vec4 = b7; + v3 = (e5 * e6); + let e8: i32 = a7; + let e9: vec4 = b7; + v3 = (vec4(e8) + e9); + let e12: i32 = a7; + let e13: vec4 = b7; + v3 = (vec4(e12) - e13); + let e16: i32 = a7; + let e17: vec4 = b7; + v3 = (vec4(e16) & e17); + let e20: i32 = a7; + let e21: vec4 = b7; + v3 = (vec4(e20) | e21); + let e24: i32 = a7; + let e25: vec4 = b7; + v3 = (vec4(e24) ^ e25); return; } @@ -112,33 +112,33 @@ fn testBinOpUVecUint(a8: vec4, b8: u32) { a9 = a8; b9 = b8; - let _e5: vec4 = a9; - let _e6: u32 = b9; - v4 = (_e5 * _e6); - let _e8: vec4 = a9; - let _e9: u32 = b9; - v4 = (_e8 / vec4(_e9)); - let _e12: vec4 = a9; - let _e13: u32 = b9; - v4 = (_e12 + vec4(_e13)); - let _e16: vec4 = a9; - let _e17: u32 = b9; - v4 = (_e16 - vec4(_e17)); - let _e20: vec4 = a9; - let _e21: u32 = b9; - v4 = (_e20 & vec4(_e21)); - let _e24: vec4 = a9; - let _e25: u32 = b9; - v4 = (_e24 | vec4(_e25)); - let _e28: vec4 = a9; - let _e29: u32 = b9; - v4 = (_e28 ^ vec4(_e29)); - let _e32: vec4 = a9; - let _e33: u32 = b9; - v4 = (_e32 >> vec4(_e33)); - let _e36: vec4 = a9; - let _e37: u32 = b9; - v4 = (_e36 << vec4(_e37)); + let e5: vec4 = a9; + let e6: u32 = b9; + v4 = (e5 * e6); + let e8: vec4 = a9; + let e9: u32 = b9; + v4 = (e8 / vec4(e9)); + let e12: vec4 = a9; + let e13: u32 = b9; + v4 = (e12 + vec4(e13)); + let e16: vec4 = a9; + let e17: u32 = b9; + v4 = (e16 - vec4(e17)); + let e20: vec4 = a9; + let e21: u32 = b9; + v4 = (e20 & vec4(e21)); + let e24: vec4 = a9; + let e25: u32 = b9; + v4 = (e24 | vec4(e25)); + let e28: vec4 = a9; + let e29: u32 = b9; + v4 = (e28 ^ vec4(e29)); + let e32: vec4 = a9; + let e33: u32 = b9; + v4 = (e32 >> vec4(e33)); + let e36: vec4 = a9; + let e37: u32 = b9; + v4 = (e36 << vec4(e37)); return; } @@ -149,34 +149,34 @@ fn testBinOpUintUVec(a10: u32, b10: vec4) { a11 = a10; b11 = b10; - let _e5: u32 = a11; - let _e6: vec4 = b11; - v5 = (_e5 * _e6); - let _e8: u32 = a11; - let _e9: vec4 = b11; - v5 = (vec4(_e8) + _e9); - let _e12: u32 = a11; - let _e13: vec4 = b11; - v5 = (vec4(_e12) - _e13); - let _e16: u32 = a11; - let _e17: vec4 = b11; - v5 = (vec4(_e16) & _e17); - let _e20: u32 = a11; - let _e21: vec4 = b11; - v5 = (vec4(_e20) | _e21); - let _e24: u32 = a11; - let _e25: vec4 = b11; - v5 = (vec4(_e24) ^ _e25); + let e5: u32 = a11; + let e6: vec4 = b11; + v5 = (e5 * e6); + let e8: u32 = a11; + let e9: vec4 = b11; + v5 = (vec4(e8) + e9); + let e12: u32 = a11; + let e13: vec4 = b11; + v5 = (vec4(e12) - e13); + let e16: u32 = a11; + let e17: vec4 = b11; + v5 = (vec4(e16) & e17); + let e20: u32 = a11; + let e21: vec4 = b11; + v5 = (vec4(e20) | e21); + let e24: u32 = a11; + let e25: vec4 = b11; + v5 = (vec4(e24) ^ e25); return; } fn main1() { - let _e1: vec4 = o_color; - let _e4: vec4 = vec4(1.0); - o_color.x = _e4.x; - o_color.y = _e4.y; - o_color.z = _e4.z; - o_color.w = _e4.w; + let e1: vec4 = o_color; + let e4: vec4 = vec4(1.0); + o_color.x = e4.x; + o_color.y = e4.y; + o_color.z = e4.z; + o_color.w = e4.w; return; } diff --git a/tests/out/wgsl/boids.wgsl b/tests/out/wgsl/boids.wgsl index a0e5e8eab0..902aa4edc3 100644 --- a/tests/out/wgsl/boids.wgsl +++ b/tests/out/wgsl/boids.wgsl @@ -45,109 +45,109 @@ fn main([[builtin(global_invocation_id)]] global_invocation_id: vec3) { if ((index >= NUM_PARTICLES)) { return; } - let _e10: vec2 = particlesSrc.particles[index].pos; - vPos = _e10; - let _e15: vec2 = particlesSrc.particles[index].vel; - vVel = _e15; + let e10: vec2 = particlesSrc.particles[index].pos; + vPos = e10; + let e15: vec2 = particlesSrc.particles[index].vel; + vVel = e15; cMass = vec2(0.0, 0.0); cVel = vec2(0.0, 0.0); colVel = vec2(0.0, 0.0); loop { - let _e37: u32 = i; - if ((_e37 >= NUM_PARTICLES)) { + let e37: u32 = i; + if ((e37 >= NUM_PARTICLES)) { break; } - let _e39: u32 = i; - if ((_e39 == index)) { + let e39: u32 = i; + if ((e39 == index)) { continue; } - let _e42: u32 = i; - let _e45: vec2 = particlesSrc.particles[_e42].pos; - pos = _e45; - let _e47: u32 = i; - let _e50: vec2 = particlesSrc.particles[_e47].vel; - vel = _e50; - let _e51: vec2 = pos; - let _e52: vec2 = vPos; - let _e55: f32 = params.rule1Distance; - if ((distance(_e51, _e52) < _e55)) { - let _e57: vec2 = cMass; - let _e58: vec2 = pos; - cMass = (_e57 + _e58); - let _e60: i32 = cMassCount; - cMassCount = (_e60 + 1); + let e42: u32 = i; + let e45: vec2 = particlesSrc.particles[e42].pos; + pos = e45; + let e47: u32 = i; + let e50: vec2 = particlesSrc.particles[e47].vel; + vel = e50; + let e51: vec2 = pos; + let e52: vec2 = vPos; + let e55: f32 = params.rule1Distance; + if ((distance(e51, e52) < e55)) { + let e57: vec2 = cMass; + let e58: vec2 = pos; + cMass = (e57 + e58); + let e60: i32 = cMassCount; + cMassCount = (e60 + 1); } - let _e63: vec2 = pos; - let _e64: vec2 = vPos; - let _e67: f32 = params.rule2Distance; - if ((distance(_e63, _e64) < _e67)) { - let _e69: vec2 = colVel; - let _e70: vec2 = pos; - let _e71: vec2 = vPos; - colVel = (_e69 - (_e70 - _e71)); + let e63: vec2 = pos; + let e64: vec2 = vPos; + let e67: f32 = params.rule2Distance; + if ((distance(e63, e64) < e67)) { + let e69: vec2 = colVel; + let e70: vec2 = pos; + let e71: vec2 = vPos; + colVel = (e69 - (e70 - e71)); } - let _e74: vec2 = pos; - let _e75: vec2 = vPos; - let _e78: f32 = params.rule3Distance; - if ((distance(_e74, _e75) < _e78)) { - let _e80: vec2 = cVel; - let _e81: vec2 = vel; - cVel = (_e80 + _e81); - let _e83: i32 = cVelCount; - cVelCount = (_e83 + 1); + let e74: vec2 = pos; + let e75: vec2 = vPos; + let e78: f32 = params.rule3Distance; + if ((distance(e74, e75) < e78)) { + let e80: vec2 = cVel; + let e81: vec2 = vel; + cVel = (e80 + e81); + let e83: i32 = cVelCount; + cVelCount = (e83 + 1); } continuing { - let _e86: u32 = i; - i = (_e86 + 1u); + let e86: u32 = i; + i = (e86 + 1u); } } - let _e89: i32 = cMassCount; - if ((_e89 > 0)) { - let _e92: vec2 = cMass; - let _e93: i32 = cMassCount; - let _e97: vec2 = vPos; - cMass = ((_e92 / vec2(f32(_e93))) - _e97); + let e89: i32 = cMassCount; + if ((e89 > 0)) { + let e92: vec2 = cMass; + let e93: i32 = cMassCount; + let e97: vec2 = vPos; + cMass = ((e92 / vec2(f32(e93))) - e97); } - let _e99: i32 = cVelCount; - if ((_e99 > 0)) { - let _e102: vec2 = cVel; - let _e103: i32 = cVelCount; - cVel = (_e102 / vec2(f32(_e103))); + let e99: i32 = cVelCount; + if ((e99 > 0)) { + let e102: vec2 = cVel; + let e103: i32 = cVelCount; + cVel = (e102 / vec2(f32(e103))); } - let _e107: vec2 = vVel; - let _e108: vec2 = cMass; - let _e110: f32 = params.rule1Scale; - let _e113: vec2 = colVel; - let _e115: f32 = params.rule2Scale; - let _e118: vec2 = cVel; - let _e120: f32 = params.rule3Scale; - vVel = (((_e107 + (_e108 * _e110)) + (_e113 * _e115)) + (_e118 * _e120)); - let _e123: vec2 = vVel; - let _e125: vec2 = vVel; - vVel = (normalize(_e123) * clamp(length(_e125), 0.0, 0.10000000149011612)); - let _e131: vec2 = vPos; - let _e132: vec2 = vVel; - let _e134: f32 = params.deltaT; - vPos = (_e131 + (_e132 * _e134)); - let _e138: f32 = vPos.x; - if ((_e138 < -1.0)) { + let e107: vec2 = vVel; + let e108: vec2 = cMass; + let e110: f32 = params.rule1Scale; + let e113: vec2 = colVel; + let e115: f32 = params.rule2Scale; + let e118: vec2 = cVel; + let e120: f32 = params.rule3Scale; + vVel = (((e107 + (e108 * e110)) + (e113 * e115)) + (e118 * e120)); + let e123: vec2 = vVel; + let e125: vec2 = vVel; + vVel = (normalize(e123) * clamp(length(e125), 0.0, 0.10000000149011612)); + let e131: vec2 = vPos; + let e132: vec2 = vVel; + let e134: f32 = params.deltaT; + vPos = (e131 + (e132 * e134)); + let e138: f32 = vPos.x; + if ((e138 < -1.0)) { vPos.x = 1.0; } - let _e144: f32 = vPos.x; - if ((_e144 > 1.0)) { + let e144: f32 = vPos.x; + if ((e144 > 1.0)) { vPos.x = -1.0; } - let _e150: f32 = vPos.y; - if ((_e150 < -1.0)) { + let e150: f32 = vPos.y; + if ((e150 < -1.0)) { vPos.y = 1.0; } - let _e156: f32 = vPos.y; - if ((_e156 > 1.0)) { + let e156: f32 = vPos.y; + if ((e156 > 1.0)) { vPos.y = -1.0; } - let _e164: vec2 = vPos; - particlesDst.particles[index].pos = _e164; - let _e168: vec2 = vVel; - particlesDst.particles[index].vel = _e168; + let e164: vec2 = vPos; + particlesDst.particles[index].pos = e164; + let e168: vec2 = vVel; + particlesDst.particles[index].vel = e168; return; } diff --git a/tests/out/wgsl/bool-select-frag.wgsl b/tests/out/wgsl/bool-select-frag.wgsl index 9f26d9d76a..1ef8e94654 100644 --- a/tests/out/wgsl/bool-select-frag.wgsl +++ b/tests/out/wgsl/bool-select-frag.wgsl @@ -10,9 +10,9 @@ fn TevPerCompGT(a: f32, b: f32) -> f32 { a1 = a; b1 = b; - let _e5: f32 = a1; - let _e6: f32 = b1; - return select(0.0, 1.0, (_e5 > _e6)); + let e5: f32 = a1; + let e6: f32 = b1; + return select(0.0, 1.0, (e5 > e6)); } fn TevPerCompGT1(a2: vec3, b2: vec3) -> vec3 { @@ -21,25 +21,25 @@ fn TevPerCompGT1(a2: vec3, b2: vec3) -> vec3 { a3 = a2; b3 = b2; - let _e7: vec3 = a3; - let _e8: vec3 = b3; - return select(vec3(0.0), vec3(1.0), (_e7 > _e8)); + let e7: vec3 = a3; + let e8: vec3 = b3; + return select(vec3(0.0), vec3(1.0), (e7 > e8)); } fn main1() { - let _e1: vec4 = o_color; - let _e11: vec3 = TevPerCompGT1(vec3(3.0), vec3(5.0)); - o_color.x = _e11.x; - o_color.y = _e11.y; - o_color.z = _e11.z; - let _e23: f32 = TevPerCompGT(3.0, 5.0); - o_color.w = _e23; + let e1: vec4 = o_color; + let e11: vec3 = TevPerCompGT1(vec3(3.0), vec3(5.0)); + o_color.x = e11.x; + o_color.y = e11.y; + o_color.z = e11.z; + let e23: f32 = TevPerCompGT(3.0, 5.0); + o_color.w = e23; return; } [[stage(fragment)]] fn main() -> FragmentOutput { main1(); - let _e3: vec4 = o_color; - return FragmentOutput(_e3); + let e3: vec4 = o_color; + return FragmentOutput(e3); } diff --git a/tests/out/wgsl/clamp-splat-vert.wgsl b/tests/out/wgsl/clamp-splat-vert.wgsl index bbc28b22a4..4dfea0b084 100644 --- a/tests/out/wgsl/clamp-splat-vert.wgsl +++ b/tests/out/wgsl/clamp-splat-vert.wgsl @@ -6,8 +6,8 @@ var a_pos1: vec2; var gl_Position: vec4; fn main1() { - let _e5: vec2 = a_pos1; - gl_Position = vec4(clamp(_e5, vec2(0.0), vec2(1.0)), 0.0, 1.0); + let e5: vec2 = a_pos1; + gl_Position = vec4(clamp(e5, vec2(0.0), vec2(1.0)), 0.0, 1.0); return; } @@ -15,6 +15,6 @@ fn main1() { fn main([[location(0)]] a_pos: vec2) -> VertexOutput { a_pos1 = a_pos; main1(); - let _e5: vec4 = gl_Position; - return VertexOutput(_e5); + let e5: vec4 = gl_Position; + return VertexOutput(e5); } diff --git a/tests/out/wgsl/collatz.wgsl b/tests/out/wgsl/collatz.wgsl index e3bbb2cabd..b17dbd0454 100644 --- a/tests/out/wgsl/collatz.wgsl +++ b/tests/out/wgsl/collatz.wgsl @@ -12,29 +12,29 @@ fn collatz_iterations(n_base: u32) -> u32 { n = n_base; loop { - let _e5: u32 = n; - if ((_e5 <= 1u)) { + let e5: u32 = n; + if ((e5 <= 1u)) { break; } - let _e8: u32 = n; - if (((_e8 % 2u) == 0u)) { - let _e13: u32 = n; - n = (_e13 / 2u); + let e8: u32 = n; + if (((e8 % 2u) == 0u)) { + let e13: u32 = n; + n = (e13 / 2u); } else { - let _e17: u32 = n; - n = ((3u * _e17) + 1u); + let e17: u32 = n; + n = ((3u * e17) + 1u); } - let _e21: u32 = i; - i = (_e21 + 1u); + let e21: u32 = i; + i = (e21 + 1u); } - let _e24: u32 = i; - return _e24; + let e24: u32 = i; + return e24; } [[stage(compute), workgroup_size(1, 1, 1)]] fn main([[builtin(global_invocation_id)]] global_id: vec3) { - let _e8: u32 = v_indices.data[global_id.x]; - let _e9: u32 = collatz_iterations(_e8); - v_indices.data[global_id.x] = _e9; + let e8: u32 = v_indices.data[global_id.x]; + let e9: u32 = collatz_iterations(e8); + v_indices.data[global_id.x] = e9; return; } diff --git a/tests/out/wgsl/constant-array-size-vert.wgsl b/tests/out/wgsl/constant-array-size-vert.wgsl index ac18b25398..ad51ae6b79 100644 --- a/tests/out/wgsl/constant-array-size-vert.wgsl +++ b/tests/out/wgsl/constant-array-size-vert.wgsl @@ -11,23 +11,23 @@ fn function() -> vec4 { var i: i32 = 0; loop { - let _e9: i32 = i; - if (!((_e9 < 42))) { + let e9: i32 = i; + if (!((e9 < 42))) { break; } { - let _e15: vec4 = sum; - let _e16: i32 = i; - let _e18: vec4 = global.vecs[_e16]; - sum = (_e15 + _e18); + let e15: vec4 = sum; + let e16: i32 = i; + let e18: vec4 = global.vecs[e16]; + sum = (e15 + e18); } continuing { - let _e12: i32 = i; - i = (_e12 + 1); + let e12: i32 = i; + i = (e12 + 1); } } - let _e20: vec4 = sum; - return _e20; + let e20: vec4 = sum; + return e20; } fn main1() { diff --git a/tests/out/wgsl/control-flow.wgsl b/tests/out/wgsl/control-flow.wgsl index 2859edd61f..511c08aa5f 100644 --- a/tests/out/wgsl/control-flow.wgsl +++ b/tests/out/wgsl/control-flow.wgsl @@ -37,8 +37,8 @@ fn main([[builtin(global_invocation_id)]] global_id: vec3) { pos = 1; } } - let _e4: i32 = pos; - switch(_e4) { + let e4: i32 = pos; + switch(e4) { case 1: { pos = 0; break; @@ -56,8 +56,8 @@ fn main([[builtin(global_invocation_id)]] global_id: vec3) { pos = 3; } } - let _e9: i32 = pos; - switch(_e9) { + let e9: i32 = pos; + switch(e9) { case 1: { pos = 0; break; diff --git a/tests/out/wgsl/fma-frag.wgsl b/tests/out/wgsl/fma-frag.wgsl index 3529458080..e943de29bc 100644 --- a/tests/out/wgsl/fma-frag.wgsl +++ b/tests/out/wgsl/fma-frag.wgsl @@ -12,28 +12,28 @@ fn Fma(d: ptr, m: Mat4x3_, s: f32) { m1 = m; s1 = s; - let _e6: Mat4x3_ = (*d); - let _e8: Mat4x3_ = m1; - let _e10: f32 = s1; - (*d).mx = (_e6.mx + (_e8.mx * _e10)); - let _e14: Mat4x3_ = (*d); - let _e16: Mat4x3_ = m1; - let _e18: f32 = s1; - (*d).my = (_e14.my + (_e16.my * _e18)); - let _e22: Mat4x3_ = (*d); - let _e24: Mat4x3_ = m1; - let _e26: f32 = s1; - (*d).mz = (_e22.mz + (_e24.mz * _e26)); + let e6: Mat4x3_ = (*d); + let e8: Mat4x3_ = m1; + let e10: f32 = s1; + (*d).mx = (e6.mx + (e8.mx * e10)); + let e14: Mat4x3_ = (*d); + let e16: Mat4x3_ = m1; + let e18: f32 = s1; + (*d).my = (e14.my + (e16.my * e18)); + let e22: Mat4x3_ = (*d); + let e24: Mat4x3_ = m1; + let e26: f32 = s1; + (*d).mz = (e22.mz + (e24.mz * e26)); return; } fn main1() { - let _e1: vec4 = o_color; - let _e4: vec4 = vec4(1.0); - o_color.x = _e4.x; - o_color.y = _e4.y; - o_color.z = _e4.z; - o_color.w = _e4.w; + let e1: vec4 = o_color; + let e4: vec4 = vec4(1.0); + o_color.x = e4.x; + o_color.y = e4.y; + o_color.z = e4.z; + o_color.w = e4.w; return; } diff --git a/tests/out/wgsl/global-constant-array-vert.wgsl b/tests/out/wgsl/global-constant-array-vert.wgsl index 01ec742e04..066088b1f5 100644 --- a/tests/out/wgsl/global-constant-array-vert.wgsl +++ b/tests/out/wgsl/global-constant-array-vert.wgsl @@ -3,7 +3,7 @@ var i: u32; fn main1() { var local: array = array(1.0, 2.0); - let _e2: u32 = i; + let e2: u32 = i; } [[stage(vertex)]] diff --git a/tests/out/wgsl/interpolate.wgsl b/tests/out/wgsl/interpolate.wgsl index cf1a3824ce..972bc25231 100644 --- a/tests/out/wgsl/interpolate.wgsl +++ b/tests/out/wgsl/interpolate.wgsl @@ -21,8 +21,8 @@ fn main() -> FragmentInput { out.perspective = vec4(729.0, 1000.0, 1331.0, 1728.0); out.perspective_centroid = 2197.0; out.perspective_sample = 2744.0; - let _e30: FragmentInput = out; - return _e30; + let e30: FragmentInput = out; + return e30; } [[stage(fragment)]] diff --git a/tests/out/wgsl/inv-hyperbolic-trig-functions.wgsl b/tests/out/wgsl/inv-hyperbolic-trig-functions.wgsl index 7378cb3001..ff4d9fa0ea 100644 --- a/tests/out/wgsl/inv-hyperbolic-trig-functions.wgsl +++ b/tests/out/wgsl/inv-hyperbolic-trig-functions.wgsl @@ -5,12 +5,12 @@ fn main1() { var c: f32; var d: f32; - let _e8: f32 = a; - b = log(_e8 + sqrt(_e8 * _e8 + 1.0)); - let _e10: f32 = a; - c = log(_e10 + sqrt(_e10 * _e10 - 1.0)); - let _e12: f32 = a; - d = 0.5 * log((1.0 + _e12) / (1.0 - _e12)); + let e8: f32 = a; + b = log(e8 + sqrt(e8 * e8 + 1.0)); + let e10: f32 = a; + c = log(e10 + sqrt(e10 * e10 - 1.0)); + let e12: f32 = a; + d = 0.5 * log((1.0 + e12) / (1.0 - e12)); return; } diff --git a/tests/out/wgsl/long-form-matrix-vert.wgsl b/tests/out/wgsl/long-form-matrix-vert.wgsl index dee8738ffe..9806b11850 100644 --- a/tests/out/wgsl/long-form-matrix-vert.wgsl +++ b/tests/out/wgsl/long-form-matrix-vert.wgsl @@ -7,20 +7,20 @@ fn main1() { var d: mat3x3 = mat3x3(vec3(2.0, 2.0, 1.0), vec3(1.0, 1.0, 1.0), vec3(1.0, 1.0, 1.0)); var e: mat4x4 = mat4x4(vec4(2.0, 2.0, 1.0, 1.0), vec4(1.0, 1.0, 2.0, 2.0), vec4(1.0, 1.0, 1.0, 1.0), vec4(1.0, 1.0, 1.0, 1.0)); - let _e1: f32 = f32(1); - let _e9: vec2 = vec2(f32(1)); - let _e12: vec2 = vec2(f32(2)); - let _e38: vec2 = vec2(f32(2), f32(3)); - let _e53: vec3 = vec3(f32(1)); - let _e56: vec3 = vec3(f32(1)); - let _e73: vec2 = vec2(f32(2)); - let _e77: vec3 = vec3(f32(1)); - let _e80: vec3 = vec3(f32(1)); - let _e97: vec2 = vec2(f32(2)); - let _e100: vec4 = vec4(f32(1)); - let _e103: vec2 = vec2(f32(2)); - let _e106: vec4 = vec4(f32(1)); - let _e109: vec4 = vec4(f32(1)); + let e1: f32 = f32(1); + let e9: vec2 = vec2(f32(1)); + let e12: vec2 = vec2(f32(2)); + let e38: vec2 = vec2(f32(2), f32(3)); + let e53: vec3 = vec3(f32(1)); + let e56: vec3 = vec3(f32(1)); + let e73: vec2 = vec2(f32(2)); + let e77: vec3 = vec3(f32(1)); + let e80: vec3 = vec3(f32(1)); + let e97: vec2 = vec2(f32(2)); + let e100: vec4 = vec4(f32(1)); + let e103: vec2 = vec2(f32(2)); + let e106: vec4 = vec4(f32(1)); + let e109: vec4 = vec4(f32(1)); } [[stage(vertex)]] diff --git a/tests/out/wgsl/math-functions-vert.wgsl b/tests/out/wgsl/math-functions-vert.wgsl index 32602b9b5a..33a8f909e7 100644 --- a/tests/out/wgsl/math-functions-vert.wgsl +++ b/tests/out/wgsl/math-functions-vert.wgsl @@ -43,107 +43,107 @@ fn main1() { var distanceOut: f32; var stepOut: vec4; - let _e6: vec4 = a; - let _e7: vec4 = b; - let _e8: vec4 = a; - let _e9: vec4 = b; - m = mat4x4(vec4(_e6.x, _e6.y, _e6.z, _e6.w), vec4(_e7.x, _e7.y, _e7.z, _e7.w), vec4(_e8.x, _e8.y, _e8.z, _e8.w), vec4(_e9.x, _e9.y, _e9.z, _e9.w)); - let _e35: vec4 = a; - ceilOut = ceil(_e35); - let _e39: vec4 = a; - roundOut = round(_e39); - let _e43: vec4 = a; - floorOut = floor(_e43); - let _e47: vec4 = a; - fractOut = fract(_e47); - let _e51: vec4 = a; - truncOut = trunc(_e51); - let _e55: vec4 = a; - sinOut = sin(_e55); - let _e59: vec4 = a; - absOut = abs(_e59); - let _e63: vec4 = a; - sqrtOut = sqrt(_e63); - let _e67: vec4 = a; - inversesqrtOut = inverseSqrt(_e67); - let _e71: vec4 = a; - expOut = exp(_e71); - let _e75: vec4 = a; - exp2Out = exp2(_e75); - let _e79: vec4 = a; - signOut = sign(_e79); - let _e83: mat4x4 = m; - transposeOut = transpose(_e83); - let _e87: vec4 = a; - normalizeOut = normalize(_e87); - let _e91: vec4 = a; - sinhOut = sinh(_e91); - let _e95: vec4 = a; - cosOut = cos(_e95); - let _e99: vec4 = a; - coshOut = cosh(_e99); - let _e103: vec4 = a; - tanOut = tan(_e103); - let _e107: vec4 = a; - tanhOut = tanh(_e107); - let _e111: vec4 = a; - acosOut = acos(_e111); - let _e115: vec4 = a; - asinOut = asin(_e115); - let _e119: vec4 = a; - logOut = log(_e119); - let _e123: vec4 = a; - log2Out = log2(_e123); - let _e127: vec4 = a; - lengthOut = length(_e127); - let _e131: mat4x4 = m; - determinantOut = determinant(_e131); - let _e135: i32 = i; - bitCountOut = countOneBits(_e135); - let _e139: i32 = i; - bitfieldReverseOut = reverseBits(_e139); - let _e142: vec4 = a; - let _e144: vec4 = a; - atanOut = atan(_e144.x); - let _e148: vec4 = a; - let _e150: vec4 = a; - let _e152: vec4 = a; - let _e154: vec4 = a; - atan2Out = atan2(_e152.x, _e154.y); - let _e158: vec4 = a; - let _e160: vec4 = b; - let _e162: vec4 = a; - let _e164: vec4 = b; - modOut = (_e162.x % _e164.x); - let _e170: vec4 = a; - let _e171: vec4 = b; - powOut = pow(_e170, _e171); - let _e176: vec4 = a; - let _e177: vec4 = b; - dotOut = dot(_e176, _e177); - let _e182: vec4 = a; - let _e183: vec4 = b; - maxOut = max(_e182, _e183); - let _e188: vec4 = a; - let _e189: vec4 = b; - minOut = min(_e188, _e189); - let _e194: vec4 = a; - let _e195: vec4 = b; - reflectOut = reflect(_e194, _e195); - let _e198: vec4 = a; - let _e200: vec4 = b; - let _e202: vec4 = a; - let _e204: vec4 = b; - crossOut = cross(_e202.xyz, _e204.xyz); - let _e210: vec4 = a; - let _e211: vec4 = b; - outerProductOut = outerProduct(_e210, _e211); - let _e216: vec4 = a; - let _e217: vec4 = b; - distanceOut = distance(_e216, _e217); - let _e222: vec4 = a; - let _e223: vec4 = b; - stepOut = step(_e222, _e223); + let e6: vec4 = a; + let e7: vec4 = b; + let e8: vec4 = a; + let e9: vec4 = b; + m = mat4x4(vec4(e6.x, e6.y, e6.z, e6.w), vec4(e7.x, e7.y, e7.z, e7.w), vec4(e8.x, e8.y, e8.z, e8.w), vec4(e9.x, e9.y, e9.z, e9.w)); + let e35: vec4 = a; + ceilOut = ceil(e35); + let e39: vec4 = a; + roundOut = round(e39); + let e43: vec4 = a; + floorOut = floor(e43); + let e47: vec4 = a; + fractOut = fract(e47); + let e51: vec4 = a; + truncOut = trunc(e51); + let e55: vec4 = a; + sinOut = sin(e55); + let e59: vec4 = a; + absOut = abs(e59); + let e63: vec4 = a; + sqrtOut = sqrt(e63); + let e67: vec4 = a; + inversesqrtOut = inverseSqrt(e67); + let e71: vec4 = a; + expOut = exp(e71); + let e75: vec4 = a; + exp2Out = exp2(e75); + let e79: vec4 = a; + signOut = sign(e79); + let e83: mat4x4 = m; + transposeOut = transpose(e83); + let e87: vec4 = a; + normalizeOut = normalize(e87); + let e91: vec4 = a; + sinhOut = sinh(e91); + let e95: vec4 = a; + cosOut = cos(e95); + let e99: vec4 = a; + coshOut = cosh(e99); + let e103: vec4 = a; + tanOut = tan(e103); + let e107: vec4 = a; + tanhOut = tanh(e107); + let e111: vec4 = a; + acosOut = acos(e111); + let e115: vec4 = a; + asinOut = asin(e115); + let e119: vec4 = a; + logOut = log(e119); + let e123: vec4 = a; + log2Out = log2(e123); + let e127: vec4 = a; + lengthOut = length(e127); + let e131: mat4x4 = m; + determinantOut = determinant(e131); + let e135: i32 = i; + bitCountOut = countOneBits(e135); + let e139: i32 = i; + bitfieldReverseOut = reverseBits(e139); + let e142: vec4 = a; + let e144: vec4 = a; + atanOut = atan(e144.x); + let e148: vec4 = a; + let e150: vec4 = a; + let e152: vec4 = a; + let e154: vec4 = a; + atan2Out = atan2(e152.x, e154.y); + let e158: vec4 = a; + let e160: vec4 = b; + let e162: vec4 = a; + let e164: vec4 = b; + modOut = (e162.x % e164.x); + let e170: vec4 = a; + let e171: vec4 = b; + powOut = pow(e170, e171); + let e176: vec4 = a; + let e177: vec4 = b; + dotOut = dot(e176, e177); + let e182: vec4 = a; + let e183: vec4 = b; + maxOut = max(e182, e183); + let e188: vec4 = a; + let e189: vec4 = b; + minOut = min(e188, e189); + let e194: vec4 = a; + let e195: vec4 = b; + reflectOut = reflect(e194, e195); + let e198: vec4 = a; + let e200: vec4 = b; + let e202: vec4 = a; + let e204: vec4 = b; + crossOut = cross(e202.xyz, e204.xyz); + let e210: vec4 = a; + let e211: vec4 = b; + outerProductOut = outerProduct(e210, e211); + let e216: vec4 = a; + let e217: vec4 = b; + distanceOut = distance(e216, e217); + let e222: vec4 = a; + let e223: vec4 = b; + stepOut = step(e222, e223); return; } diff --git a/tests/out/wgsl/operators.wgsl b/tests/out/wgsl/operators.wgsl index 8f6c6ad8fb..f43c1c88a1 100644 --- a/tests/out/wgsl/operators.wgsl +++ b/tests/out/wgsl/operators.wgsl @@ -37,15 +37,15 @@ fn constructors() -> f32 { var foo: Foo; foo = Foo(vec4(1.0), 1); - let _e11: f32 = foo.a.x; - return _e11; + let e11: f32 = foo.a.x; + return e11; } [[stage(compute), workgroup_size(1, 1, 1)]] fn main() { - let _e4: vec4 = builtins(); - let _e5: vec4 = splat(); - let _e6: i32 = unary(); - let _e7: f32 = constructors(); + let e4: vec4 = builtins(); + let e5: vec4 = splat(); + let e6: i32 = unary(); + let e7: f32 = constructors(); return; } diff --git a/tests/out/wgsl/prepostfix-frag.wgsl b/tests/out/wgsl/prepostfix-frag.wgsl index df723ccf75..5b2e53a815 100644 --- a/tests/out/wgsl/prepostfix-frag.wgsl +++ b/tests/out/wgsl/prepostfix-frag.wgsl @@ -6,30 +6,30 @@ fn main1() { var mat_target: mat4x3; var mat: mat4x3 = mat4x3(vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), vec3(0.0, 0.0, 1.0), vec3(0.0, 0.0, 0.0)); - let _e3: i32 = scalar; - scalar = (_e3 + 1); - scalar_target = _e3; - let _e6: i32 = scalar; - let _e8: i32 = (_e6 - 1); - scalar = _e8; - scalar_target = _e8; - let _e14: vec2 = vec; - vec = (_e14 - vec2(1u)); - vec_target = _e14; - let _e18: vec2 = vec; - let _e21: vec2 = (_e18 + vec2(1u)); - vec = _e21; - vec_target = _e21; - let _e24: f32 = f32(1); - let _e32: mat4x3 = mat; - let _e34: vec3 = vec3(1.0); - mat = (_e32 + mat4x3(_e34, _e34, _e34, _e34)); - mat_target = _e32; - let _e37: mat4x3 = mat; - let _e39: vec3 = vec3(1.0); - let _e41: mat4x3 = (_e37 - mat4x3(_e39, _e39, _e39, _e39)); - mat = _e41; - mat_target = _e41; + let e3: i32 = scalar; + scalar = (e3 + 1); + scalar_target = e3; + let e6: i32 = scalar; + let e8: i32 = (e6 - 1); + scalar = e8; + scalar_target = e8; + let e14: vec2 = vec; + vec = (e14 - vec2(1u)); + vec_target = e14; + let e18: vec2 = vec; + let e21: vec2 = (e18 + vec2(1u)); + vec = e21; + vec_target = e21; + let e24: f32 = f32(1); + let e32: mat4x3 = mat; + let e34: vec3 = vec3(1.0); + mat = (e32 + mat4x3(e34, e34, e34, e34)); + mat_target = e32; + let e37: mat4x3 = mat; + let e39: vec3 = vec3(1.0); + let e41: mat4x3 = (e37 - mat4x3(e39, e39, e39, e39)); + mat = e41; + mat_target = e41; return; } diff --git a/tests/out/wgsl/quad-vert.wgsl b/tests/out/wgsl/quad-vert.wgsl index bb6a86a19c..09a9cfdbb2 100644 --- a/tests/out/wgsl/quad-vert.wgsl +++ b/tests/out/wgsl/quad-vert.wgsl @@ -14,10 +14,10 @@ var perVertexStruct: gl_PerVertex = gl_PerVertex(vec4(0.0, 0.0, 0. var a_pos1: vec2; fn main1() { - let _e12: vec2 = a_uv1; - v_uv = _e12; - let _e13: vec2 = a_pos1; - perVertexStruct.gl_Position = vec4(_e13.x, _e13.y, 0.0, 1.0); + let e12: vec2 = a_uv1; + v_uv = e12; + let e13: vec2 = a_pos1; + perVertexStruct.gl_Position = vec4(e13.x, e13.y, 0.0, 1.0); return; } @@ -26,7 +26,7 @@ fn main([[location(1)]] a_uv: vec2, [[location(0)]] a_pos: vec2) -> Ve a_uv1 = a_uv; a_pos1 = a_pos; main1(); - let _e10: vec2 = v_uv; - let _e11: vec4 = perVertexStruct.gl_Position; - return VertexOutput(_e10, _e11); + let e10: vec2 = v_uv; + let e11: vec4 = perVertexStruct.gl_Position; + return VertexOutput(e10, e11); } diff --git a/tests/out/wgsl/quad_glsl-frag.wgsl b/tests/out/wgsl/quad_glsl-frag.wgsl index 18ee145e73..022cc70ad5 100644 --- a/tests/out/wgsl/quad_glsl-frag.wgsl +++ b/tests/out/wgsl/quad_glsl-frag.wgsl @@ -14,6 +14,6 @@ fn main1() { fn main([[location(0)]] v_uv: vec2) -> FragmentOutput { v_uv1 = v_uv; main1(); - let _e7: vec4 = o_color; - return FragmentOutput(_e7); + let e7: vec4 = o_color; + return FragmentOutput(e7); } diff --git a/tests/out/wgsl/quad_glsl-vert.wgsl b/tests/out/wgsl/quad_glsl-vert.wgsl index c010a38cbc..81c1555648 100644 --- a/tests/out/wgsl/quad_glsl-vert.wgsl +++ b/tests/out/wgsl/quad_glsl-vert.wgsl @@ -9,10 +9,10 @@ var v_uv: vec2; var gl_Position: vec4; fn main1() { - let _e4: vec2 = a_uv1; - v_uv = _e4; - let _e6: vec2 = a_pos1; - gl_Position = vec4((1.2000000476837158 * _e6), 0.0, 1.0); + let e4: vec2 = a_uv1; + v_uv = e4; + let e6: vec2 = a_pos1; + gl_Position = vec4((1.2000000476837158 * e6), 0.0, 1.0); return; } @@ -21,7 +21,7 @@ fn main([[location(0)]] a_pos: vec2, [[location(1)]] a_uv: vec2) -> Ve a_pos1 = a_pos; a_uv1 = a_uv; main1(); - let _e14: vec2 = v_uv; - let _e16: vec4 = gl_Position; - return VertexOutput(_e14, _e16); + let e14: vec2 = v_uv; + let e16: vec4 = gl_Position; + return VertexOutput(e14, e16); } diff --git a/tests/out/wgsl/samplers-frag.wgsl b/tests/out/wgsl/samplers-frag.wgsl index 3381d21053..18433b50f0 100644 --- a/tests/out/wgsl/samplers-frag.wgsl +++ b/tests/out/wgsl/samplers-frag.wgsl @@ -33,110 +33,110 @@ fn testTex1D(coord: f32) { var c: vec4; coord1 = coord; - let _e18: f32 = coord1; - let _e19: vec4 = textureSample(tex1D, samp, _e18); - c = _e19; - let _e22: f32 = coord1; - let _e24: vec4 = textureSampleBias(tex1D, samp, _e22, 2.0); - c = _e24; - let _e28: f32 = coord1; - let _e31: vec4 = textureSampleGrad(tex1D, samp, _e28, 4.0, 4.0); - c = _e31; - let _e36: f32 = coord1; - let _e40: vec4 = textureSampleGrad(tex1D, samp, _e36, 4.0, 4.0, 5); - c = _e40; - let _e43: f32 = coord1; - let _e45: vec4 = textureSampleLevel(tex1D, samp, _e43, 3.0); - c = _e45; - let _e49: f32 = coord1; - let _e52: vec4 = textureSampleLevel(tex1D, samp, _e49, 3.0, 5); - c = _e52; - let _e55: f32 = coord1; - let _e57: vec4 = textureSample(tex1D, samp, _e55, 5); - c = _e57; - let _e61: f32 = coord1; - let _e64: vec4 = textureSampleBias(tex1D, samp, _e61, 2.0, 5); - c = _e64; - let _e65: f32 = coord1; - let _e68: f32 = coord1; - let _e70: vec2 = vec2(_e68, 6.0); - let _e74: vec4 = textureSample(tex1D, samp, (_e70.x / _e70.y)); - c = _e74; - let _e75: f32 = coord1; - let _e80: f32 = coord1; - let _e84: vec4 = vec4(_e80, 0.0, 0.0, 6.0); - let _e90: vec4 = textureSample(tex1D, samp, (_e84.xyz / vec3(_e84.w)).x); - c = _e90; - let _e91: f32 = coord1; - let _e95: f32 = coord1; - let _e97: vec2 = vec2(_e95, 6.0); - let _e102: vec4 = textureSampleBias(tex1D, samp, (_e97.x / _e97.y), 2.0); - c = _e102; - let _e103: f32 = coord1; - let _e109: f32 = coord1; - let _e113: vec4 = vec4(_e109, 0.0, 0.0, 6.0); - let _e120: vec4 = textureSampleBias(tex1D, samp, (_e113.xyz / vec3(_e113.w)).x, 2.0); - c = _e120; - let _e121: f32 = coord1; - let _e126: f32 = coord1; - let _e128: vec2 = vec2(_e126, 6.0); - let _e134: vec4 = textureSampleGrad(tex1D, samp, (_e128.x / _e128.y), 4.0, 4.0); - c = _e134; - let _e135: f32 = coord1; - let _e142: f32 = coord1; - let _e146: vec4 = vec4(_e142, 0.0, 0.0, 6.0); - let _e154: vec4 = textureSampleGrad(tex1D, samp, (_e146.xyz / vec3(_e146.w)).x, 4.0, 4.0); - c = _e154; - let _e155: f32 = coord1; - let _e161: f32 = coord1; - let _e163: vec2 = vec2(_e161, 6.0); - let _e170: vec4 = textureSampleGrad(tex1D, samp, (_e163.x / _e163.y), 4.0, 4.0, 5); - c = _e170; - let _e171: f32 = coord1; - let _e179: f32 = coord1; - let _e183: vec4 = vec4(_e179, 0.0, 0.0, 6.0); - let _e192: vec4 = textureSampleGrad(tex1D, samp, (_e183.xyz / vec3(_e183.w)).x, 4.0, 4.0, 5); - c = _e192; - let _e193: f32 = coord1; - let _e197: f32 = coord1; - let _e199: vec2 = vec2(_e197, 6.0); - let _e204: vec4 = textureSampleLevel(tex1D, samp, (_e199.x / _e199.y), 3.0); - c = _e204; - let _e205: f32 = coord1; - let _e211: f32 = coord1; - let _e215: vec4 = vec4(_e211, 0.0, 0.0, 6.0); - let _e222: vec4 = textureSampleLevel(tex1D, samp, (_e215.xyz / vec3(_e215.w)).x, 3.0); - c = _e222; - let _e223: f32 = coord1; - let _e228: f32 = coord1; - let _e230: vec2 = vec2(_e228, 6.0); - let _e236: vec4 = textureSampleLevel(tex1D, samp, (_e230.x / _e230.y), 3.0, 5); - c = _e236; - let _e237: f32 = coord1; - let _e244: f32 = coord1; - let _e248: vec4 = vec4(_e244, 0.0, 0.0, 6.0); - let _e256: vec4 = textureSampleLevel(tex1D, samp, (_e248.xyz / vec3(_e248.w)).x, 3.0, 5); - c = _e256; - let _e257: f32 = coord1; - let _e261: f32 = coord1; - let _e263: vec2 = vec2(_e261, 6.0); - let _e268: vec4 = textureSample(tex1D, samp, (_e263.x / _e263.y), 5); - c = _e268; - let _e269: f32 = coord1; - let _e275: f32 = coord1; - let _e279: vec4 = vec4(_e275, 0.0, 0.0, 6.0); - let _e286: vec4 = textureSample(tex1D, samp, (_e279.xyz / vec3(_e279.w)).x, 5); - c = _e286; - let _e287: f32 = coord1; - let _e292: f32 = coord1; - let _e294: vec2 = vec2(_e292, 6.0); - let _e300: vec4 = textureSampleBias(tex1D, samp, (_e294.x / _e294.y), 2.0, 5); - c = _e300; - let _e301: f32 = coord1; - let _e308: f32 = coord1; - let _e312: vec4 = vec4(_e308, 0.0, 0.0, 6.0); - let _e320: vec4 = textureSampleBias(tex1D, samp, (_e312.xyz / vec3(_e312.w)).x, 2.0, 5); - c = _e320; + let e18: f32 = coord1; + let e19: vec4 = textureSample(tex1D, samp, e18); + c = e19; + let e22: f32 = coord1; + let e24: vec4 = textureSampleBias(tex1D, samp, e22, 2.0); + c = e24; + let e28: f32 = coord1; + let e31: vec4 = textureSampleGrad(tex1D, samp, e28, 4.0, 4.0); + c = e31; + let e36: f32 = coord1; + let e40: vec4 = textureSampleGrad(tex1D, samp, e36, 4.0, 4.0, 5); + c = e40; + let e43: f32 = coord1; + let e45: vec4 = textureSampleLevel(tex1D, samp, e43, 3.0); + c = e45; + let e49: f32 = coord1; + let e52: vec4 = textureSampleLevel(tex1D, samp, e49, 3.0, 5); + c = e52; + let e55: f32 = coord1; + let e57: vec4 = textureSample(tex1D, samp, e55, 5); + c = e57; + let e61: f32 = coord1; + let e64: vec4 = textureSampleBias(tex1D, samp, e61, 2.0, 5); + c = e64; + let e65: f32 = coord1; + let e68: f32 = coord1; + let e70: vec2 = vec2(e68, 6.0); + let e74: vec4 = textureSample(tex1D, samp, (e70.x / e70.y)); + c = e74; + let e75: f32 = coord1; + let e80: f32 = coord1; + let e84: vec4 = vec4(e80, 0.0, 0.0, 6.0); + let e90: vec4 = textureSample(tex1D, samp, (e84.xyz / vec3(e84.w)).x); + c = e90; + let e91: f32 = coord1; + let e95: f32 = coord1; + let e97: vec2 = vec2(e95, 6.0); + let e102: vec4 = textureSampleBias(tex1D, samp, (e97.x / e97.y), 2.0); + c = e102; + let e103: f32 = coord1; + let e109: f32 = coord1; + let e113: vec4 = vec4(e109, 0.0, 0.0, 6.0); + let e120: vec4 = textureSampleBias(tex1D, samp, (e113.xyz / vec3(e113.w)).x, 2.0); + c = e120; + let e121: f32 = coord1; + let e126: f32 = coord1; + let e128: vec2 = vec2(e126, 6.0); + let e134: vec4 = textureSampleGrad(tex1D, samp, (e128.x / e128.y), 4.0, 4.0); + c = e134; + let e135: f32 = coord1; + let e142: f32 = coord1; + let e146: vec4 = vec4(e142, 0.0, 0.0, 6.0); + let e154: vec4 = textureSampleGrad(tex1D, samp, (e146.xyz / vec3(e146.w)).x, 4.0, 4.0); + c = e154; + let e155: f32 = coord1; + let e161: f32 = coord1; + let e163: vec2 = vec2(e161, 6.0); + let e170: vec4 = textureSampleGrad(tex1D, samp, (e163.x / e163.y), 4.0, 4.0, 5); + c = e170; + let e171: f32 = coord1; + let e179: f32 = coord1; + let e183: vec4 = vec4(e179, 0.0, 0.0, 6.0); + let e192: vec4 = textureSampleGrad(tex1D, samp, (e183.xyz / vec3(e183.w)).x, 4.0, 4.0, 5); + c = e192; + let e193: f32 = coord1; + let e197: f32 = coord1; + let e199: vec2 = vec2(e197, 6.0); + let e204: vec4 = textureSampleLevel(tex1D, samp, (e199.x / e199.y), 3.0); + c = e204; + let e205: f32 = coord1; + let e211: f32 = coord1; + let e215: vec4 = vec4(e211, 0.0, 0.0, 6.0); + let e222: vec4 = textureSampleLevel(tex1D, samp, (e215.xyz / vec3(e215.w)).x, 3.0); + c = e222; + let e223: f32 = coord1; + let e228: f32 = coord1; + let e230: vec2 = vec2(e228, 6.0); + let e236: vec4 = textureSampleLevel(tex1D, samp, (e230.x / e230.y), 3.0, 5); + c = e236; + let e237: f32 = coord1; + let e244: f32 = coord1; + let e248: vec4 = vec4(e244, 0.0, 0.0, 6.0); + let e256: vec4 = textureSampleLevel(tex1D, samp, (e248.xyz / vec3(e248.w)).x, 3.0, 5); + c = e256; + let e257: f32 = coord1; + let e261: f32 = coord1; + let e263: vec2 = vec2(e261, 6.0); + let e268: vec4 = textureSample(tex1D, samp, (e263.x / e263.y), 5); + c = e268; + let e269: f32 = coord1; + let e275: f32 = coord1; + let e279: vec4 = vec4(e275, 0.0, 0.0, 6.0); + let e286: vec4 = textureSample(tex1D, samp, (e279.xyz / vec3(e279.w)).x, 5); + c = e286; + let e287: f32 = coord1; + let e292: f32 = coord1; + let e294: vec2 = vec2(e292, 6.0); + let e300: vec4 = textureSampleBias(tex1D, samp, (e294.x / e294.y), 2.0, 5); + c = e300; + let e301: f32 = coord1; + let e308: f32 = coord1; + let e312: vec4 = vec4(e308, 0.0, 0.0, 6.0); + let e320: vec4 = textureSampleBias(tex1D, samp, (e312.xyz / vec3(e312.w)).x, 2.0, 5); + c = e320; return; } @@ -145,30 +145,30 @@ fn testTex1DArray(coord2: vec2) { var c1: vec4; coord3 = coord2; - let _e18: vec2 = coord3; - let _e22: vec4 = textureSample(tex1DArray, samp, _e18.x, i32(_e18.x)); - c1 = _e22; - let _e25: vec2 = coord3; - let _e30: vec4 = textureSampleBias(tex1DArray, samp, _e25.x, i32(_e25.x), 2.0); - c1 = _e30; - let _e34: vec2 = coord3; - let _e40: vec4 = textureSampleGrad(tex1DArray, samp, _e34.x, i32(_e34.x), 4.0, 4.0); - c1 = _e40; - let _e45: vec2 = coord3; - let _e52: vec4 = textureSampleGrad(tex1DArray, samp, _e45.x, i32(_e45.x), 4.0, 4.0, 5); - c1 = _e52; - let _e55: vec2 = coord3; - let _e60: vec4 = textureSampleLevel(tex1DArray, samp, _e55.x, i32(_e55.x), 3.0); - c1 = _e60; - let _e64: vec2 = coord3; - let _e70: vec4 = textureSampleLevel(tex1DArray, samp, _e64.x, i32(_e64.x), 3.0, 5); - c1 = _e70; - let _e73: vec2 = coord3; - let _e78: vec4 = textureSample(tex1DArray, samp, _e73.x, i32(_e73.x), 5); - c1 = _e78; - let _e82: vec2 = coord3; - let _e88: vec4 = textureSampleBias(tex1DArray, samp, _e82.x, i32(_e82.x), 2.0, 5); - c1 = _e88; + let e18: vec2 = coord3; + let e22: vec4 = textureSample(tex1DArray, samp, e18.x, i32(e18.x)); + c1 = e22; + let e25: vec2 = coord3; + let e30: vec4 = textureSampleBias(tex1DArray, samp, e25.x, i32(e25.x), 2.0); + c1 = e30; + let e34: vec2 = coord3; + let e40: vec4 = textureSampleGrad(tex1DArray, samp, e34.x, i32(e34.x), 4.0, 4.0); + c1 = e40; + let e45: vec2 = coord3; + let e52: vec4 = textureSampleGrad(tex1DArray, samp, e45.x, i32(e45.x), 4.0, 4.0, 5); + c1 = e52; + let e55: vec2 = coord3; + let e60: vec4 = textureSampleLevel(tex1DArray, samp, e55.x, i32(e55.x), 3.0); + c1 = e60; + let e64: vec2 = coord3; + let e70: vec4 = textureSampleLevel(tex1DArray, samp, e64.x, i32(e64.x), 3.0, 5); + c1 = e70; + let e73: vec2 = coord3; + let e78: vec4 = textureSample(tex1DArray, samp, e73.x, i32(e73.x), 5); + c1 = e78; + let e82: vec2 = coord3; + let e88: vec4 = textureSampleBias(tex1DArray, samp, e82.x, i32(e82.x), 2.0, 5); + c1 = e88; return; } @@ -177,110 +177,110 @@ fn testTex2D(coord4: vec2) { var c2: vec4; coord5 = coord4; - let _e18: vec2 = coord5; - let _e19: vec4 = textureSample(tex2D, samp, _e18); - c2 = _e19; - let _e22: vec2 = coord5; - let _e24: vec4 = textureSampleBias(tex2D, samp, _e22, 2.0); - c2 = _e24; - let _e30: vec2 = coord5; - let _e35: vec4 = textureSampleGrad(tex2D, samp, _e30, vec2(4.0), vec2(4.0)); - c2 = _e35; - let _e43: vec2 = coord5; - let _e50: vec4 = textureSampleGrad(tex2D, samp, _e43, vec2(4.0), vec2(4.0), vec2(5, 5)); - c2 = _e50; - let _e53: vec2 = coord5; - let _e55: vec4 = textureSampleLevel(tex2D, samp, _e53, 3.0); - c2 = _e55; - let _e60: vec2 = coord5; - let _e64: vec4 = textureSampleLevel(tex2D, samp, _e60, 3.0, vec2(5, 5)); - c2 = _e64; - let _e68: vec2 = coord5; - let _e71: vec4 = textureSample(tex2D, samp, _e68, vec2(5, 5)); - c2 = _e71; - let _e76: vec2 = coord5; - let _e80: vec4 = textureSampleBias(tex2D, samp, _e76, 2.0, vec2(5, 5)); - c2 = _e80; - let _e81: vec2 = coord5; - let _e84: vec2 = coord5; - let _e86: vec3 = vec3(_e84, 6.0); - let _e91: vec4 = textureSample(tex2D, samp, (_e86.xy / vec2(_e86.z))); - c2 = _e91; - let _e92: vec2 = coord5; - let _e96: vec2 = coord5; - let _e99: vec4 = vec4(_e96, 0.0, 6.0); - let _e105: vec4 = textureSample(tex2D, samp, (_e99.xyz / vec3(_e99.w)).xy); - c2 = _e105; - let _e106: vec2 = coord5; - let _e110: vec2 = coord5; - let _e112: vec3 = vec3(_e110, 6.0); - let _e118: vec4 = textureSampleBias(tex2D, samp, (_e112.xy / vec2(_e112.z)), 2.0); - c2 = _e118; - let _e119: vec2 = coord5; - let _e124: vec2 = coord5; - let _e127: vec4 = vec4(_e124, 0.0, 6.0); - let _e134: vec4 = textureSampleBias(tex2D, samp, (_e127.xyz / vec3(_e127.w)).xy, 2.0); - c2 = _e134; - let _e135: vec2 = coord5; - let _e142: vec2 = coord5; - let _e144: vec3 = vec3(_e142, 6.0); - let _e153: vec4 = textureSampleGrad(tex2D, samp, (_e144.xy / vec2(_e144.z)), vec2(4.0), vec2(4.0)); - c2 = _e153; - let _e154: vec2 = coord5; - let _e162: vec2 = coord5; - let _e165: vec4 = vec4(_e162, 0.0, 6.0); - let _e175: vec4 = textureSampleGrad(tex2D, samp, (_e165.xyz / vec3(_e165.w)).xy, vec2(4.0), vec2(4.0)); - c2 = _e175; - let _e176: vec2 = coord5; - let _e185: vec2 = coord5; - let _e187: vec3 = vec3(_e185, 6.0); - let _e198: vec4 = textureSampleGrad(tex2D, samp, (_e187.xy / vec2(_e187.z)), vec2(4.0), vec2(4.0), vec2(5, 5)); - c2 = _e198; - let _e199: vec2 = coord5; - let _e209: vec2 = coord5; - let _e212: vec4 = vec4(_e209, 0.0, 6.0); - let _e224: vec4 = textureSampleGrad(tex2D, samp, (_e212.xyz / vec3(_e212.w)).xy, vec2(4.0), vec2(4.0), vec2(5, 5)); - c2 = _e224; - let _e225: vec2 = coord5; - let _e229: vec2 = coord5; - let _e231: vec3 = vec3(_e229, 6.0); - let _e237: vec4 = textureSampleLevel(tex2D, samp, (_e231.xy / vec2(_e231.z)), 3.0); - c2 = _e237; - let _e238: vec2 = coord5; - let _e243: vec2 = coord5; - let _e246: vec4 = vec4(_e243, 0.0, 6.0); - let _e253: vec4 = textureSampleLevel(tex2D, samp, (_e246.xyz / vec3(_e246.w)).xy, 3.0); - c2 = _e253; - let _e254: vec2 = coord5; - let _e260: vec2 = coord5; - let _e262: vec3 = vec3(_e260, 6.0); - let _e270: vec4 = textureSampleLevel(tex2D, samp, (_e262.xy / vec2(_e262.z)), 3.0, vec2(5, 5)); - c2 = _e270; - let _e271: vec2 = coord5; - let _e278: vec2 = coord5; - let _e281: vec4 = vec4(_e278, 0.0, 6.0); - let _e290: vec4 = textureSampleLevel(tex2D, samp, (_e281.xyz / vec3(_e281.w)).xy, 3.0, vec2(5, 5)); - c2 = _e290; - let _e291: vec2 = coord5; - let _e296: vec2 = coord5; - let _e298: vec3 = vec3(_e296, 6.0); - let _e305: vec4 = textureSample(tex2D, samp, (_e298.xy / vec2(_e298.z)), vec2(5, 5)); - c2 = _e305; - let _e306: vec2 = coord5; - let _e312: vec2 = coord5; - let _e315: vec4 = vec4(_e312, 0.0, 6.0); - let _e323: vec4 = textureSample(tex2D, samp, (_e315.xyz / vec3(_e315.w)).xy, vec2(5, 5)); - c2 = _e323; - let _e324: vec2 = coord5; - let _e330: vec2 = coord5; - let _e332: vec3 = vec3(_e330, 6.0); - let _e340: vec4 = textureSampleBias(tex2D, samp, (_e332.xy / vec2(_e332.z)), 2.0, vec2(5, 5)); - c2 = _e340; - let _e341: vec2 = coord5; - let _e348: vec2 = coord5; - let _e351: vec4 = vec4(_e348, 0.0, 6.0); - let _e360: vec4 = textureSampleBias(tex2D, samp, (_e351.xyz / vec3(_e351.w)).xy, 2.0, vec2(5, 5)); - c2 = _e360; + let e18: vec2 = coord5; + let e19: vec4 = textureSample(tex2D, samp, e18); + c2 = e19; + let e22: vec2 = coord5; + let e24: vec4 = textureSampleBias(tex2D, samp, e22, 2.0); + c2 = e24; + let e30: vec2 = coord5; + let e35: vec4 = textureSampleGrad(tex2D, samp, e30, vec2(4.0), vec2(4.0)); + c2 = e35; + let e43: vec2 = coord5; + let e50: vec4 = textureSampleGrad(tex2D, samp, e43, vec2(4.0), vec2(4.0), vec2(5, 5)); + c2 = e50; + let e53: vec2 = coord5; + let e55: vec4 = textureSampleLevel(tex2D, samp, e53, 3.0); + c2 = e55; + let e60: vec2 = coord5; + let e64: vec4 = textureSampleLevel(tex2D, samp, e60, 3.0, vec2(5, 5)); + c2 = e64; + let e68: vec2 = coord5; + let e71: vec4 = textureSample(tex2D, samp, e68, vec2(5, 5)); + c2 = e71; + let e76: vec2 = coord5; + let e80: vec4 = textureSampleBias(tex2D, samp, e76, 2.0, vec2(5, 5)); + c2 = e80; + let e81: vec2 = coord5; + let e84: vec2 = coord5; + let e86: vec3 = vec3(e84, 6.0); + let e91: vec4 = textureSample(tex2D, samp, (e86.xy / vec2(e86.z))); + c2 = e91; + let e92: vec2 = coord5; + let e96: vec2 = coord5; + let e99: vec4 = vec4(e96, 0.0, 6.0); + let e105: vec4 = textureSample(tex2D, samp, (e99.xyz / vec3(e99.w)).xy); + c2 = e105; + let e106: vec2 = coord5; + let e110: vec2 = coord5; + let e112: vec3 = vec3(e110, 6.0); + let e118: vec4 = textureSampleBias(tex2D, samp, (e112.xy / vec2(e112.z)), 2.0); + c2 = e118; + let e119: vec2 = coord5; + let e124: vec2 = coord5; + let e127: vec4 = vec4(e124, 0.0, 6.0); + let e134: vec4 = textureSampleBias(tex2D, samp, (e127.xyz / vec3(e127.w)).xy, 2.0); + c2 = e134; + let e135: vec2 = coord5; + let e142: vec2 = coord5; + let e144: vec3 = vec3(e142, 6.0); + let e153: vec4 = textureSampleGrad(tex2D, samp, (e144.xy / vec2(e144.z)), vec2(4.0), vec2(4.0)); + c2 = e153; + let e154: vec2 = coord5; + let e162: vec2 = coord5; + let e165: vec4 = vec4(e162, 0.0, 6.0); + let e175: vec4 = textureSampleGrad(tex2D, samp, (e165.xyz / vec3(e165.w)).xy, vec2(4.0), vec2(4.0)); + c2 = e175; + let e176: vec2 = coord5; + let e185: vec2 = coord5; + let e187: vec3 = vec3(e185, 6.0); + let e198: vec4 = textureSampleGrad(tex2D, samp, (e187.xy / vec2(e187.z)), vec2(4.0), vec2(4.0), vec2(5, 5)); + c2 = e198; + let e199: vec2 = coord5; + let e209: vec2 = coord5; + let e212: vec4 = vec4(e209, 0.0, 6.0); + let e224: vec4 = textureSampleGrad(tex2D, samp, (e212.xyz / vec3(e212.w)).xy, vec2(4.0), vec2(4.0), vec2(5, 5)); + c2 = e224; + let e225: vec2 = coord5; + let e229: vec2 = coord5; + let e231: vec3 = vec3(e229, 6.0); + let e237: vec4 = textureSampleLevel(tex2D, samp, (e231.xy / vec2(e231.z)), 3.0); + c2 = e237; + let e238: vec2 = coord5; + let e243: vec2 = coord5; + let e246: vec4 = vec4(e243, 0.0, 6.0); + let e253: vec4 = textureSampleLevel(tex2D, samp, (e246.xyz / vec3(e246.w)).xy, 3.0); + c2 = e253; + let e254: vec2 = coord5; + let e260: vec2 = coord5; + let e262: vec3 = vec3(e260, 6.0); + let e270: vec4 = textureSampleLevel(tex2D, samp, (e262.xy / vec2(e262.z)), 3.0, vec2(5, 5)); + c2 = e270; + let e271: vec2 = coord5; + let e278: vec2 = coord5; + let e281: vec4 = vec4(e278, 0.0, 6.0); + let e290: vec4 = textureSampleLevel(tex2D, samp, (e281.xyz / vec3(e281.w)).xy, 3.0, vec2(5, 5)); + c2 = e290; + let e291: vec2 = coord5; + let e296: vec2 = coord5; + let e298: vec3 = vec3(e296, 6.0); + let e305: vec4 = textureSample(tex2D, samp, (e298.xy / vec2(e298.z)), vec2(5, 5)); + c2 = e305; + let e306: vec2 = coord5; + let e312: vec2 = coord5; + let e315: vec4 = vec4(e312, 0.0, 6.0); + let e323: vec4 = textureSample(tex2D, samp, (e315.xyz / vec3(e315.w)).xy, vec2(5, 5)); + c2 = e323; + let e324: vec2 = coord5; + let e330: vec2 = coord5; + let e332: vec3 = vec3(e330, 6.0); + let e340: vec4 = textureSampleBias(tex2D, samp, (e332.xy / vec2(e332.z)), 2.0, vec2(5, 5)); + c2 = e340; + let e341: vec2 = coord5; + let e348: vec2 = coord5; + let e351: vec4 = vec4(e348, 0.0, 6.0); + let e360: vec4 = textureSampleBias(tex2D, samp, (e351.xyz / vec3(e351.w)).xy, 2.0, vec2(5, 5)); + c2 = e360; return; } @@ -289,72 +289,72 @@ fn testTex2DShadow(coord6: vec2) { var d: f32; coord7 = coord6; - let _e17: vec2 = coord7; - let _e20: vec2 = coord7; - let _e22: vec3 = vec3(_e20, 1.0); - let _e25: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e22.xy, _e22.z); - d = _e25; - let _e26: vec2 = coord7; - let _e33: vec2 = coord7; - let _e35: vec3 = vec3(_e33, 1.0); - let _e42: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e35.xy, _e35.z); - d = _e42; - let _e43: vec2 = coord7; - let _e52: vec2 = coord7; - let _e54: vec3 = vec3(_e52, 1.0); - let _e63: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e54.xy, _e54.z, vec2(5, 5)); - d = _e63; - let _e64: vec2 = coord7; - let _e68: vec2 = coord7; - let _e70: vec3 = vec3(_e68, 1.0); - let _e74: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e70.xy, _e70.z); - d = _e74; - let _e75: vec2 = coord7; - let _e81: vec2 = coord7; - let _e83: vec3 = vec3(_e81, 1.0); - let _e89: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e83.xy, _e83.z, vec2(5, 5)); - d = _e89; - let _e90: vec2 = coord7; - let _e95: vec2 = coord7; - let _e97: vec3 = vec3(_e95, 1.0); - let _e102: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e97.xy, _e97.z, vec2(5, 5)); - d = _e102; - let _e103: vec2 = coord7; - let _e107: vec2 = coord7; - let _e110: vec4 = vec4(_e107, 1.0, 6.0); - let _e114: vec3 = (_e110.xyz / vec3(_e110.w)); - let _e117: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e114.xy, _e114.z); - d = _e117; - let _e118: vec2 = coord7; - let _e126: vec2 = coord7; - let _e129: vec4 = vec4(_e126, 1.0, 6.0); - let _e137: vec3 = (_e129.xyz / vec3(_e129.w)); - let _e140: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e137.xy, _e137.z); - d = _e140; - let _e141: vec2 = coord7; - let _e151: vec2 = coord7; - let _e154: vec4 = vec4(_e151, 1.0, 6.0); - let _e164: vec3 = (_e154.xyz / vec3(_e154.w)); - let _e167: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e164.xy, _e164.z, vec2(5, 5)); - d = _e167; - let _e168: vec2 = coord7; - let _e173: vec2 = coord7; - let _e176: vec4 = vec4(_e173, 1.0, 6.0); - let _e181: vec3 = (_e176.xyz / vec3(_e176.w)); - let _e184: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e181.xy, _e181.z); - d = _e184; - let _e185: vec2 = coord7; - let _e192: vec2 = coord7; - let _e195: vec4 = vec4(_e192, 1.0, 6.0); - let _e202: vec3 = (_e195.xyz / vec3(_e195.w)); - let _e205: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e202.xy, _e202.z, vec2(5, 5)); - d = _e205; - let _e206: vec2 = coord7; - let _e212: vec2 = coord7; - let _e215: vec4 = vec4(_e212, 1.0, 6.0); - let _e221: vec3 = (_e215.xyz / vec3(_e215.w)); - let _e224: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e221.xy, _e221.z, vec2(5, 5)); - d = _e224; + let e17: vec2 = coord7; + let e20: vec2 = coord7; + let e22: vec3 = vec3(e20, 1.0); + let e25: f32 = textureSampleCompare(tex2DShadow, sampShadow, e22.xy, e22.z); + d = e25; + let e26: vec2 = coord7; + let e33: vec2 = coord7; + let e35: vec3 = vec3(e33, 1.0); + let e42: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e35.xy, e35.z); + d = e42; + let e43: vec2 = coord7; + let e52: vec2 = coord7; + let e54: vec3 = vec3(e52, 1.0); + let e63: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e54.xy, e54.z, vec2(5, 5)); + d = e63; + let e64: vec2 = coord7; + let e68: vec2 = coord7; + let e70: vec3 = vec3(e68, 1.0); + let e74: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e70.xy, e70.z); + d = e74; + let e75: vec2 = coord7; + let e81: vec2 = coord7; + let e83: vec3 = vec3(e81, 1.0); + let e89: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e83.xy, e83.z, vec2(5, 5)); + d = e89; + let e90: vec2 = coord7; + let e95: vec2 = coord7; + let e97: vec3 = vec3(e95, 1.0); + let e102: f32 = textureSampleCompare(tex2DShadow, sampShadow, e97.xy, e97.z, vec2(5, 5)); + d = e102; + let e103: vec2 = coord7; + let e107: vec2 = coord7; + let e110: vec4 = vec4(e107, 1.0, 6.0); + let e114: vec3 = (e110.xyz / vec3(e110.w)); + let e117: f32 = textureSampleCompare(tex2DShadow, sampShadow, e114.xy, e114.z); + d = e117; + let e118: vec2 = coord7; + let e126: vec2 = coord7; + let e129: vec4 = vec4(e126, 1.0, 6.0); + let e137: vec3 = (e129.xyz / vec3(e129.w)); + let e140: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e137.xy, e137.z); + d = e140; + let e141: vec2 = coord7; + let e151: vec2 = coord7; + let e154: vec4 = vec4(e151, 1.0, 6.0); + let e164: vec3 = (e154.xyz / vec3(e154.w)); + let e167: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e164.xy, e164.z, vec2(5, 5)); + d = e167; + let e168: vec2 = coord7; + let e173: vec2 = coord7; + let e176: vec4 = vec4(e173, 1.0, 6.0); + let e181: vec3 = (e176.xyz / vec3(e176.w)); + let e184: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e181.xy, e181.z); + d = e184; + let e185: vec2 = coord7; + let e192: vec2 = coord7; + let e195: vec4 = vec4(e192, 1.0, 6.0); + let e202: vec3 = (e195.xyz / vec3(e195.w)); + let e205: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e202.xy, e202.z, vec2(5, 5)); + d = e205; + let e206: vec2 = coord7; + let e212: vec2 = coord7; + let e215: vec4 = vec4(e212, 1.0, 6.0); + let e221: vec3 = (e215.xyz / vec3(e215.w)); + let e224: f32 = textureSampleCompare(tex2DShadow, sampShadow, e221.xy, e221.z, vec2(5, 5)); + d = e224; return; } @@ -363,30 +363,30 @@ fn testTex2DArray(coord8: vec3) { var c3: vec4; coord9 = coord8; - let _e18: vec3 = coord9; - let _e22: vec4 = textureSample(tex2DArray, samp, _e18.xy, i32(_e18.z)); - c3 = _e22; - let _e25: vec3 = coord9; - let _e30: vec4 = textureSampleBias(tex2DArray, samp, _e25.xy, i32(_e25.z), 2.0); - c3 = _e30; - let _e36: vec3 = coord9; - let _e44: vec4 = textureSampleGrad(tex2DArray, samp, _e36.xy, i32(_e36.z), vec2(4.0), vec2(4.0)); - c3 = _e44; - let _e52: vec3 = coord9; - let _e62: vec4 = textureSampleGrad(tex2DArray, samp, _e52.xy, i32(_e52.z), vec2(4.0), vec2(4.0), vec2(5, 5)); - c3 = _e62; - let _e65: vec3 = coord9; - let _e70: vec4 = textureSampleLevel(tex2DArray, samp, _e65.xy, i32(_e65.z), 3.0); - c3 = _e70; - let _e75: vec3 = coord9; - let _e82: vec4 = textureSampleLevel(tex2DArray, samp, _e75.xy, i32(_e75.z), 3.0, vec2(5, 5)); - c3 = _e82; - let _e86: vec3 = coord9; - let _e92: vec4 = textureSample(tex2DArray, samp, _e86.xy, i32(_e86.z), vec2(5, 5)); - c3 = _e92; - let _e97: vec3 = coord9; - let _e104: vec4 = textureSampleBias(tex2DArray, samp, _e97.xy, i32(_e97.z), 2.0, vec2(5, 5)); - c3 = _e104; + let e18: vec3 = coord9; + let e22: vec4 = textureSample(tex2DArray, samp, e18.xy, i32(e18.z)); + c3 = e22; + let e25: vec3 = coord9; + let e30: vec4 = textureSampleBias(tex2DArray, samp, e25.xy, i32(e25.z), 2.0); + c3 = e30; + let e36: vec3 = coord9; + let e44: vec4 = textureSampleGrad(tex2DArray, samp, e36.xy, i32(e36.z), vec2(4.0), vec2(4.0)); + c3 = e44; + let e52: vec3 = coord9; + let e62: vec4 = textureSampleGrad(tex2DArray, samp, e52.xy, i32(e52.z), vec2(4.0), vec2(4.0), vec2(5, 5)); + c3 = e62; + let e65: vec3 = coord9; + let e70: vec4 = textureSampleLevel(tex2DArray, samp, e65.xy, i32(e65.z), 3.0); + c3 = e70; + let e75: vec3 = coord9; + let e82: vec4 = textureSampleLevel(tex2DArray, samp, e75.xy, i32(e75.z), 3.0, vec2(5, 5)); + c3 = e82; + let e86: vec3 = coord9; + let e92: vec4 = textureSample(tex2DArray, samp, e86.xy, i32(e86.z), vec2(5, 5)); + c3 = e92; + let e97: vec3 = coord9; + let e104: vec4 = textureSampleBias(tex2DArray, samp, e97.xy, i32(e97.z), 2.0, vec2(5, 5)); + c3 = e104; return; } @@ -395,36 +395,36 @@ fn testTex2DArrayShadow(coord10: vec3) { var d1: f32; coord11 = coord10; - let _e17: vec3 = coord11; - let _e20: vec3 = coord11; - let _e22: vec4 = vec4(_e20, 1.0); - let _e27: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e22.xy, i32(_e22.z), _e22.w); - d1 = _e27; - let _e28: vec3 = coord11; - let _e35: vec3 = coord11; - let _e37: vec4 = vec4(_e35, 1.0); - let _e46: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e37.xy, i32(_e37.z), _e37.w); - d1 = _e46; - let _e47: vec3 = coord11; - let _e56: vec3 = coord11; - let _e58: vec4 = vec4(_e56, 1.0); - let _e69: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e58.xy, i32(_e58.z), _e58.w, vec2(5, 5)); - d1 = _e69; - let _e70: vec3 = coord11; - let _e74: vec3 = coord11; - let _e76: vec4 = vec4(_e74, 1.0); - let _e82: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e76.xy, i32(_e76.z), _e76.w); - d1 = _e82; - let _e83: vec3 = coord11; - let _e89: vec3 = coord11; - let _e91: vec4 = vec4(_e89, 1.0); - let _e99: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e91.xy, i32(_e91.z), _e91.w, vec2(5, 5)); - d1 = _e99; - let _e100: vec3 = coord11; - let _e105: vec3 = coord11; - let _e107: vec4 = vec4(_e105, 1.0); - let _e114: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e107.xy, i32(_e107.z), _e107.w, vec2(5, 5)); - d1 = _e114; + let e17: vec3 = coord11; + let e20: vec3 = coord11; + let e22: vec4 = vec4(e20, 1.0); + let e27: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, e22.xy, i32(e22.z), e22.w); + d1 = e27; + let e28: vec3 = coord11; + let e35: vec3 = coord11; + let e37: vec4 = vec4(e35, 1.0); + let e46: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e37.xy, i32(e37.z), e37.w); + d1 = e46; + let e47: vec3 = coord11; + let e56: vec3 = coord11; + let e58: vec4 = vec4(e56, 1.0); + let e69: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e58.xy, i32(e58.z), e58.w, vec2(5, 5)); + d1 = e69; + let e70: vec3 = coord11; + let e74: vec3 = coord11; + let e76: vec4 = vec4(e74, 1.0); + let e82: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e76.xy, i32(e76.z), e76.w); + d1 = e82; + let e83: vec3 = coord11; + let e89: vec3 = coord11; + let e91: vec4 = vec4(e89, 1.0); + let e99: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e91.xy, i32(e91.z), e91.w, vec2(5, 5)); + d1 = e99; + let e100: vec3 = coord11; + let e105: vec3 = coord11; + let e107: vec4 = vec4(e105, 1.0); + let e114: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, e107.xy, i32(e107.z), e107.w, vec2(5, 5)); + d1 = e114; return; } @@ -433,27 +433,27 @@ fn testTexCube(coord12: vec3) { var c4: vec4; coord13 = coord12; - let _e18: vec3 = coord13; - let _e19: vec4 = textureSample(texCube, samp, _e18); - c4 = _e19; - let _e22: vec3 = coord13; - let _e24: vec4 = textureSampleBias(texCube, samp, _e22, 2.0); - c4 = _e24; - let _e30: vec3 = coord13; - let _e35: vec4 = textureSampleGrad(texCube, samp, _e30, vec3(4.0), vec3(4.0)); - c4 = _e35; - let _e38: vec3 = coord13; - let _e40: vec4 = textureSampleLevel(texCube, samp, _e38, 3.0); - c4 = _e40; - let _e45: vec3 = coord13; - let _e49: vec4 = textureSampleLevel(texCube, samp, _e45, 3.0, vec3(5, 5, 5)); - c4 = _e49; - let _e53: vec3 = coord13; - let _e56: vec4 = textureSample(texCube, samp, _e53, vec3(5, 5, 5)); - c4 = _e56; - let _e61: vec3 = coord13; - let _e65: vec4 = textureSampleBias(texCube, samp, _e61, 2.0, vec3(5, 5, 5)); - c4 = _e65; + let e18: vec3 = coord13; + let e19: vec4 = textureSample(texCube, samp, e18); + c4 = e19; + let e22: vec3 = coord13; + let e24: vec4 = textureSampleBias(texCube, samp, e22, 2.0); + c4 = e24; + let e30: vec3 = coord13; + let e35: vec4 = textureSampleGrad(texCube, samp, e30, vec3(4.0), vec3(4.0)); + c4 = e35; + let e38: vec3 = coord13; + let e40: vec4 = textureSampleLevel(texCube, samp, e38, 3.0); + c4 = e40; + let e45: vec3 = coord13; + let e49: vec4 = textureSampleLevel(texCube, samp, e45, 3.0, vec3(5, 5, 5)); + c4 = e49; + let e53: vec3 = coord13; + let e56: vec4 = textureSample(texCube, samp, e53, vec3(5, 5, 5)); + c4 = e56; + let e61: vec3 = coord13; + let e65: vec4 = textureSampleBias(texCube, samp, e61, 2.0, vec3(5, 5, 5)); + c4 = e65; return; } @@ -462,31 +462,31 @@ fn testTexCubeShadow(coord14: vec3) { var d2: f32; coord15 = coord14; - let _e17: vec3 = coord15; - let _e20: vec3 = coord15; - let _e22: vec4 = vec4(_e20, 1.0); - let _e25: f32 = textureSampleCompare(texCubeShadow, sampShadow, _e22.xyz, _e22.w); - d2 = _e25; - let _e26: vec3 = coord15; - let _e33: vec3 = coord15; - let _e35: vec4 = vec4(_e33, 1.0); - let _e42: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e35.xyz, _e35.w); - d2 = _e42; - let _e43: vec3 = coord15; - let _e47: vec3 = coord15; - let _e49: vec4 = vec4(_e47, 1.0); - let _e53: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e49.xyz, _e49.w); - d2 = _e53; - let _e54: vec3 = coord15; - let _e60: vec3 = coord15; - let _e62: vec4 = vec4(_e60, 1.0); - let _e68: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e62.xyz, _e62.w, vec3(5, 5, 5)); - d2 = _e68; - let _e69: vec3 = coord15; - let _e74: vec3 = coord15; - let _e76: vec4 = vec4(_e74, 1.0); - let _e81: f32 = textureSampleCompare(texCubeShadow, sampShadow, _e76.xyz, _e76.w, vec3(5, 5, 5)); - d2 = _e81; + let e17: vec3 = coord15; + let e20: vec3 = coord15; + let e22: vec4 = vec4(e20, 1.0); + let e25: f32 = textureSampleCompare(texCubeShadow, sampShadow, e22.xyz, e22.w); + d2 = e25; + let e26: vec3 = coord15; + let e33: vec3 = coord15; + let e35: vec4 = vec4(e33, 1.0); + let e42: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, e35.xyz, e35.w); + d2 = e42; + let e43: vec3 = coord15; + let e47: vec3 = coord15; + let e49: vec4 = vec4(e47, 1.0); + let e53: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, e49.xyz, e49.w); + d2 = e53; + let e54: vec3 = coord15; + let e60: vec3 = coord15; + let e62: vec4 = vec4(e60, 1.0); + let e68: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, e62.xyz, e62.w, vec3(5, 5, 5)); + d2 = e68; + let e69: vec3 = coord15; + let e74: vec3 = coord15; + let e76: vec4 = vec4(e74, 1.0); + let e81: f32 = textureSampleCompare(texCubeShadow, sampShadow, e76.xyz, e76.w, vec3(5, 5, 5)); + d2 = e81; return; } @@ -495,27 +495,27 @@ fn testTexCubeArray(coord16: vec4) { var c5: vec4; coord17 = coord16; - let _e18: vec4 = coord17; - let _e22: vec4 = textureSample(texCubeArray, samp, _e18.xyz, i32(_e18.w)); - c5 = _e22; - let _e25: vec4 = coord17; - let _e30: vec4 = textureSampleBias(texCubeArray, samp, _e25.xyz, i32(_e25.w), 2.0); - c5 = _e30; - let _e36: vec4 = coord17; - let _e44: vec4 = textureSampleGrad(texCubeArray, samp, _e36.xyz, i32(_e36.w), vec3(4.0), vec3(4.0)); - c5 = _e44; - let _e47: vec4 = coord17; - let _e52: vec4 = textureSampleLevel(texCubeArray, samp, _e47.xyz, i32(_e47.w), 3.0); - c5 = _e52; - let _e57: vec4 = coord17; - let _e64: vec4 = textureSampleLevel(texCubeArray, samp, _e57.xyz, i32(_e57.w), 3.0, vec3(5, 5, 5)); - c5 = _e64; - let _e68: vec4 = coord17; - let _e74: vec4 = textureSample(texCubeArray, samp, _e68.xyz, i32(_e68.w), vec3(5, 5, 5)); - c5 = _e74; - let _e79: vec4 = coord17; - let _e86: vec4 = textureSampleBias(texCubeArray, samp, _e79.xyz, i32(_e79.w), 2.0, vec3(5, 5, 5)); - c5 = _e86; + let e18: vec4 = coord17; + let e22: vec4 = textureSample(texCubeArray, samp, e18.xyz, i32(e18.w)); + c5 = e22; + let e25: vec4 = coord17; + let e30: vec4 = textureSampleBias(texCubeArray, samp, e25.xyz, i32(e25.w), 2.0); + c5 = e30; + let e36: vec4 = coord17; + let e44: vec4 = textureSampleGrad(texCubeArray, samp, e36.xyz, i32(e36.w), vec3(4.0), vec3(4.0)); + c5 = e44; + let e47: vec4 = coord17; + let e52: vec4 = textureSampleLevel(texCubeArray, samp, e47.xyz, i32(e47.w), 3.0); + c5 = e52; + let e57: vec4 = coord17; + let e64: vec4 = textureSampleLevel(texCubeArray, samp, e57.xyz, i32(e57.w), 3.0, vec3(5, 5, 5)); + c5 = e64; + let e68: vec4 = coord17; + let e74: vec4 = textureSample(texCubeArray, samp, e68.xyz, i32(e68.w), vec3(5, 5, 5)); + c5 = e74; + let e79: vec4 = coord17; + let e86: vec4 = textureSampleBias(texCubeArray, samp, e79.xyz, i32(e79.w), 2.0, vec3(5, 5, 5)); + c5 = e86; return; } @@ -524,9 +524,9 @@ fn testTexCubeArrayShadow(coord18: vec4) { var d3: f32; coord19 = coord18; - let _e19: vec4 = coord19; - let _e24: f32 = textureSampleCompare(texCubeArrayShadow, sampShadow, _e19.xyz, i32(_e19.w), 1.0); - d3 = _e24; + let e19: vec4 = coord19; + let e24: f32 = textureSampleCompare(texCubeArrayShadow, sampShadow, e19.xyz, i32(e19.w), 1.0); + d3 = e24; return; } @@ -535,30 +535,30 @@ fn testTex3D(coord20: vec3) { var c6: vec4; coord21 = coord20; - let _e18: vec3 = coord21; - let _e19: vec4 = textureSample(tex3D, samp, _e18); - c6 = _e19; - let _e22: vec3 = coord21; - let _e24: vec4 = textureSampleBias(tex3D, samp, _e22, 2.0); - c6 = _e24; - let _e30: vec3 = coord21; - let _e35: vec4 = textureSampleGrad(tex3D, samp, _e30, vec3(4.0), vec3(4.0)); - c6 = _e35; - let _e43: vec3 = coord21; - let _e50: vec4 = textureSampleGrad(tex3D, samp, _e43, vec3(4.0), vec3(4.0), vec3(5, 5, 5)); - c6 = _e50; - let _e53: vec3 = coord21; - let _e55: vec4 = textureSampleLevel(tex3D, samp, _e53, 3.0); - c6 = _e55; - let _e60: vec3 = coord21; - let _e64: vec4 = textureSampleLevel(tex3D, samp, _e60, 3.0, vec3(5, 5, 5)); - c6 = _e64; - let _e68: vec3 = coord21; - let _e71: vec4 = textureSample(tex3D, samp, _e68, vec3(5, 5, 5)); - c6 = _e71; - let _e76: vec3 = coord21; - let _e80: vec4 = textureSampleBias(tex3D, samp, _e76, 2.0, vec3(5, 5, 5)); - c6 = _e80; + let e18: vec3 = coord21; + let e19: vec4 = textureSample(tex3D, samp, e18); + c6 = e19; + let e22: vec3 = coord21; + let e24: vec4 = textureSampleBias(tex3D, samp, e22, 2.0); + c6 = e24; + let e30: vec3 = coord21; + let e35: vec4 = textureSampleGrad(tex3D, samp, e30, vec3(4.0), vec3(4.0)); + c6 = e35; + let e43: vec3 = coord21; + let e50: vec4 = textureSampleGrad(tex3D, samp, e43, vec3(4.0), vec3(4.0), vec3(5, 5, 5)); + c6 = e50; + let e53: vec3 = coord21; + let e55: vec4 = textureSampleLevel(tex3D, samp, e53, 3.0); + c6 = e55; + let e60: vec3 = coord21; + let e64: vec4 = textureSampleLevel(tex3D, samp, e60, 3.0, vec3(5, 5, 5)); + c6 = e64; + let e68: vec3 = coord21; + let e71: vec4 = textureSample(tex3D, samp, e68, vec3(5, 5, 5)); + c6 = e71; + let e76: vec3 = coord21; + let e80: vec4 = textureSampleBias(tex3D, samp, e76, 2.0, vec3(5, 5, 5)); + c6 = e80; return; } diff --git a/tests/out/wgsl/shadow.wgsl b/tests/out/wgsl/shadow.wgsl index e6b3967d74..376b66d87b 100644 --- a/tests/out/wgsl/shadow.wgsl +++ b/tests/out/wgsl/shadow.wgsl @@ -32,8 +32,8 @@ fn fetch_shadow(light_id: u32, homogeneous_coords: vec4) -> f32 { } let flip_correction: vec2 = vec2(0.5, -0.5); let light_local: vec2 = (((homogeneous_coords.xy * flip_correction) / vec2(homogeneous_coords.w)) + vec2(0.5, 0.5)); - let _e26: f32 = textureSampleCompareLevel(t_shadow, sampler_shadow, light_local, i32(light_id), (homogeneous_coords.z / homogeneous_coords.w)); - return _e26; + let e26: f32 = textureSampleCompareLevel(t_shadow, sampler_shadow, light_local, i32(light_id), (homogeneous_coords.z / homogeneous_coords.w)); + return e26; } [[stage(fragment)]] @@ -43,24 +43,24 @@ fn fs_main([[location(0)]] raw_normal: vec3, [[location(1)]] position: vec4 let normal: vec3 = normalize(raw_normal); loop { - let _e12: u32 = i; - let _e15: u32 = u_globals.num_lights.x; - if ((_e12 >= min(_e15, c_max_lights))) { + let e12: u32 = i; + let e15: u32 = u_globals.num_lights.x; + if ((e12 >= min(e15, c_max_lights))) { break; } - let _e19: u32 = i; - let light: Light = s_lights.data[_e19]; - let _e22: u32 = i; - let _e25: f32 = fetch_shadow(_e22, (light.proj * position)); + let e19: u32 = i; + let light: Light = s_lights.data[e19]; + let e22: u32 = i; + let e25: f32 = fetch_shadow(e22, (light.proj * position)); let light_dir: vec3 = normalize((light.pos.xyz - position.xyz)); let diffuse: f32 = max(0.0, dot(normal, light_dir)); - let _e34: vec3 = color; - color = (_e34 + ((_e25 * diffuse) * light.color.xyz)); + let e34: vec3 = color; + color = (e34 + ((e25 * diffuse) * light.color.xyz)); continuing { - let _e40: u32 = i; - i = (_e40 + 1u); + let e40: u32 = i; + i = (e40 + 1u); } } - let _e43: vec3 = color; - return vec4(_e43, 1.0); + let e43: vec3 = color; + return vec4(e43, 1.0); } diff --git a/tests/out/wgsl/skybox.wgsl b/tests/out/wgsl/skybox.wgsl index 75460c49b8..27565be731 100644 --- a/tests/out/wgsl/skybox.wgsl +++ b/tests/out/wgsl/skybox.wgsl @@ -23,20 +23,20 @@ fn vs_main([[builtin(vertex_index)]] vertex_index: u32) -> VertexOutput { tmp1_ = (i32(vertex_index) / 2); tmp2_ = (i32(vertex_index) & 1); - let _e10: i32 = tmp1_; - let _e16: i32 = tmp2_; - let pos: vec4 = vec4(((f32(_e10) * 4.0) - 1.0), ((f32(_e16) * 4.0) - 1.0), 0.0, 1.0); - let _e27: vec4 = r_data.view[0]; - let _e31: vec4 = r_data.view[1]; - let _e35: vec4 = r_data.view[2]; - let inv_model_view: mat3x3 = transpose(mat3x3(_e27.xyz, _e31.xyz, _e35.xyz)); - let _e40: mat4x4 = r_data.proj_inv; - let unprojected: vec4 = (_e40 * pos); + let e10: i32 = tmp1_; + let e16: i32 = tmp2_; + let pos: vec4 = vec4(((f32(e10) * 4.0) - 1.0), ((f32(e16) * 4.0) - 1.0), 0.0, 1.0); + let e27: vec4 = r_data.view[0]; + let e31: vec4 = r_data.view[1]; + let e35: vec4 = r_data.view[2]; + let inv_model_view: mat3x3 = transpose(mat3x3(e27.xyz, e31.xyz, e35.xyz)); + let e40: mat4x4 = r_data.proj_inv; + let unprojected: vec4 = (e40 * pos); return VertexOutput(pos, (inv_model_view * unprojected.xyz)); } [[stage(fragment)]] fn fs_main(in: VertexOutput) -> [[location(0)]] vec4 { - let _e5: vec4 = textureSample(r_texture, r_sampler, in.uv); - return _e5; + let e5: vec4 = textureSample(r_texture, r_sampler, in.uv); + return e5; } diff --git a/tests/out/wgsl/swizzle_write-frag.wgsl b/tests/out/wgsl/swizzle_write-frag.wgsl index 63c0696f88..1e56f90a5a 100644 --- a/tests/out/wgsl/swizzle_write-frag.wgsl +++ b/tests/out/wgsl/swizzle_write-frag.wgsl @@ -1,15 +1,15 @@ fn main1() { var x: vec3 = vec3(2.0, 2.0, 2.0); - let _e3: vec3 = x; - let _e8: vec2 = vec2(3.0, 4.0); - x.z = _e8.x; - x.x = _e8.y; - let _e13: vec3 = x; - let _e15: vec3 = x; - let _e18: vec2 = (_e15.xy * 5.0); - x.x = _e18.x; - x.y = _e18.y; + let e3: vec3 = x; + let e8: vec2 = vec2(3.0, 4.0); + x.z = e8.x; + x.x = e8.y; + let e13: vec3 = x; + let e15: vec3 = x; + let e18: vec2 = (e15.xy * 5.0); + x.x = e18.x; + x.y = e18.y; return; } diff --git a/tests/out/wgsl/texture-arg.wgsl b/tests/out/wgsl/texture-arg.wgsl index 420b437801..a013b15276 100644 --- a/tests/out/wgsl/texture-arg.wgsl +++ b/tests/out/wgsl/texture-arg.wgsl @@ -4,12 +4,12 @@ var Texture: texture_2d; var Sampler: sampler; fn test(Passed_Texture: texture_2d, Passed_Sampler: sampler) -> vec4 { - let _e7: vec4 = textureSample(Passed_Texture, Passed_Sampler, vec2(0.0, 0.0)); - return _e7; + let e7: vec4 = textureSample(Passed_Texture, Passed_Sampler, vec2(0.0, 0.0)); + return e7; } [[stage(fragment)]] fn main() -> [[location(0)]] vec4 { - let _e2: vec4 = test(Texture, Sampler); - return _e2; + let e2: vec4 = test(Texture, Sampler); + return e2; }