gl-transitions 1.74.0 → 1.76.0

package/wgsl/VerticalOpen.wgsl

@@ -0,0 +1,75 @@
+// VerticalOpen — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/VerticalOpen.glsl
+// Author: martiniti
+// License: MIT
+// Description: The incoming image opens from a line in the middle toward the left and right edges
+// 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 _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(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var regress: f32;
+    var s: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e19 = uniforms.progress;
+    regress = (1f - _e19);
+    let _e22 = (*uv_2)[0u];
+    let _e24 = regress;
+    let _e29 = regress;
+    s = ((2f - abs(((_e22 - 0.5f) / (_e24 - 1f)))) - (2f * _e29));
+    let _e32 = (*uv_2);
+    param = _e32;
+    let _e33 = getFromColor((&param));
+    let _e34 = (*uv_2);
+    param_1 = _e34;
+    let _e35 = getToColor((&param_1));
+    let _e36 = s;
+    return mix(_e33, _e35, vec4(smoothstep(0f, 0.5f, _e36)));
+}
+
+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/WaterDrop.wgsl

@@ -0,0 +1,98 @@
+// WaterDrop — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/WaterDrop.glsl
+// Author: Paweł Płóciennik
+// License: MIT
+// Description: Ripples spread from the center like a drop falling into water, crossfading to the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    amplitude: 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 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(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var dir: vec2<f32>;
+    var dist: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var offset: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    let _e23 = (*p);
+    dir = (_e23 - vec2<f32>(0.5f, 0.5f));
+    let _e25 = dir;
+    dist = length(_e25);
+    let _e27 = dist;
+    let _e29 = uniforms.progress;
+    if (_e27 > _e29) {
+        let _e31 = (*p);
+        param = _e31;
+        let _e32 = getFromColor((&param));
+        let _e33 = (*p);
+        param_1 = _e33;
+        let _e34 = getToColor((&param_1));
+        let _e36 = uniforms.progress;
+        return mix(_e32, _e34, vec4(_e36));
+    } else {
+        let _e39 = dir;
+        let _e40 = dist;
+        let _e42 = uniforms.amplitude;
+        let _e45 = uniforms.progress;
+        let _e47 = uniforms.speed;
+        offset = (_e39 * sin(((_e40 * _e42) - (_e45 * _e47))));
+        let _e52 = (*p);
+        let _e53 = offset;
+        param_2 = (_e52 + _e53);
+        let _e55 = getFromColor((&param_2));
+        let _e56 = (*p);
+        param_3 = _e56;
+        let _e57 = getToColor((&param_3));
+        let _e59 = uniforms.progress;
+        return mix(_e55, _e57, vec4(_e59));
+    }
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e16 = _uv_1;
+    param_4 = _e16;
+    let _e17 = transition((&param_4));
+    _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/ZoomInCircles.wgsl

