diff --git a/src/front/glsl/functions.rs b/src/front/glsl/functions.rs
index 1db1b4bc88..acaa5c9759 100644
--- a/src/front/glsl/functions.rs
+++ b/src/front/glsl/functions.rs
@@ -115,7 +115,20 @@ impl Parser {
             TypeInner::Vector { size, kind, width } if vector_size.is_none() => {
                 ctx.implicit_conversion(self, &mut value, meta, kind, width)?;
 
-                ctx.add_expression(Expression::Splat { size, value }, meta, body)
+                if let TypeInner::Scalar { .. } = *self.resolve_type(ctx, value, expr_meta)? {
+                    ctx.add_expression(Expression::Splat { size, value }, meta, body)
+                } else {
+                    self.vector_constructor(
+                        ctx,
+                        body,
+                        ty,
+                        size,
+                        kind,
+                        width,
+                        &[(value, expr_meta)],
+                        meta,
+                    )?
+                }
             }
             TypeInner::Scalar { kind, width } => {
                 let mut expr = value;
@@ -393,6 +406,68 @@ impl Parser {
         Ok(ctx.add_expression(Expression::Compose { ty, components }, meta, body))
     }
 
+    #[allow(clippy::too_many_arguments)]
+    fn vector_constructor(
+        &mut self,
+        ctx: &mut Context,
+        body: &mut Block,
+        ty: Handle<Type>,
+        size: crate::VectorSize,
+        kind: ScalarKind,
+        width: crate::Bytes,
+        args: &[(Handle<Expression>, Span)],
+        meta: Span,
+    ) -> Result<Handle<Expression>> {
+        let mut components = Vec::with_capacity(size as usize);
+
+        for (mut arg, expr_meta) in args.iter().copied() {
+            ctx.implicit_conversion(self, &mut arg, expr_meta, kind, width)?;
+
+            if components.len() >= size as usize {
+                break;
+            }
+
+            match *self.resolve_type(ctx, arg, expr_meta)? {
+                TypeInner::Scalar { .. } => components.push(arg),
+                TypeInner::Matrix { rows, columns, .. } => {
+                    components.reserve(rows as usize * columns as usize);
+                    for c in 0..(columns as u32) {
+                        let base = ctx.add_expression(
+                            Expression::AccessIndex {
+                                base: arg,
+                                index: c,
+                            },
+                            expr_meta,
+                            body,
+                        );
+                        for r in 0..(rows as u32) {
+                            components.push(ctx.add_expression(
+                                Expression::AccessIndex { base, index: r },
+                                expr_meta,
+                                body,
+                            ))
+                        }
+                    }
+                }
+                TypeInner::Vector { size: ori_size, .. } => {
+                    components.reserve(ori_size as usize);
+                    for index in 0..(ori_size as u32) {
+                        components.push(ctx.add_expression(
+                            Expression::AccessIndex { base: arg, index },
+                            expr_meta,
+                            body,
+                        ))
+                    }
+                }
+                _ => components.push(arg),
+            }
+        }
+
+        components.truncate(size as usize);
+
+        Ok(ctx.add_expression(Expression::Compose { ty, components }, meta, body))
+    }
+
     fn constructor_many(
         &mut self,
         ctx: &mut Context,
@@ -457,15 +532,14 @@ impl Parser {
                     ))
                 }
             }
+            TypeInner::Vector { size, kind, width } => {
+                return self.vector_constructor(ctx, body, ty, size, kind, width, &args, meta)
+            }
             _ => {
-                for (mut arg, meta) in args.iter().copied() {
-                    let scalar_components = scalar_components(&self.module.types[ty].inner);
-                    if let Some((kind, width)) = scalar_components {
-                        ctx.implicit_conversion(self, &mut arg, meta, kind, width)?;
-                    }
-
-                    components.push(arg)
-                }
+                return Err(Error {
+                    kind: ErrorKind::SemanticError("Constructor: Too many arguments".into()),
+                    meta,
+                })
             }
         }
 
diff --git a/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl b/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl
index 61e6a013c6..7db8c99255 100644
--- a/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl
+++ b/tests/out/wgsl/210-bevy-2d-shader-vert.wgsl
@@ -37,11 +37,11 @@ fn main_1() {
     v_Uv = _e10;
     let _e11 = Vertex_Position_1;
     let _e12 = global_2.size;
-    position = (_e11 * vec3<f32>(_e12, 1.0));
-    let _e18 = global.ViewProj;
-    let _e19 = global_1.Model;
-    let _e21 = position;
-    gl_Position = ((_e18 * _e19) * vec4<f32>(_e21, 1.0));
+    position = (_e11 * vec3<f32>(_e12.x, _e12.y, 1.0));
+    let _e20 = global.ViewProj;
+    let _e21 = global_1.Model;
+    let _e23 = position;
+    gl_Position = ((_e20 * _e21) * vec4<f32>(_e23.x, _e23.y, _e23.z, 1.0));
     return;
 }
 
