gl-transitions 1.74.0 → 1.76.0

package/wgsl/DefocusBlur.wgsl

@@ -0,0 +1,269 @@
+// DefocusBlur — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DefocusBlur.glsl
+// Author: Sergey Kosarevsky
+// License: MIT
+// Description: A crossfade through an out-of-focus blur
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    blurSize: 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 _e52 = (*uv)[0u];
+    let _e54 = (*uv)[1u];
+    let _e57 = textureSampleLevel(_to, _sampler, vec2<f32>(_e52, (1f - _e54)), 0f);
+    return _e57;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e52 = (*uv_1)[0u];
+    let _e54 = (*uv_1)[1u];
+    let _e57 = textureSampleLevel(_from, _sampler, vec2<f32>(_e52, (1f - _e54)), 0f);
+    return _e57;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var T: f32;
+    var half: f32;
+    var D: f32;
+    var local: f32;
+    var C0_: vec4<f32>;
+    var param: vec2<f32>;
+    var C1_: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var param_4: vec2<f32>;
+    var param_5: vec2<f32>;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+    var param_8: vec2<f32>;
+    var param_9: vec2<f32>;
+    var param_10: vec2<f32>;
+    var param_11: vec2<f32>;
+    var param_12: vec2<f32>;
+    var param_13: vec2<f32>;
+    var param_14: vec2<f32>;
+    var param_15: vec2<f32>;
+    var param_16: vec2<f32>;
+    var param_17: vec2<f32>;
+    var param_18: vec2<f32>;
+    var param_19: vec2<f32>;
+    var param_20: vec2<f32>;
+    var param_21: vec2<f32>;
+    var param_22: vec2<f32>;
+    var param_23: vec2<f32>;
+    var param_24: vec2<f32>;
+    var param_25: vec2<f32>;
+
+    let _e84 = uniforms.progress;
+    T = _e84;
+    half = 0.5f;
+    let _e85 = T;
+    let _e86 = half;
+    if (_e85 < _e86) {
+        let _e89 = uniforms.blurSize;
+        let _e90 = T;
+        let _e91 = half;
+        local = mix(0f, _e89, (_e90 / _e91));
+    } else {
+        let _e95 = uniforms.blurSize;
+        let _e96 = T;
+        let _e97 = half;
+        let _e99 = half;
+        local = mix(_e95, 0f, ((_e96 - _e97) / _e99));
+    }
+    let _e102 = local;
+    D = _e102;
+    let _e103 = (*uv_2);
+    param = _e103;
+    let _e104 = getFromColor((&param));
+    C0_ = _e104;
+    let _e105 = (*uv_2);
+    param_1 = _e105;
+    let _e106 = getToColor((&param_1));
+    C1_ = _e106;
+    let _e107 = D;
+    let _e109 = (*uv_2);
+    param_2 = ((vec2<f32>(-0.326f, -0.406f) * _e107) + _e109);
+    let _e111 = getFromColor((&param_2));
+    let _e112 = C0_;
+    C0_ = (_e112 + _e111);
+    let _e114 = D;
+    let _e116 = (*uv_2);
+    param_3 = ((vec2<f32>(-0.326f, -0.406f) * _e114) + _e116);
+    let _e118 = getToColor((&param_3));
+    let _e119 = C1_;
+    C1_ = (_e119 + _e118);
+    let _e121 = D;
+    let _e123 = (*uv_2);
+    param_4 = ((vec2<f32>(-0.84f, -0.074f) * _e121) + _e123);
+    let _e125 = getFromColor((&param_4));
+    let _e126 = C0_;
+    C0_ = (_e126 + _e125);
+    let _e128 = D;
+    let _e130 = (*uv_2);
+    param_5 = ((vec2<f32>(-0.84f, -0.074f) * _e128) + _e130);
+    let _e132 = getToColor((&param_5));
+    let _e133 = C1_;
+    C1_ = (_e133 + _e132);
+    let _e135 = D;
+    let _e137 = (*uv_2);
+    param_6 = ((vec2<f32>(-0.696f, 0.457f) * _e135) + _e137);
+    let _e139 = getFromColor((&param_6));
+    let _e140 = C0_;
+    C0_ = (_e140 + _e139);
+    let _e142 = D;
+    let _e144 = (*uv_2);
+    param_7 = ((vec2<f32>(-0.696f, 0.457f) * _e142) + _e144);
+    let _e146 = getToColor((&param_7));
+    let _e147 = C1_;
+    C1_ = (_e147 + _e146);
+    let _e149 = D;
+    let _e151 = (*uv_2);
+    param_8 = ((vec2<f32>(-0.203f, 0.621f) * _e149) + _e151);
+    let _e153 = getFromColor((&param_8));
+    let _e154 = C0_;
+    C0_ = (_e154 + _e153);
+    let _e156 = D;
+    let _e158 = (*uv_2);
+    param_9 = ((vec2<f32>(-0.203f, 0.621f) * _e156) + _e158);
+    let _e160 = getToColor((&param_9));
+    let _e161 = C1_;
+    C1_ = (_e161 + _e160);
+    let _e163 = D;
+    let _e165 = (*uv_2);
+    param_10 = ((vec2<f32>(0.962f, -0.195f) * _e163) + _e165);
+    let _e167 = getFromColor((&param_10));
+    let _e168 = C0_;
+    C0_ = (_e168 + _e167);
+    let _e170 = D;
+    let _e172 = (*uv_2);
+    param_11 = ((vec2<f32>(0.962f, -0.195f) * _e170) + _e172);
+    let _e174 = getToColor((&param_11));
+    let _e175 = C1_;
+    C1_ = (_e175 + _e174);
+    let _e177 = D;
+    let _e179 = (*uv_2);
+    param_12 = ((vec2<f32>(0.473f, -0.48f) * _e177) + _e179);
+    let _e181 = getFromColor((&param_12));
+    let _e182 = C0_;
+    C0_ = (_e182 + _e181);
+    let _e184 = D;
+    let _e186 = (*uv_2);
+    param_13 = ((vec2<f32>(0.473f, -0.48f) * _e184) + _e186);
+    let _e188 = getToColor((&param_13));
+    let _e189 = C1_;
+    C1_ = (_e189 + _e188);
+    let _e191 = D;
+    let _e193 = (*uv_2);
+    param_14 = ((vec2<f32>(0.519f, 0.767f) * _e191) + _e193);
+    let _e195 = getFromColor((&param_14));
+    let _e196 = C0_;
+    C0_ = (_e196 + _e195);
+    let _e198 = D;
+    let _e200 = (*uv_2);
+    param_15 = ((vec2<f32>(0.519f, 0.767f) * _e198) + _e200);
+    let _e202 = getToColor((&param_15));
+    let _e203 = C1_;
+    C1_ = (_e203 + _e202);
+    let _e205 = D;
+    let _e207 = (*uv_2);
+    param_16 = ((vec2<f32>(0.185f, -0.893f) * _e205) + _e207);
+    let _e209 = getFromColor((&param_16));
+    let _e210 = C0_;
+    C0_ = (_e210 + _e209);
+    let _e212 = D;
+    let _e214 = (*uv_2);
+    param_17 = ((vec2<f32>(0.185f, -0.893f) * _e212) + _e214);
+    let _e216 = getToColor((&param_17));
+    let _e217 = C1_;
+    C1_ = (_e217 + _e216);
+    let _e219 = D;
+    let _e221 = (*uv_2);
+    param_18 = ((vec2<f32>(0.507f, 0.064f) * _e219) + _e221);
+    let _e223 = getFromColor((&param_18));
+    let _e224 = C0_;
+    C0_ = (_e224 + _e223);
+    let _e226 = D;
+    let _e228 = (*uv_2);
+    param_19 = ((vec2<f32>(0.507f, 0.064f) * _e226) + _e228);
+    let _e230 = getToColor((&param_19));
+    let _e231 = C1_;
+    C1_ = (_e231 + _e230);
+    let _e233 = D;
+    let _e235 = (*uv_2);
+    param_20 = ((vec2<f32>(0.896f, 0.412f) * _e233) + _e235);
+    let _e237 = getFromColor((&param_20));
+    let _e238 = C0_;
+    C0_ = (_e238 + _e237);
+    let _e240 = D;
+    let _e242 = (*uv_2);
+    param_21 = ((vec2<f32>(0.896f, 0.412f) * _e240) + _e242);
+    let _e244 = getToColor((&param_21));
+    let _e245 = C1_;
+    C1_ = (_e245 + _e244);
+    let _e247 = D;
+    let _e249 = (*uv_2);
+    param_22 = ((vec2<f32>(-0.322f, -0.933f) * _e247) + _e249);
+    let _e251 = getFromColor((&param_22));
+    let _e252 = C0_;
+    C0_ = (_e252 + _e251);
+    let _e254 = D;
+    let _e256 = (*uv_2);
+    param_23 = ((vec2<f32>(-0.322f, -0.933f) * _e254) + _e256);
+    let _e258 = getToColor((&param_23));
+    let _e259 = C1_;
+    C1_ = (_e259 + _e258);
+    let _e261 = D;
+    let _e263 = (*uv_2);
+    param_24 = ((vec2<f32>(-0.792f, -0.598f) * _e261) + _e263);
+    let _e265 = getFromColor((&param_24));
+    let _e266 = C0_;
+    C0_ = (_e266 + _e265);
+    let _e268 = D;
+    let _e270 = (*uv_2);
+    param_25 = ((vec2<f32>(-0.792f, -0.598f) * _e268) + _e270);
+    let _e272 = getToColor((&param_25));
+    let _e273 = C1_;
+    C1_ = (_e273 + _e272);
+    let _e275 = C0_;
+    C0_ = (_e275 / vec4(13f));
+    let _e278 = C1_;
+    C1_ = (_e278 / vec4(13f));
+    let _e281 = C0_;
+    let _e282 = C1_;
+    let _e283 = T;
+    return mix(_e281, _e282, vec4(_e283));
+}
+
+fn main_1() {
+    var param_26: vec2<f32>;
+
+    let _e51 = _uv_1;
+    param_26 = _e51;
+    let _e52 = transition((&param_26));
+    _fragColor = _e52;
+    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/Directional.wgsl

@@ -0,0 +1,79 @@
+// Directional — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Directional.glsl
+// Author: Gaëtan Renaudeau
+// License: MIT
+// Description: The incoming image pushes the outgoing one out in a given direction
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    direction: vec2<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 getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv)[0u];
+    let _e16 = (*uv)[1u];
+    let _e19 = textureSampleLevel(_from, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e14 = (*uv_1)[0u];
+    let _e16 = (*uv_1)[1u];
+    let _e19 = textureSampleLevel(_to, _sampler, vec2<f32>(_e14, (1f - _e16)), 0f);
+    return _e19;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p: vec2<f32>;
+    var f: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e17 = (*uv_2);
+    let _e19 = uniforms.progress;
+    let _e21 = uniforms.direction;
+    p = (_e17 + (sign(_e21) * _e19));
+    let _e25 = p;
+    f = fract(_e25);
+    let _e27 = f;
+    param = _e27;
+    let _e28 = getToColor((&param));
+    let _e29 = f;
+    param_1 = _e29;
+    let _e30 = getFromColor((&param_1));
+    let _e32 = p[1u];
+    let _e35 = p[1u];
+    let _e39 = p[0u];
+    let _e43 = p[0u];
+    return mix(_e28, _e30, vec4((((step(0f, _e32) * step(_e35, 1f)) * step(0f, _e39)) * step(_e43, 1f))));
+}
+
+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/DirectionalScaled.wgsl

