gl-transitions 1.74.0 → 1.76.0

package/wgsl/GlitchDisplace.wgsl

@@ -0,0 +1,327 @@
+// GlitchDisplace — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GlitchDisplace.glsl
+// Author: Matt DesLauriers
+// License: MIT
+// Description: Blocks of the image are displaced in a glitch that flashes into the incoming image
+// 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 ease2(t: ptr<function, f32>) -> f32 {
+    var local: f32;
+
+    let _e34 = (*t);
+    if (_e34 == 1f) {
+        let _e36 = (*t);
+        local = _e36;
+    } else {
+        let _e37 = (*t);
+        local = (1f - pow(2f, (-10f * _e37)));
+    }
+    let _e41 = local;
+    return _e41;
+}
+
+fn random(co: ptr<function, vec2<f32>>) -> f32 {
+    var a: f32;
+    var b: f32;
+    var c: f32;
+    var dt: f32;
+    var sn: f32;
+
+    a = 12.9898f;
+    b = 78.233f;
+    c = 43758.547f;
+    let _e38 = (*co);
+    let _e39 = a;
+    let _e40 = b;
+    dt = dot(_e38, vec2<f32>(_e39, _e40));
+    let _e43 = dt;
+    sn = (_e43 - (floor((_e43 / 3.14f)) * 3.14f));
+    let _e48 = sn;
+    let _e50 = c;
+    return fract((sin(_e48) * _e50));
+}
+
+fn voronoi(x: ptr<function, vec2<f32>>) -> f32 {
+    var p: vec2<f32>;
+    var f: vec2<f32>;
+    var res: f32;
+    var j: f32;
+    var i: f32;
+    var b_1: vec2<f32>;
+    var r: vec2<f32>;
+    var param: vec2<f32>;
+    var d: f32;
+
+    let _e42 = (*x);
+    p = floor(_e42);
+    let _e44 = (*x);
+    f = fract(_e44);
+    res = 8f;
+    j = -1f;
+    loop {
+        let _e46 = j;
+        if (_e46 <= 1f) {
+            i = -1f;
+            loop {
+                let _e48 = i;
+                if (_e48 <= 1f) {
+                    let _e50 = i;
+                    let _e51 = j;
+                    b_1 = vec2<f32>(_e50, _e51);
+                    let _e53 = b_1;
+                    let _e54 = f;
+                    let _e56 = p;
+                    let _e57 = b_1;
+                    param = (_e56 + _e57);
+                    let _e59 = random((&param));
+                    r = ((_e53 - _e54) + vec2(_e59));
+                    let _e62 = r;
+                    let _e63 = r;
+                    d = dot(_e62, _e63);
+                    let _e65 = res;
+                    let _e66 = d;
+                    res = min(_e65, _e66);
+                    continue;
+                } else {
+                    break;
+                }
+                continuing {
+                    let _e68 = i;
+                    i = (_e68 + 1f);
+                }
+            }
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e70 = j;
+            j = (_e70 + 1f);
+        }
+    }
+    let _e72 = res;
+    return sqrt(_e72);
+}
+
+fn displace(tex: ptr<function, vec4<f32>>, texCoord: ptr<function, vec2<f32>>, dotDepth: ptr<function, f32>, textureDepth: ptr<function, f32>, strength: ptr<function, f32>) -> vec2<f32> {
+    var b_2: f32;
+    var param_1: vec2<f32>;
+    var g: f32;
+    var param_2: vec2<f32>;
+    var r_1: f32;
+    var param_3: vec2<f32>;
+    var dt_1: vec4<f32>;
+    var dis: vec4<f32>;
+    var res_uv: vec2<f32>;
+
+    let _e46 = (*texCoord);
+    param_1 = ((_e46 * 0.003f) + vec2(2f));
+    let _e50 = voronoi((&param_1));
+    b_2 = _e50;
+    let _e51 = (*texCoord);
+    param_2 = (_e51 * 0.2f);
+    let _e53 = voronoi((&param_2));
+    g = _e53;
+    let _e54 = (*texCoord);
+    param_3 = (_e54 - vec2(1f));
+    let _e57 = voronoi((&param_3));
+    r_1 = _e57;
+    let _e58 = (*tex);
+    dt_1 = (_e58 * 1f);
+    let _e60 = dt_1;
+    let _e61 = (*dotDepth);
+    let _e65 = (*tex);
+    let _e66 = (*textureDepth);
+    dis = (((_e60 * _e61) + vec4(1f)) - (_e65 * _e66));
+    let _e70 = dis[0u];
+    let _e72 = (*textureDepth);
+    let _e73 = (*dotDepth);
+    dis[0u] = ((_e70 - 1f) + (_e72 * _e73));
+    let _e78 = dis[1u];
+    let _e80 = (*textureDepth);
+    let _e81 = (*dotDepth);
+    dis[1u] = ((_e78 - 1f) + (_e80 * _e81));
+    let _e85 = (*strength);
+    let _e87 = dis[0u];
+    dis[0u] = (_e87 * _e85);
+    let _e90 = (*strength);
+    let _e92 = dis[1u];
+    dis[1u] = (_e92 * _e90);
+    let _e95 = (*texCoord);
+    res_uv = _e95;
+    let _e97 = res_uv[0u];
+    let _e99 = dis[0u];
+    res_uv[0u] = ((_e97 + _e99) - 0f);
+    let _e104 = res_uv[1u];
+    let _e106 = dis[1u];
+    res_uv[1u] = (_e104 + _e106);
+    let _e109 = res_uv;
+    return _e109;
+}
+
+fn ease1(t_1: ptr<function, f32>) -> f32 {
+    var local_1: f32;
+    var local_2: f32;
+
+    let _e35 = (*t_1);
+    let _e37 = (*t_1);
+    if ((_e35 == 0f) || (_e37 == 1f)) {
+        let _e40 = (*t_1);
+        local_1 = _e40;
+    } else {
+        let _e41 = (*t_1);
+        if (_e41 < 0.5f) {
+            let _e43 = (*t_1);
+            local_2 = (0.5f * pow(2f, ((20f * _e43) - 10f)));
+        } else {
+            let _e48 = (*t_1);
+            local_2 = ((-0.5f * pow(2f, (10f - (_e48 * 20f)))) + 1f);
+        }
+        let _e54 = local_2;
+        local_1 = _e54;
+    }
+    let _e55 = local_1;
+    return _e55;
+}
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e34 = (*uv)[0u];
+    let _e36 = (*uv)[1u];
+    let _e39 = textureSampleLevel(_to, _sampler, vec2<f32>(_e34, (1f - _e36)), 0f);
+    return _e39;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e34 = (*uv_1)[0u];
+    let _e36 = (*uv_1)[1u];
+    let _e39 = textureSampleLevel(_from, _sampler, vec2<f32>(_e34, (1f - _e36)), 0f);
+    return _e39;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p_1: vec2<f32>;
+    var color1_: vec4<f32>;
+    var param_4: vec2<f32>;
+    var color2_: vec4<f32>;
+    var param_5: vec2<f32>;
+    var disp: vec2<f32>;
+    var param_6: f32;
+    var param_7: vec4<f32>;
+    var param_8: vec2<f32>;
+    var param_9: f32;
+    var param_10: f32;
+    var param_11: f32;
+    var disp2_: vec2<f32>;
+    var param_12: f32;
+    var param_13: vec4<f32>;
+    var param_14: vec2<f32>;
+    var param_15: f32;
+    var param_16: f32;
+    var param_17: f32;
+    var dColor1_: vec4<f32>;
+    var param_18: vec2<f32>;
+    var dColor2_: vec4<f32>;
+    var param_19: vec2<f32>;
+    var val: f32;
+    var param_20: f32;
+    var gray: vec3<f32>;
+
+    let _e59 = (*uv_2);
+    p_1 = (_e59 / vec2<f32>(1f, 1f));
+    let _e61 = p_1;
+    param_4 = _e61;
+    let _e62 = getFromColor((&param_4));
+    color1_ = _e62;
+    let _e63 = p_1;
+    param_5 = _e63;
+    let _e64 = getToColor((&param_5));
+    color2_ = _e64;
+    let _e66 = uniforms.progress;
+    param_6 = _e66;
+    let _e67 = ease1((&param_6));
+    let _e69 = color1_;
+    param_7 = _e69;
+    let _e70 = p_1;
+    param_8 = _e70;
+    param_9 = 0.33f;
+    param_10 = 0.7f;
+    param_11 = (1f - _e67);
+    let _e71 = displace((&param_7), (&param_8), (&param_9), (&param_10), (&param_11));
+    disp = _e71;
+    let _e73 = uniforms.progress;
+    param_12 = _e73;
+    let _e74 = ease2((&param_12));
+    let _e75 = color2_;
+    param_13 = _e75;
+    let _e76 = p_1;
+    param_14 = _e76;
+    param_15 = 0.33f;
+    param_16 = 0.5f;
+    param_17 = _e74;
+    let _e77 = displace((&param_13), (&param_14), (&param_15), (&param_16), (&param_17));
+    disp2_ = _e77;
+    let _e78 = disp;
+    param_18 = _e78;
+    let _e79 = getToColor((&param_18));
+    dColor1_ = _e79;
+    let _e80 = disp2_;
+    param_19 = _e80;
+    let _e81 = getFromColor((&param_19));
+    dColor2_ = _e81;
+    let _e83 = uniforms.progress;
+    param_20 = _e83;
+    let _e84 = ease1((&param_20));
+    val = _e84;
+    let _e85 = dColor2_;
+    let _e86 = dColor1_;
+    gray = vec3(dot(min(_e85, _e86).xyz, vec3<f32>(0.299f, 0.587f, 0.114f)));
+    let _e91 = gray;
+    dColor2_ = vec4<f32>(_e91.x, _e91.y, _e91.z, 1f);
+    let _e96 = dColor2_;
+    dColor2_ = (_e96 * 2f);
+    let _e98 = color1_;
+    let _e99 = dColor2_;
+    let _e101 = uniforms.progress;
+    color1_ = mix(_e98, _e99, vec4(smoothstep(0f, 0.5f, _e101)));
+    let _e105 = color2_;
+    let _e106 = dColor1_;
+    let _e108 = uniforms.progress;
+    color2_ = mix(_e105, _e106, vec4(smoothstep(1f, 0.5f, _e108)));
+    let _e112 = color1_;
+    let _e113 = color2_;
+    let _e114 = val;
+    return mix(_e112, _e113, vec4(_e114));
+}
+
+fn main_1() {
+    var param_21: vec2<f32>;
+
+    let _e33 = _uv_1;
+    param_21 = _e33;
+    let _e34 = transition((&param_21));
+    _fragColor = _e34;
+    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/GlitchMemories.wgsl

@@ -0,0 +1,118 @@
+// GlitchMemories — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GlitchMemories.glsl
+// Author: Gunnar Roth
+// License: MIT
+// Description: A crossfade with glitchy, color-shifted blocks
+// 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 _e25 = (*uv)[0u];
+    let _e27 = (*uv)[1u];
+    let _e30 = textureSampleLevel(_to, _sampler, vec2<f32>(_e25, (1f - _e27)), 0f);
+    return _e30;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e25 = (*uv_1)[0u];
+    let _e27 = (*uv_1)[1u];
+    let _e30 = textureSampleLevel(_from, _sampler, vec2<f32>(_e25, (1f - _e27)), 0f);
+    return _e30;
+}
+
+fn transition(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var block: vec2<f32>;
+    var uv_noise: vec2<f32>;
+    var dist: vec2<f32>;
+    var local: vec2<f32>;
+    var red: vec2<f32>;
+    var green: vec2<f32>;
+    var blue: vec2<f32>;
+    var param: vec2<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>;
+
+    let _e37 = (*p);
+    block = floor((_e37 / vec2<f32>(16f, 16f)));
+    let _e40 = block;
+    uv_noise = (_e40 / vec2<f32>(64f, 64f));
+    let _e43 = uniforms.progress;
+    let _e48 = uv_noise;
+    uv_noise = (_e48 + (floor((vec2(_e43) * vec2<f32>(1200f, 3500f))) / vec2<f32>(64f, 64f)));
+    let _e51 = uniforms.progress;
+    if (_e51 > 0f) {
+        let _e53 = uv_noise;
+        let _e59 = uniforms.progress;
+        local = (((fract(_e53) - vec2(0.5f)) * 0.3f) * (1f - _e59));
+    } else {
+        local = vec2<f32>(0f, 0f);
+    }
+    let _e62 = local;
+    dist = _e62;
+    let _e63 = (*p);
+    let _e64 = dist;
+    red = (_e63 + (_e64 * 0.2f));
+    let _e67 = (*p);
+    let _e68 = dist;
+    green = (_e67 + (_e68 * 0.3f));
+    let _e71 = (*p);
+    let _e72 = dist;
+    blue = (_e71 + (_e72 * 0.5f));
+    let _e75 = red;
+    param = _e75;
+    let _e76 = getFromColor((&param));
+    let _e77 = red;
+    param_1 = _e77;
+    let _e78 = getToColor((&param_1));
+    let _e80 = uniforms.progress;
+    let _e84 = green;
+    param_2 = _e84;
+    let _e85 = getFromColor((&param_2));
+    let _e86 = green;
+    param_3 = _e86;
+    let _e87 = getToColor((&param_3));
+    let _e89 = uniforms.progress;
+    let _e93 = blue;
+    param_4 = _e93;
+    let _e94 = getFromColor((&param_4));
+    let _e95 = blue;
+    param_5 = _e95;
+    let _e96 = getToColor((&param_5));
+    let _e98 = uniforms.progress;
+    return vec4<f32>(mix(_e76, _e78, vec4(_e80)).x, mix(_e85, _e87, vec4(_e89)).y, mix(_e94, _e96, vec4(_e98)).z, 1f);
+}
+
+fn main_1() {
+    var param_6: vec2<f32>;
+
+    let _e24 = _uv_1;
+    param_6 = _e24;
+    let _e25 = transition((&param_6));
+    _fragColor = _e25;
+    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/GridFlip.wgsl

@@ -0,0 +1,250 @@
+// GridFlip — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GridFlip.glsl
+// Author: TimDonselaar
+// License: MIT
+// Description: The image splits into a grid of tiles that flip one by one to the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    size: vec2<i32>,
+    pause: f32,
+    dividerWidth: f32,
+    bgcolor: vec4<f32>,
+    randomness: 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 _e24 = (*uv)[0u];
+    let _e26 = (*uv)[1u];
+    let _e29 = textureSampleLevel(_to, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn rand(co: ptr<function, vec2<f32>>) -> f32 {
+    let _e23 = (*co);
+    return fract((sin(dot(_e23, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e24 = (*uv_1)[0u];
+    let _e26 = (*uv_1)[1u];
+    let _e29 = textureSampleLevel(_from, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn getDividerSize_u0028_() -> f32 {
+    var rectangleSize: vec2<f32>;
+
+    let _e24 = uniforms.size;
+    let _e29 = uniforms.size;
+    rectangleSize = vec2<f32>((1f / vec2<f32>(_e24).x), (1f / vec2<f32>(_e29).y));
+    let _e35 = rectangleSize[0u];
+    let _e37 = rectangleSize[1u];
+    let _e40 = uniforms.dividerWidth;
+    return (min(_e35, _e37) * _e40);
+}
+
+fn getDelta(p: ptr<function, vec2<f32>>) -> f32 {
+    var rectanglePos: vec2<f32>;
+    var rectangleSize_1: vec2<f32>;
+    var top: f32;
+    var bottom: f32;
+    var left: f32;
+    var right: f32;
+    var minX: f32;
+    var minY: f32;
+
+    let _e32 = uniforms.size;
+    let _e34 = (*p);
+    rectanglePos = floor((vec2<f32>(_e32) * _e34));
+    let _e38 = uniforms.size;
+    let _e43 = uniforms.size;
+    rectangleSize_1 = vec2<f32>((1f / vec2<f32>(_e38).x), (1f / vec2<f32>(_e43).y));
+    let _e49 = rectangleSize_1[1u];
+    let _e51 = rectanglePos[1u];
+    top = (_e49 * (_e51 + 1f));
+    let _e55 = rectangleSize_1[1u];
+    let _e57 = rectanglePos[1u];
+    bottom = (_e55 * _e57);
+    let _e60 = rectangleSize_1[0u];
+    let _e62 = rectanglePos[0u];
+    left = (_e60 * _e62);
+    let _e65 = rectangleSize_1[0u];
+    let _e67 = rectanglePos[0u];
+    right = (_e65 * (_e67 + 1f));
+    let _e71 = (*p)[0u];
+    let _e72 = left;
+    let _e76 = (*p)[0u];
+    let _e77 = right;
+    minX = min(abs((_e71 - _e72)), abs((_e76 - _e77)));
+    let _e82 = (*p)[1u];
+    let _e83 = top;
+    let _e87 = (*p)[1u];
+    let _e88 = bottom;
+    minY = min(abs((_e82 - _e83)), abs((_e87 - _e88)));
+    let _e92 = minX;
+    let _e93 = minY;
+    return min(_e92, _e93);
+}
+
+fn transition(p_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var currentProg: f32;
+    var a: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var currentProg_1: f32;
+    var q: vec2<f32>;
+    var rectanglePos_1: vec2<f32>;
+    var r: f32;
+    var param_3: vec2<f32>;
+    var cp: f32;
+    var rectangleSize_2: f32;
+    var delta: f32;
+    var offset: f32;
+    var a_1: vec4<f32>;
+    var param_4: vec2<f32>;
+    var b: vec4<f32>;
+    var param_5: vec2<f32>;
+    var s: f32;
+    var currentProg_2: f32;
+    var a_2: f32;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+
+    let _e47 = uniforms.progress;
+    let _e49 = uniforms.pause;
+    if (_e47 < _e49) {
+        let _e52 = uniforms.progress;
+        let _e54 = uniforms.pause;
+        currentProg = (_e52 / _e54);
+        a = 1f;
+        let _e56 = (*p_1);
+        param = _e56;
+        let _e57 = getDelta((&param));
+        let _e58 = getDividerSize_u0028_();
+        if (_e57 < _e58) {
+            let _e60 = currentProg;
+            a = (1f - _e60);
+        }
+        let _e63 = uniforms.bgcolor;
+        let _e64 = (*p_1);
+        param_1 = _e64;
+        let _e65 = getFromColor((&param_1));
+        let _e66 = a;
+        return mix(_e63, _e65, vec4(_e66));
+    } else {
+        let _e70 = uniforms.progress;
+        let _e72 = uniforms.pause;
+        if (_e70 < (1f - _e72)) {
+            let _e75 = (*p_1);
+            param_2 = _e75;
+            let _e76 = getDelta((&param_2));
+            let _e77 = getDividerSize_u0028_();
+            if (_e76 < _e77) {
+                let _e80 = uniforms.bgcolor;
+                return _e80;
+            } else {
+                let _e82 = uniforms.progress;
+                let _e84 = uniforms.pause;
+                let _e87 = uniforms.pause;
+                currentProg_1 = ((_e82 - _e84) / (1f - (_e87 * 2f)));
+                let _e91 = (*p_1);
+                q = _e91;
+                let _e93 = uniforms.size;
+                let _e95 = q;
+                rectanglePos_1 = floor((vec2<f32>(_e93) * _e95));
+                let _e98 = rectanglePos_1;
+                param_3 = _e98;
+                let _e99 = rand((&param_3));
+                let _e101 = uniforms.randomness;
+                r = (_e99 - _e101);
+                let _e103 = r;
+                let _e105 = currentProg_1;
+                cp = smoothstep(0f, (1f - _e103), _e105);
+                let _e108 = uniforms.size;
+                rectangleSize_2 = (1f / vec2<f32>(_e108).x);
+                let _e113 = rectanglePos_1[0u];
+                let _e114 = rectangleSize_2;
+                delta = (_e113 * _e114);
+                let _e116 = rectangleSize_2;
+                let _e118 = delta;
+                offset = ((_e116 / 2f) + _e118);
+                let _e121 = (*p_1)[0u];
+                let _e122 = offset;
+                let _e124 = cp;
+                let _e129 = offset;
+                (*p_1)[0u] = ((((_e121 - _e122) / abs((_e124 - 0.5f))) * 0.5f) + _e129);
+                let _e132 = (*p_1);
+                param_4 = _e132;
+                let _e133 = getFromColor((&param_4));
+                a_1 = _e133;
+                let _e134 = (*p_1);
+                param_5 = _e134;
+                let _e135 = getToColor((&param_5));
+                b = _e135;
+                let _e137 = uniforms.size;
+                let _e141 = q[0u];
+                let _e142 = delta;
+                let _e147 = cp;
+                s = step(abs(((vec2<f32>(_e137).x * (_e141 - _e142)) - 0.5f)), abs((_e147 - 0.5f)));
+                let _e152 = uniforms.bgcolor;
+                let _e153 = b;
+                let _e154 = a_1;
+                let _e155 = cp;
+                let _e159 = s;
+                return mix(_e152, mix(_e153, _e154, vec4(step(_e155, 0.5f))), vec4(_e159));
+            }
+        } else {
+            let _e163 = uniforms.progress;
+            let _e166 = uniforms.pause;
+            let _e169 = uniforms.pause;
+            currentProg_2 = (((_e163 - 1f) + _e166) / _e169);
+            a_2 = 1f;
+            let _e171 = (*p_1);
+            param_6 = _e171;
+            let _e172 = getDelta((&param_6));
+            let _e173 = getDividerSize_u0028_();
+            if (_e172 < _e173) {
+                let _e175 = currentProg_2;
+                a_2 = _e175;
+            }
+            let _e177 = uniforms.bgcolor;
+            let _e178 = (*p_1);
+            param_7 = _e178;
+            let _e179 = getToColor((&param_7));
+            let _e180 = a_2;
+            return mix(_e177, _e179, vec4(_e180));
+        }
+    }
+}
+
+fn main_1() {
+    var param_8: vec2<f32>;
+
+    let _e23 = _uv_1;
+    param_8 = _e23;
+    let _e24 = transition((&param_8));
+    _fragColor = _e24;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}