diff --git a/tests/out/wgsl/210-bevy-shader-vert.wgsl b/tests/out/wgsl/210-bevy-shader-vert.wgsl
index 2619b60641..94ccaea3e9 100644
--- a/tests/out/wgsl/210-bevy-shader-vert.wgsl
+++ b/tests/out/wgsl/210-bevy-shader-vert.wgsl
@@ -30,18 +30,18 @@ var<private> gl_Position: vec4<f32>;
 fn main_1() {
     let _e10 = global_1.Model;
     let _e11 = Vertex_Normal_1;
-    v_Normal = (_e10 * vec4<f32>(_e11, 1.0)).xyz;
-    let _e16 = global_1.Model;
-    let _e26 = Vertex_Normal_1;
-    v_Normal = (mat3x3<f32>(_e16[0].xyz, _e16[1].xyz, _e16[2].xyz) * _e26);
-    let _e28 = global_1.Model;
-    let _e29 = Vertex_Position_1;
-    v_Position = (_e28 * vec4<f32>(_e29, 1.0)).xyz;
-    let _e34 = Vertex_Uv_1;
-    v_Uv = _e34;
-    let _e36 = global.ViewProj;
-    let _e37 = v_Position;
-    gl_Position = (_e36 * vec4<f32>(_e37, 1.0));
+    v_Normal = (_e10 * vec4<f32>(_e11.x, _e11.y, _e11.z, 1.0)).xyz;
+    let _e19 = global_1.Model;
+    let _e29 = Vertex_Normal_1;
+    v_Normal = (mat3x3<f32>(_e19[0].xyz, _e19[1].xyz, _e19[2].xyz) * _e29);
+    let _e31 = global_1.Model;
+    let _e32 = Vertex_Position_1;
+    v_Position = (_e31 * vec4<f32>(_e32.x, _e32.y, _e32.z, 1.0)).xyz;
+    let _e40 = Vertex_Uv_1;
+    v_Uv = _e40;
+    let _e42 = global.ViewProj;
+    let _e43 = v_Position;
+    gl_Position = (_e42 * vec4<f32>(_e43.x, _e43.y, _e43.z, 1.0));
     return;
 }
 
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 febc5390f5..06fd0f486d 100644
--- a/tests/out/wgsl/800-out-of-bounds-panic-vert.wgsl
+++ b/tests/out/wgsl/800-out-of-bounds-panic-vert.wgsl
@@ -27,10 +27,10 @@ fn main_1() {
     let _e9 = global.view_matrix;
     let _e10 = global_1.world_matrix;
     let _e12 = position_1;
-    gl_Position = ((_e9 * _e10) * vec4<f32>(_e12, 0.0, 1.0));
-    let _e18 = gl_Position;
+    gl_Position = ((_e9 * _e10) * vec4<f32>(_e12.x, _e12.y, 0.0, 1.0));
     let _e20 = gl_Position;
-    gl_Position.z = ((_e18.z + _e20.w) / 2.0);
+    let _e22 = gl_Position;
+    gl_Position.z = ((_e20.z + _e22.w) / 2.0);
     return;
 }
 
diff --git a/tests/out/wgsl/bevy-pbr-vert.wgsl b/tests/out/wgsl/bevy-pbr-vert.wgsl
index b8ba3337bc..1863c9681b 100644
--- a/tests/out/wgsl/bevy-pbr-vert.wgsl
+++ b/tests/out/wgsl/bevy-pbr-vert.wgsl
@@ -35,21 +35,22 @@ fn main_1() {
 
     let _e12 = global_1.Model;
     let _e13 = Vertex_Position_1;
-    world_position = (_e12 * vec4<f32>(_e13, 1.0));
-    let _e18 = world_position;
-    v_WorldPosition = _e18.xyz;
-    let _e20 = global_1.Model;
-    let _e30 = Vertex_Normal_1;
-    v_WorldNormal = (mat3x3<f32>(_e20[0].xyz, _e20[1].xyz, _e20[2].xyz) * _e30);
-    let _e32 = Vertex_Uv_1;
-    v_Uv = _e32;
-    let _e33 = global_1.Model;
-    let _e43 = Vertex_Tangent_1;
+    world_position = (_e12 * vec4<f32>(_e13.x, _e13.y, _e13.z, 1.0));
+    let _e21 = world_position;
+    v_WorldPosition = _e21.xyz;
+    let _e23 = global_1.Model;
+    let _e33 = Vertex_Normal_1;
+    v_WorldNormal = (mat3x3<f32>(_e23[0].xyz, _e23[1].xyz, _e23[2].xyz) * _e33);
+    let _e35 = Vertex_Uv_1;
+    v_Uv = _e35;
+    let _e36 = global_1.Model;
     let _e46 = Vertex_Tangent_1;
-    v_WorldTangent = vec4<f32>((mat3x3<f32>(_e33[0].xyz, _e33[1].xyz, _e33[2].xyz) * _e43.xyz), _e46.w);
-    let _e50 = global.ViewProj;
-    let _e51 = world_position;
-    gl_Position = (_e50 * _e51);
+    let _e48 = (mat3x3<f32>(_e36[0].xyz, _e36[1].xyz, _e36[2].xyz) * _e46.xyz);
+    let _e49 = Vertex_Tangent_1;
+    v_WorldTangent = vec4<f32>(_e48.x, _e48.y, _e48.z, _e49.w);
+    let _e56 = global.ViewProj;
+    let _e57 = world_position;
+    gl_Position = (_e56 * _e57);
     return;
 }
 
