github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

Don't output identifiers starting with _

Browse Source
This commit is contained in:
João Capucho
2021-09-17 22:03:54 +01:00
committed by Dzmitry Malyshau
parent aea755fd32
commit 7895e7f036
36 changed files with 1557 additions and 1555 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/back/wgsl/mod.rs
View File

@@ -5,6 +5,8 @@ use thiserror::Error;
pub use writer::Writer;
const BAKE_PREFIX: &str = "e";
#[derive(Error, Debug)]
pub enum Error {
#[error(transparent)]

6
src/back/wgsl/writer.rs
View File

@@ -701,7 +701,7 @@ impl<W: Write> Writer<W> {
}
}
Some(format!("{}{}", back::BAKE_PREFIX, handle.index()))
Some(format!("{}{}", super::BAKE_PREFIX, handle.index()))
} else {
None
}
@@ -804,7 +804,7 @@ impl<W: Write> Writer<W> {
} => {
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<W: Write> Writer<W> {
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);

2
src/proc/namer.rs
View File

@@ -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::<String>();
// close the name by '_' if the re is a number, so that

12
tests/out/wgsl/210-bevy-2d-shader-frag.wgsl
View File

@@ -15,10 +15,10 @@ var<uniform> global: ColorMaterial_color;
fn main1() {
var color: vec4<f32>;
let _e4: vec4<f32> = global.Color;
color = _e4;
let _e6: vec4<f32> = color;
o_Target = _e6;
let e4: vec4<f32> = global.Color;
color = e4;
let e6: vec4<f32> = color;
o_Target = e6;
return;
}
@@ -26,6 +26,6 @@ fn main1() {
fn main([[location(0)]] v_Uv: vec2<f32>) -> FragmentOutput {
v_Uv1 = v_Uv;
main1();
let _e9: vec4<f32> = o_Target;
return FragmentOutput(_e9);
let e9: vec4<f32> = o_Target;
return FragmentOutput(e9);
}

24
tests/out/wgsl/210-bevy-2d-shader-vert.wgsl
View File

@@ -33,15 +33,15 @@ var<private> gl_Position: vec4<f32>;
fn main1() {
var position: vec3<f32>;
let _e10: vec2<f32> = Vertex_Uv1;
v_Uv = _e10;
let _e11: vec3<f32> = Vertex_Position1;
let _e12: vec2<f32> = global2.size;
position = (_e11 * vec3<f32>(_e12, 1.0));
let _e18: mat4x4<f32> = global.ViewProj;
let _e19: mat4x4<f32> = global1.Model;
let _e21: vec3<f32> = position;
gl_Position = ((_e18 * _e19) * vec4<f32>(_e21, 1.0));
let e10: vec2<f32> = Vertex_Uv1;
v_Uv = e10;
let e11: vec3<f32> = Vertex_Position1;
let e12: vec2<f32> = global2.size;
position = (e11 * vec3<f32>(e12, 1.0));
let e18: mat4x4<f32> = global.ViewProj;
let e19: mat4x4<f32> = global1.Model;
let e21: vec3<f32> = position;
gl_Position = ((e18 * e19) * vec4<f32>(e21, 1.0));
return;
}
@@ -51,7 +51,7 @@ fn main([[location(0)]] Vertex_Position: vec3<f32>, [[location(1)]] Vertex_Norma
Vertex_Normal1 = Vertex_Normal;
Vertex_Uv1 = Vertex_Uv;
main1();
let _e21: vec2<f32> = v_Uv;
let _e23: vec4<f32> = gl_Position;
return VertexOutput(_e21, _e23);
let e21: vec2<f32> = v_Uv;
let e23: vec4<f32> = gl_Position;
return VertexOutput(e21, e23);
}

38
tests/out/wgsl/210-bevy-shader-vert.wgsl
View File

@@ -28,20 +28,20 @@ var<uniform> global1: Transform;
var<private> gl_Position: vec4<f32>;
fn main1() {
let _e10: mat4x4<f32> = global1.Model;
let _e11: vec3<f32> = Vertex_Normal1;
v_Normal = (_e10 * vec4<f32>(_e11, 1.0)).xyz;
let _e16: mat4x4<f32> = global1.Model;
let _e24: vec3<f32> = Vertex_Normal1;
v_Normal = (mat3x3<f32>(_e16[0].xyz, _e16[1].xyz, _e16[2].xyz) * _e24);
let _e26: mat4x4<f32> = global1.Model;
let _e27: vec3<f32> = Vertex_Position1;
v_Position = (_e26 * vec4<f32>(_e27, 1.0)).xyz;
let _e32: vec2<f32> = Vertex_Uv1;
v_Uv = _e32;
let _e34: mat4x4<f32> = global.ViewProj;
let _e35: vec3<f32> = v_Position;
gl_Position = (_e34 * vec4<f32>(_e35, 1.0));
let e10: mat4x4<f32> = global1.Model;
let e11: vec3<f32> = Vertex_Normal1;
v_Normal = (e10 * vec4<f32>(e11, 1.0)).xyz;
let e16: mat4x4<f32> = global1.Model;
let e24: vec3<f32> = Vertex_Normal1;
v_Normal = (mat3x3<f32>(e16[0].xyz, e16[1].xyz, e16[2].xyz) * e24);
let e26: mat4x4<f32> = global1.Model;
let e27: vec3<f32> = Vertex_Position1;
v_Position = (e26 * vec4<f32>(e27, 1.0)).xyz;
let e32: vec2<f32> = Vertex_Uv1;
v_Uv = e32;
let e34: mat4x4<f32> = global.ViewProj;
let e35: vec3<f32> = v_Position;
gl_Position = (e34 * vec4<f32>(e35, 1.0));
return;
}
@@ -51,9 +51,9 @@ fn main([[location(0)]] Vertex_Position: vec3<f32>, [[location(1)]] Vertex_Norma
Vertex_Normal1 = Vertex_Normal;
Vertex_Uv1 = Vertex_Uv;
main1();
let _e23: vec3<f32> = v_Position;
let _e25: vec3<f32> = v_Normal;
let _e27: vec2<f32> = v_Uv;
let _e29: vec4<f32> = gl_Position;
return VertexOutput(_e23, _e25, _e27, _e29);
let e23: vec3<f32> = v_Position;
let e25: vec3<f32> = v_Normal;
let e27: vec2<f32> = v_Uv;
let e29: vec4<f32> = gl_Position;
return VertexOutput(e23, e25, e27, e29);
}

40
tests/out/wgsl/246-collatz-comp.wgsl
View File

@@ -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<u32> = 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<u32> = 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;
}

2
tests/out/wgsl/280-matrix-cast-vert.wgsl
View File

@@ -1,7 +1,7 @@
fn main1() {
var a: mat4x4<f32> = mat4x4<f32>(vec4<f32>(1.0, 0.0, 0.0, 0.0), vec4<f32>(0.0, 1.0, 0.0, 0.0), vec4<f32>(0.0, 0.0, 1.0, 0.0), vec4<f32>(0.0, 0.0, 0.0, 1.0));
let _e1: f32 = f32(1);
let e1: f32 = f32(1);
}
[[stage(vertex)]]

24
tests/out/wgsl/800-out-of-bounds-panic-vert.wgsl
View File

@@ -22,15 +22,15 @@ var<private> frag_color: vec4<f32>;
var<private> gl_Position: vec4<f32>;
fn main1() {
let _e7: vec4<f32> = color1;
frag_color = _e7;
let _e9: mat4x4<f32> = global.view_matrix;
let _e10: mat4x4<f32> = global1.world_matrix;
let _e12: vec2<f32> = position1;
gl_Position = ((_e9 * _e10) * vec4<f32>(_e12, 0.0, 1.0));
let _e18: vec4<f32> = gl_Position;
let _e20: vec4<f32> = gl_Position;
gl_Position.z = ((_e18.z + _e20.w) / 2.0);
let e7: vec4<f32> = color1;
frag_color = e7;
let e9: mat4x4<f32> = global.view_matrix;
let e10: mat4x4<f32> = global1.world_matrix;
let e12: vec2<f32> = position1;
gl_Position = ((e9 * e10) * vec4<f32>(e12, 0.0, 1.0));
let e18: vec4<f32> = gl_Position;
let e20: vec4<f32> = gl_Position;
gl_Position.z = ((e18.z + e20.w) / 2.0);
return;
}
@@ -39,7 +39,7 @@ fn main([[location(0)]] position: vec2<f32>, [[location(1)]] color: vec4<f32>) -
position1 = position;
color1 = color;
main1();
let _e15: vec4<f32> = frag_color;
let _e17: vec4<f32> = gl_Position;
return VertexOutput(_e15, _e17);
let e15: vec4<f32> = frag_color;
let e17: vec4<f32> = gl_Position;
return VertexOutput(e15, e17);
}

8
tests/out/wgsl/932-for-loop-if-vert.wgsl
View File

@@ -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;

32
tests/out/wgsl/access.wgsl
View File

@@ -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;
}

1042
tests/out/wgsl/bevy-pbr-frag.wgsl
View File

File diff suppressed because it is too large Load Diff

46
tests/out/wgsl/bevy-pbr-vert.wgsl
View File

@@ -33,23 +33,23 @@ var<private> gl_Position: vec4<f32>;
fn main1() {
var world_position: vec4<f32>;
let _e12: mat4x4<f32> = global1.Model;
let _e13: vec3<f32> = Vertex_Position1;
world_position = (_e12 * vec4<f32>(_e13, 1.0));
let _e18: vec4<f32> = world_position;
v_WorldPosition = _e18.xyz;
let _e20: mat4x4<f32> = global1.Model;
let _e28: vec3<f32> = Vertex_Normal1;
v_WorldNormal = (mat3x3<f32>(_e20[0].xyz, _e20[1].xyz, _e20[2].xyz) * _e28);
let _e30: vec2<f32> = Vertex_Uv1;
v_Uv = _e30;
let _e31: mat4x4<f32> = global1.Model;
let _e39: vec4<f32> = Vertex_Tangent1;
let _e42: vec4<f32> = Vertex_Tangent1;
v_WorldTangent = vec4<f32>((mat3x3<f32>(_e31[0].xyz, _e31[1].xyz, _e31[2].xyz) * _e39.xyz), _e42.w);
let _e46: mat4x4<f32> = global.ViewProj;
let _e47: vec4<f32> = world_position;
gl_Position = (_e46 * _e47);
let e12: mat4x4<f32> = global1.Model;
let e13: vec3<f32> = Vertex_Position1;
world_position = (e12 * vec4<f32>(e13, 1.0));
let e18: vec4<f32> = world_position;
v_WorldPosition = e18.xyz;
let e20: mat4x4<f32> = global1.Model;
let e28: vec3<f32> = Vertex_Normal1;
v_WorldNormal = (mat3x3<f32>(e20[0].xyz, e20[1].xyz, e20[2].xyz) * e28);
let e30: vec2<f32> = Vertex_Uv1;
v_Uv = e30;
let e31: mat4x4<f32> = global1.Model;
let e39: vec4<f32> = Vertex_Tangent1;
let e42: vec4<f32> = Vertex_Tangent1;
v_WorldTangent = vec4<f32>((mat3x3<f32>(e31[0].xyz, e31[1].xyz, e31[2].xyz) * e39.xyz), e42.w);
let e46: mat4x4<f32> = global.ViewProj;
let e47: vec4<f32> = world_position;
gl_Position = (e46 * e47);
return;
}
@@ -60,10 +60,10 @@ fn main([[location(0)]] Vertex_Position: vec3<f32>, [[location(1)]] Vertex_Norma
Vertex_Uv1 = Vertex_Uv;
Vertex_Tangent1 = Vertex_Tangent;
main1();
let _e29: vec3<f32> = v_WorldPosition;
let _e31: vec3<f32> = v_WorldNormal;
let _e33: vec2<f32> = v_Uv;
let _e35: vec4<f32> = v_WorldTangent;
let _e37: vec4<f32> = gl_Position;
return VertexOutput(_e29, _e31, _e33, _e35, _e37);
let e29: vec3<f32> = v_WorldPosition;
let e31: vec3<f32> = v_WorldNormal;
let e33: vec2<f32> = v_Uv;
let e35: vec4<f32> = v_WorldTangent;
let e37: vec4<f32> = gl_Position;
return VertexOutput(e29, e31, e33, e35, e37);
}

232
tests/out/wgsl/binop-frag.wgsl
View File

