gl-transitions 1.74.0 → 1.76.0

package/wgsl/old_tv_lost_signal.wgsl

@@ -0,0 +1,142 @@
+// old_tv_lost_signal — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/old_tv_lost_signal.glsl
+// Author: mernking (gitlab.com/Godswork)
+// License: MIT
+// Description: A crossfade with drifting tracking lines and tearing, like a TV losing its signal
+// 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 hash(p: ptr<function, vec2<f32>>) -> f32 {
+    let _e26 = (*p);
+    return fract((sin(dot(_e26, vec2<f32>(127.1f, 311.7f))) * 43758.547f));
+}
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e27 = (*uv)[0u];
+    let _e29 = (*uv)[1u];
+    let _e32 = textureSampleLevel(_to, _sampler, vec2<f32>(_e27, (1f - _e29)), 0f);
+    return _e32;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e27 = (*uv_1)[0u];
+    let _e29 = (*uv_1)[1u];
+    let _e32 = textureSampleLevel(_from, _sampler, vec2<f32>(_e27, (1f - _e29)), 0f);
+    return _e32;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p_1: f32;
+    var strength: f32;
+    var tv: vec2<f32>;
+    var fromColor: vec4<f32>;
+    var param: vec2<f32>;
+    var toColor: vec4<f32>;
+    var param_1: vec2<f32>;
+    var color: vec4<f32>;
+    var lineY: f32;
+    var noise: f32;
+    var param_2: vec2<f32>;
+    var line: f32;
+    var drift: f32;
+    var shiftedFrom: vec4<f32>;
+    var param_3: vec2<f32>;
+    var shiftedTo: vec4<f32>;
+    var param_4: vec2<f32>;
+    var lineColor: vec4<f32>;
+    var scan: f32;
+
+    let _e46 = uniforms.progress;
+    p_1 = _e46;
+    let _e47 = p_1;
+    strength = sin((_e47 * 3.1415927f));
+    let _e50 = (*uv_2);
+    tv = _e50;
+    let _e51 = tv;
+    param = _e51;
+    let _e52 = getFromColor((&param));
+    fromColor = _e52;
+    let _e53 = tv;
+    param_1 = _e53;
+    let _e54 = getToColor((&param_1));
+    toColor = _e54;
+    let _e55 = fromColor;
+    let _e56 = toColor;
+    let _e57 = p_1;
+    color = mix(_e55, _e56, vec4(_e57));
+    let _e61 = tv[1u];
+    lineY = floor((_e61 * 120f));
+    let _e64 = lineY;
+    let _e65 = p_1;
+    param_2 = vec2<f32>(_e64, (_e65 * 20f));
+    let _e68 = hash((&param_2));
+    noise = _e68;
+    let _e69 = noise;
+    line = step(0.92f, _e69);
+    let _e72 = tv[1u];
+    let _e74 = p_1;
+    let _e79 = strength;
+    drift = ((sin(((_e72 * 30f) + (_e74 * 10f))) * 0.02f) * _e79);
+    let _e81 = tv;
+    let _e82 = drift;
+    param_3 = (_e81 + vec2<f32>(_e82, 0f));
+    let _e85 = getFromColor((&param_3));
+    shiftedFrom = _e85;
+    let _e86 = tv;
+    let _e87 = drift;
+    param_4 = (_e86 + vec2<f32>(_e87, 0f));
+    let _e90 = getToColor((&param_4));
+    shiftedTo = _e90;
+    let _e91 = shiftedFrom;
+    let _e92 = shiftedTo;
+    let _e93 = p_1;
+    lineColor = mix(_e91, _e92, vec4(_e93));
+    let _e96 = color;
+    let _e97 = lineColor;
+    let _e98 = line;
+    let _e99 = strength;
+    color = mix(_e96, _e97, vec4((_e98 * _e99)));
+    let _e104 = tv[1u];
+    scan = (sin((_e104 * 900f)) * 0.03f);
+    let _e108 = scan;
+    let _e109 = strength;
+    let _e111 = color;
+    let _e114 = (_e111.xyz - vec3((_e108 * _e109)));
+    color[0u] = _e114.x;
+    color[1u] = _e114.y;
+    color[2u] = _e114.z;
+    let _e121 = color;
+    return _e121;
+}
+
+fn main_1() {
+    var param_5: vec2<f32>;
+
+    let _e26 = _uv_1;
+    param_5 = _e26;
+    let _e27 = transition((&param_5));
+    _fragColor = _e27;
+    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/parametric_glitch.wgsl

@@ -0,0 +1,124 @@
+// parametric_glitch — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/parametric_glitch.glsl
+// Author: Yoni Maltsman @friendlyspinach
+// License: MIT
+// Description: A crossfade with glitchy horizontal bands and color shifts
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    ampx: f32,
+    ampy: 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 from_: vec4<f32>;
+    var param: vec2<f32>;
+    var to: vec4<f32>;
+    var param_1: vec2<f32>;
+    var r: f32;
+    var g: f32;
+    var b: f32;
+    var sphere: f32;
+    var spiralX: f32;
+    var spiralY: f32;
+    var st: vec2<f32>;
+    var diff: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e29 = (*uv_2);
+    param = _e29;
+    let _e30 = getFromColor((&param));
+    from_ = _e30;
+    let _e31 = (*uv_2);
+    param_1 = _e31;
+    let _e32 = getToColor((&param_1));
+    to = _e32;
+    let _e34 = from_[0u];
+    r = _e34;
+    let _e36 = from_[1u];
+    g = _e36;
+    let _e38 = from_[2u];
+    b = _e38;
+    let _e39 = r;
+    let _e40 = r;
+    let _e42 = g;
+    let _e43 = g;
+    let _e46 = b;
+    let _e47 = b;
+    sphere = ((((_e39 * _e40) + (_e42 * _e43)) + (_e46 * _e47)) - 1f);
+    let _e51 = sphere;
+    let _e53 = (*uv_2)[0u];
+    let _e55 = uniforms.progress;
+    spiralX = cos((_e51 - (_e53 / (_e55 + 0.01f))));
+    let _e60 = sphere;
+    let _e62 = (*uv_2)[1u];
+    let _e64 = uniforms.progress;
+    spiralY = sin((_e60 - (_e62 / (_e64 + 0.01f))));
+    let _e69 = (*uv_2);
+    st = _e69;
+    let _e71 = uniforms.ampx;
+    let _e73 = st[0u];
+    let _e75 = spiralX;
+    st[0u] = fract(((_e71 * _e73) * _e75));
+    let _e80 = uniforms.ampy;
+    let _e82 = st[1u];
+    let _e84 = spiralY;
+    st[1u] = fract(((_e80 * _e82) * _e84));
+    let _e88 = (*uv_2);
+    let _e89 = st;
+    diff = (_e88 - _e89);
+    let _e91 = (*uv_2);
+    let _e93 = uniforms.progress;
+    let _e94 = diff;
+    param_2 = (_e91 + (_e94 * _e93));
+    let _e97 = getFromColor((&param_2));
+    from_ = _e97;
+    let _e98 = from_;
+    let _e99 = to;
+    let _e101 = uniforms.progress;
+    return mix(_e98, _e99, vec4(_e101));
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e16 = _uv_1;
+    param_3 = _e16;
+    let _e17 = transition((&param_3));
+    _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/perlin.wgsl

@@ -0,0 +1,174 @@
+// perlin — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/perlin.glsl
+// Author: Rich Harris
+// License: MIT
+// Description: The incoming image appears through blobs of Perlin noise
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    scale: f32,
+    smoothness: f32,
+    seed: 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 random(co: ptr<function, vec2<f32>>) -> f32 {
+    var a: f32;
+    var b: f32;
+    var c: f32;
+    var dt: f32;
+    var sn: f32;
+
+    let _e29 = uniforms.seed;
+    a = _e29;
+    b = 78.233f;
+    c = 43758.547f;
+    let _e30 = (*co);
+    let _e31 = a;
+    let _e32 = b;
+    dt = dot(_e30, vec2<f32>(_e31, _e32));
+    let _e35 = dt;
+    sn = (_e35 - (floor((_e35 / 3.14f)) * 3.14f));
+    let _e40 = sn;
+    let _e42 = c;
+    return fract((sin(_e40) * _e42));
+}
+
+fn noise(st: ptr<function, vec2<f32>>) -> f32 {
+    var i: vec2<f32>;
+    var f: vec2<f32>;
+    var a_1: f32;
+    var param: vec2<f32>;
+    var b_1: f32;
+    var param_1: vec2<f32>;
+    var c_1: f32;
+    var param_2: vec2<f32>;
+    var d: f32;
+    var param_3: vec2<f32>;
+    var u: vec2<f32>;
+
+    let _e34 = (*st);
+    i = floor(_e34);
+    let _e36 = (*st);
+    f = fract(_e36);
+    let _e38 = i;
+    param = _e38;
+    let _e39 = random((&param));
+    a_1 = _e39;
+    let _e40 = i;
+    param_1 = (_e40 + vec2<f32>(1f, 0f));
+    let _e42 = random((&param_1));
+    b_1 = _e42;
+    let _e43 = i;
+    param_2 = (_e43 + vec2<f32>(0f, 1f));
+    let _e45 = random((&param_2));
+    c_1 = _e45;
+    let _e46 = i;
+    param_3 = (_e46 + vec2<f32>(1f, 1f));
+    let _e48 = random((&param_3));
+    d = _e48;
+    let _e49 = f;
+    let _e50 = f;
+    let _e52 = f;
+    u = ((_e49 * _e50) * (vec2(3f) - (_e52 * 2f)));
+    let _e57 = a_1;
+    let _e58 = b_1;
+    let _e60 = u[0u];
+    let _e62 = c_1;
+    let _e63 = a_1;
+    let _e66 = u[1u];
+    let _e69 = u[0u];
+    let _e73 = d;
+    let _e74 = b_1;
+    let _e77 = u[0u];
+    let _e80 = u[1u];
+    return ((mix(_e57, _e58, _e60) + (((_e62 - _e63) * _e66) * (1f - _e69))) + (((_e73 - _e74) * _e77) * _e80));
+}
+
+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 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 transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var from_: vec4<f32>;
+    var param_4: vec2<f32>;
+    var to: vec4<f32>;
+    var param_5: vec2<f32>;
+    var n: f32;
+    var param_6: vec2<f32>;
+    var p: f32;
+    var lower: f32;
+    var higher: f32;
+    var q: f32;
+
+    let _e33 = (*uv_2);
+    param_4 = _e33;
+    let _e34 = getFromColor((&param_4));
+    from_ = _e34;
+    let _e35 = (*uv_2);
+    param_5 = _e35;
+    let _e36 = getToColor((&param_5));
+    to = _e36;
+    let _e37 = (*uv_2);
+    let _e39 = uniforms.scale;
+    param_6 = (_e37 * _e39);
+    let _e41 = noise((&param_6));
+    n = _e41;
+    let _e43 = uniforms.smoothness;
+    let _e46 = uniforms.smoothness;
+    let _e49 = uniforms.progress;
+    p = mix(-(_e43), (1f + _e46), _e49);
+    let _e51 = p;
+    let _e53 = uniforms.smoothness;
+    lower = (_e51 - _e53);
+    let _e55 = p;
+    let _e57 = uniforms.smoothness;
+    higher = (_e55 + _e57);
+    let _e59 = lower;
+    let _e60 = higher;
+    let _e61 = n;
+    q = smoothstep(_e59, _e60, _e61);
+    let _e63 = from_;
+    let _e64 = to;
+    let _e65 = q;
+    return mix(_e63, _e64, vec4((1f - _e65)));
+}
+
+fn main_1() {
+    var param_7: vec2<f32>;
+
+    let _e23 = _uv_1;
+    param_7 = _e23;
+    let _e24 = transition((&param_7));
+    _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;
+}