diff --git a/tests/out/wgsl/clamp-splat-vert.wgsl b/tests/out/wgsl/clamp-splat-vert.wgsl
index 91df54d796..15cf4abbe5 100644
--- a/tests/out/wgsl/clamp-splat-vert.wgsl
+++ b/tests/out/wgsl/clamp-splat-vert.wgsl
@@ -7,7 +7,8 @@ var<private> gl_Position: vec4<f32>;
 
 fn main_1() {
     let _e5 = a_pos_1;
-    gl_Position = vec4<f32>(clamp(_e5, vec2<f32>(0.0), vec2<f32>(1.0)), 0.0, 1.0);
+    let _e10 = clamp(_e5, vec2<f32>(0.0), vec2<f32>(1.0));
+    gl_Position = vec4<f32>(_e10.x, _e10.y, 0.0, 1.0);
     return;
 }
 
diff --git a/tests/out/wgsl/quad_glsl-vert.wgsl b/tests/out/wgsl/quad_glsl-vert.wgsl
index 8f878abe64..5af301d959 100644
--- a/tests/out/wgsl/quad_glsl-vert.wgsl
+++ b/tests/out/wgsl/quad_glsl-vert.wgsl
@@ -12,7 +12,8 @@ fn main_1() {
     let _e4 = a_uv_1;
     v_uv = _e4;
     let _e6 = a_pos_1;
-    gl_Position = vec4<f32>((1.2000000476837158 * _e6), 0.0, 1.0);
+    let _e7 = (1.2000000476837158 * _e6);
+    gl_Position = vec4<f32>(_e7.x, _e7.y, 0.0, 1.0);
     return;
 }
 