@@ -0,0 +1,117 @@
+// DirectionalScaled — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DirectionalScaled.glsl
+// Author: Thibaut Foussard
+// License: MIT
+// Description: Like Directional, with both images scaled down while they slide
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    direction: vec2<f32>,
+    scale: 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 getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e19 = (*uv)[0u];
+    let _e21 = (*uv)[1u];
+    let _e24 = textureSampleLevel(_from, _sampler, vec2<f32>(_e19, (1f - _e21)), 0f);
+    return _e24;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e19 = (*uv_1)[0u];
+    let _e21 = (*uv_1)[1u];
+    let _e24 = textureSampleLevel(_to, _sampler, vec2<f32>(_e19, (1f - _e21)), 0f);
+    return _e24;
+}
+
+fn parabola(x: ptr<function, f32>) -> f32 {
+    var y: f32;
+
+    let _e19 = (*x);
+    y = pow(sin((_e19 * 3.1415927f)), 1f);
+    let _e23 = y;
+    return _e23;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var easedProgress: f32;
+    var p: vec2<f32>;
+    var f: vec2<f32>;
+    var s: f32;
+    var param: f32;
+    var mixer: f32;
+    var col: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var border: f32;
+
+    let _e29 = uniforms.progress;
+    easedProgress = pow(sin(((_e29 * 3.1415927f) / 2f)), 3f);
+    let _e34 = (*uv_2);
+    let _e35 = easedProgress;
+    let _e37 = uniforms.direction;
+    p = (_e34 + (sign(_e37) * _e35));
+    let _e41 = p;
+    f = fract(_e41);
+    let _e44 = uniforms.scale;
+    let _e48 = uniforms.progress;
+    param = _e48;
+    let _e49 = parabola((&param));
+    s = (1f - ((1f - (1f / _e44)) * _e49));
+    let _e52 = f;
+    let _e55 = s;
+    f = (((_e52 - vec2(0.5f)) * _e55) + vec2(0.5f));
+    let _e60 = p[1u];
+    let _e63 = p[1u];
+    let _e67 = p[0u];
+    let _e71 = p[0u];
+    mixer = (((step(0f, _e60) * step(_e63, 1f)) * step(0f, _e67)) * step(_e71, 1f));
+    let _e74 = f;
+    param_1 = _e74;
+    let _e75 = getToColor((&param_1));
+    let _e76 = f;
+    param_2 = _e76;
+    let _e77 = getFromColor((&param_2));
+    let _e78 = mixer;
+    col = mix(_e75, _e77, vec4(_e78));
+    let _e82 = f[0u];
+    let _e85 = f[0u];
+    let _e90 = f[1u];
+    let _e94 = f[1u];
+    border = (((step(0f, _e82) * step(0f, (1f - _e85))) * step(0f, _e90)) * step(0f, (1f - _e94)));
+    let _e98 = border;
+    let _e99 = col;
+    col = (_e99 * _e98);
+    let _e101 = col;
+    return _e101;
+}
+
+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/DoomScreenTransition.wgsl