package/wgsl/pinwheel.wgsl

@@ -0,0 +1,84 @@
+// pinwheel — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/pinwheel.glsl
+// Author: Mr Speaker
+// License: MIT
+// Description: A spinning pinwheel reveals the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    speed: 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 _e17 = (*uv)[0u];
+    let _e19 = (*uv)[1u];
+    let _e22 = textureSampleLevel(_from, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e17 = (*uv_1)[0u];
+    let _e19 = (*uv_1)[1u];
+    let _e22 = textureSampleLevel(_to, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p: vec2<f32>;
+    var circPos: f32;
+    var modPos: f32;
+    var signed: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e22 = (*uv_2);
+    p = (_e22 / vec2<f32>(1f, 1f));
+    let _e25 = p[1u];
+    let _e28 = p[0u];
+    let _e32 = uniforms.progress;
+    let _e34 = uniforms.speed;
+    circPos = (atan2((_e25 - 0.5f), (_e28 - 0.5f)) + (_e32 * _e34));
+    let _e37 = circPos;
+    modPos = (_e37 - (floor((_e37 / 0.785375f)) * 0.785375f));
+    let _e43 = uniforms.progress;
+    let _e44 = modPos;
+    signed = sign((_e43 - _e44));
+    let _e47 = p;
+    param = _e47;
+    let _e48 = getToColor((&param));
+    let _e49 = p;
+    param_1 = _e49;
+    let _e50 = getFromColor((&param_1));
+    let _e51 = signed;
+    return mix(_e48, _e50, vec4(step(_e51, 0.5f)));
+}
+
+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/pixelize.wgsl

@@ -0,0 +1,105 @@
+// pixelize — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/pixelize.glsl
+// Author: gre
+// License: MIT
+// Description: Both images pixelate, crossfade, then sharpen again
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    squaresMin: vec2<i32>,
+    steps: 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 _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 d: f32;
+    var dist: f32;
+    var local: f32;
+    var squareSize: vec2<f32>;
+    var p: vec2<f32>;
+    var local_1: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e25 = uniforms.progress;
+    let _e27 = uniforms.progress;
+    d = min(_e25, (1f - _e27));
+    let _e31 = uniforms.steps;
+    if (_e31 > 0i) {
+        let _e33 = d;
+        let _e35 = uniforms.steps;
+        let _e40 = uniforms.steps;
+        local = (ceil((_e33 * f32(_e35))) / f32(_e40));
+    } else {
+        let _e43 = d;
+        local = _e43;
+    }
+    let _e44 = local;
+    dist = _e44;
+    let _e45 = dist;
+    let _e48 = uniforms.squaresMin;
+    squareSize = (vec2((2f * _e45)) / vec2<f32>(_e48));
+    let _e52 = dist;
+    if (_e52 > 0f) {
+        let _e54 = (*uv_2);
+        let _e55 = squareSize;
+        let _e60 = squareSize;
+        local_1 = ((floor((_e54 / _e55)) + vec2(0.5f)) * _e60);
+    } else {
+        let _e62 = (*uv_2);
+        local_1 = _e62;
+    }
+    let _e63 = local_1;
+    p = _e63;
+    let _e64 = p;
+    param = _e64;
+    let _e65 = getFromColor((&param));
+    let _e66 = p;
+    param_1 = _e66;
+    let _e67 = getToColor((&param_1));
+    let _e69 = uniforms.progress;
+    return mix(_e65, _e67, vec4(_e69));
+}
+
+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/polar_function.wgsl