diff --git a/tests/out/wgsl/samplers-frag.wgsl b/tests/out/wgsl/samplers-frag.wgsl
index 96e487cafb..a902c4e835 100644
--- a/tests/out/wgsl/samplers-frag.wgsl
+++ b/tests/out/wgsl/samplers-frag.wgsl
@@ -202,85 +202,85 @@ fn testTex2D(coord_4: vec2<f32>) {
     let _e80 = textureSampleBias(tex2D, samp, _e76, 2.0, vec2<i32>(5, 5));
     c_2 = _e80;
     let _e81 = coord_5;
-    let _e84 = coord_5;
-    let _e86 = vec3<f32>(_e84, 6.0);
-    let _e91 = textureSample(tex2D, samp, (_e86.xy / vec2<f32>(_e86.z)));
-    c_2 = _e91;
-    let _e92 = coord_5;
+    let _e86 = coord_5;
+    let _e90 = vec3<f32>(_e86.x, _e86.y, 6.0);
+    let _e95 = textureSample(tex2D, samp, (_e90.xy / vec2<f32>(_e90.z)));
+    c_2 = _e95;
     let _e96 = coord_5;
-    let _e99 = vec4<f32>(_e96, 0.0, 6.0);
-    let _e105 = textureSample(tex2D, samp, (_e99.xyz / vec3<f32>(_e99.w)).xy);
-    c_2 = _e105;
-    let _e106 = coord_5;
-    let _e110 = coord_5;
-    let _e112 = vec3<f32>(_e110, 6.0);
-    let _e118 = textureSampleBias(tex2D, samp, (_e112.xy / vec2<f32>(_e112.z)), 2.0);
-    c_2 = _e118;
-    let _e119 = coord_5;
-    let _e124 = coord_5;
-    let _e127 = vec4<f32>(_e124, 0.0, 6.0);
-    let _e134 = textureSampleBias(tex2D, samp, (_e127.xyz / vec3<f32>(_e127.w)).xy, 2.0);
-    c_2 = _e134;
-    let _e135 = coord_5;
-    let _e142 = coord_5;
-    let _e144 = vec3<f32>(_e142, 6.0);
-    let _e153 = textureSampleGrad(tex2D, samp, (_e144.xy / vec2<f32>(_e144.z)), vec2<f32>(4.0), vec2<f32>(4.0));
-    c_2 = _e153;
-    let _e154 = coord_5;
-    let _e162 = coord_5;
-    let _e165 = vec4<f32>(_e162, 0.0, 6.0);
-    let _e175 = textureSampleGrad(tex2D, samp, (_e165.xyz / vec3<f32>(_e165.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0));
-    c_2 = _e175;
-    let _e176 = coord_5;
-    let _e185 = coord_5;
-    let _e187 = vec3<f32>(_e185, 6.0);
-    let _e198 = textureSampleGrad(tex2D, samp, (_e187.xy / vec2<f32>(_e187.z)), vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
-    c_2 = _e198;
-    let _e199 = coord_5;
-    let _e209 = coord_5;
-    let _e212 = vec4<f32>(_e209, 0.0, 6.0);
-    let _e224 = textureSampleGrad(tex2D, samp, (_e212.xyz / vec3<f32>(_e212.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
-    c_2 = _e224;
-    let _e225 = coord_5;
-    let _e229 = coord_5;
-    let _e231 = vec3<f32>(_e229, 6.0);
-    let _e237 = textureSampleLevel(tex2D, samp, (_e231.xy / vec2<f32>(_e231.z)), 3.0);
-    c_2 = _e237;
-    let _e238 = coord_5;
-    let _e243 = coord_5;
-    let _e246 = vec4<f32>(_e243, 0.0, 6.0);
-    let _e253 = textureSampleLevel(tex2D, samp, (_e246.xyz / vec3<f32>(_e246.w)).xy, 3.0);
-    c_2 = _e253;
-    let _e254 = coord_5;
-    let _e260 = coord_5;
-    let _e262 = vec3<f32>(_e260, 6.0);
-    let _e270 = textureSampleLevel(tex2D, samp, (_e262.xy / vec2<f32>(_e262.z)), 3.0, vec2<i32>(5, 5));
-    c_2 = _e270;
-    let _e271 = coord_5;
-    let _e278 = coord_5;
-    let _e281 = vec4<f32>(_e278, 0.0, 6.0);
-    let _e290 = textureSampleLevel(tex2D, samp, (_e281.xyz / vec3<f32>(_e281.w)).xy, 3.0, vec2<i32>(5, 5));
-    c_2 = _e290;
-    let _e291 = coord_5;
-    let _e296 = coord_5;
-    let _e298 = vec3<f32>(_e296, 6.0);
-    let _e305 = textureSample(tex2D, samp, (_e298.xy / vec2<f32>(_e298.z)), vec2<i32>(5, 5));
-    c_2 = _e305;
-    let _e306 = coord_5;
-    let _e312 = coord_5;
-    let _e315 = vec4<f32>(_e312, 0.0, 6.0);
-    let _e323 = textureSample(tex2D, samp, (_e315.xyz / vec3<f32>(_e315.w)).xy, vec2<i32>(5, 5));
-    c_2 = _e323;
+    let _e102 = coord_5;
+    let _e107 = vec4<f32>(_e102.x, _e102.y, 0.0, 6.0);
+    let _e113 = textureSample(tex2D, samp, (_e107.xyz / vec3<f32>(_e107.w)).xy);
+    c_2 = _e113;
+    let _e114 = coord_5;
+    let _e120 = coord_5;
+    let _e124 = vec3<f32>(_e120.x, _e120.y, 6.0);
+    let _e130 = textureSampleBias(tex2D, samp, (_e124.xy / vec2<f32>(_e124.z)), 2.0);
+    c_2 = _e130;
+    let _e131 = coord_5;
+    let _e138 = coord_5;
+    let _e143 = vec4<f32>(_e138.x, _e138.y, 0.0, 6.0);
+    let _e150 = textureSampleBias(tex2D, samp, (_e143.xyz / vec3<f32>(_e143.w)).xy, 2.0);
+    c_2 = _e150;
+    let _e151 = coord_5;
+    let _e160 = coord_5;
+    let _e164 = vec3<f32>(_e160.x, _e160.y, 6.0);
+    let _e173 = textureSampleGrad(tex2D, samp, (_e164.xy / vec2<f32>(_e164.z)), vec2<f32>(4.0), vec2<f32>(4.0));
+    c_2 = _e173;
+    let _e174 = coord_5;
+    let _e184 = coord_5;
+    let _e189 = vec4<f32>(_e184.x, _e184.y, 0.0, 6.0);
+    let _e199 = textureSampleGrad(tex2D, samp, (_e189.xyz / vec3<f32>(_e189.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0));
+    c_2 = _e199;
+    let _e200 = coord_5;
+    let _e211 = coord_5;
+    let _e215 = vec3<f32>(_e211.x, _e211.y, 6.0);
+    let _e226 = textureSampleGrad(tex2D, samp, (_e215.xy / vec2<f32>(_e215.z)), vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
+    c_2 = _e226;
+    let _e227 = coord_5;
+    let _e239 = coord_5;
+    let _e244 = vec4<f32>(_e239.x, _e239.y, 0.0, 6.0);
+    let _e256 = textureSampleGrad(tex2D, samp, (_e244.xyz / vec3<f32>(_e244.w)).xy, vec2<f32>(4.0), vec2<f32>(4.0), vec2<i32>(5, 5));
+    c_2 = _e256;
+    let _e257 = coord_5;
+    let _e263 = coord_5;
+    let _e267 = vec3<f32>(_e263.x, _e263.y, 6.0);
+    let _e273 = textureSampleLevel(tex2D, samp, (_e267.xy / vec2<f32>(_e267.z)), 3.0);
+    c_2 = _e273;
+    let _e274 = coord_5;
+    let _e281 = coord_5;
+    let _e286 = vec4<f32>(_e281.x, _e281.y, 0.0, 6.0);
+    let _e293 = textureSampleLevel(tex2D, samp, (_e286.xyz / vec3<f32>(_e286.w)).xy, 3.0);
+    c_2 = _e293;
+    let _e294 = coord_5;
+    let _e302 = coord_5;
+    let _e306 = vec3<f32>(_e302.x, _e302.y, 6.0);
+    let _e314 = textureSampleLevel(tex2D, samp, (_e306.xy / vec2<f32>(_e306.z)), 3.0, vec2<i32>(5, 5));
+    c_2 = _e314;
+    let _e315 = coord_5;
     let _e324 = coord_5;
-    let _e330 = coord_5;
-    let _e332 = vec3<f32>(_e330, 6.0);
-    let _e340 = textureSampleBias(tex2D, samp, (_e332.xy / vec2<f32>(_e332.z)), 2.0, vec2<i32>(5, 5));
-    c_2 = _e340;
-    let _e341 = coord_5;
-    let _e348 = coord_5;
-    let _e351 = vec4<f32>(_e348, 0.0, 6.0);
-    let _e360 = textureSampleBias(tex2D, samp, (_e351.xyz / vec3<f32>(_e351.w)).xy, 2.0, vec2<i32>(5, 5));
-    c_2 = _e360;
+    let _e329 = vec4<f32>(_e324.x, _e324.y, 0.0, 6.0);
+    let _e338 = textureSampleLevel(tex2D, samp, (_e329.xyz / vec3<f32>(_e329.w)).xy, 3.0, vec2<i32>(5, 5));
+    c_2 = _e338;
+    let _e339 = coord_5;
+    let _e346 = coord_5;
+    let _e350 = vec3<f32>(_e346.x, _e346.y, 6.0);
+    let _e357 = textureSample(tex2D, samp, (_e350.xy / vec2<f32>(_e350.z)), vec2<i32>(5, 5));
+    c_2 = _e357;
+    let _e358 = coord_5;
+    let _e366 = coord_5;
+    let _e371 = vec4<f32>(_e366.x, _e366.y, 0.0, 6.0);
+    let _e379 = textureSample(tex2D, samp, (_e371.xyz / vec3<f32>(_e371.w)).xy, vec2<i32>(5, 5));
+    c_2 = _e379;
+    let _e380 = coord_5;
+    let _e388 = coord_5;
+    let _e392 = vec3<f32>(_e388.x, _e388.y, 6.0);
+    let _e400 = textureSampleBias(tex2D, samp, (_e392.xy / vec2<f32>(_e392.z)), 2.0, vec2<i32>(5, 5));
+    c_2 = _e400;
+    let _e401 = coord_5;
+    let _e410 = coord_5;
+    let _e415 = vec4<f32>(_e410.x, _e410.y, 0.0, 6.0);
+    let _e424 = textureSampleBias(tex2D, samp, (_e415.xyz / vec3<f32>(_e415.w)).xy, 2.0, vec2<i32>(5, 5));
+    c_2 = _e424;
     return;
 }
 
@@ -290,71 +290,71 @@ fn testTex2DShadow(coord_6: vec2<f32>) {
 
     coord_7 = coord_6;
     let _e17 = coord_7;
-    let _e20 = coord_7;
-    let _e22 = vec3<f32>(_e20, 1.0);
-    let _e25 = textureSampleCompare(tex2DShadow, sampShadow, _e22.xy, _e22.z);
-    d = _e25;
-    let _e26 = coord_7;
-    let _e33 = coord_7;
-    let _e35 = vec3<f32>(_e33, 1.0);
-    let _e42 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e35.xy, _e35.z);
-    d = _e42;
-    let _e43 = coord_7;
-    let _e52 = coord_7;
-    let _e54 = vec3<f32>(_e52, 1.0);
-    let _e63 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e54.xy, _e54.z, vec2<i32>(5, 5));
-    d = _e63;
-    let _e64 = coord_7;
-    let _e68 = coord_7;
-    let _e70 = vec3<f32>(_e68, 1.0);
-    let _e74 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e70.xy, _e70.z);
-    d = _e74;
-    let _e75 = coord_7;
-    let _e81 = coord_7;
-    let _e83 = vec3<f32>(_e81, 1.0);
-    let _e89 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e83.xy, _e83.z, vec2<i32>(5, 5));
-    d = _e89;
-    let _e90 = coord_7;
-    let _e95 = coord_7;
-    let _e97 = vec3<f32>(_e95, 1.0);
-    let _e102 = textureSampleCompare(tex2DShadow, sampShadow, _e97.xy, _e97.z, vec2<i32>(5, 5));
-    d = _e102;
-    let _e103 = coord_7;
-    let _e107 = coord_7;
-    let _e110 = vec4<f32>(_e107, 1.0, 6.0);
-    let _e114 = (_e110.xyz / vec3<f32>(_e110.w));
-    let _e117 = textureSampleCompare(tex2DShadow, sampShadow, _e114.xy, _e114.z);
-    d = _e117;
-    let _e118 = coord_7;
-    let _e126 = coord_7;
-    let _e129 = vec4<f32>(_e126, 1.0, 6.0);
-    let _e137 = (_e129.xyz / vec3<f32>(_e129.w));
-    let _e140 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e137.xy, _e137.z);
-    d = _e140;
-    let _e141 = coord_7;
-    let _e151 = coord_7;
-    let _e154 = vec4<f32>(_e151, 1.0, 6.0);
-    let _e164 = (_e154.xyz / vec3<f32>(_e154.w));
-    let _e167 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e164.xy, _e164.z, vec2<i32>(5, 5));
-    d = _e167;
-    let _e168 = coord_7;
+    let _e22 = coord_7;
+    let _e26 = vec3<f32>(_e22.x, _e22.y, 1.0);
+    let _e29 = textureSampleCompare(tex2DShadow, sampShadow, _e26.xy, _e26.z);
+    d = _e29;
+    let _e30 = coord_7;
+    let _e39 = coord_7;
+    let _e43 = vec3<f32>(_e39.x, _e39.y, 1.0);
+    let _e50 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e43.xy, _e43.z);
+    d = _e50;
+    let _e51 = coord_7;
+    let _e62 = coord_7;
+    let _e66 = vec3<f32>(_e62.x, _e62.y, 1.0);
+    let _e75 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e66.xy, _e66.z, vec2<i32>(5, 5));
+    d = _e75;
+    let _e76 = coord_7;
+    let _e82 = coord_7;
+    let _e86 = vec3<f32>(_e82.x, _e82.y, 1.0);
+    let _e90 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e86.xy, _e86.z);
+    d = _e90;
+    let _e91 = coord_7;
+    let _e99 = coord_7;
+    let _e103 = vec3<f32>(_e99.x, _e99.y, 1.0);
+    let _e109 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e103.xy, _e103.z, vec2<i32>(5, 5));
+    d = _e109;
+    let _e110 = coord_7;
+    let _e117 = coord_7;
+    let _e121 = vec3<f32>(_e117.x, _e117.y, 1.0);
+    let _e126 = textureSampleCompare(tex2DShadow, sampShadow, _e121.xy, _e121.z, vec2<i32>(5, 5));
+    d = _e126;
+    let _e127 = coord_7;
+    let _e133 = coord_7;
+    let _e138 = vec4<f32>(_e133.x, _e133.y, 1.0, 6.0);
+    let _e142 = (_e138.xyz / vec3<f32>(_e138.w));
+    let _e145 = textureSampleCompare(tex2DShadow, sampShadow, _e142.xy, _e142.z);
+    d = _e145;
+    let _e146 = coord_7;
+    let _e156 = coord_7;
+    let _e161 = vec4<f32>(_e156.x, _e156.y, 1.0, 6.0);
+    let _e169 = (_e161.xyz / vec3<f32>(_e161.w));
+    let _e172 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e169.xy, _e169.z);
+    d = _e172;
     let _e173 = coord_7;
