gl-transitions 1.74.0 → 1.76.0

package/wgsl/swap.wgsl

@@ -0,0 +1,218 @@
+// swap — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/swap.glsl
+// Author: gre
+// License: MIT
+// Description: The two images swap places in 3D, with a floor reflection
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    reflection: f32,
+    perspective: f32,
+    depth: 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 _e32 = (*uv)[0u];
+    let _e34 = (*uv)[1u];
+    let _e37 = textureSampleLevel(_to, _sampler, vec2<f32>(_e32, (1f - _e34)), 0f);
+    return _e37;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e32 = (*uv_1)[0u];
+    let _e34 = (*uv_1)[1u];
+    let _e37 = textureSampleLevel(_from, _sampler, vec2<f32>(_e32, (1f - _e34)), 0f);
+    return _e37;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_84_: bool;
+
+    let _e31 = (*p);
+    let _e33 = all((vec2<f32>(0f, 0f) < _e31));
+    phi_84_ = _e33;
+    if _e33 {
+        let _e34 = (*p);
+        phi_84_ = all((_e34 < vec2<f32>(1f, 1f)));
+    }
+    let _e38 = phi_84_;
+    return _e38;
+}
+
+fn project(p_1: ptr<function, vec2<f32>>) -> vec2<f32> {
+    let _e31 = (*p_1);
+    return ((_e31 * vec2<f32>(1f, -1.2f)) + vec2<f32>(0f, -0.02f));
+}
+
+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 _e40 = (*pfr);
+    param = _e40;
+    let _e41 = project((&param));
+    (*pfr) = _e41;
+    let _e42 = (*pfr);
+    param_1 = _e42;
+    let _e43 = inBounds((&param_1));
+    if _e43 {
+        let _e44 = (*pfr);
+        param_2 = _e44;
+        let _e45 = getFromColor((&param_2));
+        let _e47 = uniforms.reflection;
+        let _e49 = (*pfr)[1u];
+        let _e54 = c;
+        c = (_e54 + mix(vec4<f32>(0f, 0f, 0f, 1f), _e45, vec4((_e47 * mix(1f, 0f, _e49)))));
+    }
+    let _e56 = (*pto);
+    param_3 = _e56;
+    let _e57 = project((&param_3));
+    (*pto) = _e57;
+    let _e58 = (*pto);
+    param_4 = _e58;
+    let _e59 = inBounds((&param_4));
+    if _e59 {
+        let _e60 = (*pto);
+        param_5 = _e60;
+        let _e61 = getToColor((&param_5));
+        let _e63 = uniforms.reflection;
+        let _e65 = (*pto)[1u];
+        let _e70 = c;
+        c = (_e70 + mix(vec4<f32>(0f, 0f, 0f, 1f), _e61, vec4((_e63 * mix(1f, 0f, _e65)))));
+    }
+    let _e72 = c;
+    return _e72;
+}
+
+fn transition(p_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var pto_1: vec2<f32>;
+    var size: f32;
+    var persp: f32;
+    var pfr_1: vec2<f32>;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+    var param_8: vec2<f32>;
+    var param_9: vec2<f32>;
+    var param_10: vec2<f32>;
+    var param_11: vec2<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>;
+
+    pto_1 = vec2<f32>(-1f, -1f);
+    let _e47 = uniforms.depth;
+    let _e49 = uniforms.progress;
+    size = mix(1f, _e47, _e49);
+    let _e52 = uniforms.perspective;
+    let _e54 = uniforms.progress;
+    persp = (_e52 * _e54);
+    let _e56 = (*p_3);
+    let _e58 = size;
+    let _e60 = uniforms.perspective;
+    let _e62 = uniforms.progress;
+    let _e66 = size;
+    let _e67 = size;
+    let _e68 = persp;
+    let _e71 = (*p_3)[0u];
+    pfr_1 = (((_e56 + vec2<f32>(-0f, -0.5f)) * vec2<f32>((_e58 / (1f - (_e60 * _e62))), (_e66 / (1f - ((_e67 * _e68) * _e71))))) + vec2<f32>(0f, 0.5f));
+    let _e79 = uniforms.depth;
+    let _e81 = uniforms.progress;
+    size = mix(1f, _e79, (1f - _e81));
+    let _e85 = uniforms.perspective;
+    let _e87 = uniforms.progress;
+    persp = (_e85 * (1f - _e87));
+    let _e90 = (*p_3);
+    let _e92 = size;
+    let _e94 = uniforms.perspective;
+    let _e96 = uniforms.progress;
+    let _e101 = size;
+    let _e102 = size;
+    let _e103 = persp;
+    let _e106 = (*p_3)[0u];
+    pto_1 = (((_e90 + vec2<f32>(-1f, -0.5f)) * vec2<f32>((_e92 / (1f - (_e94 * (1f - _e96)))), (_e101 / (1f - ((_e102 * _e103) * (0.5f - _e106)))))) + vec2<f32>(1f, 0.5f));
+    let _e115 = uniforms.progress;
+    if (_e115 < 0.5f) {
+        let _e117 = pfr_1;
+        param_6 = _e117;
+        let _e118 = inBounds((&param_6));
+        if _e118 {
+            let _e119 = pfr_1;
+            param_7 = _e119;
+            let _e120 = getFromColor((&param_7));
+            return _e120;
+        }
+        let _e121 = pto_1;
+        param_8 = _e121;
+        let _e122 = inBounds((&param_8));
+        if _e122 {
+            let _e123 = pto_1;
+            param_9 = _e123;
+            let _e124 = getToColor((&param_9));
+            return _e124;
+        }
+    }
+    let _e125 = pto_1;
+    param_10 = _e125;
+    let _e126 = inBounds((&param_10));
+    if _e126 {
+        let _e127 = pto_1;
+        param_11 = _e127;
+        let _e128 = getToColor((&param_11));
+        return _e128;
+    }
+    let _e129 = pfr_1;
+    param_12 = _e129;
+    let _e130 = inBounds((&param_12));
+    if _e130 {
+        let _e131 = pfr_1;
+        param_13 = _e131;
+        let _e132 = getFromColor((&param_13));
+        return _e132;
+    }
+    let _e133 = (*p_3);
+    param_14 = _e133;
+    let _e134 = pfr_1;
+    param_15 = _e134;
+    let _e135 = pto_1;
+    param_16 = _e135;
+    let _e136 = bgColor((&param_14), (&param_15), (&param_16));
+    return _e136;
+}
+
+fn main_1() {
+    var param_17: vec2<f32>;
+
+    let _e31 = _uv_1;
+    param_17 = _e31;
+    let _e32 = transition((&param_17));
+    _fragColor = _e32;
+    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/tangentMotionBlur.wgsl

@@ -0,0 +1,503 @@
+// tangentMotionBlur — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/tangentMotionBlur.glsl
+// Author: chenkai
+// License: MIT
+// Description: The outgoing image is flung away along a curve with motion blur
+// 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 _e36 = (*uv)[0u];
+    let _e38 = (*uv)[1u];
+    let _e41 = textureSampleLevel(_to, _sampler, vec2<f32>(_e36, (1f - _e38)), 0f);
+    return _e41;
+}
+
+fn rand(co: ptr<function, vec2<f32>>) -> f32 {
+    let _e35 = (*co);
+    return fract((sin(dot(_e35, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn motionBlurTo(_st: ptr<function, vec2<f32>>, speed: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var texCoord: vec2<f32>;
+    var color: vec3<f32>;
+    var total: f32;
+    var offset: f32;
+    var param: vec2<f32>;
+    var t: f32;
+    var percent: f32;
+    var weight: f32;
+    var newuv: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e46 = (*_st);
+    texCoord = (_e46 / vec2<f32>(1f, 1f));
+    color = vec3<f32>(0f, 0f, 0f);
+    total = 0f;
+    let _e48 = (*_st);
+    param = _e48;
+    let _e49 = rand((&param));
+    offset = _e49;
+    t = 0f;
+    loop {
+        let _e50 = t;
+        if (_e50 <= 20f) {
+            let _e52 = t;
+            let _e53 = offset;
+            percent = ((_e52 + _e53) / 20f);
+            let _e56 = percent;
+            let _e57 = percent;
+            let _e58 = percent;
+            weight = (4f * (_e56 - (_e57 * _e58)));
+            let _e62 = texCoord;
+            let _e63 = (*speed);
+            let _e64 = percent;
+            newuv = (_e62 + (_e63 * _e64));
+            let _e67 = newuv;
+            newuv = fract(_e67);
+            let _e69 = newuv;
+            param_1 = _e69;
+            let _e70 = getToColor((&param_1));
+            let _e72 = weight;
+            let _e74 = color;
+            color = (_e74 + (_e70.xyz * _e72));
+            let _e76 = weight;
+            let _e77 = total;
+            total = (_e77 + _e76);
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e79 = t;
+            t = (_e79 + 1f);
+        }
+    }
+    let _e81 = color;
+    let _e82 = total;
+    let _e84 = (_e81 / vec3(_e82));
+    return vec4<f32>(_e84.x, _e84.y, _e84.z, 1f);
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e36 = (*uv_1)[0u];
+    let _e38 = (*uv_1)[1u];
+    let _e41 = textureSampleLevel(_from, _sampler, vec2<f32>(_e36, (1f - _e38)), 0f);
+    return _e41;
+}
+
+fn motionBlurFrom(_st_1: ptr<function, vec2<f32>>, speed_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var texCoord_1: vec2<f32>;
+    var color_1: vec3<f32>;
+    var total_1: f32;
+    var offset_1: f32;
+    var param_2: vec2<f32>;
+    var t_1: f32;
+    var percent_1: f32;
+    var weight_1: f32;
+    var newuv_1: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    let _e46 = (*_st_1);
+    texCoord_1 = (_e46 / vec2<f32>(1f, 1f));
+    color_1 = vec3<f32>(0f, 0f, 0f);
+    total_1 = 0f;
+    let _e48 = (*_st_1);
+    param_2 = _e48;
+    let _e49 = rand((&param_2));
+    offset_1 = _e49;
+    t_1 = 0f;
+    loop {
+        let _e50 = t_1;
+        if (_e50 <= 20f) {
+            let _e52 = t_1;
+            let _e53 = offset_1;
+            percent_1 = ((_e52 + _e53) / 20f);
+            let _e56 = percent_1;
+            let _e57 = percent_1;
+            let _e58 = percent_1;
+            weight_1 = (4f * (_e56 - (_e57 * _e58)));
+            let _e62 = texCoord_1;
+            let _e63 = (*speed_1);
+            let _e64 = percent_1;
+            newuv_1 = (_e62 + (_e63 * _e64));
+            let _e67 = newuv_1;
+            newuv_1 = fract(_e67);
+            let _e69 = newuv_1;
+            param_3 = _e69;
+            let _e70 = getFromColor((&param_3));
+            let _e72 = weight_1;
+            let _e74 = color_1;
+            color_1 = (_e74 + (_e70.xyz * _e72));
+            let _e76 = weight_1;
+            let _e77 = total_1;
+            total_1 = (_e77 + _e76);
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e79 = t_1;
+            t_1 = (_e79 + 1f);
+        }
+    }
+    let _e81 = color_1;
+    let _e82 = total_1;
+    let _e84 = (_e81 / vec3(_e82));
+    return vec4<f32>(_e84.x, _e84.y, _e84.z, 1f);
+}
+
+fn rotateUv(uv_2: ptr<function, vec2<f32>>, angle: ptr<function, f32>, anchor: ptr<function, vec2<f32>>, zDirection: ptr<function, f32>) -> vec2<f32> {
+    var s: f32;
+    var c: f32;
+    var m: mat2x2<f32>;
+
+    let _e41 = (*uv_2);
+    let _e42 = (*anchor);
+    (*uv_2) = (_e41 - _e42);
+    let _e44 = (*angle);
+    s = sin(_e44);
+    let _e46 = (*angle);
+    c = cos(_e46);
+    let _e48 = c;
+    let _e49 = s;
+    let _e51 = s;
+    let _e52 = c;
+    m = mat2x2<f32>(vec2<f32>(_e48, -(_e49)), vec2<f32>(_e51, _e52));
+    let _e56 = m;
+    let _e57 = (*uv_2);
+    (*uv_2) = (_e56 * _e57);
+    let _e59 = (*anchor);
+    let _e60 = (*uv_2);
+    (*uv_2) = (_e60 + _e59);
+    let _e62 = (*uv_2);
+    return _e62;
+}
+
+fn normpdf(x: ptr<function, f32>) -> f32 {
+    var d: f32;
+
+    let _e36 = (*x);
+    d = (_e36 - 0.5f);
+    let _e38 = d;
+    let _e40 = d;
+    return exp(((-20f * _e38) * _e40));
+}
+
+fn C(aA1_: ptr<function, f32>) -> f32 {
+    let _e35 = (*aA1_);
+    return (3f * _e35);
+}
+
+fn B(aA1_1: ptr<function, f32>, aA2_: ptr<function, f32>) -> f32 {
+    let _e36 = (*aA2_);
+    let _e38 = (*aA1_1);
+    return ((3f * _e36) - (6f * _e38));
+}
+
+fn A(aA1_2: ptr<function, f32>, aA2_1: ptr<function, f32>) -> f32 {
+    let _e36 = (*aA2_1);
+    let _e39 = (*aA1_2);
+    return ((1f - (3f * _e36)) + (3f * _e39));
+}
+
+fn CalcBezier(aT: ptr<function, f32>, aA1_3: ptr<function, f32>, aA2_2: ptr<function, f32>) -> f32 {
+    var param_4: f32;
+    var param_5: f32;
+    var param_6: f32;
+    var param_7: f32;
+    var param_8: f32;
+
+    let _e42 = (*aA1_3);
+    param_4 = _e42;
+    let _e43 = (*aA2_2);
+    param_5 = _e43;
+    let _e44 = A((&param_4), (&param_5));
+    let _e45 = (*aT);
+    let _e47 = (*aA1_3);
+    param_6 = _e47;
+    let _e48 = (*aA2_2);
+    param_7 = _e48;
+    let _e49 = B((&param_6), (&param_7));
+    let _e51 = (*aT);
+    let _e53 = (*aA1_3);
+    param_8 = _e53;
+    let _e54 = C((&param_8));
+    let _e56 = (*aT);
+    return (((((_e44 * _e45) + _e49) * _e51) + _e54) * _e56);
+}
+
+fn GetSlope(aT_1: ptr<function, f32>, aA1_4: ptr<function, f32>, aA2_3: ptr<function, f32>) -> f32 {
+    var param_9: f32;
+    var param_10: f32;
+    var param_11: f32;
+    var param_12: f32;
+    var param_13: f32;
+
+    let _e42 = (*aA1_4);
+    param_9 = _e42;
+    let _e43 = (*aA2_3);
+    param_10 = _e43;
+    let _e44 = A((&param_9), (&param_10));
+    let _e46 = (*aT_1);
+    let _e48 = (*aT_1);
+    let _e50 = (*aA1_4);
+    param_11 = _e50;
+    let _e51 = (*aA2_3);
+    param_12 = _e51;
+    let _e52 = B((&param_11), (&param_12));
+    let _e54 = (*aT_1);
+    let _e57 = (*aA1_4);
+    param_13 = _e57;
+    let _e58 = C((&param_13));
+    return (((((3f * _e44) * _e46) * _e48) + ((2f * _e52) * _e54)) + _e58);
+}
+
+fn GetTForX(aX: ptr<function, f32>, mX1_: ptr<function, f32>, mX2_: ptr<function, f32>) -> f32 {
+    var aGuessT: f32;
+    var i: i32;
+    var currentSlope: f32;
+    var param_14: f32;
+    var param_15: f32;
+    var param_16: f32;
+    var currentX: f32;
+    var param_17: f32;
+    var param_18: f32;
+    var param_19: f32;
+
+    let _e47 = (*aX);
+    aGuessT = _e47;
+    i = 0i;
+    loop {
+        let _e48 = i;
+        if (_e48 < 4i) {
+            let _e50 = aGuessT;
+            param_14 = _e50;
+            let _e51 = (*mX1_);
+            param_15 = _e51;
+            let _e52 = (*mX2_);
+            param_16 = _e52;
+            let _e53 = GetSlope((&param_14), (&param_15), (&param_16));
+            currentSlope = _e53;
+            let _e54 = currentSlope;
+            if (_e54 == 0f) {
+                let _e56 = aGuessT;
+                return _e56;
+            }
+            let _e57 = aGuessT;
+            param_17 = _e57;
+            let _e58 = (*mX1_);
+            param_18 = _e58;
+            let _e59 = (*mX2_);
+            param_19 = _e59;
+            let _e60 = CalcBezier((&param_17), (&param_18), (&param_19));
+            let _e61 = (*aX);
+            currentX = (_e60 - _e61);
+            let _e63 = currentX;
+            let _e64 = currentSlope;
+            let _e66 = aGuessT;
+            aGuessT = (_e66 - (_e63 / _e64));
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e68 = i;
+            i = (_e68 + 1i);
+        }
+    }
+    let _e70 = aGuessT;
+    return _e70;
+}
+
+fn KeySpline(aX_1: ptr<function, f32>, mX1_1: ptr<function, f32>, mY1_: ptr<function, f32>, mX2_1: ptr<function, f32>, mY2_: ptr<function, f32>) -> f32 {
+    var param_20: f32;
+    var param_21: f32;
+    var param_22: f32;
+    var param_23: f32;
+    var param_24: f32;
+    var param_25: f32;
+
+    let _e45 = (*mX1_1);
+    let _e46 = (*mY1_);
+    let _e48 = (*mX2_1);
+    let _e49 = (*mY2_);
+    if ((_e45 == _e46) && (_e48 == _e49)) {
+        let _e52 = (*aX_1);
+        return _e52;
+    }
+    let _e53 = (*aX_1);
+    param_20 = _e53;
+    let _e54 = (*mX1_1);
+    param_21 = _e54;
+    let _e55 = (*mX2_1);
+    param_22 = _e55;
+    let _e56 = GetTForX((&param_20), (&param_21), (&param_22));
+    param_23 = _e56;
+    let _e57 = (*mY1_);
+    param_24 = _e57;
+    let _e58 = (*mY2_);
+    param_25 = _e58;
+    let _e59 = CalcBezier((&param_23), (&param_24), (&param_25));
+    return _e59;
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var myst: vec2<f32>;
+    var animationTime: f32;
+    var easingTime: f32;
+    var param_26: f32;
+    var param_27: f32;
+    var param_28: f32;
+    var param_29: f32;
+    var param_30: f32;
+    var blur: f32;
+    var param_31: f32;
+    var r: f32;
+    var rotation: f32;
+    var mystCurrent: vec2<f32>;
+    var param_32: vec2<f32>;
+    var param_33: f32;
+    var param_34: vec2<f32>;
+    var param_35: f32;
+    var timeInterval: f32;
+    var mystNext: vec2<f32>;
+    var param_36: vec2<f32>;
+    var param_37: f32;
+    var param_38: vec2<f32>;
+    var param_39: f32;
+    var speed_2: vec2<f32>;
+    var param_40: vec2<f32>;
+    var param_41: vec2<f32>;
+    var param_42: vec2<f32>;
+    var param_43: vec2<f32>;
+
+    let _e63 = (*uv_3);
+    myst = _e63;
+    let _e65 = uniforms.progress;
+    animationTime = _e65;
+    let _e66 = animationTime;
+    param_26 = _e66;
+    param_27 = 0.68f;
+    param_28 = 0.01f;
+    param_29 = 0.17f;
+    param_30 = 0.98f;
+    let _e67 = KeySpline((&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
+    easingTime = _e67;
+    let _e68 = easingTime;
+    param_31 = _e68;
+    let _e69 = normpdf((&param_31));
+    blur = _e69;
+    r = 0f;
+    rotation = 3.14159f;
+    let _e70 = easingTime;
+    if (_e70 <= 0.5f) {
+        let _e72 = rotation;
+        let _e73 = easingTime;
+        r = (_e72 * _e73);
+    } else {
+        let _e75 = rotation;
+        let _e77 = rotation;
+        let _e78 = easingTime;
+        r = (-(_e75) + (_e77 * _e78));
+    }
+    let _e81 = myst;
+    mystCurrent = _e81;
+    let _e83 = uniforms.ratio;
+    let _e86 = mystCurrent[1u];
+    mystCurrent[1u] = (_e86 * (1f / _e83));
+    let _e89 = mystCurrent;
+    param_32 = _e89;
+    let _e90 = r;
+    param_33 = _e90;
+    param_34 = vec2<f32>(1f, 0f);
+    param_35 = -1f;
+    let _e91 = rotateUv((&param_32), (&param_33), (&param_34), (&param_35));
+    mystCurrent = _e91;
+    let _e93 = uniforms.ratio;
+    let _e95 = mystCurrent[1u];
+    mystCurrent[1u] = (_e95 * _e93);
+    timeInterval = 0.0334f;
+    let _e98 = easingTime;
+    if (_e98 <= 0.5f) {
+        let _e100 = rotation;
+        let _e101 = easingTime;
+        let _e102 = timeInterval;
+        r = (_e100 * (_e101 + _e102));
+    } else {
+        let _e105 = rotation;
+        let _e107 = rotation;
+        let _e108 = easingTime;
+        let _e109 = timeInterval;
+        r = (-(_e105) + (_e107 * (_e108 + _e109)));
+    }
+    let _e113 = myst;
+    mystNext = _e113;
+    let _e115 = uniforms.ratio;
+    let _e118 = mystNext[1u];
+    mystNext[1u] = (_e118 * (1f / _e115));
+    let _e121 = mystNext;
+    param_36 = _e121;
+    let _e122 = r;
+    param_37 = _e122;
+    param_38 = vec2<f32>(1f, 0f);
+    param_39 = -1f;
+    let _e123 = rotateUv((&param_36), (&param_37), (&param_38), (&param_39));
+    mystNext = _e123;
+    let _e125 = uniforms.ratio;
+    let _e127 = mystNext[1u];
+    mystNext[1u] = (_e127 * _e125);
+    let _e130 = mystNext;
+    let _e131 = mystCurrent;
+    let _e133 = timeInterval;
+    let _e136 = blur;
+    speed_2 = ((((_e130 - _e131) / vec2(_e133)) * _e136) * 0.5f);
+    let _e139 = easingTime;
+    if (_e139 <= 0.5f) {
+        let _e141 = mystCurrent;
+        param_40 = _e141;
+        let _e142 = speed_2;
+        param_41 = _e142;
+        let _e143 = motionBlurFrom((&param_40), (&param_41));
+        return _e143;
+    } else {
+        let _e144 = mystCurrent;
+        param_42 = _e144;
+        let _e145 = speed_2;
+        param_43 = _e145;
+        let _e146 = motionBlurTo((&param_42), (&param_43));
+        return _e146;
+    }
+}
+
+fn main_1() {
+    var param_44: vec2<f32>;
+
+    let _e35 = _uv_1;
+    param_44 = _e35;
+    let _e36 = transition((&param_44));
+    _fragColor = _e36;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}