@@ -0,0 +1,88 @@
+// polar_function — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/polar_function.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: A flower shape with several petals grows to reveal the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    segments: 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 _e20 = (*uv)[0u];
+    let _e22 = (*uv)[1u];
+    let _e25 = textureSampleLevel(_to, _sampler, vec2<f32>(_e20, (1f - _e22)), 0f);
+    return _e25;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e20 = (*uv_1)[0u];
+    let _e22 = (*uv_1)[1u];
+    let _e25 = textureSampleLevel(_from, _sampler, vec2<f32>(_e20, (1f - _e22)), 0f);
+    return _e25;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var angle: f32;
+    var normalized: f32;
+    var radius: f32;
+    var difference: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e26 = (*uv_2)[1u];
+    let _e29 = (*uv_2)[0u];
+    angle = (atan2((_e26 - 0.5f), (_e29 - 0.5f)) - 1.5707964f);
+    let _e33 = angle;
+    normalized = ((_e33 + 4.712389f) * 6.2831855f);
+    let _e37 = uniforms.segments;
+    let _e39 = angle;
+    radius = ((cos((f32(_e37) * _e39)) + 4f) / 4f);
+    let _e44 = (*uv_2);
+    difference = length((_e44 - vec2<f32>(0.5f, 0.5f)));
+    let _e47 = difference;
+    let _e48 = radius;
+    let _e50 = uniforms.progress;
+    if (_e47 > (_e48 * _e50)) {
+        let _e53 = (*uv_2);
+        param = _e53;
+        let _e54 = getFromColor((&param));
+        return _e54;
+    } else {
+        let _e55 = (*uv_2);
+        param_1 = _e55;
+        let _e56 = getToColor((&param_1));
+        return _e56;
+    }
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e19 = _uv_1;
+    param_2 = _e19;
+    let _e20 = transition((&param_2));
+    _fragColor = _e20;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}