-    let _e176 = vec4<f32>(_e173, 1.0, 6.0);
-    let _e181 = (_e176.xyz / vec3<f32>(_e176.w));
-    let _e184 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e181.xy, _e181.z);
-    d = _e184;
     let _e185 = coord_7;
-    let _e192 = coord_7;
-    let _e195 = vec4<f32>(_e192, 1.0, 6.0);
-    let _e202 = (_e195.xyz / vec3<f32>(_e195.w));
-    let _e205 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e202.xy, _e202.z, vec2<i32>(5, 5));
-    d = _e205;
-    let _e206 = coord_7;
-    let _e212 = coord_7;
-    let _e215 = vec4<f32>(_e212, 1.0, 6.0);
-    let _e221 = (_e215.xyz / vec3<f32>(_e215.w));
-    let _e224 = textureSampleCompare(tex2DShadow, sampShadow, _e221.xy, _e221.z, vec2<i32>(5, 5));
+    let _e190 = vec4<f32>(_e185.x, _e185.y, 1.0, 6.0);
+    let _e200 = (_e190.xyz / vec3<f32>(_e190.w));
+    let _e203 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e200.xy, _e200.z, vec2<i32>(5, 5));
+    d = _e203;
+    let _e204 = coord_7;
+    let _e211 = coord_7;
+    let _e216 = vec4<f32>(_e211.x, _e211.y, 1.0, 6.0);
+    let _e221 = (_e216.xyz / vec3<f32>(_e216.w));
+    let _e224 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e221.xy, _e221.z);
     d = _e224;
