gl-transitions 1.74.0 → 1.76.0

package/wgsl/Revolve_Left.wgsl

@@ -0,0 +1,314 @@
+// Revolve_Left — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Revolve_Left.glsl
+// Author: bread
+// License: MIT
+// Description: The outgoing image swirls and zooms with motion blur into the incoming one
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    center: vec2<f32>,
+    direction: f32,
+    maxRotation: f32,
+    peakZoom: f32,
+    swirl: f32,
+    barrel: f32,
+    motionBlur: f32,
+    switchStart: f32,
+    switchEnd: f32,
+    shadow: 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 _e48 = (*uv)[0u];
+    let _e50 = (*uv)[1u];
+    let _e53 = textureSampleLevel(_to, _sampler, vec2<f32>(_e48, (1f - _e50)), 0f);
+    return _e53;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e48 = (*uv_1)[0u];
+    let _e50 = (*uv_1)[1u];
+    let _e53 = textureSampleLevel(_from, _sampler, vec2<f32>(_e48, (1f - _e50)), 0f);
+    return _e53;
+}
+
+fn rotate2(p: ptr<function, vec2<f32>>, a: ptr<function, f32>) -> vec2<f32> {
+    var s: f32;
+    var c: f32;
+
+    let _e50 = (*a);
+    s = sin(_e50);
+    let _e52 = (*a);
+    c = cos(_e52);
+    let _e54 = c;
+    let _e56 = (*p)[0u];
+    let _e58 = s;
+    let _e60 = (*p)[1u];
+    let _e63 = s;
+    let _e65 = (*p)[0u];
+    let _e67 = c;
+    let _e69 = (*p)[1u];
+    return vec2<f32>(((_e54 * _e56) - (_e58 * _e60)), ((_e63 * _e65) + (_e67 * _e69)));
+}
+
+fn sat(x: ptr<function, f32>) -> f32 {
+    let _e47 = (*x);
+    return clamp(_e47, 0f, 1f);
+}
+
+fn ease(x_1: ptr<function, f32>) -> f32 {
+    var param: f32;
+
+    let _e48 = (*x_1);
+    param = _e48;
+    let _e49 = sat((&param));
+    (*x_1) = _e49;
+    let _e50 = (*x_1);
+    let _e51 = (*x_1);
+    let _e53 = (*x_1);
+    return ((_e50 * _e51) * (3f - (2f * _e53)));
+}
+
+fn revolveEnvelope(t: ptr<function, f32>) -> f32 {
+    var rise: f32;
+    var param_1: f32;
+    var fall: f32;
+    var param_2: f32;
+
+    let _e51 = (*t);
+    param_1 = ((_e51 - 0.1f) / 0.33f);
+    let _e54 = ease((&param_1));
+    rise = _e54;
+    let _e55 = (*t);
+    param_2 = ((_e55 - 0.43f) / 0.29f);
+    let _e58 = ease((&param_2));
+    fall = (1f - _e58);
+    let _e60 = rise;
+    let _e61 = fall;
+    return (_e60 * _e61);
+}
+
+fn warpUv(uv_2: ptr<function, vec2<f32>>, t_1: ptr<function, f32>) -> vec2<f32> {
+    var e: f32;
+    var param_3: f32;
+    var p_1: vec2<f32>;
+    var r: f32;
+    var edgeSpin: f32;
+    var coreSpin: f32;
+    var param_4: f32;
+    var visibleAngle: f32;
+    var param_5: vec2<f32>;
+    var param_6: f32;
+    var sc: f32;
+    var rr: f32;
+
+    let _e60 = (*t_1);
+    param_3 = _e60;
+    let _e61 = revolveEnvelope((&param_3));
+    e = _e61;
+    let _e62 = (*uv_2);
+    let _e64 = uniforms.center;
+    p_1 = (_e62 - _e64);
+    let _e67 = uniforms.ratio;
+    let _e69 = p_1[0u];
+    p_1[0u] = (_e69 * _e67);
+    let _e72 = p_1;
+    r = length(_e72);
+    let _e75 = uniforms.maxRotation;
+    let _e76 = e;
+    edgeSpin = (_e75 * _e76);
+    let _e79 = uniforms.swirl;
+    let _e80 = e;
+    let _e82 = r;
+    param_4 = (_e82 / 0.96f);
+    let _e84 = sat((&param_4));
+    coreSpin = ((_e79 * _e80) * pow((1f - _e84), 1.55f));
+    let _e89 = uniforms.direction;
+    let _e90 = edgeSpin;
+    let _e91 = coreSpin;
+    visibleAngle = (_e89 * (_e90 + _e91));
+    let _e94 = visibleAngle;
+    let _e96 = p_1;
+    param_5 = _e96;
+    param_6 = -(_e94);
+    let _e97 = rotate2((&param_5), (&param_6));
+    p_1 = _e97;
+    let _e99 = uniforms.peakZoom;
+    let _e101 = e;
+    sc = (1f + ((_e99 - 1f) * pow(_e101, 0.85f)));
+    let _e105 = sc;
+    let _e106 = p_1;
+    p_1 = (_e106 / vec2(_e105));
+    let _e109 = p_1;
+    rr = length(_e109);
+    let _e112 = uniforms.barrel;
+    let _e113 = e;
+    let _e115 = rr;
+    let _e117 = rr;
+    let _e121 = p_1;
+    p_1 = (_e121 * (1f + ((((_e112 * _e113) * _e115) * _e117) * 2.8f)));
+    let _e124 = uniforms.ratio;
+    let _e126 = p_1[0u];
+    p_1[0u] = (_e126 / _e124);
+    let _e129 = p_1;
+    let _e131 = uniforms.center;
+    return clamp((_e129 + _e131), vec2<f32>(0.001f, 0.001f), vec2<f32>(0.999f, 0.999f));
+}
+
+fn sampleRevolve(uv_3: ptr<function, vec2<f32>>, t_2: ptr<function, f32>) -> vec4<f32> {
+    var p_2: vec2<f32>;
+    var param_7: vec2<f32>;
+    var param_8: f32;
+    var reveal: f32;
+    var param_9: vec2<f32>;
+    var param_10: vec2<f32>;
+
+    let _e54 = (*uv_3);
+    param_7 = _e54;
+    let _e55 = (*t_2);
+    param_8 = _e55;
+    let _e56 = warpUv((&param_7), (&param_8));
+    p_2 = _e56;
+    let _e58 = uniforms.switchStart;
+    let _e60 = uniforms.switchEnd;
+    let _e61 = (*t_2);
+    reveal = smoothstep(_e58, _e60, _e61);
+    let _e63 = p_2;
+    param_9 = _e63;
+    let _e64 = getFromColor((&param_9));
+    let _e65 = p_2;
+    param_10 = _e65;
+    let _e66 = getToColor((&param_10));
+    let _e67 = reveal;
+    return mix(_e64, _e66, vec4(_e67));
+}
+
+fn transition(uv_4: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param_11: vec2<f32>;
+    var param_12: vec2<f32>;
+    var e_1: f32;
+    var param_13: f32;
+    var span: f32;
+    var color: vec4<f32>;
+    var total: f32;
+    var i: i32;
+    var x_2: f32;
+    var w: f32;
+    var t_3: f32;
+    var param_14: f32;
+    var param_15: vec2<f32>;
+    var param_16: f32;
+    var q: vec2<f32>;
+    var vignette: f32;
+
+    let _e64 = uniforms.progress;
+    if (_e64 <= 0f) {
+        let _e66 = (*uv_4);
+        param_11 = _e66;
+        let _e67 = getFromColor((&param_11));
+        return _e67;
+    }
+    let _e69 = uniforms.progress;
+    if (_e69 >= 1f) {
+        let _e71 = (*uv_4);
+        param_12 = _e71;
+        let _e72 = getToColor((&param_12));
+        return _e72;
+    }
+    let _e74 = uniforms.progress;
+    param_13 = _e74;
+    let _e75 = revolveEnvelope((&param_13));
+    e_1 = _e75;
+    let _e77 = uniforms.motionBlur;
+    let _e79 = e_1;
+    span = ((0.06f * _e77) * _e79);
+    color = vec4<f32>(0f, 0f, 0f, 0f);
+    total = 0f;
+    i = -8i;
+    loop {
+        let _e81 = i;
+        if (_e81 <= 8i) {
+            let _e83 = i;
+            x_2 = (f32(_e83) / 8f);
+            let _e86 = x_2;
+            w = (1f - abs(_e86));
+            let _e89 = w;
+            let _e90 = w;
+            w = ((_e89 * _e90) + 0.01f);
+            let _e94 = uniforms.progress;
+            let _e95 = x_2;
+            let _e96 = span;
+            param_14 = (_e94 + (_e95 * _e96));
+            let _e99 = sat((&param_14));
+            t_3 = _e99;
+            let _e100 = (*uv_4);
+            param_15 = _e100;
+            let _e101 = t_3;
+            param_16 = _e101;
+            let _e102 = sampleRevolve((&param_15), (&param_16));
+            let _e103 = w;
+            let _e105 = color;
+            color = (_e105 + (_e102 * _e103));
+            let _e107 = w;
+            let _e108 = total;
+            total = (_e108 + _e107);
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e110 = i;
+            i = (_e110 + 1i);
+        }
+    }
+    let _e112 = total;
+    let _e113 = color;
+    color = (_e113 / vec4(_e112));
+    let _e116 = (*uv_4);
+    q = (_e116 - vec2<f32>(0.5f, 0.5f));
+    let _e119 = uniforms.ratio;
+    let _e121 = q[0u];
+    q[0u] = (_e121 * _e119);
+    let _e125 = uniforms.shadow;
+    let _e126 = e_1;
+    let _e128 = q;
+    vignette = (1f - ((_e125 * _e126) * smoothstep(0.35f, 0.95f, length(_e128))));
+    let _e133 = vignette;
+    let _e134 = color;
+    let _e136 = (_e134.xyz * _e133);
+    color[0u] = _e136.x;
+    color[1u] = _e136.y;
+    color[2u] = _e136.z;
+    let _e143 = color;
+    return _e143;
+}
+
+fn main_1() {
+    var param_17: vec2<f32>;
+
+    let _e47 = _uv_1;
+    param_17 = _e47;
+    let _e48 = transition((&param_17));
+    _fragColor = _e48;
+    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/Rolls.wgsl

@@ -0,0 +1,181 @@
+// Rolls — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rolls.glsl
+// Author: Mark Craig
+// License: MIT
+// Description: The outgoing image rolls away around a corner, revealing the incoming one
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    type_: i32,
+    RotDown: 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 transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var iResolution: vec2<f32>;
+    var theta: f32;
+    var uvi: vec2<f32>;
+    var c1_: f32;
+    var s1_: f32;
+    var uv2_: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var phi_200_: bool;
+    var phi_206_: bool;
+    var phi_214_: bool;
+
+    let _e27 = uniforms.ratio;
+    iResolution = vec2<f32>(_e27, 1f);
+    let _e30 = uniforms.type_;
+    if (_e30 == 0i) {
+        let _e33 = uniforms.RotDown;
+        let _e38 = uniforms.progress;
+        theta = ((select(-3.1415927f, 3.1415927f, (_e33 != 0i)) / 2f) * _e38);
+        let _e41 = (*uv_2)[0u];
+        uvi[0u] = (1f - _e41);
+        let _e45 = (*uv_2)[1u];
+        uvi[1u] = _e45;
+    } else {
+        let _e48 = uniforms.type_;
+        if (_e48 == 1i) {
+            let _e51 = uniforms.RotDown;
+            let _e56 = uniforms.progress;
+            theta = ((select(-3.1415927f, 3.1415927f, (_e51 != 0i)) / 2f) * _e56);
+            let _e58 = (*uv_2);
+            uvi = _e58;
+        } else {
+            let _e60 = uniforms.type_;
+            if (_e60 == 2i) {
+                let _e63 = uniforms.RotDown;
+                let _e68 = uniforms.progress;
+                theta = ((select(3.1415927f, -3.1415927f, (_e63 != 0i)) / 2f) * _e68);
+                let _e71 = (*uv_2)[0u];
+                uvi[0u] = _e71;
+                let _e74 = (*uv_2)[1u];
+                uvi[1u] = (1f - _e74);
+            } else {
+                let _e78 = uniforms.type_;
+                if (_e78 == 3i) {
+                    let _e81 = uniforms.RotDown;
+                    let _e86 = uniforms.progress;
+                    theta = ((select(3.1415927f, -3.1415927f, (_e81 != 0i)) / 2f) * _e86);
+                    let _e88 = (*uv_2);
+                    uvi = (vec2(1f) - _e88);
+                }
+            }
+        }
+    }
+    let _e91 = theta;
+    c1_ = cos(_e91);
+    let _e93 = theta;
+    s1_ = sin(_e93);
+    let _e96 = uvi[0u];
+    let _e98 = iResolution[0u];
+    let _e100 = c1_;
+    let _e103 = uvi[1u];
+    let _e105 = iResolution[1u];
+    let _e107 = s1_;
+    uv2_[0u] = (((_e96 * _e98) * _e100) - ((_e103 * _e105) * _e107));
+    let _e112 = uvi[0u];
+    let _e114 = iResolution[0u];
+    let _e116 = s1_;
+    let _e119 = uvi[1u];
+    let _e121 = iResolution[1u];
+    let _e123 = c1_;
+    uv2_[1u] = (((_e112 * _e114) * _e116) + ((_e119 * _e121) * _e123));
+    let _e128 = uv2_[0u];
+    let _e129 = (_e128 >= 0f);
+    phi_200_ = _e129;
+    if _e129 {
+        let _e131 = uv2_[0u];
+        let _e133 = iResolution[0u];
+        phi_200_ = (_e131 <= _e133);
+    }
+    let _e136 = phi_200_;
+    phi_206_ = _e136;
+    if _e136 {
+        let _e138 = uv2_[1u];
+        phi_206_ = (_e138 >= 0f);
+    }
+    let _e141 = phi_206_;
+    phi_214_ = _e141;
+    if _e141 {
+        let _e143 = uv2_[1u];
+        let _e145 = iResolution[1u];
+        phi_214_ = (_e143 <= _e145);
+    }
+    let _e148 = phi_214_;
+    if _e148 {
+        let _e149 = iResolution;
+        let _e150 = uv2_;
+        uv2_ = (_e150 / _e149);
+        let _e153 = uniforms.type_;
+        if (_e153 == 0i) {
+            let _e156 = uv2_[0u];
+            uv2_[0u] = (1f - _e156);
+        } else {
+            let _e160 = uniforms.type_;
+            if (_e160 == 2i) {
+                let _e163 = uv2_[1u];
+                uv2_[1u] = (1f - _e163);
+            } else {
+                let _e167 = uniforms.type_;
+                if (_e167 == 3i) {
+                    let _e169 = uv2_;
+                    uv2_ = (vec2(1f) - _e169);
+                }
+            }
+        }
+        let _e172 = uv2_;
+        param = _e172;
+        let _e173 = getFromColor((&param));
+        return _e173;
+    }
+    let _e174 = (*uv_2);
+    param_1 = _e174;
+    let _e175 = getToColor((&param_1));
+    return _e175;
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e18 = _uv_1;
+    param_2 = _e18;
+    let _e19 = transition((&param_2));
+    _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/RotateScaleVanish.wgsl

@@ -0,0 +1,199 @@
+// RotateScaleVanish — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RotateScaleVanish.glsl
+// Author: Mark Craig
+// License: MIT
+// Description: The outgoing image spins and shrinks away over the incoming one
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    FadeInSecond: i32,
+    ReverseEffect: i32,
+    ReverseRotation: 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 _e23 = (*uv)[0u];
+    let _e25 = (*uv)[1u];
+    let _e28 = textureSampleLevel(_to, _sampler, vec2<f32>(_e23, (1f - _e25)), 0f);
+    return _e28;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e23 = (*uv_1)[0u];
+    let _e25 = (*uv_1)[1u];
+    let _e28 = textureSampleLevel(_from, _sampler, vec2<f32>(_e23, (1f - _e25)), 0f);
+    return _e28;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var iResolution: vec2<f32>;
+    var t: f32;
+    var local: f32;
+    var theta: f32;
+    var local_1: f32;
+    var c1_: f32;
+    var s1_: f32;
+    var rad: f32;
+    var xc1_: f32;
+    var yc1_: f32;
+    var xc2_: f32;
+    var yc2_: f32;
+    var uv2_: vec2<f32>;
+    var ColorTo: vec4<f32>;
+    var local_2: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var col3_: vec4<f32>;
+    var local_3: vec4<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var phi_187_: bool;
+    var phi_193_: bool;
+    var phi_201_: bool;
+
+    let _e44 = uniforms.ratio;
+    iResolution = vec2<f32>(_e44, 1f);
+    let _e47 = uniforms.ReverseEffect;
+    if (_e47 != 0i) {
+        let _e50 = uniforms.progress;
+        local = (1f - _e50);
+    } else {
+        let _e53 = uniforms.progress;
+        local = _e53;
+    }
+    let _e54 = local;
+    t = _e54;
+    let _e56 = uniforms.ReverseRotation;
+    if (_e56 != 0i) {
+        let _e58 = t;
+        local_1 = (6.2831855f * _e58);
+    } else {
+        let _e60 = t;
+        local_1 = (-6.2831855f * _e60);
+    }
+    let _e62 = local_1;
+    theta = _e62;
+    let _e63 = theta;
+    c1_ = cos(_e63);
+    let _e65 = theta;
+    s1_ = sin(_e65);
+    let _e67 = t;
+    rad = max(0.00001f, (1f - _e67));
+    let _e71 = (*uv_2)[0u];
+    let _e74 = iResolution[0u];
+    xc1_ = ((_e71 - 0.5f) * _e74);
+    let _e77 = (*uv_2)[1u];
+    let _e80 = iResolution[1u];
+    yc1_ = ((_e77 - 0.5f) * _e80);
+    let _e82 = xc1_;
+    let _e83 = c1_;
+    let _e85 = yc1_;
+    let _e86 = s1_;
+    let _e89 = rad;
+    xc2_ = (((_e82 * _e83) - (_e85 * _e86)) / _e89);
+    let _e91 = xc1_;
+    let _e92 = s1_;
+    let _e94 = yc1_;
+    let _e95 = c1_;
+    let _e98 = rad;
+    yc2_ = (((_e91 * _e92) + (_e94 * _e95)) / _e98);
+    let _e100 = xc2_;
+    let _e102 = iResolution[0u];
+    let _e105 = yc2_;
+    let _e107 = iResolution[1u];
+    uv2_ = vec2<f32>((_e100 + (_e102 / 2f)), (_e105 + (_e107 / 2f)));
+    let _e112 = uniforms.ReverseEffect;
+    if (_e112 != 0i) {
+        let _e114 = (*uv_2);
+        param = _e114;
+        let _e115 = getFromColor((&param));
+        local_2 = _e115;
+    } else {
+        let _e116 = (*uv_2);
+        param_1 = _e116;
+        let _e117 = getToColor((&param_1));
+        local_2 = _e117;
+    }
+    let _e118 = local_2;
+    ColorTo = _e118;
+    let _e120 = uv2_[0u];
+    let _e121 = (_e120 >= 0f);
+    phi_187_ = _e121;
+    if _e121 {
+        let _e123 = uv2_[0u];
+        let _e125 = iResolution[0u];
+        phi_187_ = (_e123 <= _e125);
+    }
+    let _e128 = phi_187_;
+    phi_193_ = _e128;
+    if _e128 {
+        let _e130 = uv2_[1u];
+        phi_193_ = (_e130 >= 0f);
+    }
+    let _e133 = phi_193_;
+    phi_201_ = _e133;
+    if _e133 {
+        let _e135 = uv2_[1u];
+        let _e137 = iResolution[1u];
+        phi_201_ = (_e135 <= _e137);
+    }
+    let _e140 = phi_201_;
+    if _e140 {
+        let _e141 = iResolution;
+        let _e142 = uv2_;
+        uv2_ = (_e142 / _e141);
+        let _e145 = uniforms.ReverseEffect;
+        if (_e145 != 0i) {
+            let _e147 = uv2_;
+            param_2 = _e147;
+            let _e148 = getToColor((&param_2));
+            local_3 = _e148;
+        } else {
+            let _e149 = uv2_;
+            param_3 = _e149;
+            let _e150 = getFromColor((&param_3));
+            local_3 = _e150;
+        }
+        let _e151 = local_3;
+        col3_ = _e151;
+    } else {
+        let _e153 = uniforms.FadeInSecond;
+        let _e155 = ColorTo;
+        col3_ = select(_e155, vec4<f32>(0f, 0f, 0f, 1f), vec4((_e153 != 0i)));
+    }
+    let _e158 = t;
+    let _e160 = col3_;
+    let _e162 = t;
+    let _e163 = ColorTo;
+    return ((_e160 * (1f - _e158)) + (_e163 * _e162));
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e22 = _uv_1;
+    param_4 = _e22;
+    let _e23 = transition((&param_4));
+    _fragColor = _e23;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}