@@ -0,0 +1,171 @@
+// DoomScreenTransition — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/DoomScreenTransition.glsl
+// Author: Zeh Fernando
+// License: MIT
+// Description: The outgoing image melts down in uneven columns, like the Doom screen wipe
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    bars: i32,
+    amplitude: f32,
+    noise: f32,
+    frequency: f32,
+    dripScale: 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 _e30 = (*uv)[0u];
+    let _e32 = (*uv)[1u];
+    let _e35 = textureSampleLevel(_to, _sampler, vec2<f32>(_e30, (1f - _e32)), 0f);
+    return _e35;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e30 = (*uv_1)[0u];
+    let _e32 = (*uv_1)[1u];
+    let _e35 = textureSampleLevel(_from, _sampler, vec2<f32>(_e30, (1f - _e32)), 0f);
+    return _e35;
+}
+
+fn drip(num: ptr<function, i32>) -> f32 {
+    let _e29 = (*num);
+    let _e32 = uniforms.bars;
+    let _e39 = uniforms.dripScale;
+    return (sin(((f32(_e29) / f32((_e32 - 1i))) * 3.141592f)) * _e39);
+}
+
+fn rand(num_1: ptr<function, i32>) -> f32 {
+    let _e29 = (*num_1);
+    let _e31 = (f32(_e29) * 67123.31f);
+    let _e36 = (*num_1);
+    let _e41 = (*num_1);
+    return fract((((_e31 - (floor((_e31 / 12f)) * 12f)) * sin((f32(_e36) * 10.3f))) * cos(f32(_e41))));
+}
+
+fn wave(num_2: ptr<function, i32>) -> f32 {
+    var fn_: f32;
+
+    let _e30 = (*num_2);
+    let _e33 = uniforms.frequency;
+    let _e37 = uniforms.bars;
+    fn_ = (((f32(_e30) * _e33) * 0.1f) * f32(_e37));
+    let _e40 = fn_;
+    let _e43 = fn_;
+    let _e47 = fn_;
+    return ((((cos((_e40 * 0.5f)) * cos((_e43 * 0.13f))) * sin(((_e47 + 10f) * 0.3f))) / 2f) + 0.5f);
+}
+
+fn pos(num_3: ptr<function, i32>) -> f32 {
+    var local: f32;
+    var param: i32;
+    var param_1: i32;
+    var param_2: i32;
+    var local_1: f32;
+    var param_3: i32;
+
+    let _e36 = uniforms.noise;
+    if (_e36 == 0f) {
+        let _e38 = (*num_3);
+        param = _e38;
+        let _e39 = wave((&param));
+        local = _e39;
+    } else {
+        let _e40 = (*num_3);
+        param_1 = _e40;
+        let _e41 = wave((&param_1));
+        let _e42 = (*num_3);
+        param_2 = _e42;
+        let _e43 = rand((&param_2));
+        let _e45 = uniforms.noise;
+        local = mix(_e41, _e43, _e45);
+    }
+    let _e47 = local;
+    let _e49 = uniforms.dripScale;
+    if (_e49 == 0f) {
+        local_1 = 0f;
+    } else {
+        let _e51 = (*num_3);
+        param_3 = _e51;
+        let _e52 = drip((&param_3));
+        local_1 = _e52;
+    }
+    let _e53 = local_1;
+    return (_e47 + _e53);
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var bar: i32;
+    var scale: f32;
+    var param_4: i32;
+    var phase: f32;
+    var posY: f32;
+    var p: vec2<f32>;
+    var c: vec4<f32>;
+    var param_5: vec2<f32>;
+    var param_6: vec2<f32>;
+
+    let _e39 = (*uv_2)[0u];
+    let _e41 = uniforms.bars;
+    bar = i32((_e39 * f32(_e41)));
+    let _e45 = bar;
+    param_4 = _e45;
+    let _e46 = pos((&param_4));
+    let _e48 = uniforms.amplitude;
+    scale = (1f + (_e46 * _e48));
+    let _e52 = uniforms.progress;
+    let _e53 = scale;
+    phase = (_e52 * _e53);
+    let _e56 = (*uv_2)[1u];
+    posY = (_e56 / 1f);
+    let _e58 = phase;
+    let _e59 = posY;
+    if ((_e58 + _e59) < 1f) {
+        let _e63 = (*uv_2)[0u];
+        let _e65 = (*uv_2)[1u];
+        let _e66 = phase;
+        p = (vec2<f32>(_e63, (_e65 + mix(0f, 1f, _e66))) / vec2<f32>(1f, 1f));
+        let _e71 = p;
+        param_5 = _e71;
+        let _e72 = getFromColor((&param_5));
+        c = _e72;
+    } else {
+        let _e73 = (*uv_2);
+        p = (_e73 / vec2<f32>(1f, 1f));
+        let _e75 = p;
+        param_6 = _e75;
+        let _e76 = getToColor((&param_6));
+        c = _e76;
+    }
+    let _e77 = c;
+    return _e77;
+}
+
+fn main_1() {
+    var param_7: vec2<f32>;
+
+    let _e29 = _uv_1;
+    param_7 = _e29;
+    let _e30 = transition((&param_7));
+    _fragColor = _e30;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}