+    let _e225 = coord_7;
+    let _e234 = coord_7;
+    let _e239 = vec4<f32>(_e234.x, _e234.y, 1.0, 6.0);
+    let _e246 = (_e239.xyz / vec3<f32>(_e239.w));
+    let _e249 = textureSampleCompareLevel(tex2DShadow, sampShadow, _e246.xy, _e246.z, vec2<i32>(5, 5));
+    d = _e249;
+    let _e250 = coord_7;
+    let _e258 = coord_7;
+    let _e263 = vec4<f32>(_e258.x, _e258.y, 1.0, 6.0);
+    let _e269 = (_e263.xyz / vec3<f32>(_e263.w));
+    let _e272 = textureSampleCompare(tex2DShadow, sampShadow, _e269.xy, _e269.z, vec2<i32>(5, 5));
+    d = _e272;
     return;
 }
 
@@ -396,35 +396,35 @@ fn testTex2DArrayShadow(coord_10: vec3<f32>) {
 
     coord_11 = coord_10;
     let _e17 = coord_11;
-    let _e20 = coord_11;
-    let _e22 = vec4<f32>(_e20, 1.0);
-    let _e27 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e22.xy, i32(_e22.z), _e22.w);
-    d_1 = _e27;
-    let _e28 = coord_11;
-    let _e35 = coord_11;
-    let _e37 = vec4<f32>(_e35, 1.0);
-    let _e46 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e37.xy, i32(_e37.z), _e37.w);
-    d_1 = _e46;
-    let _e47 = coord_11;
-    let _e56 = coord_11;
-    let _e58 = vec4<f32>(_e56, 1.0);
-    let _e69 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e58.xy, i32(_e58.z), _e58.w, vec2<i32>(5, 5));
-    d_1 = _e69;
-    let _e70 = coord_11;
-    let _e74 = coord_11;
-    let _e76 = vec4<f32>(_e74, 1.0);
-    let _e82 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e76.xy, i32(_e76.z), _e76.w);
-    d_1 = _e82;
-    let _e83 = coord_11;
-    let _e89 = coord_11;
-    let _e91 = vec4<f32>(_e89, 1.0);
-    let _e99 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e91.xy, i32(_e91.z), _e91.w, vec2<i32>(5, 5));
-    d_1 = _e99;
-    let _e100 = coord_11;
-    let _e105 = coord_11;
-    let _e107 = vec4<f32>(_e105, 1.0);
-    let _e114 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e107.xy, i32(_e107.z), _e107.w, vec2<i32>(5, 5));
-    d_1 = _e114;
+    let _e23 = coord_11;
+    let _e28 = vec4<f32>(_e23.x, _e23.y, _e23.z, 1.0);
+    let _e33 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e28.xy, i32(_e28.z), _e28.w);
+    d_1 = _e33;
+    let _e34 = coord_11;
+    let _e44 = coord_11;
+    let _e49 = vec4<f32>(_e44.x, _e44.y, _e44.z, 1.0);
+    let _e58 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e49.xy, i32(_e49.z), _e49.w);
+    d_1 = _e58;
+    let _e59 = coord_11;
+    let _e71 = coord_11;
+    let _e76 = vec4<f32>(_e71.x, _e71.y, _e71.z, 1.0);
+    let _e87 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e76.xy, i32(_e76.z), _e76.w, vec2<i32>(5, 5));
+    d_1 = _e87;
+    let _e88 = coord_11;
+    let _e95 = coord_11;
+    let _e100 = vec4<f32>(_e95.x, _e95.y, _e95.z, 1.0);
+    let _e106 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e100.xy, i32(_e100.z), _e100.w);
+    d_1 = _e106;
+    let _e107 = coord_11;
+    let _e116 = coord_11;
+    let _e121 = vec4<f32>(_e116.x, _e116.y, _e116.z, 1.0);
+    let _e129 = textureSampleCompareLevel(tex2DArrayShadow, sampShadow, _e121.xy, i32(_e121.z), _e121.w, vec2<i32>(5, 5));
+    d_1 = _e129;
+    let _e130 = coord_11;
+    let _e138 = coord_11;
+    let _e143 = vec4<f32>(_e138.x, _e138.y, _e138.z, 1.0);
+    let _e150 = textureSampleCompare(tex2DArrayShadow, sampShadow, _e143.xy, i32(_e143.z), _e143.w, vec2<i32>(5, 5));
+    d_1 = _e150;
     return;
 }
 