@@ -0,0 +1,138 @@
+// ZoomInCircles — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomInCircles.glsl
+// Author: dycm8009
+// License: MIT
+// Description: Concentric rings of the outgoing image zoom at different speeds before revealing the incoming one
+// 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 zoom(uv_2: ptr<function, vec2<f32>>, amount: ptr<function, f32>) -> vec2<f32> {
+    let _e25 = (*uv_2);
+    let _e28 = (*amount);
+    return (vec2(0.5f) + ((_e25 - vec2(0.5f)) * _e28));
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var ratio2_: vec2<f32>;
+    var r: vec2<f32>;
+    var pro: f32;
+    var z: f32;
+    var t: f32;
+    var param: vec2<f32>;
+    var param_1: f32;
+    var param_2: vec2<f32>;
+    var param_3: f32;
+    var param_4: vec2<f32>;
+    var param_5: f32;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+
+    let _e38 = uniforms.ratio;
+    ratio2_ = vec2<f32>(1f, (1f / _e38));
+    let _e41 = (*uv_3);
+    let _e44 = ratio2_;
+    r = (((_e41 - vec2(0.5f)) * _e44) * 2f);
+    let _e48 = uniforms.progress;
+    pro = (_e48 / 0.8f);
+    let _e50 = pro;
+    z = (_e50 * 0.2f);
+    t = 0f;
+    let _e52 = pro;
+    if (_e52 > 1f) {
+        let _e54 = pro;
+        z = (0.2f + ((_e54 - 1f) * 5f));
+        let _e59 = uniforms.progress;
+        t = clamp(((_e59 - 0.8f) / 0.07f), 0f, 1f);
+    }
+    let _e63 = r;
+    let _e65 = z;
+    if (length(_e63) < (0.5f + _e65)) {
+    } else {
+        let _e68 = r;
+        let _e70 = z;
+        if (length(_e68) < (0.8f + (_e70 * 1.5f))) {
+            let _e74 = pro;
+            let _e77 = (*uv_3);
+            param = _e77;
+            param_1 = (1f - (0.15f * _e74));
+            let _e78 = zoom((&param), (&param_1));
+            (*uv_3) = _e78;
+            let _e79 = t;
+            t = (_e79 * 0.5f);
+        } else {
+            let _e81 = r;
+            let _e83 = z;
+            if (length(_e81) < (1.2f + (_e83 * 2.5f))) {
+                let _e87 = pro;
+                let _e90 = (*uv_3);
+                param_2 = _e90;
+                param_3 = (1f - (0.2f * _e87));
+                let _e91 = zoom((&param_2), (&param_3));
+                (*uv_3) = _e91;
+                let _e92 = t;
+                t = (_e92 * 0.2f);
+            } else {
+                let _e94 = pro;
+                let _e97 = (*uv_3);
+                param_4 = _e97;
+                param_5 = (1f - (0.25f * _e94));
+                let _e98 = zoom((&param_4), (&param_5));
+                (*uv_3) = _e98;
+            }
+        }
+    }
+    let _e99 = (*uv_3);
+    param_6 = _e99;
+    let _e100 = getFromColor((&param_6));
+    let _e101 = (*uv_3);
+    param_7 = _e101;
+    let _e102 = getToColor((&param_7));
+    let _e103 = t;
+    return mix(_e100, _e102, vec4(_e103));
+}
+
+fn main_1() {
+    var param_8: vec2<f32>;
+
+    let _e24 = _uv_1;
+    param_8 = _e24;
+    let _e25 = transition((&param_8));
+    _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/ZoomLeftWipe.wgsl

@@ -0,0 +1,121 @@
+// ZoomLeftWipe — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomLeftWipe.glsl
+// Author: Handk
+// License: MIT
+// Description: Zooms into the outgoing image, then the incoming one wipes in from right to left
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    zoom_quickness: 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 zoom(uv_2: ptr<function, vec2<f32>>, amount: ptr<function, f32>) -> vec2<f32> {
+    let _e17 = (*amount);
+    if (_e17 < 0.5f) {
+        let _e19 = (*uv_2);
+        let _e22 = (*amount);
+        return (vec2(0.5f) + ((_e19 - vec2(0.5f)) * (1f - _e22)));
+    } else {
+        let _e27 = (*uv_2);
+        let _e30 = (*amount);
+        return (vec2(0.5f) + ((_e27 - vec2(0.5f)) * _e30));
+    }
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var nQuick: f32;
+    var c: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: f32;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var p: vec2<f32>;
+    var d: vec4<f32>;
+    var param_4: vec2<f32>;
+    var e: vec4<f32>;
+    var param_5: vec2<f32>;
+    var f: vec4<f32>;
+
+    let _e29 = uniforms.zoom_quickness;
+    nQuick = clamp(_e29, 0f, 0.5f);
+    let _e32 = uniforms.progress;
+    if (_e32 < 0.5f) {
+        let _e34 = nQuick;
+        let _e36 = uniforms.progress;
+        let _e38 = (*uv_3);
+        param = _e38;
+        param_1 = smoothstep(0f, _e34, _e36);
+        let _e39 = zoom((&param), (&param_1));
+        param_2 = _e39;
+        let _e40 = getFromColor((&param_2));
+        let _e41 = (*uv_3);
+        param_3 = _e41;
+        let _e42 = getToColor((&param_3));
+        let _e44 = uniforms.progress;
+        c = mix(_e40, _e42, vec4(step(0.5f, _e44)));
+        let _e48 = c;
+        return _e48;
+    } else {
+        let _e49 = (*uv_3);
+        p = (_e49 / vec2<f32>(1f, 1f));
+        let _e51 = p;
+        param_4 = _e51;
+        let _e52 = getFromColor((&param_4));
+        d = _e52;
+        let _e53 = p;
+        param_5 = _e53;
+        let _e54 = getToColor((&param_5));
+        e = _e54;
+        let _e55 = d;
+        let _e56 = e;
+        let _e58 = p[0u];
+        let _e61 = uniforms.progress;
+        f = mix(_e55, _e56, vec4(step((1f - _e58), ((_e61 - 0.5f) * 2f))));
+        let _e67 = f;
+        return _e67;
+    }
+}
+
+fn main_1() {
+    var param_6: vec2<f32>;
+
+    let _e16 = _uv_1;
+    param_6 = _e16;
+    let _e17 = transition((&param_6));
+    _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/ZoomRigthWipe.wgsl

@@ -0,0 +1,121 @@
+// ZoomRigthWipe — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomRigthWipe.glsl
+// Author: Handk
+// License: MIT
+// Description: Zooms into the outgoing image, then the incoming one wipes in from left to right
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    zoom_quickness: 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 zoom(uv_2: ptr<function, vec2<f32>>, amount: ptr<function, f32>) -> vec2<f32> {
+    let _e17 = (*amount);
+    if (_e17 < 0.5f) {
+        let _e19 = (*uv_2);
+        let _e22 = (*amount);
+        return (vec2(0.5f) + ((_e19 - vec2(0.5f)) * (1f - _e22)));
+    } else {
+        let _e27 = (*uv_2);
+        let _e30 = (*amount);
+        return (vec2(0.5f) + ((_e27 - vec2(0.5f)) * _e30));
+    }
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var nQuick: f32;
+    var c: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: f32;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var p: vec2<f32>;
+    var d: vec4<f32>;
+    var param_4: vec2<f32>;
+    var e: vec4<f32>;
+    var param_5: vec2<f32>;
+    var f: vec4<f32>;
+
+    let _e29 = uniforms.zoom_quickness;
+    nQuick = clamp(_e29, 0f, 0.5f);
+    let _e32 = uniforms.progress;
+    if (_e32 < 0.5f) {
+        let _e34 = nQuick;
+        let _e36 = uniforms.progress;
+        let _e38 = (*uv_3);
+        param = _e38;
+        param_1 = smoothstep(0f, _e34, _e36);
+        let _e39 = zoom((&param), (&param_1));
+        param_2 = _e39;
+        let _e40 = getFromColor((&param_2));
+        let _e41 = (*uv_3);
+        param_3 = _e41;
+        let _e42 = getToColor((&param_3));
+        let _e44 = uniforms.progress;
+        c = mix(_e40, _e42, vec4(step(0.5f, _e44)));
+        let _e48 = c;
+        return _e48;
+    } else {
+        let _e49 = (*uv_3);
+        p = (_e49 / vec2<f32>(1f, 1f));
+        let _e51 = p;
+        param_4 = _e51;
+        let _e52 = getFromColor((&param_4));
+        d = _e52;
+        let _e53 = p;
+        param_5 = _e53;
+        let _e54 = getToColor((&param_5));
+        e = _e54;
+        let _e55 = d;
+        let _e56 = e;
+        let _e58 = p[0u];
+        let _e61 = uniforms.progress;
+        f = mix(_e55, _e56, vec4(step((0f + _e58), ((_e61 - 0.5f) * 2f))));
+        let _e67 = f;
+        return _e67;
+    }
+}
+
+fn main_1() {
+    var param_6: vec2<f32>;
+
+    let _e16 = _uv_1;
+    param_6 = _e16;
+    let _e17 = transition((&param_6));
+    _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/angular.wgsl

@@ -0,0 +1,83 @@
+// angular — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/angular.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: A wipe that sweeps around the center from a starting angle
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    startingAngle: 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 _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var offset: f32;
+    var angle: f32;
+    var normalizedAngle: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e23 = uniforms.startingAngle;
+    offset = ((_e23 * 3.1415927f) / 180f);
+    let _e27 = (*uv_2)[1u];
+    let _e30 = (*uv_2)[0u];
+    let _e33 = offset;
+    angle = (atan2((_e27 - 0.5f), (_e30 - 0.5f)) + _e33);
+    let _e35 = angle;
+    normalizedAngle = ((_e35 + 3.1415927f) / 6.2831855f);
+    let _e38 = normalizedAngle;
+    let _e39 = normalizedAngle;
+    normalizedAngle = (_e38 - floor(_e39));
+    let _e42 = (*uv_2);
+    param = _e42;
+    let _e43 = getFromColor((&param));
+    let _e44 = (*uv_2);
+    param_1 = _e44;
+    let _e45 = getToColor((&param_1));
+    let _e46 = normalizedAngle;
+    let _e48 = uniforms.progress;
+    return mix(_e43, _e45, vec4(step(_e46, _e48)));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_2 = _e17;
+    let _e18 = transition((&param_2));
+    _fragColor = _e18;
+    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/burn.wgsl

@@ -0,0 +1,74 @@
+// burn — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/burn.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade that brightens toward a color in the middle
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: 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 _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 param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e15 = (*uv_2);
+    param = _e15;
+    let _e16 = getFromColor((&param));
+    let _e18 = uniforms.progress;
+    let _e20 = uniforms.color;
+    let _e21 = (_e20 * _e18);
+    let _e27 = (*uv_2);
+    param_1 = _e27;
+    let _e28 = getToColor((&param_1));
+    let _e30 = uniforms.progress;
+    let _e33 = uniforms.color;
+    let _e34 = (_e33 * (1f - _e30));
+    let _e41 = uniforms.progress;
+    return mix((_e16 + vec4<f32>(_e21.x, _e21.y, _e21.z, 1f)), (_e28 + vec4<f32>(_e34.x, _e34.y, _e34.z, 1f)), vec4(_e41));
+}
+
+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;
+}