@@ -7,14 +7,14 @@ fn testBinOpVecFloat(a: vec4<f32>, b: f32) {
a1 = a;
b1 = b;
let _e5: vec4<f32> = a1;
v = (_e5 * 2.0);
let _e8: vec4<f32> = a1;
v = (_e8 / vec4<f32>(2.0));
let _e12: vec4<f32> = a1;
v = (_e12 + vec4<f32>(2.0));
let _e16: vec4<f32> = a1;
v = (_e16 - vec4<f32>(2.0));
let e5: vec4<f32> = a1;
v = (e5 * 2.0);
let e8: vec4<f32> = a1;
v = (e8 / vec4<f32>(2.0));
let e12: vec4<f32> = a1;
v = (e12 + vec4<f32>(2.0));
let e16: vec4<f32> = a1;
v = (e16 - vec4<f32>(2.0));
return;
}
@@ -25,18 +25,18 @@ fn testBinOpFloatVec(a2: vec4<f32>, b2: f32) {
a3 = a2;
b3 = b2;
let _e5: vec4<f32> = a3;
let _e6: f32 = b3;
v1 = (_e5 * _e6);
let _e8: vec4<f32> = a3;
let _e9: f32 = b3;
v1 = (_e8 / vec4<f32>(_e9));
let _e12: vec4<f32> = a3;
let _e13: f32 = b3;
v1 = (_e12 + vec4<f32>(_e13));
let _e16: vec4<f32> = a3;
let _e17: f32 = b3;
v1 = (_e16 - vec4<f32>(_e17));
let e5: vec4<f32> = a3;
let e6: f32 = b3;
v1 = (e5 * e6);
let e8: vec4<f32> = a3;
let e9: f32 = b3;
v1 = (e8 / vec4<f32>(e9));
let e12: vec4<f32> = a3;
let e13: f32 = b3;
v1 = (e12 + vec4<f32>(e13));
let e16: vec4<f32> = a3;
let e17: f32 = b3;
v1 = (e16 - vec4<f32>(e17));
return;
}
@@ -47,33 +47,33 @@ fn testBinOpIVecInt(a4: vec4<i32>, b4: i32) {
a5 = a4;
b5 = b4;
let _e5: vec4<i32> = a5;
let _e6: i32 = b5;
v2 = (_e5 * _e6);
let _e8: vec4<i32> = a5;
let _e9: i32 = b5;
v2 = (_e8 / vec4<i32>(_e9));
let _e12: vec4<i32> = a5;
let _e13: i32 = b5;
v2 = (_e12 + vec4<i32>(_e13));
let _e16: vec4<i32> = a5;
let _e17: i32 = b5;
v2 = (_e16 - vec4<i32>(_e17));
let _e20: vec4<i32> = a5;
let _e21: i32 = b5;
v2 = (_e20 & vec4<i32>(_e21));
let _e24: vec4<i32> = a5;
let _e25: i32 = b5;
v2 = (_e24 | vec4<i32>(_e25));
let _e28: vec4<i32> = a5;
let _e29: i32 = b5;
v2 = (_e28 ^ vec4<i32>(_e29));
let _e32: vec4<i32> = a5;
let _e33: i32 = b5;
v2 = (_e32 >> vec4<u32>(u32(_e33)));
let _e37: vec4<i32> = a5;
let _e38: i32 = b5;
v2 = (_e37 << vec4<u32>(u32(_e38)));
let e5: vec4<i32> = a5;
let e6: i32 = b5;
v2 = (e5 * e6);
let e8: vec4<i32> = a5;
let e9: i32 = b5;
v2 = (e8 / vec4<i32>(e9));
let e12: vec4<i32> = a5;
let e13: i32 = b5;
v2 = (e12 + vec4<i32>(e13));
let e16: vec4<i32> = a5;
let e17: i32 = b5;
v2 = (e16 - vec4<i32>(e17));
let e20: vec4<i32> = a5;
let e21: i32 = b5;
v2 = (e20 & vec4<i32>(e21));
let e24: vec4<i32> = a5;
let e25: i32 = b5;
v2 = (e24 | vec4<i32>(e25));
let e28: vec4<i32> = a5;
let e29: i32 = b5;
v2 = (e28 ^ vec4<i32>(e29));
let e32: vec4<i32> = a5;
let e33: i32 = b5;
v2 = (e32 >> vec4<u32>(u32(e33)));
let e37: vec4<i32> = a5;
let e38: i32 = b5;
v2 = (e37 << vec4<u32>(u32(e38)));
return;
}
@@ -84,24 +84,24 @@ fn testBinOpIntIVec(a6: i32, b6: vec4<i32>) {
a7 = a6;
b7 = b6;
let _e5: i32 = a7;
let _e6: vec4<i32> = b7;
v3 = (_e5 * _e6);
let _e8: i32 = a7;
let _e9: vec4<i32> = b7;
v3 = (vec4<i32>(_e8) + _e9);
let _e12: i32 = a7;
let _e13: vec4<i32> = b7;
v3 = (vec4<i32>(_e12) - _e13);
let _e16: i32 = a7;
let _e17: vec4<i32> = b7;
v3 = (vec4<i32>(_e16) & _e17);
let _e20: i32 = a7;
let _e21: vec4<i32> = b7;
v3 = (vec4<i32>(_e20) | _e21);
let _e24: i32 = a7;
let _e25: vec4<i32> = b7;
v3 = (vec4<i32>(_e24) ^ _e25);
let e5: i32 = a7;
let e6: vec4<i32> = b7;
v3 = (e5 * e6);
let e8: i32 = a7;
let e9: vec4<i32> = b7;
v3 = (vec4<i32>(e8) + e9);
let e12: i32 = a7;
let e13: vec4<i32> = b7;
v3 = (vec4<i32>(e12) - e13);
let e16: i32 = a7;
let e17: vec4<i32> = b7;
v3 = (vec4<i32>(e16) & e17);
let e20: i32 = a7;
let e21: vec4<i32> = b7;
v3 = (vec4<i32>(e20) | e21);
let e24: i32 = a7;
let e25: vec4<i32> = b7;
v3 = (vec4<i32>(e24) ^ e25);
return;
}
@@ -112,33 +112,33 @@ fn testBinOpUVecUint(a8: vec4<u32>, b8: u32) {
a9 = a8;
b9 = b8;
let _e5: vec4<u32> = a9;
let _e6: u32 = b9;
v4 = (_e5 * _e6);
let _e8: vec4<u32> = a9;
let _e9: u32 = b9;
v4 = (_e8 / vec4<u32>(_e9));
let _e12: vec4<u32> = a9;
let _e13: u32 = b9;
v4 = (_e12 + vec4<u32>(_e13));
let _e16: vec4<u32> = a9;
let _e17: u32 = b9;
v4 = (_e16 - vec4<u32>(_e17));
let _e20: vec4<u32> = a9;
let _e21: u32 = b9;
v4 = (_e20 & vec4<u32>(_e21));
let _e24: vec4<u32> = a9;
let _e25: u32 = b9;
v4 = (_e24 | vec4<u32>(_e25));
let _e28: vec4<u32> = a9;
let _e29: u32 = b9;
v4 = (_e28 ^ vec4<u32>(_e29));
let _e32: vec4<u32> = a9;
let _e33: u32 = b9;
v4 = (_e32 >> vec4<u32>(_e33));
let _e36: vec4<u32> = a9;
let _e37: u32 = b9;
v4 = (_e36 << vec4<u32>(_e37));
let e5: vec4<u32> = a9;
let e6: u32 = b9;
v4 = (e5 * e6);
let e8: vec4<u32> = a9;
let e9: u32 = b9;
v4 = (e8 / vec4<u32>(e9));
let e12: vec4<u32> = a9;
let e13: u32 = b9;
v4 = (e12 + vec4<u32>(e13));
let e16: vec4<u32> = a9;
let e17: u32 = b9;
v4 = (e16 - vec4<u32>(e17));
let e20: vec4<u32> = a9;
let e21: u32 = b9;
v4 = (e20 & vec4<u32>(e21));
let e24: vec4<u32> = a9;
let e25: u32 = b9;
v4 = (e24 | vec4<u32>(e25));
let e28: vec4<u32> = a9;
let e29: u32 = b9;
v4 = (e28 ^ vec4<u32>(e29));
let e32: vec4<u32> = a9;
let e33: u32 = b9;
v4 = (e32 >> vec4<u32>(e33));
let e36: vec4<u32> = a9;
let e37: u32 = b9;
v4 = (e36 << vec4<u32>(e37));
return;
}
@@ -149,34 +149,34 @@ fn testBinOpUintUVec(a10: u32, b10: vec4<u32>) {
a11 = a10;
b11 = b10;
let _e5: u32 = a11;
let _e6: vec4<u32> = b11;
v5 = (_e5 * _e6);
let _e8: u32 = a11;
let _e9: vec4<u32> = b11;
v5 = (vec4<u32>(_e8) + _e9);
let _e12: u32 = a11;
let _e13: vec4<u32> = b11;
v5 = (vec4<u32>(_e12) - _e13);
let _e16: u32 = a11;
let _e17: vec4<u32> = b11;
v5 = (vec4<u32>(_e16) & _e17);
let _e20: u32 = a11;
let _e21: vec4<u32> = b11;
v5 = (vec4<u32>(_e20) | _e21);
let _e24: u32 = a11;
let _e25: vec4<u32> = b11;
v5 = (vec4<u32>(_e24) ^ _e25);
let e5: u32 = a11;
let e6: vec4<u32> = b11;
v5 = (e5 * e6);
let e8: u32 = a11;
let e9: vec4<u32> = b11;
v5 = (vec4<u32>(e8) + e9);
let e12: u32 = a11;
let e13: vec4<u32> = b11;
v5 = (vec4<u32>(e12) - e13);
let e16: u32 = a11;
let e17: vec4<u32> = b11;
v5 = (vec4<u32>(e16) & e17);
let e20: u32 = a11;
let e21: vec4<u32> = b11;
v5 = (vec4<u32>(e20) | e21);
let e24: u32 = a11;
let e25: vec4<u32> = b11;
v5 = (vec4<u32>(e24) ^ e25);
return;
}
fn main1() {
let _e1: vec4<f32> = o_color;
let _e4: vec4<f32> = vec4<f32>(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<f32> = o_color;
let e4: vec4<f32> = vec4<f32>(1.0);
o_color.x = e4.x;
o_color.y = e4.y;
o_color.z = e4.z;
o_color.w = e4.w;
return;
}

160
tests/out/wgsl/boids.wgsl
View File

@@ -45,109 +45,109 @@ fn main([[builtin(global_invocation_id)]] global_invocation_id: vec3<u32>) {
if ((index >= NUM_PARTICLES)) {
return;
}
let _e10: vec2<f32> = particlesSrc.particles[index].pos;
vPos = _e10;
let _e15: vec2<f32> = particlesSrc.particles[index].vel;
vVel = _e15;
let e10: vec2<f32> = particlesSrc.particles[index].pos;
vPos = e10;
let e15: vec2<f32> = particlesSrc.particles[index].vel;
vVel = e15;
cMass = vec2<f32>(0.0, 0.0);
cVel = vec2<f32>(0.0, 0.0);
colVel = vec2<f32>(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<f32> = particlesSrc.particles[_e42].pos;
pos = _e45;
let _e47: u32 = i;
let _e50: vec2<f32> = particlesSrc.particles[_e47].vel;
vel = _e50;
let _e51: vec2<f32> = pos;
let _e52: vec2<f32> = vPos;
let _e55: f32 = params.rule1Distance;
if ((distance(_e51, _e52) < _e55)) {
let _e57: vec2<f32> = cMass;
let _e58: vec2<f32> = pos;
cMass = (_e57 + _e58);
let _e60: i32 = cMassCount;
cMassCount = (_e60 + 1);
let e42: u32 = i;
let e45: vec2<f32> = particlesSrc.particles[e42].pos;
pos = e45;
let e47: u32 = i;
let e50: vec2<f32> = particlesSrc.particles[e47].vel;
vel = e50;
let e51: vec2<f32> = pos;
let e52: vec2<f32> = vPos;
let e55: f32 = params.rule1Distance;
if ((distance(e51, e52) < e55)) {
let e57: vec2<f32> = cMass;
let e58: vec2<f32> = pos;
cMass = (e57 + e58);
let e60: i32 = cMassCount;
cMassCount = (e60 + 1);
}
let _e63: vec2<f32> = pos;
let _e64: vec2<f32> = vPos;
let _e67: f32 = params.rule2Distance;
if ((distance(_e63, _e64) < _e67)) {
let _e69: vec2<f32> = colVel;
let _e70: vec2<f32> = pos;
let _e71: vec2<f32> = vPos;
colVel = (_e69 - (_e70 - _e71));
let e63: vec2<f32> = pos;
let e64: vec2<f32> = vPos;
let e67: f32 = params.rule2Distance;
if ((distance(e63, e64) < e67)) {
let e69: vec2<f32> = colVel;
let e70: vec2<f32> = pos;
let e71: vec2<f32> = vPos;
colVel = (e69 - (e70 - e71));
}
let _e74: vec2<f32> = pos;
let _e75: vec2<f32> = vPos;
let _e78: f32 = params.rule3Distance;
if ((distance(_e74, _e75) < _e78)) {
let _e80: vec2<f32> = cVel;
let _e81: vec2<f32> = vel;
cVel = (_e80 + _e81);
let _e83: i32 = cVelCount;
cVelCount = (_e83 + 1);
let e74: vec2<f32> = pos;
let e75: vec2<f32> = vPos;
let e78: f32 = params.rule3Distance;
if ((distance(e74, e75) < e78)) {
let e80: vec2<f32> = cVel;
let e81: vec2<f32> = 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<f32> = cMass;
let _e93: i32 = cMassCount;
let _e97: vec2<f32> = vPos;
cMass = ((_e92 / vec2<f32>(f32(_e93))) - _e97);
let e89: i32 = cMassCount;
if ((e89 > 0)) {
let e92: vec2<f32> = cMass;
let e93: i32 = cMassCount;
let e97: vec2<f32> = vPos;
cMass = ((e92 / vec2<f32>(f32(e93))) - e97);
}
let _e99: i32 = cVelCount;
if ((_e99 > 0)) {
let _e102: vec2<f32> = cVel;
let _e103: i32 = cVelCount;
cVel = (_e102 / vec2<f32>(f32(_e103)));
let e99: i32 = cVelCount;
if ((e99 > 0)) {
let e102: vec2<f32> = cVel;
let e103: i32 = cVelCount;
cVel = (e102 / vec2<f32>(f32(e103)));
}
let _e107: vec2<f32> = vVel;
let _e108: vec2<f32> = cMass;
let _e110: f32 = params.rule1Scale;
let _e113: vec2<f32> = colVel;
let _e115: f32 = params.rule2Scale;
let _e118: vec2<f32> = cVel;
let _e120: f32 = params.rule3Scale;
vVel = (((_e107 + (_e108 * _e110)) + (_e113 * _e115)) + (_e118 * _e120));
let _e123: vec2<f32> = vVel;
let _e125: vec2<f32> = vVel;
vVel = (normalize(_e123) * clamp(length(_e125), 0.0, 0.10000000149011612));
let _e131: vec2<f32> = vPos;
let _e132: vec2<f32> = vVel;
let _e134: f32 = params.deltaT;
vPos = (_e131 + (_e132 * _e134));
let _e138: f32 = vPos.x;
if ((_e138 < -1.0)) {
let e107: vec2<f32> = vVel;
let e108: vec2<f32> = cMass;
let e110: f32 = params.rule1Scale;
let e113: vec2<f32> = colVel;
let e115: f32 = params.rule2Scale;
let e118: vec2<f32> = cVel;
let e120: f32 = params.rule3Scale;
vVel = (((e107 + (e108 * e110)) + (e113 * e115)) + (e118 * e120));
let e123: vec2<f32> = vVel;
let e125: vec2<f32> = vVel;
vVel = (normalize(e123) * clamp(length(e125), 0.0, 0.10000000149011612));
let e131: vec2<f32> = vPos;
let e132: vec2<f32> = 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<f32> = vPos;
particlesDst.particles[index].pos = _e164;
let _e168: vec2<f32> = vVel;
particlesDst.particles[index].vel = _e168;
let e164: vec2<f32> = vPos;
particlesDst.particles[index].pos = e164;
let e168: vec2<f32> = vVel;
particlesDst.particles[index].vel = e168;
return;
}

30
tests/out/wgsl/bool-select-frag.wgsl
View File

@@ -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<f32>, b2: vec3<f32>) -> vec3<f32> {
@@ -21,25 +21,25 @@ fn TevPerCompGT1(a2: vec3<f32>, b2: vec3<f32>) -> vec3<f32> {
a3 = a2;
b3 = b2;
let _e7: vec3<f32> = a3;
let _e8: vec3<f32> = b3;
return select(vec3<f32>(0.0), vec3<f32>(1.0), (_e7 > _e8));
let e7: vec3<f32> = a3;
let e8: vec3<f32> = b3;
return select(vec3<f32>(0.0), vec3<f32>(1.0), (e7 > e8));
}
fn main1() {
let _e1: vec4<f32> = o_color;
let _e11: vec3<f32> = TevPerCompGT1(vec3<f32>(3.0), vec3<f32>(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<f32> = o_color;
let e11: vec3<f32> = TevPerCompGT1(vec3<f32>(3.0), vec3<f32>(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<f32> = o_color;
return FragmentOutput(_e3);
let e3: vec4<f32> = o_color;
return FragmentOutput(e3);
}

8
tests/out/wgsl/clamp-splat-vert.wgsl
View File

@@ -6,8 +6,8 @@ var<private> a_pos1: vec2<f32>;
var<private> gl_Position: vec4<f32>;
fn main1() {
let _e5: vec2<f32> = a_pos1;
gl_Position = vec4<f32>(clamp(_e5, vec2<f32>(0.0), vec2<f32>(1.0)), 0.0, 1.0);
let e5: vec2<f32> = a_pos1;
gl_Position = vec4<f32>(clamp(e5, vec2<f32>(0.0), vec2<f32>(1.0)), 0.0, 1.0);
return;
}
@@ -15,6 +15,6 @@ fn main1() {
fn main([[location(0)]] a_pos: vec2<f32>) -> VertexOutput {
a_pos1 = a_pos;
main1();
let _e5: vec4<f32> = gl_Position;
return VertexOutput(_e5);
let e5: vec4<f32> = gl_Position;
return VertexOutput(e5);
}

30
tests/out/wgsl/collatz.wgsl
View File

@@ -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<u32>) {
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;
}

20
tests/out/wgsl/constant-array-size-vert.wgsl
View File

@@ -11,23 +11,23 @@ fn function() -> vec4<f32> {
var i: i32 = 0;
loop {
let _e9: i32 = i;
if (!((_e9 < 42))) {
let e9: i32 = i;
if (!((e9 < 42))) {
break;
}
{
let _e15: vec4<f32> = sum;
let _e16: i32 = i;
let _e18: vec4<f32> = global.vecs[_e16];
sum = (_e15 + _e18);
let e15: vec4<f32> = sum;
let e16: i32 = i;
let e18: vec4<f32> = global.vecs[e16];
sum = (e15 + e18);
}
continuing {
let _e12: i32 = i;
i = (_e12 + 1);
let e12: i32 = i;
i = (e12 + 1);
}
}
let _e20: vec4<f32> = sum;
return _e20;
let e20: vec4<f32> = sum;
return e20;
}
fn main1() {

8
tests/out/wgsl/control-flow.wgsl
View File

@@ -37,8 +37,8 @@ fn main([[builtin(global_invocation_id)]] global_id: vec3<u32>) {
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<u32>) {
pos = 3;
}
}
let _e9: i32 = pos;
switch(_e9) {
let e9: i32 = pos;
switch(e9) {
case 1: {
pos = 0;
break;

36
tests/out/wgsl/fma-frag.wgsl
View File

@@ -12,28 +12,28 @@ fn Fma(d: ptr<function, Mat4x3_>, 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<f32> = o_color;
let _e4: vec4<f32> = vec4<f32>(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<f32> = o_color;
let e4: vec4<f32> = vec4<f32>(1.0);
o_color.x = e4.x;
o_color.y = e4.y;
o_color.z = e4.z;
o_color.w = e4.w;
return;
}

2
tests/out/wgsl/global-constant-array-vert.wgsl
View File

@@ -3,7 +3,7 @@ var<private> i: u32;
fn main1() {
var local: array<f32,2> = array<f32,2>(1.0, 2.0);
let _e2: u32 = i;
let e2: u32 = i;
}
[[stage(vertex)]]

4
tests/out/wgsl/interpolate.wgsl
View File

@@ -21,8 +21,8 @@ fn main() -> FragmentInput {
out.perspective = vec4<f32>(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)]]

12
tests/out/wgsl/inv-hyperbolic-trig-functions.wgsl
View File

@@ -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;
}

28
tests/out/wgsl/long-form-matrix-vert.wgsl
View File

@@ -7,20 +7,20 @@ fn main1() {
var d: mat3x3<f32> = mat3x3<f32>(vec3<f32>(2.0, 2.0, 1.0), vec3<f32>(1.0, 1.0, 1.0), vec3<f32>(1.0, 1.0, 1.0));
var e: mat4x4<f32> = mat4x4<f32>(vec4<f32>(2.0, 2.0, 1.0, 1.0), vec4<f32>(1.0, 1.0, 2.0, 2.0), vec4<f32>(1.0, 1.0, 1.0, 1.0), vec4<f32>(1.0, 1.0, 1.0, 1.0));
let _e1: f32 = f32(1);
let _e9: vec2<f32> = vec2<f32>(f32(1));
let _e12: vec2<f32> = vec2<f32>(f32(2));
let _e38: vec2<f32> = vec2<f32>(f32(2), f32(3));
let _e53: vec3<f32> = vec3<f32>(f32(1));
let _e56: vec3<f32> = vec3<f32>(f32(1));
let _e73: vec2<f32> = vec2<f32>(f32(2));
let _e77: vec3<f32> = vec3<f32>(f32(1));
let _e80: vec3<f32> = vec3<f32>(f32(1));
let _e97: vec2<f32> = vec2<f32>(f32(2));
let _e100: vec4<f32> = vec4<f32>(f32(1));
let _e103: vec2<f32> = vec2<f32>(f32(2));
let _e106: vec4<f32> = vec4<f32>(f32(1));
let _e109: vec4<f32> = vec4<f32>(f32(1));
let e1: f32 = f32(1);
let e9: vec2<f32> = vec2<f32>(f32(1));
let e12: vec2<f32> = vec2<f32>(f32(2));
let e38: vec2<f32> = vec2<f32>(f32(2), f32(3));
let e53: vec3<f32> = vec3<f32>(f32(1));
let e56: vec3<f32> = vec3<f32>(f32(1));
let e73: vec2<f32> = vec2<f32>(f32(2));
let e77: vec3<f32> = vec3<f32>(f32(1));
let e80: vec3<f32> = vec3<f32>(f32(1));
let e97: vec2<f32> = vec2<f32>(f32(2));
let e100: vec4<f32> = vec4<f32>(f32(1));
let e103: vec2<f32> = vec2<f32>(f32(2));
let e106: vec4<f32> = vec4<f32>(f32(1));
let e109: vec4<f32> = vec4<f32>(f32(1));
}
[[stage(vertex)]]

202
tests/out/wgsl/math-functions-vert.wgsl
View File

@@ -43,107 +43,107 @@ fn main1() {
var distanceOut: f32;
var stepOut: vec4<f32>;
let _e6: vec4<f32> = a;
let _e7: vec4<f32> = b;
let _e8: vec4<f32> = a;
let _e9: vec4<f32> = b;
m = mat4x4<f32>(vec4<f32>(_e6.x, _e6.y, _e6.z, _e6.w), vec4<f32>(_e7.x, _e7.y, _e7.z, _e7.w), vec4<f32>(_e8.x, _e8.y, _e8.z, _e8.w), vec4<f32>(_e9.x, _e9.y, _e9.z, _e9.w));
let _e35: vec4<f32> = a;
ceilOut = ceil(_e35);
let _e39: vec4<f32> = a;
roundOut = round(_e39);
let _e43: vec4<f32> = a;
floorOut = floor(_e43);
let _e47: vec4<f32> = a;
fractOut = fract(_e47);
let _e51: vec4<f32> = a;
truncOut = trunc(_e51);
let _e55: vec4<f32> = a;
sinOut = sin(_e55);
let _e59: vec4<f32> = a;
absOut = abs(_e59);
let _e63: vec4<f32> = a;
sqrtOut = sqrt(_e63);
let _e67: vec4<f32> = a;
inversesqrtOut = inverseSqrt(_e67);
let _e71: vec4<f32> = a;
expOut = exp(_e71);
let _e75: vec4<f32> = a;
exp2Out = exp2(_e75);
let _e79: vec4<f32> = a;
signOut = sign(_e79);
let _e83: mat4x4<f32> = m;
transposeOut = transpose(_e83);
let _e87: vec4<f32> = a;
normalizeOut = normalize(_e87);
let _e91: vec4<f32> = a;
sinhOut = sinh(_e91);
let _e95: vec4<f32> = a;
cosOut = cos(_e95);
let _e99: vec4<f32> = a;
coshOut = cosh(_e99);
let _e103: vec4<f32> = a;
tanOut = tan(_e103);
let _e107: vec4<f32> = a;
tanhOut = tanh(_e107);
let _e111: vec4<f32> = a;
acosOut = acos(_e111);
let _e115: vec4<f32> = a;
asinOut = asin(_e115);
let _e119: vec4<f32> = a;
logOut = log(_e119);
let _e123: vec4<f32> = a;
log2Out = log2(_e123);
let _e127: vec4<f32> = a;
lengthOut = length(_e127);
let _e131: mat4x4<f32> = m;
determinantOut = determinant(_e131);
let _e135: i32 = i;
bitCountOut = countOneBits(_e135);
let _e139: i32 = i;
bitfieldReverseOut = reverseBits(_e139);
let _e142: vec4<f32> = a;
let _e144: vec4<f32> = a;
atanOut = atan(_e144.x);
let _e148: vec4<f32> = a;
let _e150: vec4<f32> = a;
let _e152: vec4<f32> = a;
let _e154: vec4<f32> = a;
atan2Out = atan2(_e152.x, _e154.y);
let _e158: vec4<f32> = a;
let _e160: vec4<f32> = b;
let _e162: vec4<f32> = a;
let _e164: vec4<f32> = b;
modOut = (_e162.x % _e164.x);
let _e170: vec4<f32> = a;
let _e171: vec4<f32> = b;
powOut = pow(_e170, _e171);
let _e176: vec4<f32> = a;
let _e177: vec4<f32> = b;
dotOut = dot(_e176, _e177);
let _e182: vec4<f32> = a;
let _e183: vec4<f32> = b;
maxOut = max(_e182, _e183);
let _e188: vec4<f32> = a;
let _e189: vec4<f32> = b;
minOut = min(_e188, _e189);
let _e194: vec4<f32> = a;
let _e195: vec4<f32> = b;
reflectOut = reflect(_e194, _e195);
let _e198: vec4<f32> = a;
let _e200: vec4<f32> = b;
let _e202: vec4<f32> = a;
let _e204: vec4<f32> = b;
crossOut = cross(_e202.xyz, _e204.xyz);
let _e210: vec4<f32> = a;
let _e211: vec4<f32> = b;
outerProductOut = outerProduct(_e210, _e211);
let _e216: vec4<f32> = a;
let _e217: vec4<f32> = b;
distanceOut = distance(_e216, _e217);
let _e222: vec4<f32> = a;
let _e223: vec4<f32> = b;
stepOut = step(_e222, _e223);
let e6: vec4<f32> = a;
let e7: vec4<f32> = b;
let e8: vec4<f32> = a;
let e9: vec4<f32> = b;
m = mat4x4<f32>(vec4<f32>(e6.x, e6.y, e6.z, e6.w), vec4<f32>(e7.x, e7.y, e7.z, e7.w), vec4<f32>(e8.x, e8.y, e8.z, e8.w), vec4<f32>(e9.x, e9.y, e9.z, e9.w));
let e35: vec4<f32> = a;
ceilOut = ceil(e35);
let e39: vec4<f32> = a;
roundOut = round(e39);
let e43: vec4<f32> = a;
floorOut = floor(e43);
let e47: vec4<f32> = a;
fractOut = fract(e47);
let e51: vec4<f32> = a;
truncOut = trunc(e51);
let e55: vec4<f32> = a;
sinOut = sin(e55);
let e59: vec4<f32> = a;
absOut = abs(e59);
let e63: vec4<f32> = a;
sqrtOut = sqrt(e63);
let e67: vec4<f32> = a;
inversesqrtOut = inverseSqrt(e67);
let e71: vec4<f32> = a;
expOut = exp(e71);
let e75: vec4<f32> = a;
exp2Out = exp2(e75);
let e79: vec4<f32> = a;
signOut = sign(e79);
let e83: mat4x4<f32> = m;
transposeOut = transpose(e83);
let e87: vec4<f32> = a;
normalizeOut = normalize(e87);
let e91: vec4<f32> = a;
sinhOut = sinh(e91);
let e95: vec4<f32> = a;
cosOut = cos(e95);
let e99: vec4<f32> = a;
coshOut = cosh(e99);
let e103: vec4<f32> = a;
tanOut = tan(e103);
let e107: vec4<f32> = a;
tanhOut = tanh(e107);
let e111: vec4<f32> = a;
acosOut = acos(e111);
let e115: vec4<f32> = a;
asinOut = asin(e115);
let e119: vec4<f32> = a;
logOut = log(e119);
let e123: vec4<f32> = a;
log2Out = log2(e123);
let e127: vec4<f32> = a;
lengthOut = length(e127);
let e131: mat4x4<f32> = m;
determinantOut = determinant(e131);
let e135: i32 = i;
bitCountOut = countOneBits(e135);
let e139: i32 = i;
bitfieldReverseOut = reverseBits(e139);
let e142: vec4<f32> = a;
let e144: vec4<f32> = a;
atanOut = atan(e144.x);
let e148: vec4<f32> = a;
let e150: vec4<f32> = a;
let e152: vec4<f32> = a;
let e154: vec4<f32> = a;
atan2Out = atan2(e152.x, e154.y);
let e158: vec4<f32> = a;
let e160: vec4<f32> = b;
let e162: vec4<f32> = a;
let e164: vec4<f32> = b;
modOut = (e162.x % e164.x);
let e170: vec4<f32> = a;
let e171: vec4<f32> = b;
powOut = pow(e170, e171);
let e176: vec4<f32> = a;
let e177: vec4<f32> = b;
dotOut = dot(e176, e177);
let e182: vec4<f32> = a;
let e183: vec4<f32> = b;
maxOut = max(e182, e183);
let e188: vec4<f32> = a;
let e189: vec4<f32> = b;
minOut = min(e188, e189);
let e194: vec4<f32> = a;
let e195: vec4<f32> = b;
reflectOut = reflect(e194, e195);
let e198: vec4<f32> = a;
let e200: vec4<f32> = b;
let e202: vec4<f32> = a;
let e204: vec4<f32> = b;
crossOut = cross(e202.xyz, e204.xyz);
let e210: vec4<f32> = a;
let e211: vec4<f32> = b;
outerProductOut = outerProduct(e210, e211);
let e216: vec4<f32> = a;
let e217: vec4<f32> = b;
distanceOut = distance(e216, e217);
let e222: vec4<f32> = a;
let e223: vec4<f32> = b;
stepOut = step(e222, e223);
return;
}

12
tests/out/wgsl/operators.wgsl
View File

@@ -37,15 +37,15 @@ fn constructors() -> f32 {
var foo: Foo;
foo = Foo(vec4<f32>(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<f32> = builtins();
let _e5: vec4<f32> = splat();
let _e6: i32 = unary();
let _e7: f32 = constructors();
let e4: vec4<f32> = builtins();
let e5: vec4<f32> = splat();
let e6: i32 = unary();
let e7: f32 = constructors();
return;
}

48
tests/out/wgsl/prepostfix-frag.wgsl
View File

@@ -6,30 +6,30 @@ fn main1() {
var mat_target: mat4x3<f32>;
var mat: mat4x3<f32> = mat4x3<f32>(vec3<f32>(1.0, 0.0, 0.0), vec3<f32>(0.0, 1.0, 0.0), vec3<f32>(0.0, 0.0, 1.0), vec3<f32>(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<u32> = vec;
vec = (_e14 - vec2<u32>(1u));
vec_target = _e14;
let _e18: vec2<u32> = vec;
let _e21: vec2<u32> = (_e18 + vec2<u32>(1u));
vec = _e21;
vec_target = _e21;
let _e24: f32 = f32(1);
let _e32: mat4x3<f32> = mat;
let _e34: vec3<f32> = vec3<f32>(1.0);
mat = (_e32 + mat4x3<f32>(_e34, _e34, _e34, _e34));
mat_target = _e32;
let _e37: mat4x3<f32> = mat;
let _e39: vec3<f32> = vec3<f32>(1.0);
let _e41: mat4x3<f32> = (_e37 - mat4x3<f32>(_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<u32> = vec;
vec = (e14 - vec2<u32>(1u));
vec_target = e14;
let e18: vec2<u32> = vec;
let e21: vec2<u32> = (e18 + vec2<u32>(1u));
vec = e21;
vec_target = e21;
let e24: f32 = f32(1);
let e32: mat4x3<f32> = mat;
let e34: vec3<f32> = vec3<f32>(1.0);
mat = (e32 + mat4x3<f32>(e34, e34, e34, e34));
mat_target = e32;
let e37: mat4x3<f32> = mat;
let e39: vec3<f32> = vec3<f32>(1.0);
let e41: mat4x3<f32> = (e37 - mat4x3<f32>(e39, e39, e39, e39));
mat = e41;
mat_target = e41;
return;
}

14
tests/out/wgsl/quad-vert.wgsl
View File

@@ -14,10 +14,10 @@ var<private> perVertexStruct: gl_PerVertex = gl_PerVertex(vec4<f32>(0.0, 0.0, 0.
var<private> a_pos1: vec2<f32>;
fn main1() {
let _e12: vec2<f32> = a_uv1;
v_uv = _e12;
let _e13: vec2<f32> = a_pos1;
perVertexStruct.gl_Position = vec4<f32>(_e13.x, _e13.y, 0.0, 1.0);
let e12: vec2<f32> = a_uv1;
v_uv = e12;
let e13: vec2<f32> = a_pos1;
perVertexStruct.gl_Position = vec4<f32>(e13.x, e13.y, 0.0, 1.0);
return;
}
@@ -26,7 +26,7 @@ fn main([[location(1)]] a_uv: vec2<f32>, [[location(0)]] a_pos: vec2<f32>) -> Ve
a_uv1 = a_uv;
a_pos1 = a_pos;
main1();
let _e10: vec2<f32> = v_uv;
let _e11: vec4<f32> = perVertexStruct.gl_Position;
return VertexOutput(_e10, _e11);
let e10: vec2<f32> = v_uv;
let e11: vec4<f32> = perVertexStruct.gl_Position;
return VertexOutput(e10, e11);
}

4
tests/out/wgsl/quad_glsl-frag.wgsl
View File

@@ -14,6 +14,6 @@ fn main1() {
fn main([[location(0)]] v_uv: vec2<f32>) -> FragmentOutput {
v_uv1 = v_uv;
main1();
let _e7: vec4<f32> = o_color;
return FragmentOutput(_e7);
let e7: vec4<f32> = o_color;
return FragmentOutput(e7);
}

14
tests/out/wgsl/quad_glsl-vert.wgsl
View File

@@ -9,10 +9,10 @@ var<private> v_uv: vec2<f32>;
var<private> gl_Position: vec4<f32>;
fn main1() {
let _e4: vec2<f32> = a_uv1;
v_uv = _e4;
let _e6: vec2<f32> = a_pos1;
gl_Position = vec4<f32>((1.2000000476837158 * _e6), 0.0, 1.0);
let e4: vec2<f32> = a_uv1;
v_uv = e4;
let e6: vec2<f32> = a_pos1;
gl_Position = vec4<f32>((1.2000000476837158 * e6), 0.0, 1.0);
return;
}
@@ -21,7 +21,7 @@ fn main([[location(0)]] a_pos: vec2<f32>, [[location(1)]] a_uv: vec2<f32>) -> Ve
a_pos1 = a_pos;
a_uv1 = a_uv;
main1();
let _e14: vec2<f32> = v_uv;
let _e16: vec4<f32> = gl_Position;
return VertexOutput(_e14, _e16);
let e14: vec2<f32> = v_uv;
let e16: vec4<f32> = gl_Position;
return VertexOutput(e14, e16);
}

892
tests/out/wgsl/samplers-frag.wgsl
View File

@@ -33,110 +33,110 @@ fn testTex1D(coord: f32) {
var c: vec4<f32>;
coord1 = coord;
let _e18: f32 = coord1;
let _e19: vec4<f32> = textureSample(tex1D, samp, _e18);
c = _e19;
let _e22: f32 = coord1;
let _e24: vec4<f32> = textureSampleBias(tex1D, samp, _e22, 2.0);
c = _e24;
let _e28: f32 = coord1;
let _e31: vec4<f32> = textureSampleGrad(tex1D, samp, _e28, 4.0, 4.0);
c = _e31;
let _e36: f32 = coord1;
let _e40: vec4<f32> = textureSampleGrad(tex1D, samp, _e36, 4.0, 4.0, 5);
c = _e40;
let _e43: f32 = coord1;
let _e45: vec4<f32> = textureSampleLevel(tex1D, samp, _e43, 3.0);
c = _e45;
let _e49: f32 = coord1;
let _e52: vec4<f32> = textureSampleLevel(tex1D, samp, _e49, 3.0, 5);
c = _e52;
let _e55: f32 = coord1;
let _e57: vec4<f32> = textureSample(tex1D, samp, _e55, 5);
c = _e57;
let _e61: f32 = coord1;
let _e64: vec4<f32> = textureSampleBias(tex1D, samp, _e61, 2.0, 5);
c = _e64;
let _e65: f32 = coord1;
let _e68: f32 = coord1;
let _e70: vec2<f32> = vec2<f32>(_e68, 6.0);
let _e74: vec4<f32> = textureSample(tex1D, samp, (_e70.x / _e70.y));
c = _e74;
let _e75: f32 = coord1;
let _e80: f32 = coord1;
let _e84: vec4<f32> = vec4<f32>(_e80, 0.0, 0.0, 6.0);
let _e90: vec4<f32> = textureSample(tex1D, samp, (_e84.xyz / vec3<f32>(_e84.w)).x);
c = _e90;
let _e91: f32 = coord1;
let _e95: f32 = coord1;
let _e97: vec2<f32> = vec2<f32>(_e95, 6.0);
let _e102: vec4<f32> = textureSampleBias(tex1D, samp, (_e97.x / _e97.y), 2.0);
c = _e102;
let _e103: f32 = coord1;
let _e109: f32 = coord1;
let _e113: vec4<f32> = vec4<f32>(_e109, 0.0, 0.0, 6.0);
let _e120: vec4<f32> = textureSampleBias(tex1D, samp, (_e113.xyz / vec3<f32>(_e113.w)).x, 2.0);
c = _e120;
let _e121: f32 = coord1;
let _e126: f32 = coord1;
let _e128: vec2<f32> = vec2<f32>(_e126, 6.0);
let _e134: vec4<f32> = textureSampleGrad(tex1D, samp, (_e128.x / _e128.y), 4.0, 4.0);
c = _e134;
let _e135: f32 = coord1;
let _e142: f32 = coord1;
let _e146: vec4<f32> = vec4<f32>(_e142, 0.0, 0.0, 6.0);
let _e154: vec4<f32> = textureSampleGrad(tex1D, samp, (_e146.xyz / vec3<f32>(_e146.w)).x, 4.0, 4.0);
c = _e154;
let _e155: f32 = coord1;
let _e161: f32 = coord1;
let _e163: vec2<f32> = vec2<f32>(_e161, 6.0);
let _e170: vec4<f32> = 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<f32> = vec4<f32>(_e179, 0.0, 0.0, 6.0);
let _e192: vec4<f32> = textureSampleGrad(tex1D, samp, (_e183.xyz / vec3<f32>(_e183.w)).x, 4.0, 4.0, 5);
c = _e192;
let _e193: f32 = coord1;
let _e197: f32 = coord1;
let _e199: vec2<f32> = vec2<f32>(_e197, 6.0);
let _e204: vec4<f32> = textureSampleLevel(tex1D, samp, (_e199.x / _e199.y), 3.0);
c = _e204;
let _e205: f32 = coord1;
let _e211: f32 = coord1;
let _e215: vec4<f32> = vec4<f32>(_e211, 0.0, 0.0, 6.0);
let _e222: vec4<f32> = textureSampleLevel(tex1D, samp, (_e215.xyz / vec3<f32>(_e215.w)).x, 3.0);
c = _e222;
let _e223: f32 = coord1;
let _e228: f32 = coord1;
let _e230: vec2<f32> = vec2<f32>(_e228, 6.0);
let _e236: vec4<f32> = textureSampleLevel(tex1D, samp, (_e230.x / _e230.y), 3.0, 5);
c = _e236;
let _e237: f32 = coord1;
let _e244: f32 = coord1;
let _e248: vec4<f32> = vec4<f32>(_e244, 0.0, 0.0, 6.0);
let _e256: vec4<f32> = textureSampleLevel(tex1D, samp, (_e248.xyz / vec3<f32>(_e248.w)).x, 3.0, 5);
c = _e256;
let _e257: f32 = coord1;
let _e261: f32 = coord1;
let _e263: vec2<f32> = vec2<f32>(_e261, 6.0);
let _e268: vec4<f32> = textureSample(tex1D, samp, (_e263.x / _e263.y), 5);
c = _e268;
let _e269: f32 = coord1;
let _e275: f32 = coord1;
let _e279: vec4<f32> = vec4<f32>(_e275, 0.0, 0.0, 6.0);
let _e286: vec4<f32> = textureSample(tex1D, samp, (_e279.xyz / vec3<f32>(_e279.w)).x, 5);
c = _e286;
let _e287: f32 = coord1;
let _e292: f32 = coord1;
let _e294: vec2<f32> = vec2<f32>(_e292, 6.0);
let _e300: vec4<f32> = textureSampleBias(tex1D, samp, (_e294.x / _e294.y), 2.0, 5);
c = _e300;
let _e301: f32 = coord1;
let _e308: f32 = coord1;
let _e312: vec4<f32> = vec4<f32>(_e308, 0.0, 0.0, 6.0);
let _e320: vec4<f32> = textureSampleBias(tex1D, samp, (_e312.xyz / vec3<f32>(_e312.w)).x, 2.0, 5);
c = _e320;
let e18: f32 = coord1;
let e19: vec4<f32> = textureSample(tex1D, samp, e18);
c = e19;
let e22: f32 = coord1;
let e24: vec4<f32> = textureSampleBias(tex1D, samp, e22, 2.0);
c = e24;
let e28: f32 = coord1;
let e31: vec4<f32> = textureSampleGrad(tex1D, samp, e28, 4.0, 4.0);
c = e31;
let e36: f32 = coord1;
let e40: vec4<f32> = textureSampleGrad(tex1D, samp, e36, 4.0, 4.0, 5);
c = e40;
let e43: f32 = coord1;
let e45: vec4<f32> = textureSampleLevel(tex1D, samp, e43, 3.0);
c = e45;
let e49: f32 = coord1;
let e52: vec4<f32> = textureSampleLevel(tex1D, samp, e49, 3.0, 5);
c = e52;
let e55: f32 = coord1;
let e57: vec4<f32> = textureSample(tex1D, samp, e55, 5);
c = e57;
let e61: f32 = coord1;
let e64: vec4<f32> = textureSampleBias(tex1D, samp, e61, 2.0, 5);
c = e64;
let e65: f32 = coord1;
let e68: f32 = coord1;
let e70: vec2<f32> = vec2<f32>(e68, 6.0);
let e74: vec4<f32> = textureSample(tex1D, samp, (e70.x / e70.y));
c = e74;
let e75: f32 = coord1;
let e80: f32 = coord1;
let e84: vec4<f32> = vec4<f32>(e80, 0.0, 0.0, 6.0);
let e90: vec4<f32> = textureSample(tex1D, samp, (e84.xyz / vec3<f32>(e84.w)).x);
c = e90;
let e91: f32 = coord1;
let e95: f32 = coord1;
let e97: vec2<f32> = vec2<f32>(e95, 6.0);
let e102: vec4<f32> = textureSampleBias(tex1D, samp, (e97.x / e97.y), 2.0);
c = e102;
let e103: f32 = coord1;
let e109: f32 = coord1;
let e113: vec4<f32> = vec4<f32>(e109, 0.0, 0.0, 6.0);
let e120: vec4<f32> = textureSampleBias(tex1D, samp, (e113.xyz / vec3<f32>(e113.w)).x, 2.0);
c = e120;
let e121: f32 = coord1;
let e126: f32 = coord1;
let e128: vec2<f32> = vec2<f32>(e126, 6.0);
let e134: vec4<f32> = textureSampleGrad(tex1D, samp, (e128.x / e128.y), 4.0, 4.0);
c = e134;
let e135: f32 = coord1;
let e142: f32 = coord1;
let e146: vec4<f32> = vec4<f32>(e142, 0.0, 0.0, 6.0);
let e154: vec4<f32> = textureSampleGrad(tex1D, samp, (e146.xyz / vec3<f32>(e146.w)).x, 4.0, 4.0);
c = e154;
let e155: f32 = coord1;
let e161: f32 = coord1;
let e163: vec2<f32> = vec2<f32>(e161, 6.0);
let e170: vec4<f32> = 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<f32> = vec4<f32>(e179, 0.0, 0.0, 6.0);
let e192: vec4<f32> = textureSampleGrad(tex1D, samp, (e183.xyz / vec3<f32>(e183.w)).x, 4.0, 4.0, 5);
c = e192;
let e193: f32 = coord1;
let e197: f32 = coord1;
let e199: vec2<f32> = vec2<f32>(e197, 6.0);
let e204: vec4<f32> = textureSampleLevel(tex1D, samp, (e199.x / e199.y), 3.0);
c = e204;
let e205: f32 = coord1;
let e211: f32 = coord1;
let e215: vec4<f32> = vec4<f32>(e211, 0.0, 0.0, 6.0);
let e222: vec4<f32> = textureSampleLevel(tex1D, samp, (e215.xyz / vec3<f32>(e215.w)).x, 3.0);
c = e222;
let e223: f32 = coord1;
let e228: f32 = coord1;
let e230: vec2<f32> = vec2<f32>(e228, 6.0);
let e236: vec4<f32> = textureSampleLevel(tex1D, samp, (e230.x / e230.y), 3.0, 5);
c = e236;
let e237: f32 = coord1;
let e244: f32 = coord1;
let e248: vec4<f32> = vec4<f32>(e244, 0.0, 0.0, 6.0);
let e256: vec4<f32> = textureSampleLevel(tex1D, samp, (e248.xyz / vec3<f32>(e248.w)).x, 3.0, 5);
c = e256;
let e257: f32 = coord1;
let e261: f32 = coord1;
let e263: vec2<f32> = vec2<f32>(e261, 6.0);
let e268: vec4<f32> = textureSample(tex1D, samp, (e263.x / e263.y), 5);
c = e268;
let e269: f32 = coord1;
let e275: f32 = coord1;
let e279: vec4<f32> = vec4<f32>(e275, 0.0, 0.0, 6.0);
let e286: vec4<f32> = textureSample(tex1D, samp, (e279.xyz / vec3<f32>(e279.w)).x, 5);
c = e286;
let e287: f32 = coord1;
let e292: f32 = coord1;
let e294: vec2<f32> = vec2<f32>(e292, 6.0);
let e300: vec4<f32> = textureSampleBias(tex1D, samp, (e294.x / e294.y), 2.0, 5);
c = e300;
let e301: f32 = coord1;
let e308: f32 = coord1;
let e312: vec4<f32> = vec4<f32>(e308, 0.0, 0.0, 6.0);
let e320: vec4<f32> = textureSampleBias(tex1D, samp, (e312.xyz / vec3<f32>(e312.w)).x, 2.0, 5);
c = e320;
return;
}
@@ -145,30 +145,30 @@ fn testTex1DArray(coord2: vec2<f32>) {
var c1: vec4<f32>;
coord3 = coord2;
let _e18: vec2<f32> = coord3;
let _e22: vec4<f32> = textureSample(tex1DArray, samp, _e18.x, i32(_e18.x));
c1 = _e22;
let _e25: vec2<f32> = coord3;
let _e30: vec4<f32> = textureSampleBias(tex1DArray, samp, _e25.x, i32(_e25.x), 2.0);
c1 = _e30;
let _e34: vec2<f32> = coord3;
let _e40: vec4<f32> = textureSampleGrad(tex1DArray, samp, _e34.x, i32(_e34.x), 4.0, 4.0);
c1 = _e40;
let _e45: vec2<f32> = coord3;
let _e52: vec4<f32> = textureSampleGrad(tex1DArray, samp, _e45.x, i32(_e45.x), 4.0, 4.0, 5);
c1 = _e52;
let _e55: vec2<f32> = coord3;
let _e60: vec4<f32> = textureSampleLevel(tex1DArray, samp, _e55.x, i32(_e55.x), 3.0);
c1 = _e60;
let _e64: vec2<f32> = coord3;
let _e70: vec4<f32> = textureSampleLevel(tex1DArray, samp, _e64.x, i32(_e64.x), 3.0, 5);
c1 = _e70;
let _e73: vec2<f32> = coord3;
let _e78: vec4<f32> = textureSample(tex1DArray, samp, _e73.x, i32(_e73.x), 5);
c1 = _e78;
let _e82: vec2<f32> = coord3;
let _e88: vec4<f32> = textureSampleBias(tex1DArray, samp, _e82.x, i32(_e82.x), 2.0, 5);
c1 = _e88;
let e18: vec2<f32> = coord3;
let e22: vec4<f32> = textureSample(tex1DArray, samp, e18.x, i32(e18.x));
c1 = e22;
let e25: vec2<f32> = coord3;
let e30: vec4<f32> = textureSampleBias(tex1DArray, samp, e25.x, i32(e25.x), 2.0);
c1 = e30;
let e34: vec2<f32> = coord3;
let e40: vec4<f32> = textureSampleGrad(tex1DArray, samp, e34.x, i32(e34.x), 4.0, 4.0);
c1 = e40;
let e45: vec2<f32> = coord3;
let e52: vec4<f32> = textureSampleGrad(tex1DArray, samp, e45.x, i32(e45.x), 4.0, 4.0, 5);
c1 = e52;
let e55: vec2<f32> = coord3;
let e60: vec4<f32> = textureSampleLevel(tex1DArray, samp, e55.x, i32(e55.x), 3.0);
c1 = e60;
let e64: vec2<f32> = coord3;
let e70: vec4<f32> = textureSampleLevel(tex1DArray, samp, e64.x, i32(e64.x), 3.0, 5);
c1 = e70;
let e73: vec2<f32> = coord3;
let e78: vec4<f32> = textureSample(tex1DArray, samp, e73.x, i32(e73.x), 5);
c1 = e78;
let e82: vec2<f32> = coord3;
let e88: vec4<f32> = textureSampleBias(tex1DArray, samp, e82.x, i32(e82.x), 2.0, 5);
c1 = e88;
return;
}
@@ -177,110 +177,110 @@ fn testTex2D(coord4: vec2<f32>) {
var c2: vec4<f32>;
coord5 = coord4;
let _e18: vec2<f32> = coord5;
let _e19: vec4<f32> = textureSample(tex2D, samp, _e18);
c2 = _e19;
let _e22: vec2<f32> = coord5;
let _e24: vec4<f32> = textureSampleBias(tex2D, samp, _e22, 2.0);
c2 = _e24;
let _e30: vec2<f32> = coord5;
let _e35: vec4<f32> = textureSampleGrad(tex2D, samp, _e30, vec2<f32>(4.0), vec2<f32>(4.0));
c2 = _e35;
let _e43: vec2<f32> = coord5;
let _e50: vec4<f32> = textureSampleGrad(tex2D, samp, _e43, vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c2 = _e50;
let _e53: vec2<f32> = coord5;
let _e55: vec4<f32> = textureSampleLevel(tex2D, samp, _e53, 3.0);
c2 = _e55;
let _e60: vec2<f32> = coord5;
let _e64: vec4<f32> = textureSampleLevel(tex2D, samp, _e60, 3.0, vec2<i32>(5, 5));
c2 = _e64;
let _e68: vec2<f32> = coord5;
let _e71: vec4<f32> = textureSample(tex2D, samp, _e68, vec2<i32>(5, 5));
c2 = _e71;
let _e76: vec2<f32> = coord5;
let _e80: vec4<f32> = textureSampleBias(tex2D, samp, _e76, 2.0, vec2<i32>(5, 5));
c2 = _e80;
let _e81: vec2<f32> = coord5;
let _e84: vec2<f32> = coord5;
let _e86: vec3<f32> = vec3<f32>(_e84, 6.0);
let _e91: vec4<f32> = textureSample(tex2D, samp, (_e86.xy / vec2<f32>(_e86.z)));
c2 = _e91;
let _e92: vec2<f32> = coord5;
let _e96: vec2<f32> = coord5;
let _e99: vec4<f32> = vec4<f32>(_e96, 0.0, 6.0);
let _e105: vec4<f32> = textureSample(tex2D, samp, (_e99.xyz / vec3<f32>(_e99.w)).xy);
c2 = _e105;
let _e106: vec2<f32> = coord5;
let _e110: vec2<f32> = coord5;
let _e112: vec3<f32> = vec3<f32>(_e110, 6.0);
let _e118: vec4<f32> = textureSampleBias(tex2D, samp, (_e112.xy / vec2<f32>(_e112.z)), 2.0);
c2 = _e118;
let _e119: vec2<f32> = coord5;
let _e124: vec2<f32> = coord5;
let _e127: vec4<f32> = vec4<f32>(_e124, 0.0, 6.0);
let _e134: vec4<f32> = textureSampleBias(tex2D, samp, (_e127.xyz / vec3<f32>(_e127.w)).xy, 2.0);
c2 = _e134;
let _e135: vec2<f32> = coord5;
let _e142: vec2<f32> = coord5;
let _e144: vec3<f32> = vec3<f32>(_e142, 6.0);
let _e153: vec4<f32> = textureSampleGrad(tex2D, samp, (_e144.xy / vec2<f32>(_e144.z)), vec2<f32>(4.0), vec2<f32>(4.0));
c2 = _e153;
let _e154: vec2<f32> = coord5;
let _e162: vec2<f32> = coord5;
let _e165: vec4<f32> = vec4<f32>(_e162, 0.0, 6.0);
let _e175: vec4<f32> = textureSampleGrad(tex2D, samp, (_e165.xyz / vec3<f32>(_e165.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0));
c2 = _e175;
let _e176: vec2<f32> = coord5;
let _e185: vec2<f32> = coord5;
let _e187: vec3<f32> = vec3<f32>(_e185, 6.0);
let _e198: vec4<f32> = textureSampleGrad(tex2D, samp, (_e187.xy / vec2<f32>(_e187.z)), vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c2 = _e198;
let _e199: vec2<f32> = coord5;
let _e209: vec2<f32> = coord5;
let _e212: vec4<f32> = vec4<f32>(_e209, 0.0, 6.0);
let _e224: vec4<f32> = textureSampleGrad(tex2D, samp, (_e212.xyz / vec3<f32>(_e212.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c2 = _e224;
let _e225: vec2<f32> = coord5;
let _e229: vec2<f32> = coord5;
let _e231: vec3<f32> = vec3<f32>(_e229, 6.0);
let _e237: vec4<f32> = textureSampleLevel(tex2D, samp, (_e231.xy / vec2<f32>(_e231.z)), 3.0);
c2 = _e237;
let _e238: vec2<f32> = coord5;
let _e243: vec2<f32> = coord5;
let _e246: vec4<f32> = vec4<f32>(_e243, 0.0, 6.0);
let _e253: vec4<f32> = textureSampleLevel(tex2D, samp, (_e246.xyz / vec3<f32>(_e246.w)).xy, 3.0);
c2 = _e253;
let _e254: vec2<f32> = coord5;
let _e260: vec2<f32> = coord5;
let _e262: vec3<f32> = vec3<f32>(_e260, 6.0);
let _e270: vec4<f32> = textureSampleLevel(tex2D, samp, (_e262.xy / vec2<f32>(_e262.z)), 3.0, vec2<i32>(5, 5));
c2 = _e270;
let _e271: vec2<f32> = coord5;
let _e278: vec2<f32> = coord5;
let _e281: vec4<f32> = vec4<f32>(_e278, 0.0, 6.0);
let _e290: vec4<f32> = textureSampleLevel(tex2D, samp, (_e281.xyz / vec3<f32>(_e281.w)).xy, 3.0, vec2<i32>(5, 5));
c2 = _e290;
let _e291: vec2<f32> = coord5;
let _e296: vec2<f32> = coord5;
let _e298: vec3<f32> = vec3<f32>(_e296, 6.0);
let _e305: vec4<f32> = textureSample(tex2D, samp, (_e298.xy / vec2<f32>(_e298.z)), vec2<i32>(5, 5));
c2 = _e305;
let _e306: vec2<f32> = coord5;
let _e312: vec2<f32> = coord5;
let _e315: vec4<f32> = vec4<f32>(_e312, 0.0, 6.0);
let _e323: vec4<f32> = textureSample(tex2D, samp, (_e315.xyz / vec3<f32>(_e315.w)).xy, vec2<i32>(5, 5));
c2 = _e323;
let _e324: vec2<f32> = coord5;
let _e330: vec2<f32> = coord5;
let _e332: vec3<f32> = vec3<f32>(_e330, 6.0);
let _e340: vec4<f32> = textureSampleBias(tex2D, samp, (_e332.xy / vec2<f32>(_e332.z)), 2.0, vec2<i32>(5, 5));
c2 = _e340;
let _e341: vec2<f32> = coord5;
let _e348: vec2<f32> = coord5;
let _e351: vec4<f32> = vec4<f32>(_e348, 0.0, 6.0);
let _e360: vec4<f32> = textureSampleBias(tex2D, samp, (_e351.xyz / vec3<f32>(_e351.w)).xy, 2.0, vec2<i32>(5, 5));
c2 = _e360;
let e18: vec2<f32> = coord5;
let e19: vec4<f32> = textureSample(tex2D, samp, e18);
c2 = e19;
let e22: vec2<f32> = coord5;
let e24: vec4<f32> = textureSampleBias(tex2D, samp, e22, 2.0);
c2 = e24;
let e30: vec2<f32> = coord5;
let e35: vec4<f32> = textureSampleGrad(tex2D, samp, e30, vec2<f32>(4.0), vec2<f32>(4.0));
c2 = e35;
let e43: vec2<f32> = coord5;
let e50: vec4<f32> = textureSampleGrad(tex2D, samp, e43, vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c2 = e50;
let e53: vec2<f32> = coord5;
let e55: vec4<f32> = textureSampleLevel(tex2D, samp, e53, 3.0);
c2 = e55;
let e60: vec2<f32> = coord5;
let e64: vec4<f32> = textureSampleLevel(tex2D, samp, e60, 3.0, vec2<i32>(5, 5));
c2 = e64;
let e68: vec2<f32> = coord5;
let e71: vec4<f32> = textureSample(tex2D, samp, e68, vec2<i32>(5, 5));
c2 = e71;
let e76: vec2<f32> = coord5;
let e80: vec4<f32> = textureSampleBias(tex2D, samp, e76, 2.0, vec2<i32>(5, 5));
c2 = e80;
let e81: vec2<f32> = coord5;
let e84: vec2<f32> = coord5;
let e86: vec3<f32> = vec3<f32>(e84, 6.0);
let e91: vec4<f32> = textureSample(tex2D, samp, (e86.xy / vec2<f32>(e86.z)));
c2 = e91;
let e92: vec2<f32> = coord5;
let e96: vec2<f32> = coord5;
let e99: vec4<f32> = vec4<f32>(e96, 0.0, 6.0);
let e105: vec4<f32> = textureSample(tex2D, samp, (e99.xyz / vec3<f32>(e99.w)).xy);
c2 = e105;
let e106: vec2<f32> = coord5;
let e110: vec2<f32> = coord5;
let e112: vec3<f32> = vec3<f32>(e110, 6.0);
let e118: vec4<f32> = textureSampleBias(tex2D, samp, (e112.xy / vec2<f32>(e112.z)), 2.0);
c2 = e118;
let e119: vec2<f32> = coord5;
let e124: vec2<f32> = coord5;
let e127: vec4<f32> = vec4<f32>(e124, 0.0, 6.0);
let e134: vec4<f32> = textureSampleBias(tex2D, samp, (e127.xyz / vec3<f32>(e127.w)).xy, 2.0);
c2 = e134;
let e135: vec2<f32> = coord5;
let e142: vec2<f32> = coord5;
let e144: vec3<f32> = vec3<f32>(e142, 6.0);
let e153: vec4<f32> = textureSampleGrad(tex2D, samp, (e144.xy / vec2<f32>(e144.z)), vec2<f32>(4.0), vec2<f32>(4.0));
c2 = e153;
let e154: vec2<f32> = coord5;
let e162: vec2<f32> = coord5;
let e165: vec4<f32> = vec4<f32>(e162, 0.0, 6.0);
let e175: vec4<f32> = textureSampleGrad(tex2D, samp, (e165.xyz / vec3<f32>(e165.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0));
c2 = e175;
let e176: vec2<f32> = coord5;
let e185: vec2<f32> = coord5;
let e187: vec3<f32> = vec3<f32>(e185, 6.0);
let e198: vec4<f32> = textureSampleGrad(tex2D, samp, (e187.xy / vec2<f32>(e187.z)), vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c2 = e198;
let e199: vec2<f32> = coord5;
let e209: vec2<f32> = coord5;
let e212: vec4<f32> = vec4<f32>(e209, 0.0, 6.0);
let e224: vec4<f32> = textureSampleGrad(tex2D, samp, (e212.xyz / vec3<f32>(e212.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c2 = e224;
let e225: vec2<f32> = coord5;
let e229: vec2<f32> = coord5;
let e231: vec3<f32> = vec3<f32>(e229, 6.0);
let e237: vec4<f32> = textureSampleLevel(tex2D, samp, (e231.xy / vec2<f32>(e231.z)), 3.0);
c2 = e237;
let e238: vec2<f32> = coord5;
let e243: vec2<f32> = coord5;
let e246: vec4<f32> = vec4<f32>(e243, 0.0, 6.0);
let e253: vec4<f32> = textureSampleLevel(tex2D, samp, (e246.xyz / vec3<f32>(e246.w)).xy, 3.0);
c2 = e253;
let e254: vec2<f32> = coord5;
let e260: vec2<f32> = coord5;
let e262: vec3<f32> = vec3<f32>(e260, 6.0);
let e270: vec4<f32> = textureSampleLevel(tex2D, samp, (e262.xy / vec2<f32>(e262.z)), 3.0, vec2<i32>(5, 5));
c2 = e270;
let e271: vec2<f32> = coord5;
let e278: vec2<f32> = coord5;
let e281: vec4<f32> = vec4<f32>(e278, 0.0, 6.0);
let e290: vec4<f32> = textureSampleLevel(tex2D, samp, (e281.xyz / vec3<f32>(e281.w)).xy, 3.0, vec2<i32>(5, 5));
c2 = e290;
let e291: vec2<f32> = coord5;
let e296: vec2<f32> = coord5;
let e298: vec3<f32> = vec3<f32>(e296, 6.0);
let e305: vec4<f32> = textureSample(tex2D, samp, (e298.xy / vec2<f32>(e298.z)), vec2<i32>(5, 5));
c2 = e305;
let e306: vec2<f32> = coord5;
let e312: vec2<f32> = coord5;
let e315: vec4<f32> = vec4<f32>(e312, 0.0, 6.0);
let e323: vec4<f32> = textureSample(tex2D, samp, (e315.xyz / vec3<f32>(e315.w)).xy, vec2<i32>(5, 5));
c2 = e323;
let e324: vec2<f32> = coord5;
let e330: vec2<f32> = coord5;
let e332: vec3<f32> = vec3<f32>(e330, 6.0);
let e340: vec4<f32> = textureSampleBias(tex2D, samp, (e332.xy / vec2<f32>(e332.z)), 2.0, vec2<i32>(5, 5));
c2 = e340;
let e341: vec2<f32> = coord5;
let e348: vec2<f32> = coord5;
let e351: vec4<f32> = vec4<f32>(e348, 0.0, 6.0);
let e360: vec4<f32> = textureSampleBias(tex2D, samp, (e351.xyz / vec3<f32>(e351.w)).xy, 2.0, vec2<i32>(5, 5));
c2 = e360;
return;
}
@@ -289,72 +289,72 @@ fn testTex2DShadow(coord6: vec2<f32>) {
var d: f32;
coord7 = coord6;
let _e17: vec2<f32> = coord7;
let _e20: vec2<f32> = coord7;
let _e22: vec3<f32> = vec3<f32>(_e20, 1.0);
let _e25: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e22.xy, _e22.z);
d = _e25;
let _e26: vec2<f32> = coord7;
let _e33: vec2<f32> = coord7;
let _e35: vec3<f32> = vec3<f32>(_e33, 1.0);
let _e42: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e35.xy, _e35.z);
d = _e42;
let _e43: vec2<f32> = coord7;
let _e52: vec2<f32> = coord7;
let _e54: vec3<f32> = vec3<f32>(_e52, 1.0);
let _e63: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e54.xy, _e54.z, vec2<i32>(5, 5));
d = _e63;
let _e64: vec2<f32> = coord7;
let _e68: vec2<f32> = coord7;
let _e70: vec3<f32> = vec3<f32>(_e68, 1.0);
let _e74: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e70.xy, _e70.z);
d = _e74;
let _e75: vec2<f32> = coord7;
let _e81: vec2<f32> = coord7;
let _e83: vec3<f32> = vec3<f32>(_e81, 1.0);
let _e89: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e83.xy, _e83.z, vec2<i32>(5, 5));
d = _e89;
let _e90: vec2<f32> = coord7;
let _e95: vec2<f32> = coord7;
let _e97: vec3<f32> = vec3<f32>(_e95, 1.0);
let _e102: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e97.xy, _e97.z, vec2<i32>(5, 5));
d = _e102;
let _e103: vec2<f32> = coord7;
let _e107: vec2<f32> = coord7;
let _e110: vec4<f32> = vec4<f32>(_e107, 1.0, 6.0);
let _e114: vec3<f32> = (_e110.xyz / vec3<f32>(_e110.w));
let _e117: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e114.xy, _e114.z);
d = _e117;
let _e118: vec2<f32> = coord7;
let _e126: vec2<f32> = coord7;
let _e129: vec4<f32> = vec4<f32>(_e126, 1.0, 6.0);
let _e137: vec3<f32> = (_e129.xyz / vec3<f32>(_e129.w));
let _e140: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e137.xy, _e137.z);
d = _e140;
let _e141: vec2<f32> = coord7;
let _e151: vec2<f32> = coord7;
let _e154: vec4<f32> = vec4<f32>(_e151, 1.0, 6.0);
let _e164: vec3<f32> = (_e154.xyz / vec3<f32>(_e154.w));
let _e167: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e164.xy, _e164.z, vec2<i32>(5, 5));
d = _e167;
let _e168: vec2<f32> = coord7;
let _e173: vec2<f32> = coord7;
let _e176: vec4<f32> = vec4<f32>(_e173, 1.0, 6.0);
let _e181: vec3<f32> = (_e176.xyz / vec3<f32>(_e176.w));
let _e184: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e181.xy, _e181.z);
d = _e184;
let _e185: vec2<f32> = coord7;
let _e192: vec2<f32> = coord7;
let _e195: vec4<f32> = vec4<f32>(_e192, 1.0, 6.0);
let _e202: vec3<f32> = (_e195.xyz / vec3<f32>(_e195.w));
let _e205: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e202.xy, _e202.z, vec2<i32>(5, 5));
d = _e205;
let _e206: vec2<f32> = coord7;
let _e212: vec2<f32> = coord7;
let _e215: vec4<f32> = vec4<f32>(_e212, 1.0, 6.0);
let _e221: vec3<f32> = (_e215.xyz / vec3<f32>(_e215.w));
let _e224: f32 = textureSampleCompare(tex2DShadow, sampShadow, _e221.xy, _e221.z, vec2<i32>(5, 5));
d = _e224;
let e17: vec2<f32> = coord7;
let e20: vec2<f32> = coord7;
let e22: vec3<f32> = vec3<f32>(e20, 1.0);
let e25: f32 = textureSampleCompare(tex2DShadow, sampShadow, e22.xy, e22.z);
d = e25;
let e26: vec2<f32> = coord7;
let e33: vec2<f32> = coord7;
let e35: vec3<f32> = vec3<f32>(e33, 1.0);
let e42: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e35.xy, e35.z);
d = e42;
let e43: vec2<f32> = coord7;
let e52: vec2<f32> = coord7;
let e54: vec3<f32> = vec3<f32>(e52, 1.0);
let e63: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e54.xy, e54.z, vec2<i32>(5, 5));
d = e63;
let e64: vec2<f32> = coord7;
let e68: vec2<f32> = coord7;
let e70: vec3<f32> = vec3<f32>(e68, 1.0);
let e74: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e70.xy, e70.z);
d = e74;
let e75: vec2<f32> = coord7;
let e81: vec2<f32> = coord7;
let e83: vec3<f32> = vec3<f32>(e81, 1.0);
let e89: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e83.xy, e83.z, vec2<i32>(5, 5));
d = e89;
let e90: vec2<f32> = coord7;
let e95: vec2<f32> = coord7;
let e97: vec3<f32> = vec3<f32>(e95, 1.0);
let e102: f32 = textureSampleCompare(tex2DShadow, sampShadow, e97.xy, e97.z, vec2<i32>(5, 5));
d = e102;
let e103: vec2<f32> = coord7;
let e107: vec2<f32> = coord7;
let e110: vec4<f32> = vec4<f32>(e107, 1.0, 6.0);
let e114: vec3<f32> = (e110.xyz / vec3<f32>(e110.w));
let e117: f32 = textureSampleCompare(tex2DShadow, sampShadow, e114.xy, e114.z);
d = e117;
let e118: vec2<f32> = coord7;
let e126: vec2<f32> = coord7;
let e129: vec4<f32> = vec4<f32>(e126, 1.0, 6.0);
let e137: vec3<f32> = (e129.xyz / vec3<f32>(e129.w));
let e140: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e137.xy, e137.z);
d = e140;
let e141: vec2<f32> = coord7;
let e151: vec2<f32> = coord7;
let e154: vec4<f32> = vec4<f32>(e151, 1.0, 6.0);
let e164: vec3<f32> = (e154.xyz / vec3<f32>(e154.w));
let e167: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e164.xy, e164.z, vec2<i32>(5, 5));
d = e167;
let e168: vec2<f32> = coord7;
let e173: vec2<f32> = coord7;
let e176: vec4<f32> = vec4<f32>(e173, 1.0, 6.0);
let e181: vec3<f32> = (e176.xyz / vec3<f32>(e176.w));
let e184: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e181.xy, e181.z);
d = e184;
let e185: vec2<f32> = coord7;
let e192: vec2<f32> = coord7;
let e195: vec4<f32> = vec4<f32>(e192, 1.0, 6.0);
let e202: vec3<f32> = (e195.xyz / vec3<f32>(e195.w));
let e205: f32 = textureSampleCompareLevel(tex2DShadow, sampShadow, e202.xy, e202.z, vec2<i32>(5, 5));
d = e205;
let e206: vec2<f32> = coord7;
let e212: vec2<f32> = coord7;
let e215: vec4<f32> = vec4<f32>(e212, 1.0, 6.0);
let e221: vec3<f32> = (e215.xyz / vec3<f32>(e215.w));
let e224: f32 = textureSampleCompare(tex2DShadow, sampShadow, e221.xy, e221.z, vec2<i32>(5, 5));
d = e224;
return;
}
@@ -363,30 +363,30 @@ fn testTex2DArray(coord8: vec3<f32>) {
var c3: vec4<f32>;
coord9 = coord8;
let _e18: vec3<f32> = coord9;
let _e22: vec4<f32> = textureSample(tex2DArray, samp, _e18.xy, i32(_e18.z));
c3 = _e22;
let _e25: vec3<f32> = coord9;
let _e30: vec4<f32> = textureSampleBias(tex2DArray, samp, _e25.xy, i32(_e25.z), 2.0);
c3 = _e30;
let _e36: vec3<f32> = coord9;
let _e44: vec4<f32> = textureSampleGrad(tex2DArray, samp, _e36.xy, i32(_e36.z), vec2<f32>(4.0), vec2<f32>(4.0));
c3 = _e44;
let _e52: vec3<f32> = coord9;
let _e62: vec4<f32> = textureSampleGrad(tex2DArray, samp, _e52.xy, i32(_e52.z), vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c3 = _e62;
let _e65: vec3<f32> = coord9;
let _e70: vec4<f32> = textureSampleLevel(tex2DArray, samp, _e65.xy, i32(_e65.z), 3.0);
c3 = _e70;
let _e75: vec3<f32> = coord9;
let _e82: vec4<f32> = textureSampleLevel(tex2DArray, samp, _e75.xy, i32(_e75.z), 3.0, vec2<i32>(5, 5));
c3 = _e82;
let _e86: vec3<f32> = coord9;
let _e92: vec4<f32> = textureSample(tex2DArray, samp, _e86.xy, i32(_e86.z), vec2<i32>(5, 5));
c3 = _e92;
let _e97: vec3<f32> = coord9;
let _e104: vec4<f32> = textureSampleBias(tex2DArray, samp, _e97.xy, i32(_e97.z), 2.0, vec2<i32>(5, 5));
c3 = _e104;
let e18: vec3<f32> = coord9;
let e22: vec4<f32> = textureSample(tex2DArray, samp, e18.xy, i32(e18.z));
c3 = e22;
let e25: vec3<f32> = coord9;
let e30: vec4<f32> = textureSampleBias(tex2DArray, samp, e25.xy, i32(e25.z), 2.0);
c3 = e30;
let e36: vec3<f32> = coord9;
let e44: vec4<f32> = textureSampleGrad(tex2DArray, samp, e36.xy, i32(e36.z), vec2<f32>(4.0), vec2<f32>(4.0));
c3 = e44;
let e52: vec3<f32> = coord9;
let e62: vec4<f32> = textureSampleGrad(tex2DArray, samp, e52.xy, i32(e52.z), vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
c3 = e62;
let e65: vec3<f32> = coord9;
let e70: vec4<f32> = textureSampleLevel(tex2DArray, samp, e65.xy, i32(e65.z), 3.0);
c3 = e70;
let e75: vec3<f32> = coord9;
let e82: vec4<f32> = textureSampleLevel(tex2DArray, samp, e75.xy, i32(e75.z), 3.0, vec2<i32>(5, 5));
c3 = e82;
let e86: vec3<f32> = coord9;
let e92: vec4<f32> = textureSample(tex2DArray, samp, e86.xy, i32(e86.z), vec2<i32>(5, 5));
c3 = e92;
let e97: vec3<f32> = coord9;
let e104: vec4<f32> = textureSampleBias(tex2DArray, samp, e97.xy, i32(e97.z), 2.0, vec2<i32>(5, 5));
c3 = e104;
return;
}
@@ -395,36 +395,36 @@ fn testTex2DArrayShadow(coord10: vec3<f32>) {
var d1: f32;
coord11 = coord10;
let _e17: vec3<f32> = coord11;
let _e20: vec3<f32> = coord11;
let _e22: vec4<f32> = vec4<f32>(_e20, 1.0);
let _e27: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e22.xy, i32(_e22.z), _e22.w);
d1 = _e27;
let _e28: vec3<f32> = coord11;
let _e35: vec3<f32> = coord11;
let _e37: vec4<f32> = vec4<f32>(_e35, 1.0);
let _e46: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e37.xy, i32(_e37.z), _e37.w);
d1 = _e46;
let _e47: vec3<f32> = coord11;
let _e56: vec3<f32> = coord11;
let _e58: vec4<f32> = vec4<f32>(_e56, 1.0);
let _e69: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e58.xy, i32(_e58.z), _e58.w, vec2<i32>(5, 5));
d1 = _e69;
let _e70: vec3<f32> = coord11;
let _e74: vec3<f32> = coord11;
let _e76: vec4<f32> = vec4<f32>(_e74, 1.0);
let _e82: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e76.xy, i32(_e76.z), _e76.w);
d1 = _e82;
let _e83: vec3<f32> = coord11;
let _e89: vec3<f32> = coord11;
let _e91: vec4<f32> = vec4<f32>(_e89, 1.0);
let _e99: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e91.xy, i32(_e91.z), _e91.w, vec2<i32>(5, 5));
d1 = _e99;
let _e100: vec3<f32> = coord11;
let _e105: vec3<f32> = coord11;
let _e107: vec4<f32> = vec4<f32>(_e105, 1.0);
let _e114: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e107.xy, i32(_e107.z), _e107.w, vec2<i32>(5, 5));
d1 = _e114;
let e17: vec3<f32> = coord11;
let e20: vec3<f32> = coord11;
let e22: vec4<f32> = vec4<f32>(e20, 1.0);
let e27: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, e22.xy, i32(e22.z), e22.w);
d1 = e27;
let e28: vec3<f32> = coord11;
let e35: vec3<f32> = coord11;
let e37: vec4<f32> = vec4<f32>(e35, 1.0);
let e46: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e37.xy, i32(e37.z), e37.w);
d1 = e46;
let e47: vec3<f32> = coord11;
let e56: vec3<f32> = coord11;
let e58: vec4<f32> = vec4<f32>(e56, 1.0);
let e69: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e58.xy, i32(e58.z), e58.w, vec2<i32>(5, 5));
d1 = e69;
let e70: vec3<f32> = coord11;
let e74: vec3<f32> = coord11;
let e76: vec4<f32> = vec4<f32>(e74, 1.0);
let e82: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e76.xy, i32(e76.z), e76.w);
d1 = e82;
let e83: vec3<f32> = coord11;
let e89: vec3<f32> = coord11;
let e91: vec4<f32> = vec4<f32>(e89, 1.0);
let e99: f32 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, e91.xy, i32(e91.z), e91.w, vec2<i32>(5, 5));
d1 = e99;
let e100: vec3<f32> = coord11;
let e105: vec3<f32> = coord11;
let e107: vec4<f32> = vec4<f32>(e105, 1.0);
let e114: f32 = textureSampleCompare(tex2DArrayShadow, sampShadow, e107.xy, i32(e107.z), e107.w, vec2<i32>(5, 5));
d1 = e114;
return;
}
@@ -433,27 +433,27 @@ fn testTexCube(coord12: vec3<f32>) {
var c4: vec4<f32>;
coord13 = coord12;
let _e18: vec3<f32> = coord13;
let _e19: vec4<f32> = textureSample(texCube, samp, _e18);
c4 = _e19;
let _e22: vec3<f32> = coord13;
let _e24: vec4<f32> = textureSampleBias(texCube, samp, _e22, 2.0);
c4 = _e24;
let _e30: vec3<f32> = coord13;
let _e35: vec4<f32> = textureSampleGrad(texCube, samp, _e30, vec3<f32>(4.0), vec3<f32>(4.0));
c4 = _e35;
let _e38: vec3<f32> = coord13;
let _e40: vec4<f32> = textureSampleLevel(texCube, samp, _e38, 3.0);
c4 = _e40;
let _e45: vec3<f32> = coord13;
let _e49: vec4<f32> = textureSampleLevel(texCube, samp, _e45, 3.0, vec3<i32>(5, 5, 5));
c4 = _e49;
let _e53: vec3<f32> = coord13;
let _e56: vec4<f32> = textureSample(texCube, samp, _e53, vec3<i32>(5, 5, 5));
c4 = _e56;
let _e61: vec3<f32> = coord13;
let _e65: vec4<f32> = textureSampleBias(texCube, samp, _e61, 2.0, vec3<i32>(5, 5, 5));
c4 = _e65;
let e18: vec3<f32> = coord13;
let e19: vec4<f32> = textureSample(texCube, samp, e18);
c4 = e19;
let e22: vec3<f32> = coord13;
let e24: vec4<f32> = textureSampleBias(texCube, samp, e22, 2.0);
c4 = e24;
let e30: vec3<f32> = coord13;
let e35: vec4<f32> = textureSampleGrad(texCube, samp, e30, vec3<f32>(4.0), vec3<f32>(4.0));
c4 = e35;
let e38: vec3<f32> = coord13;
let e40: vec4<f32> = textureSampleLevel(texCube, samp, e38, 3.0);
c4 = e40;
let e45: vec3<f32> = coord13;
let e49: vec4<f32> = textureSampleLevel(texCube, samp, e45, 3.0, vec3<i32>(5, 5, 5));
c4 = e49;
let e53: vec3<f32> = coord13;
let e56: vec4<f32> = textureSample(texCube, samp, e53, vec3<i32>(5, 5, 5));
c4 = e56;
let e61: vec3<f32> = coord13;
let e65: vec4<f32> = textureSampleBias(texCube, samp, e61, 2.0, vec3<i32>(5, 5, 5));
c4 = e65;
return;
}
@@ -462,31 +462,31 @@ fn testTexCubeShadow(coord14: vec3<f32>) {
var d2: f32;
coord15 = coord14;
let _e17: vec3<f32> = coord15;
let _e20: vec3<f32> = coord15;
let _e22: vec4<f32> = vec4<f32>(_e20, 1.0);
let _e25: f32 = textureSampleCompare(texCubeShadow, sampShadow, _e22.xyz, _e22.w);
d2 = _e25;
let _e26: vec3<f32> = coord15;
let _e33: vec3<f32> = coord15;
let _e35: vec4<f32> = vec4<f32>(_e33, 1.0);
let _e42: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e35.xyz, _e35.w);
d2 = _e42;
let _e43: vec3<f32> = coord15;
let _e47: vec3<f32> = coord15;
let _e49: vec4<f32> = vec4<f32>(_e47, 1.0);
let _e53: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e49.xyz, _e49.w);
d2 = _e53;
let _e54: vec3<f32> = coord15;
let _e60: vec3<f32> = coord15;
let _e62: vec4<f32> = vec4<f32>(_e60, 1.0);
let _e68: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e62.xyz, _e62.w, vec3<i32>(5, 5, 5));
d2 = _e68;
let _e69: vec3<f32> = coord15;
let _e74: vec3<f32> = coord15;
let _e76: vec4<f32> = vec4<f32>(_e74, 1.0);
let _e81: f32 = textureSampleCompare(texCubeShadow, sampShadow, _e76.xyz, _e76.w, vec3<i32>(5, 5, 5));
d2 = _e81;
let e17: vec3<f32> = coord15;
let e20: vec3<f32> = coord15;
let e22: vec4<f32> = vec4<f32>(e20, 1.0);
let e25: f32 = textureSampleCompare(texCubeShadow, sampShadow, e22.xyz, e22.w);
d2 = e25;
let e26: vec3<f32> = coord15;
let e33: vec3<f32> = coord15;
let e35: vec4<f32> = vec4<f32>(e33, 1.0);
let e42: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, e35.xyz, e35.w);
d2 = e42;
let e43: vec3<f32> = coord15;
let e47: vec3<f32> = coord15;
let e49: vec4<f32> = vec4<f32>(e47, 1.0);
let e53: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, e49.xyz, e49.w);
d2 = e53;
let e54: vec3<f32> = coord15;
let e60: vec3<f32> = coord15;
let e62: vec4<f32> = vec4<f32>(e60, 1.0);
let e68: f32 = textureSampleCompareLevel(texCubeShadow, sampShadow, e62.xyz, e62.w, vec3<i32>(5, 5, 5));
d2 = e68;
let e69: vec3<f32> = coord15;
let e74: vec3<f32> = coord15;
let e76: vec4<f32> = vec4<f32>(e74, 1.0);
let e81: f32 = textureSampleCompare(texCubeShadow, sampShadow, e76.xyz, e76.w, vec3<i32>(5, 5, 5));
d2 = e81;
return;
}
@@ -495,27 +495,27 @@ fn testTexCubeArray(coord16: vec4<f32>) {
var c5: vec4<f32>;
coord17 = coord16;
let _e18: vec4<f32> = coord17;
let _e22: vec4<f32> = textureSample(texCubeArray, samp, _e18.xyz, i32(_e18.w));
c5 = _e22;
let _e25: vec4<f32> = coord17;
let _e30: vec4<f32> = textureSampleBias(texCubeArray, samp, _e25.xyz, i32(_e25.w), 2.0);
c5 = _e30;
let _e36: vec4<f32> = coord17;
let _e44: vec4<f32> = textureSampleGrad(texCubeArray, samp, _e36.xyz, i32(_e36.w), vec3<f32>(4.0), vec3<f32>(4.0));
c5 = _e44;
let _e47: vec4<f32> = coord17;
let _e52: vec4<f32> = textureSampleLevel(texCubeArray, samp, _e47.xyz, i32(_e47.w), 3.0);
c5 = _e52;
let _e57: vec4<f32> = coord17;
let _e64: vec4<f32> = textureSampleLevel(texCubeArray, samp, _e57.xyz, i32(_e57.w), 3.0, vec3<i32>(5, 5, 5));
c5 = _e64;
let _e68: vec4<f32> = coord17;
let _e74: vec4<f32> = textureSample(texCubeArray, samp, _e68.xyz, i32(_e68.w), vec3<i32>(5, 5, 5));
c5 = _e74;
let _e79: vec4<f32> = coord17;
let _e86: vec4<f32> = textureSampleBias(texCubeArray, samp, _e79.xyz, i32(_e79.w), 2.0, vec3<i32>(5, 5, 5));
c5 = _e86;
let e18: vec4<f32> = coord17;
let e22: vec4<f32> = textureSample(texCubeArray, samp, e18.xyz, i32(e18.w));
c5 = e22;
let e25: vec4<f32> = coord17;
let e30: vec4<f32> = textureSampleBias(texCubeArray, samp, e25.xyz, i32(e25.w), 2.0);
c5 = e30;
let e36: vec4<f32> = coord17;
let e44: vec4<f32> = textureSampleGrad(texCubeArray, samp, e36.xyz, i32(e36.w), vec3<f32>(4.0), vec3<f32>(4.0));
c5 = e44;
let e47: vec4<f32> = coord17;
let e52: vec4<f32> = textureSampleLevel(texCubeArray, samp, e47.xyz, i32(e47.w), 3.0);
c5 = e52;
let e57: vec4<f32> = coord17;
let e64: vec4<f32> = textureSampleLevel(texCubeArray, samp, e57.xyz, i32(e57.w), 3.0, vec3<i32>(5, 5, 5));
c5 = e64;
let e68: vec4<f32> = coord17;
let e74: vec4<f32> = textureSample(texCubeArray, samp, e68.xyz, i32(e68.w), vec3<i32>(5, 5, 5));
c5 = e74;
let e79: vec4<f32> = coord17;
let e86: vec4<f32> = textureSampleBias(texCubeArray, samp, e79.xyz, i32(e79.w), 2.0, vec3<i32>(5, 5, 5));
c5 = e86;
return;
}
@@ -524,9 +524,9 @@ fn testTexCubeArrayShadow(coord18: vec4<f32>) {
var d3: f32;
coord19 = coord18;
let _e19: vec4<f32> = coord19;
let _e24: f32 = textureSampleCompare(texCubeArrayShadow, sampShadow, _e19.xyz, i32(_e19.w), 1.0);
d3 = _e24;
let e19: vec4<f32> = 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<f32>) {
var c6: vec4<f32>;
coord21 = coord20;
let _e18: vec3<f32> = coord21;
let _e19: vec4<f32> = textureSample(tex3D, samp, _e18);
c6 = _e19;
let _e22: vec3<f32> = coord21;
let _e24: vec4<f32> = textureSampleBias(tex3D, samp, _e22, 2.0);
c6 = _e24;
let _e30: vec3<f32> = coord21;
let _e35: vec4<f32> = textureSampleGrad(tex3D, samp, _e30, vec3<f32>(4.0), vec3<f32>(4.0));
c6 = _e35;
let _e43: vec3<f32> = coord21;
let _e50: vec4<f32> = textureSampleGrad(tex3D, samp, _e43, vec3<f32>(4.0), vec3<f32>(4.0), vec3<i32>(5, 5, 5));
c6 = _e50;
let _e53: vec3<f32> = coord21;
let _e55: vec4<f32> = textureSampleLevel(tex3D, samp, _e53, 3.0);
c6 = _e55;
let _e60: vec3<f32> = coord21;
let _e64: vec4<f32> = textureSampleLevel(tex3D, samp, _e60, 3.0, vec3<i32>(5, 5, 5));
c6 = _e64;
let _e68: vec3<f32> = coord21;
let _e71: vec4<f32> = textureSample(tex3D, samp, _e68, vec3<i32>(5, 5, 5));
c6 = _e71;
let _e76: vec3<f32> = coord21;
let _e80: vec4<f32> = textureSampleBias(tex3D, samp, _e76, 2.0, vec3<i32>(5, 5, 5));
c6 = _e80;
let e18: vec3<f32> = coord21;
let e19: vec4<f32> = textureSample(tex3D, samp, e18);
c6 = e19;
let e22: vec3<f32> = coord21;
let e24: vec4<f32> = textureSampleBias(tex3D, samp, e22, 2.0);
c6 = e24;
let e30: vec3<f32> = coord21;
let e35: vec4<f32> = textureSampleGrad(tex3D, samp, e30, vec3<f32>(4.0), vec3<f32>(4.0));
c6 = e35;
let e43: vec3<f32> = coord21;
let e50: vec4<f32> = textureSampleGrad(tex3D, samp, e43, vec3<f32>(4.0), vec3<f32>(4.0), vec3<i32>(5, 5, 5));
c6 = e50;
let e53: vec3<f32> = coord21;
let e55: vec4<f32> = textureSampleLevel(tex3D, samp, e53, 3.0);
c6 = e55;
let e60: vec3<f32> = coord21;
let e64: vec4<f32> = textureSampleLevel(tex3D, samp, e60, 3.0, vec3<i32>(5, 5, 5));
c6 = e64;
let e68: vec3<f32> = coord21;
let e71: vec4<f32> = textureSample(tex3D, samp, e68, vec3<i32>(5, 5, 5));
c6 = e71;
let e76: vec3<f32> = coord21;
let e80: vec4<f32> = textureSampleBias(tex3D, samp, e76, 2.0, vec3<i32>(5, 5, 5));
c6 = e80;
return;
}

30
tests/out/wgsl/shadow.wgsl
View File

@@ -32,8 +32,8 @@ fn fetch_shadow(light_id: u32, homogeneous_coords: vec4<f32>) -> f32 {
}
let flip_correction: vec2<f32> = vec2<f32>(0.5, -0.5);
let light_local: vec2<f32> = (((homogeneous_coords.xy * flip_correction) / vec2<f32>(homogeneous_coords.w)) + vec2<f32>(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<f32>, [[location(1)]] position: vec4
let normal: vec3<f32> = 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<f32> = normalize((light.pos.xyz - position.xyz));
let diffuse: f32 = max(0.0, dot(normal, light_dir));
let _e34: vec3<f32> = color;
color = (_e34 + ((_e25 * diffuse) * light.color.xyz));
let e34: vec3<f32> = 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<f32> = color;
return vec4<f32>(_e43, 1.0);
let e43: vec3<f32> = color;
return vec4<f32>(e43, 1.0);
}

22
tests/out/wgsl/skybox.wgsl
View File

@@ -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<f32> = vec4<f32>(((f32(_e10) * 4.0) - 1.0), ((f32(_e16) * 4.0) - 1.0), 0.0, 1.0);
let _e27: vec4<f32> = r_data.view[0];
let _e31: vec4<f32> = r_data.view[1];
let _e35: vec4<f32> = r_data.view[2];
let inv_model_view: mat3x3<f32> = transpose(mat3x3<f32>(_e27.xyz, _e31.xyz, _e35.xyz));
let _e40: mat4x4<f32> = r_data.proj_inv;
let unprojected: vec4<f32> = (_e40 * pos);
let e10: i32 = tmp1_;
let e16: i32 = tmp2_;
let pos: vec4<f32> = vec4<f32>(((f32(e10) * 4.0) - 1.0), ((f32(e16) * 4.0) - 1.0), 0.0, 1.0);
let e27: vec4<f32> = r_data.view[0];
let e31: vec4<f32> = r_data.view[1];
let e35: vec4<f32> = r_data.view[2];
let inv_model_view: mat3x3<f32> = transpose(mat3x3<f32>(e27.xyz, e31.xyz, e35.xyz));
let e40: mat4x4<f32> = r_data.proj_inv;
let unprojected: vec4<f32> = (e40 * pos);
return VertexOutput(pos, (inv_model_view * unprojected.xyz));
}
[[stage(fragment)]]
fn fs_main(in: VertexOutput) -> [[location(0)]] vec4<f32> {
let _e5: vec4<f32> = textureSample(r_texture, r_sampler, in.uv);
return _e5;
let e5: vec4<f32> = textureSample(r_texture, r_sampler, in.uv);
return e5;
}

18
tests/out/wgsl/swizzle_write-frag.wgsl
View File

@@ -1,15 +1,15 @@
fn main1() {
var x: vec3<f32> = vec3<f32>(2.0, 2.0, 2.0);
let _e3: vec3<f32> = x;
let _e8: vec2<f32> = vec2<f32>(3.0, 4.0);
x.z = _e8.x;
x.x = _e8.y;
let _e13: vec3<f32> = x;
let _e15: vec3<f32> = x;
let _e18: vec2<f32> = (_e15.xy * 5.0);
x.x = _e18.x;
x.y = _e18.y;
let e3: vec3<f32> = x;
let e8: vec2<f32> = vec2<f32>(3.0, 4.0);
x.z = e8.x;
x.x = e8.y;
let e13: vec3<f32> = x;
let e15: vec3<f32> = x;
let e18: vec2<f32> = (e15.xy * 5.0);
x.x = e18.x;
x.y = e18.y;
return;
}

8
tests/out/wgsl/texture-arg.wgsl
View File

@@ -4,12 +4,12 @@ var Texture: texture_2d<f32>;
var Sampler: sampler;
fn test(Passed_Texture: texture_2d<f32>, Passed_Sampler: sampler) -> vec4<f32> {
let _e7: vec4<f32> = textureSample(Passed_Texture, Passed_Sampler, vec2<f32>(0.0, 0.0));
return _e7;
let e7: vec4<f32> = textureSample(Passed_Texture, Passed_Sampler, vec2<f32>(0.0, 0.0));
return e7;
}
[[stage(fragment)]]
fn main() -> [[location(0)]] vec4<f32> {
let _e2: vec4<f32> = test(Texture, Sampler);
return _e2;
let e2: vec4<f32> = test(Texture, Sampler);
return e2;
}