gl-transitions 1.74.0 → 1.76.0

package/wgsl/undulatingBurnOut.wgsl

@@ -0,0 +1,181 @@
+// undulatingBurnOut — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/undulatingBurnOut.glsl
+// Author: pthrasher
+// License: MIT
+// Description: A circle with a wavy edge burns out from the center to reveal the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    smoothness: f32,
+    center: vec2<f32>,
+    color: vec3<f32>,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e37 = (*uv)[0u];
+    let _e39 = (*uv)[1u];
+    let _e42 = textureSampleLevel(_to, _sampler, vec2<f32>(_e37, (1f - _e39)), 0f);
+    return _e42;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e37 = (*uv_1)[0u];
+    let _e39 = (*uv_1)[1u];
+    let _e42 = textureSampleLevel(_from, _sampler, vec2<f32>(_e37, (1f - _e39)), 0f);
+    return _e42;
+}
+
+fn getGradient(r: ptr<function, f32>, dist: ptr<function, f32>) -> f32 {
+    var d: f32;
+
+    let _e38 = (*r);
+    let _e39 = (*dist);
+    d = (_e38 - _e39);
+    let _e42 = uniforms.smoothness;
+    let _e44 = (*r);
+    let _e45 = (*dist);
+    let _e47 = uniforms.smoothness;
+    let _e52 = d;
+    let _e55 = d;
+    let _e57 = d;
+    return mix(smoothstep(-(_e42), 0f, (_e44 - (_e45 * (1f + _e47)))), (-1f - step(0.005f, _e52)), (step(-0.005f, _e55) * step(_e57, 0.01f)));
+}
+
+fn quadraticInOut(t: ptr<function, f32>) -> f32 {
+    var p: f32;
+    var local: f32;
+
+    let _e38 = (*t);
+    let _e40 = (*t);
+    p = ((2f * _e38) * _e40);
+    let _e42 = (*t);
+    if (_e42 < 0.5f) {
+        let _e44 = p;
+        local = _e44;
+    } else {
+        let _e45 = p;
+        let _e47 = (*t);
+        local = ((-(_e45) + (4f * _e47)) - 1f);
+    }
+    let _e51 = local;
+    return _e51;
+}
+
+fn getWave(p_1: ptr<function, vec2<f32>>) -> f32 {
+    var _p: vec2<f32>;
+    var rads: f32;
+    var degs: f32;
+    var range: vec2<f32>;
+    var domain: vec2<f32>;
+    var ratio: f32;
+    var x: f32;
+    var magnitude: f32;
+    var offset: f32;
+    var ease_degs: f32;
+    var param: f32;
+    var deg_wave_pos: f32;
+
+    let _e48 = (*p_1);
+    let _e50 = uniforms.center;
+    _p = (_e48 - _e50);
+    let _e53 = _p[1u];
+    let _e55 = _p[0u];
+    rads = atan2(_e53, _e55);
+    let _e57 = rads;
+    degs = (degrees(_e57) + 180f);
+    range = vec2<f32>(0f, 94.24778f);
+    domain = vec2<f32>(0f, 360f);
+    ratio = 0.2617994f;
+    let _e60 = degs;
+    let _e61 = ratio;
+    degs = (_e60 * _e61);
+    let _e64 = uniforms.progress;
+    x = _e64;
+    let _e65 = x;
+    magnitude = mix(0.02f, 0.09f, smoothstep(0f, 1f, _e65));
+    let _e68 = x;
+    offset = mix(40f, 30f, smoothstep(0f, 1f, _e68));
+    let _e71 = degs;
+    param = sin(_e71);
+    let _e73 = quadraticInOut((&param));
+    ease_degs = _e73;
+    let _e74 = ease_degs;
+    let _e75 = magnitude;
+    let _e77 = x;
+    let _e78 = offset;
+    deg_wave_pos = ((_e74 * _e75) * sin((_e77 * _e78)));
+    let _e82 = x;
+    let _e84 = uniforms.smoothness;
+    let _e86 = x;
+    let _e91 = deg_wave_pos;
+    return ((_e82 - (max(_e84, 0.01f) * (1f - smoothstep(0f, 0.1f, _e86)))) + _e91);
+}
+
+fn transition(p_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var dist_1: f32;
+    var m: f32;
+    var param_1: vec2<f32>;
+    var param_2: f32;
+    var param_3: f32;
+    var cfrom: vec4<f32>;
+    var param_4: vec2<f32>;
+    var cto: vec4<f32>;
+    var param_5: vec2<f32>;
+
+    let _e46 = uniforms.center;
+    let _e47 = (*p_2);
+    dist_1 = distance(_e46, _e47);
+    let _e49 = (*p_2);
+    param_1 = _e49;
+    let _e50 = getWave((&param_1));
+    param_2 = _e50;
+    let _e51 = dist_1;
+    param_3 = _e51;
+    let _e52 = getGradient((&param_2), (&param_3));
+    m = _e52;
+    let _e53 = (*p_2);
+    param_4 = _e53;
+    let _e54 = getFromColor((&param_4));
+    cfrom = _e54;
+    let _e55 = (*p_2);
+    param_5 = _e55;
+    let _e56 = getToColor((&param_5));
+    cto = _e56;
+    let _e57 = cfrom;
+    let _e58 = cto;
+    let _e59 = m;
+    let _e62 = cfrom;
+    let _e64 = uniforms.color;
+    let _e71 = m;
+    return mix(mix(_e57, _e58, vec4(_e59)), mix(_e62, vec4<f32>(_e64.x, _e64.y, _e64.z, 1f), vec4(0.75f)), vec4(step(_e71, -2f)));
+}
+
+fn main_1() {
+    var param_6: vec2<f32>;
+
+    let _e36 = _uv_1;
+    param_6 = _e36;
+    let _e37 = transition((&param_6));
+    _fragColor = _e37;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/wind.wgsl

@@ -0,0 +1,101 @@
+// wind — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wind.glsl
+// Author: gre
+// License: MIT
+// Description: A ragged left-to-right wipe, as if the image was blown away by the wind
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    size: f32,
+    reversed: i32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e19 = (*uv)[0u];
+    let _e21 = (*uv)[1u];
+    let _e24 = textureSampleLevel(_to, _sampler, vec2<f32>(_e19, (1f - _e21)), 0f);
+    return _e24;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e19 = (*uv_1)[0u];
+    let _e21 = (*uv_1)[1u];
+    let _e24 = textureSampleLevel(_from, _sampler, vec2<f32>(_e19, (1f - _e21)), 0f);
+    return _e24;
+}
+
+fn rand(co: ptr<function, vec2<f32>>) -> f32 {
+    let _e18 = (*co);
+    return fract((sin(dot(_e18, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var x: f32;
+    var local: f32;
+    var r: f32;
+    var param: vec2<f32>;
+    var m: f32;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e26 = uniforms.reversed;
+    if (_e26 != 0i) {
+        let _e29 = (*uv_2)[0u];
+        local = (1f - _e29);
+    } else {
+        let _e32 = (*uv_2)[0u];
+        local = _e32;
+    }
+    let _e33 = local;
+    x = _e33;
+    let _e35 = (*uv_2)[1u];
+    param = vec2<f32>(0f, _e35);
+    let _e37 = rand((&param));
+    r = _e37;
+    let _e39 = uniforms.size;
+    let _e41 = x;
+    let _e43 = uniforms.size;
+    let _e47 = uniforms.size;
+    let _e48 = r;
+    let _e52 = uniforms.progress;
+    let _e54 = uniforms.size;
+    m = smoothstep(0f, -(_e39), (((_e41 * (1f - _e43)) + (_e47 * _e48)) - (_e52 * (1f + _e54))));
+    let _e59 = (*uv_2);
+    param_1 = _e59;
+    let _e60 = getFromColor((&param_1));
+    let _e61 = (*uv_2);
+    param_2 = _e61;
+    let _e62 = getToColor((&param_2));
+    let _e63 = m;
+    return mix(_e60, _e62, vec4(_e63));
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e18 = _uv_1;
+    param_3 = _e18;
+    let _e19 = transition((&param_3));
+    _fragColor = _e19;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/windowblinds.wgsl

@@ -0,0 +1,79 @@
+// windowblinds — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/windowblinds.glsl
+// Author: Fabien Benetou
+// License: MIT
+// Description: A crossfade through horizontal window blinds
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e17 = (*uv)[0u];
+    let _e19 = (*uv)[1u];
+    let _e22 = textureSampleLevel(_to, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e17 = (*uv_1)[0u];
+    let _e19 = (*uv_1)[1u];
+    let _e22 = textureSampleLevel(_from, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var t: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e20 = uniforms.progress;
+    t = _e20;
+    let _e22 = (*uv_2)[1u];
+    let _e25 = uniforms.progress;
+    let _e27 = floor(((_e22 * 100f) * _e25));
+    if ((_e27 - (floor((_e27 / 2f)) * 2f)) == 0f) {
+        let _e33 = t;
+        t = (_e33 * 1.5f);
+    }
+    let _e35 = (*uv_2);
+    param = _e35;
+    let _e36 = getFromColor((&param));
+    let _e37 = (*uv_2);
+    param_1 = _e37;
+    let _e38 = getToColor((&param_1));
+    let _e39 = t;
+    let _e41 = uniforms.progress;
+    let _e43 = uniforms.progress;
+    return mix(_e36, _e38, vec4(mix(_e39, _e41, smoothstep(0.8f, 1f, _e43))));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e16 = _uv_1;
+    param_2 = _e16;
+    let _e17 = transition((&param_2));
+    _fragColor = _e17;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/windowslice.wgsl

@@ -0,0 +1,80 @@
+// windowslice — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/windowslice.glsl
+// Author: gre
+// License: MIT
+// Description: The incoming image appears through vertical slices that widen
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    count: f32,
+    smoothness: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e15 = (*uv)[0u];
+    let _e17 = (*uv)[1u];
+    let _e20 = textureSampleLevel(_to, _sampler, vec2<f32>(_e15, (1f - _e17)), 0f);
+    return _e20;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e15 = (*uv_1)[0u];
+    let _e17 = (*uv_1)[1u];
+    let _e20 = textureSampleLevel(_from, _sampler, vec2<f32>(_e15, (1f - _e17)), 0f);
+    return _e20;
+}
+
+fn transition(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var pr: f32;
+    var s: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e19 = uniforms.smoothness;
+    let _e22 = (*p)[0u];
+    let _e24 = uniforms.progress;
+    let _e26 = uniforms.smoothness;
+    pr = smoothstep(-(_e19), 0f, (_e22 - (_e24 * (1f + _e26))));
+    let _e31 = pr;
+    let _e33 = uniforms.count;
+    let _e35 = (*p)[0u];
+    s = step(_e31, fract((_e33 * _e35)));
+    let _e39 = (*p);
+    param = _e39;
+    let _e40 = getFromColor((&param));
+    let _e41 = (*p);
+    param_1 = _e41;
+    let _e42 = getToColor((&param_1));
+    let _e43 = s;
+    return mix(_e40, _e42, vec4(_e43));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e14 = _uv_1;
+    param_2 = _e14;
+    let _e15 = transition((&param_2));
+    _fragColor = _e15;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/wipeDown.wgsl

@@ -0,0 +1,77 @@
+// wipeDown — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeDown.glsl
+// Author: Jake Nelson
+// License: MIT
+// Description: A hard-edged wipe from top to bottom
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv)[0u];
+    let _e16 = (*uv)[1u];
+    let _e19 = textureSampleLevel(_to, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv_1)[0u];
+    let _e16 = (*uv_1)[1u];
+    let _e19 = textureSampleLevel(_from, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p: vec2<f32>;
+    var a: vec4<f32>;
+    var param: vec2<f32>;
+    var b: vec4<f32>;
+    var param_1: vec2<f32>;
+
+    let _e18 = (*uv_2);
+    p = (_e18 / vec2<f32>(1f, 1f));
+    let _e20 = p;
+    param = _e20;
+    let _e21 = getFromColor((&param));
+    a = _e21;
+    let _e22 = p;
+    param_1 = _e22;
+    let _e23 = getToColor((&param_1));
+    b = _e23;
+    let _e24 = a;
+    let _e25 = b;
+    let _e27 = p[1u];
+    let _e30 = uniforms.progress;
+    return mix(_e24, _e25, vec4(step((1f - _e27), _e30)));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e13 = _uv_1;
+    param_2 = _e13;
+    let _e14 = transition((&param_2));
+    _fragColor = _e14;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/wipeLeft.wgsl

@@ -0,0 +1,77 @@
+// wipeLeft — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeLeft.glsl
+// Author: Jake Nelson
+// License: MIT
+// Description: A hard-edged wipe from right to left
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv)[0u];
+    let _e16 = (*uv)[1u];
+    let _e19 = textureSampleLevel(_to, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv_1)[0u];
+    let _e16 = (*uv_1)[1u];
+    let _e19 = textureSampleLevel(_from, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p: vec2<f32>;
+    var a: vec4<f32>;
+    var param: vec2<f32>;
+    var b: vec4<f32>;
+    var param_1: vec2<f32>;
+
+    let _e18 = (*uv_2);
+    p = (_e18 / vec2<f32>(1f, 1f));
+    let _e20 = p;
+    param = _e20;
+    let _e21 = getFromColor((&param));
+    a = _e21;
+    let _e22 = p;
+    param_1 = _e22;
+    let _e23 = getToColor((&param_1));
+    b = _e23;
+    let _e24 = a;
+    let _e25 = b;
+    let _e27 = p[0u];
+    let _e30 = uniforms.progress;
+    return mix(_e24, _e25, vec4(step((1f - _e27), _e30)));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e13 = _uv_1;
+    param_2 = _e13;
+    let _e14 = transition((&param_2));
+    _fragColor = _e14;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}

package/wgsl/wipeRight.wgsl

@@ -0,0 +1,77 @@
+// wipeRight — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeRight.glsl
+// Author: Jake Nelson
+// License: MIT
+// Description: A hard-edged wipe from left to right
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+}
+
+@group(0) @binding(2) 
+var _from: texture_2d<f32>;
+@group(0) @binding(1) 
+var _sampler: sampler;
+@group(0) @binding(3) 
+var _to: texture_2d<f32>;
+@group(0) @binding(0) 
+var<uniform> uniforms: Uniforms;
+var<private> _fragColor: vec4<f32>;
+var<private> _uv_1: vec2<f32>;
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv)[0u];
+    let _e16 = (*uv)[1u];
+    let _e19 = textureSampleLevel(_to, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv_1)[0u];
+    let _e16 = (*uv_1)[1u];
+    let _e19 = textureSampleLevel(_from, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p: vec2<f32>;
+    var a: vec4<f32>;
+    var param: vec2<f32>;
+    var b: vec4<f32>;
+    var param_1: vec2<f32>;
+
+    let _e18 = (*uv_2);
+    p = (_e18 / vec2<f32>(1f, 1f));
+    let _e20 = p;
+    param = _e20;
+    let _e21 = getFromColor((&param));
+    a = _e21;
+    let _e22 = p;
+    param_1 = _e22;
+    let _e23 = getToColor((&param_1));
+    b = _e23;
+    let _e24 = a;
+    let _e25 = b;
+    let _e27 = p[0u];
+    let _e30 = uniforms.progress;
+    return mix(_e24, _e25, vec4(step((0f + _e27), _e30)));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e13 = _uv_1;
+    param_2 = _e13;
+    let _e14 = transition((&param_2));
+    _fragColor = _e14;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}