gl-transitions 1.74.0 → 1.76.0

package/wgsl/coord-from-in.wgsl

@@ -0,0 +1,83 @@
+// coord-from-in — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/coord-from-in.glsl
+// Author: haiyoucuv
+// License: MIT
+// Description: A crossfade in which the colors of one image displace the other
+// 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 getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e13 = (*uv)[0u];
+    let _e15 = (*uv)[1u];
+    let _e18 = textureSampleLevel(_from, _sampler, vec2<f32>(_e13, (1f - _e15)), 0f);
+    return _e18;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e13 = (*uv_1)[0u];
+    let _e15 = (*uv_1)[1u];
+    let _e18 = textureSampleLevel(_to, _sampler, vec2<f32>(_e13, (1f - _e15)), 0f);
+    return _e18;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var coordTo: vec4<f32>;
+    var param: vec2<f32>;
+    var coordFrom: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    let _e18 = (*uv_2);
+    param = _e18;
+    let _e19 = getToColor((&param));
+    coordTo = _e19;
+    let _e20 = (*uv_2);
+    param_1 = _e20;
+    let _e21 = getFromColor((&param_1));
+    coordFrom = _e21;
+    let _e22 = (*uv_2);
+    let _e23 = coordTo;
+    let _e26 = uniforms.progress;
+    param_2 = mix(_e22, _e23.xy, vec2(_e26));
+    let _e29 = getFromColor((&param_2));
+    let _e30 = coordFrom;
+    let _e32 = (*uv_2);
+    let _e34 = uniforms.progress;
+    param_3 = mix(_e30.xy, _e32, vec2(_e34));
+    let _e37 = getToColor((&param_3));
+    let _e39 = uniforms.progress;
+    return mix(_e29, _e37, vec4(_e39));
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e12 = _uv_1;
+    param_4 = _e12;
+    let _e13 = transition((&param_4));
+    _fragColor = _e13;
+    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/crosshatch.wgsl