@@ -463,30 +463,30 @@ fn testTexCubeShadow(coord_14: vec3<f32>) {
 
     coord_15 = coord_14;
     let _e17 = coord_15;
-    let _e20 = coord_15;
-    let _e22 = vec4<f32>(_e20, 1.0);
-    let _e25 = textureSampleCompare(texCubeShadow, sampShadow, _e22.xyz, _e22.w);
-    d_2 = _e25;
-    let _e26 = coord_15;
-    let _e33 = coord_15;
-    let _e35 = vec4<f32>(_e33, 1.0);
-    let _e42 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e35.xyz, _e35.w);
-    d_2 = _e42;
-    let _e43 = coord_15;
-    let _e47 = coord_15;
-    let _e49 = vec4<f32>(_e47, 1.0);
-    let _e53 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e49.xyz, _e49.w);
-    d_2 = _e53;
-    let _e54 = coord_15;
-    let _e60 = coord_15;
-    let _e62 = vec4<f32>(_e60, 1.0);
-    let _e68 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e62.xyz, _e62.w, vec3<i32>(5, 5, 5));
-    d_2 = _e68;
-    let _e69 = coord_15;
-    let _e74 = coord_15;
-    let _e76 = vec4<f32>(_e74, 1.0);
-    let _e81 = textureSampleCompare(texCubeShadow, sampShadow, _e76.xyz, _e76.w, vec3<i32>(5, 5, 5));
-    d_2 = _e81;
+    let _e23 = coord_15;
+    let _e28 = vec4<f32>(_e23.x, _e23.y, _e23.z, 1.0);
+    let _e31 = textureSampleCompare(texCubeShadow, sampShadow, _e28.xyz, _e28.w);
+    d_2 = _e31;
+    let _e32 = coord_15;
+    let _e42 = coord_15;
+    let _e47 = vec4<f32>(_e42.x, _e42.y, _e42.z, 1.0);
+    let _e54 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e47.xyz, _e47.w);
+    d_2 = _e54;
+    let _e55 = coord_15;
+    let _e62 = coord_15;
+    let _e67 = vec4<f32>(_e62.x, _e62.y, _e62.z, 1.0);
+    let _e71 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e67.xyz, _e67.w);
+    d_2 = _e71;
+    let _e72 = coord_15;
+    let _e81 = coord_15;
+    let _e86 = vec4<f32>(_e81.x, _e81.y, _e81.z, 1.0);
+    let _e92 = textureSampleCompareLevel(texCubeShadow, sampShadow, _e86.xyz, _e86.w, vec3<i32>(5, 5, 5));
+    d_2 = _e92;
+    let _e93 = coord_15;
+    let _e101 = coord_15;
+    let _e106 = vec4<f32>(_e101.x, _e101.y, _e101.z, 1.0);
+    let _e111 = textureSampleCompare(texCubeShadow, sampShadow, _e106.xyz, _e106.w, vec3<i32>(5, 5, 5));
+    d_2 = _e111;
     return;
 }