@@ -0,0 +1,96 @@
+// crosshatch — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/crosshatch.glsl
+// Author: pthrasher
+// License: MIT
+// Description: The incoming image appears through a crosshatch of lines spreading from the center
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    center: vec2<f32>,
+    threshold: f32,
+    fadeEdge: 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 _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 rand(co: ptr<function, vec2<f32>>) -> f32 {
+    let _e19 = (*co);
+    return fract((sin(dot(_e19, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn transition(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var dist: f32;
+    var r: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    let _e26 = uniforms.center;
+    let _e27 = (*p);
+    let _e30 = uniforms.threshold;
+    dist = (distance(_e26, _e27) / _e30);
+    let _e33 = uniforms.progress;
+    let _e35 = (*p)[1u];
+    param = vec2<f32>(_e35, 0f);
+    let _e37 = rand((&param));
+    let _e39 = (*p)[0u];
+    param_1 = vec2<f32>(0f, _e39);
+    let _e41 = rand((&param_1));
+    r = (_e33 - min(_e37, _e41));
+    let _e44 = (*p);
+    param_2 = _e44;
+    let _e45 = getFromColor((&param_2));
+    let _e46 = (*p);
+    param_3 = _e46;
+    let _e47 = getToColor((&param_3));
+    let _e48 = dist;
+    let _e49 = r;
+    let _e52 = uniforms.fadeEdge;
+    let _e55 = uniforms.progress;
+    let _e59 = uniforms.fadeEdge;
+    let _e61 = uniforms.progress;
+    return mix(_e45, _e47, vec4(mix(0f, mix(step(_e48, _e49), 1f, smoothstep((1f - _e52), 1f, _e55)), smoothstep(0f, _e59, _e61))));
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e19 = _uv_1;
+    param_4 = _e19;
+    let _e20 = transition((&param_4));
+    _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;
+}

package/wgsl/crosswarp.wgsl

@@ -0,0 +1,75 @@
+// crosswarp — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/crosswarp.glsl
+// Author: Eke Péter <peterekepeter@gmail.com>
+// License: MIT
+// Description: The outgoing image zooms in while the incoming one zooms out into place, sweeping from right to left
+// 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(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var x: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e18 = uniforms.progress;
+    x = _e18;
+    let _e19 = x;
+    let _e22 = (*p)[0u];
+    x = smoothstep(0f, 1f, (((_e19 * 2f) + _e22) - 1f));
+    let _e26 = (*p);
+    let _e29 = x;
+    param = (((_e26 - vec2(0.5f)) * (1f - _e29)) + vec2(0.5f));
+    let _e34 = getFromColor((&param));
+    let _e35 = (*p);
+    let _e38 = x;
+    param_1 = (((_e35 - vec2(0.5f)) * _e38) + vec2(0.5f));
+    let _e42 = getToColor((&param_1));
+    let _e43 = x;
+    return mix(_e34, _e42, vec4(_e43));
+}
+
+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/cube.wgsl

@@ -0,0 +1,217 @@
+// cube — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/cube.glsl
+// Author: gre
+// License: MIT
+// Description: The two images are faces of a rotating 3D cube, with a floor reflection
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    persp: f32,
+    unzoom: f32,
+    reflection: f32,
+    floating: 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 _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 inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_109_: bool;
+
+    let _e26 = (*p);
+    let _e28 = all((vec2<f32>(0f, 0f) < _e26));
+    phi_109_ = _e28;
+    if _e28 {
+        let _e29 = (*p);
+        phi_109_ = all((_e29 < vec2<f32>(1f, 1f)));
+    }
+    let _e33 = phi_109_;
+    return _e33;
+}
+
+fn project(p_1: ptr<function, vec2<f32>>) -> vec2<f32> {
+    let _e26 = (*p_1);
+    let _e29 = uniforms.floating;
+    return ((_e26 * vec2<f32>(1f, -1.2f)) + vec2<f32>(0f, (-(_e29) / 100f)));
+}
+
+fn bgColor(p_2: ptr<function, vec2<f32>>, pfr: ptr<function, vec2<f32>>, pto: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var c: vec4<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>;
+
+    c = vec4<f32>(0f, 0f, 0f, 1f);
+    let _e35 = (*pfr);
+    param = _e35;
+    let _e36 = project((&param));
+    (*pfr) = _e36;
+    let _e37 = (*pfr);
+    param_1 = _e37;
+    let _e38 = inBounds((&param_1));
+    if _e38 {
+        let _e39 = (*pfr);
+        param_2 = _e39;
+        let _e40 = getFromColor((&param_2));
+        let _e42 = uniforms.reflection;
+        let _e44 = (*pfr)[1u];
+        let _e49 = c;
+        c = (_e49 + mix(vec4<f32>(0f, 0f, 0f, 0f), _e40, vec4((_e42 * mix(1f, 0f, _e44)))));
+    }
+    let _e51 = (*pto);
+    param_3 = _e51;
+    let _e52 = project((&param_3));
+    (*pto) = _e52;
+    let _e53 = (*pto);
+    param_4 = _e53;
+    let _e54 = inBounds((&param_4));
+    if _e54 {
+        let _e55 = (*pto);
+        param_5 = _e55;
+        let _e56 = getToColor((&param_5));
+        let _e58 = uniforms.reflection;
+        let _e60 = (*pto)[1u];
+        let _e65 = c;
+        c = (_e65 + mix(vec4<f32>(0f, 0f, 0f, 0f), _e56, vec4((_e58 * mix(1f, 0f, _e60)))));
+    }
+    let _e67 = c;
+    return _e67;
+}
+
+fn xskew(p_3: ptr<function, vec2<f32>>, persp: ptr<function, f32>, center: ptr<function, f32>) -> vec2<f32> {
+    var x: f32;
+
+    let _e30 = (*p_3)[0u];
+    let _e32 = (*p_3)[0u];
+    let _e34 = (*center);
+    x = mix(_e30, (1f - _e32), _e34);
+    let _e36 = x;
+    let _e38 = (*p_3)[1u];
+    let _e39 = (*persp);
+    let _e42 = x;
+    let _e45 = (*persp);
+    let _e47 = x;
+    let _e52 = (*center);
+    let _e57 = (*center);
+    let _e60 = (*center);
+    let _e66 = (*center);
+    return (((vec2<f32>(_e36, ((_e38 - ((0.5f * (1f - _e39)) * _e42)) / (1f + ((_e45 - 1f) * _e47)))) - vec2<f32>((0.5f - distance(_e52, 0.5f)), 0f)) * vec2<f32>(((0.5f / distance(_e57, 0.5f)) * select(-1f, 1f, (_e60 < 0.5f))), 1f)) + vec2<f32>(select(1f, 0f, (_e66 < 0.5f)), 0f));
+}
+
+fn transition(op: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var uz: f32;
+    var p_4: vec2<f32>;
+    var fromP: vec2<f32>;
+    var param_6: vec2<f32>;
+    var param_7: f32;
+    var param_8: f32;
+    var toP: vec2<f32>;
+    var param_9: vec2<f32>;
+    var param_10: f32;
+    var param_11: 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>;
+
+    let _e44 = uniforms.unzoom;
+    let _e47 = uniforms.progress;
+    uz = ((_e44 * 2f) * (0.5f - distance(0.5f, _e47)));
+    let _e51 = uz;
+    let _e54 = uz;
+    let _e56 = (*op);
+    p_4 = (vec2((-(_e51) * 0.5f)) + (_e56 * (1f + _e54)));
+    let _e60 = p_4;
+    let _e62 = uniforms.progress;
+    let _e66 = uniforms.progress;
+    let _e71 = uniforms.progress;
+    let _e73 = uniforms.persp;
+    param_6 = ((_e60 - vec2<f32>(_e62, 0f)) / vec2<f32>((1f - _e66), 1f));
+    param_7 = (1f - mix(_e71, 0f, _e73));
+    param_8 = 0f;
+    let _e76 = xskew((&param_6), (&param_7), (&param_8));
+    fromP = _e76;
+    let _e77 = p_4;
+    let _e79 = uniforms.progress;
+    let _e83 = uniforms.progress;
+    let _e86 = uniforms.persp;
+    param_9 = (_e77 / vec2<f32>(_e79, 1f));
+    param_10 = mix(pow(_e83, 2f), 1f, _e86);
+    param_11 = 1f;
+    let _e88 = xskew((&param_9), (&param_10), (&param_11));
+    toP = _e88;
+    let _e89 = fromP;
+    param_12 = _e89;
+    let _e90 = inBounds((&param_12));
+    if _e90 {
+        let _e91 = fromP;
+        param_13 = _e91;
+        let _e92 = getFromColor((&param_13));
+        return _e92;
+    } else {
+        let _e93 = toP;
+        param_14 = _e93;
+        let _e94 = inBounds((&param_14));
+        if _e94 {
+            let _e95 = toP;
+            param_15 = _e95;
+            let _e96 = getToColor((&param_15));
+            return _e96;
+        }
+    }
+    let _e97 = (*op);
+    param_16 = _e97;
+    let _e98 = fromP;
+    param_17 = _e98;
+    let _e99 = toP;
+    param_18 = _e99;
+    let _e100 = bgColor((&param_16), (&param_17), (&param_18));
+    return _e100;
+}
+
+fn main_1() {
+    var param_19: vec2<f32>;
+
+    let _e26 = _uv_1;
+    param_19 = _e26;
+    let _e27 = transition((&param_19));
+    _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/directional-easing.wgsl

@@ -0,0 +1,83 @@
+// directional-easing — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directional-easing.glsl
+// Author: Max Plotnikov
+// License: MIT
+// Description: Like Directional, with an eased movement
+// 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 _e15 = (*uv)[0u];
+    let _e17 = (*uv)[1u];
+    let _e20 = textureSampleLevel(_from, _sampler, vec2<f32>(_e15, (1f - _e17)), 0f);
+    return _e20;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e15 = (*uv_1)[0u];
+    let _e17 = (*uv_1)[1u];
+    let _e20 = textureSampleLevel(_to, _sampler, vec2<f32>(_e15, (1f - _e17)), 0f);
+    return _e20;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var easing: f32;
+    var p: vec2<f32>;
+    var f: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e20 = uniforms.progress;
+    let _e23 = uniforms.progress;
+    easing = sqrt(((2f - _e20) * _e23));
+    let _e26 = (*uv_2);
+    let _e27 = easing;
+    let _e29 = uniforms.direction;
+    p = (_e26 + (sign(_e29) * _e27));
+    let _e33 = p;
+    f = fract(_e33);
+    let _e35 = f;
+    param = _e35;
+    let _e36 = getToColor((&param));
+    let _e37 = f;
+    param_1 = _e37;
+    let _e38 = getFromColor((&param_1));
+    let _e40 = p[1u];
+    let _e43 = p[1u];
+    let _e47 = p[0u];
+    let _e51 = p[0u];
+    return mix(_e36, _e38, vec4((((step(0f, _e40) * step(_e43, 1f)) * step(0f, _e47)) * step(_e51, 1f))));
+}
+
+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/directionalwarp.wgsl

@@ -0,0 +1,92 @@
+// directionalwarp — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directionalwarp.glsl
+// Author: pschroen
+// License: MIT
+// Description: A diagonal wipe with a warped, smeared edge
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    smoothness: 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 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 v: vec2<f32>;
+    var d: f32;
+    var m: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e22 = uniforms.direction;
+    v = normalize(_e22);
+    let _e25 = v[0u];
+    let _e28 = v[1u];
+    let _e31 = v;
+    v = (_e31 / vec2((abs(_e25) + abs(_e28))));
+    let _e35 = v[0u];
+    let _e38 = v[1u];
+    d = ((_e35 * 0.5f) + (_e38 * 0.5f));
+    let _e42 = uniforms.smoothness;
+    let _e45 = v[0u];
+    let _e47 = (*uv_2)[0u];
+    let _e50 = v[1u];
+    let _e52 = (*uv_2)[1u];
+    let _e55 = d;
+    let _e58 = uniforms.progress;
+    let _e60 = uniforms.smoothness;
+    m = (1f - smoothstep(-(_e42), 0f, (((_e45 * _e47) + (_e50 * _e52)) - ((_e55 - 0.5f) + (_e58 * (1f + _e60))))));
+    let _e67 = (*uv_2);
+    let _e70 = m;
+    param = (((_e67 - vec2(0.5f)) * (1f - _e70)) + vec2(0.5f));
+    let _e75 = getFromColor((&param));
+    let _e76 = (*uv_2);
+    let _e79 = m;
+    param_1 = (((_e76 - vec2(0.5f)) * _e79) + vec2(0.5f));
+    let _e83 = getToColor((&param_1));
+    let _e84 = m;
+    return mix(_e75, _e83, vec4(_e84));
+}
+
+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;
+}