gl-transitions 1.74.0 → 1.76.0

package/wgsl/LeftRight.wgsl

@@ -0,0 +1,109 @@
+// LeftRight — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LeftRight.glsl
+// Author: zhmy
+// License: MIT
+// Description: The outgoing image shrinks away to the left while the incoming one slides in from the right
+// 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 _e24 = (*uv)[0u];
+    let _e26 = (*uv)[1u];
+    let _e29 = textureSampleLevel(_from, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e24 = (*uv_1)[0u];
+    let _e26 = (*uv_1)[1u];
+    let _e29 = textureSampleLevel(_to, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_74_: bool;
+
+    let _e23 = (*p);
+    let _e25 = all((vec2<f32>(0f, 0f) < _e23));
+    phi_74_ = _e25;
+    if _e25 {
+        let _e26 = (*p);
+        phi_74_ = all((_e26 < vec2<f32>(1f, 1f)));
+    }
+    let _e30 = phi_74_;
+    return _e30;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var spto: vec2<f32>;
+    var size: f32;
+    var spfr: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    spto = vec2<f32>(-1f, -1f);
+    let _e31 = uniforms.progress;
+    size = mix(1f, 3f, (_e31 * 0.2f));
+    let _e34 = (*uv_2);
+    let _e36 = size;
+    spto = (((_e34 + vec2<f32>(-0.5f, -0.5f)) * vec2(_e36)) + vec2<f32>(0.5f, 0.5f));
+    let _e40 = (*uv_2);
+    let _e42 = uniforms.progress;
+    spfr = (_e40 - vec2<f32>((1f - _e42), 0f));
+    let _e46 = spfr;
+    param = _e46;
+    let _e47 = inBounds((&param));
+    if _e47 {
+        let _e48 = spfr;
+        param_1 = _e48;
+        let _e49 = getToColor((&param_1));
+        return _e49;
+    } else {
+        let _e50 = spto;
+        param_2 = _e50;
+        let _e51 = inBounds((&param_2));
+        if _e51 {
+            let _e52 = spto;
+            param_3 = _e52;
+            let _e53 = getFromColor((&param_3));
+            let _e55 = uniforms.progress;
+            return (_e53 * (1f - _e55));
+        } else {
+            return vec4<f32>(0f, 0f, 0f, 1f);
+        }
+    }
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e23 = _uv_1;
+    param_4 = _e23;
+    let _e24 = transition((&param_4));
+    _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/LinearBlur.wgsl

@@ -0,0 +1,131 @@
+// LinearBlur — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LinearBlur.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade through a blur
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    intensity: 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 transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var c1_: vec4<f32>;
+    var c2_: vec4<f32>;
+    var disp: f32;
+    var xi: i32;
+    var x: f32;
+    var yi: i32;
+    var y: f32;
+    var v: vec2<f32>;
+    var d: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    c1_ = vec4<f32>(0f, 0f, 0f, 0f);
+    c2_ = vec4<f32>(0f, 0f, 0f, 0f);
+    let _e31 = uniforms.intensity;
+    let _e33 = uniforms.progress;
+    disp = (_e31 * (0.5f - distance(0.5f, _e33)));
+    xi = 0i;
+    loop {
+        let _e37 = xi;
+        if (_e37 < 6i) {
+            let _e39 = xi;
+            x = ((f32(_e39) / 6f) - 0.5f);
+            yi = 0i;
+            loop {
+                let _e43 = yi;
+                if (_e43 < 6i) {
+                    let _e45 = yi;
+                    y = ((f32(_e45) / 6f) - 0.5f);
+                    let _e49 = x;
+                    let _e50 = y;
+                    v = vec2<f32>(_e49, _e50);
+                    let _e52 = disp;
+                    d = _e52;
+                    let _e53 = (*uv_2);
+                    let _e54 = d;
+                    let _e55 = v;
+                    param = (_e53 + (_e55 * _e54));
+                    let _e58 = getFromColor((&param));
+                    let _e59 = c1_;
+                    c1_ = (_e59 + _e58);
+                    let _e61 = (*uv_2);
+                    let _e62 = d;
+                    let _e63 = v;
+                    param_1 = (_e61 + (_e63 * _e62));
+                    let _e66 = getToColor((&param_1));
+                    let _e67 = c2_;
+                    c2_ = (_e67 + _e66);
+                    continue;
+                } else {
+                    break;
+                }
+                continuing {
+                    let _e69 = yi;
+                    yi = (_e69 + 1i);
+                }
+            }
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e71 = xi;
+            xi = (_e71 + 1i);
+        }
+    }
+    let _e73 = c1_;
+    c1_ = (_e73 / vec4(36f));
+    let _e76 = c2_;
+    c2_ = (_e76 / vec4(36f));
+    let _e79 = c1_;
+    let _e80 = c2_;
+    let _e82 = uniforms.progress;
+    return mix(_e79, _e80, vec4(_e82));
+}
+
+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;
+}

package/wgsl/Mosaic.wgsl

@@ -0,0 +1,174 @@
+// Mosaic — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Mosaic.glsl
+// Author: Xaychru
+// License: MIT
+// Description: The view pans across a mosaic of rotated tiles from both images and settles on the incoming one
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    endx: i32,
+    endy: 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 getFromColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e26 = (*uv)[0u];
+    let _e28 = (*uv)[1u];
+    let _e31 = textureSampleLevel(_from, _sampler, vec2<f32>(_e26, (1f - _e28)), 0f);
+    return _e31;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e26 = (*uv_1)[0u];
+    let _e28 = (*uv_1)[1u];
+    let _e31 = textureSampleLevel(_to, _sampler, vec2<f32>(_e26, (1f - _e28)), 0f);
+    return _e31;
+}
+
+fn Rotate(v: ptr<function, vec2<f32>>, a: ptr<function, f32>) -> vec2<f32> {
+    var rm: mat2x2<f32>;
+
+    let _e27 = (*a);
+    let _e29 = (*a);
+    let _e32 = (*a);
+    let _e34 = (*a);
+    rm = mat2x2<f32>(vec2<f32>(cos(_e27), -(sin(_e29))), vec2<f32>(sin(_e32), cos(_e34)));
+    let _e39 = rm;
+    let _e40 = (*v);
+    return (_e39 * _e40);
+}
+
+fn Rand(v_1: ptr<function, vec2<f32>>) -> f32 {
+    let _e25 = (*v_1);
+    return fract((sin(dot(_e25, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn CosInterpolation(x: ptr<function, f32>) -> f32 {
+    let _e25 = (*x);
+    return ((-(cos((_e25 * 3.1415927f))) / 2f) + 0.5f);
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p: vec2<f32>;
+    var rp: vec2<f32>;
+    var rpr: f32;
+    var z: f32;
+    var az: f32;
+    var param: f32;
+    var param_1: f32;
+    var mrp: vec2<f32>;
+    var crp: vec2<f32>;
+    var onEnd: bool;
+    var ang: f32;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var param_4: f32;
+    var param_5: vec2<f32>;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+    var phi_197_: bool;
+    var phi_229_: bool;
+
+    let _e42 = (*uv_2);
+    p = ((_e42 / vec2<f32>(1f, 1f)) - vec2(0.5f));
+    let _e46 = p;
+    rp = _e46;
+    let _e48 = uniforms.progress;
+    rpr = ((_e48 * 2f) - 1f);
+    let _e51 = rpr;
+    let _e52 = rpr;
+    z = (-(((_e51 * _e52) * 2f)) + 3f);
+    let _e57 = z;
+    az = abs(_e57);
+    let _e59 = az;
+    let _e60 = rp;
+    rp = (_e60 * _e59);
+    let _e63 = uniforms.endx;
+    let _e67 = uniforms.endy;
+    let _e72 = uniforms.progress;
+    param = _e72;
+    let _e73 = CosInterpolation((&param));
+    let _e75 = uniforms.progress;
+    param_1 = _e75;
+    let _e76 = CosInterpolation((&param_1));
+    let _e80 = rp;
+    rp = (_e80 + mix(vec2<f32>(0.5f, 0.5f), vec2<f32>((f32(_e63) + 0.5f), (f32(_e67) + 0.5f)), vec2((_e73 * _e76))));
+    let _e82 = rp;
+    let _e83 = vec2(1f);
+    mrp = (_e82 - (floor((_e82 / _e83)) * _e83));
+    let _e88 = rp;
+    crp = _e88;
+    let _e90 = crp[0u];
+    let _e94 = uniforms.endx;
+    let _e95 = (i32(floor(_e90)) == _e94);
+    phi_197_ = _e95;
+    if _e95 {
+        let _e97 = crp[1u];
+        let _e101 = uniforms.endy;
+        phi_197_ = (i32(floor(_e97)) == _e101);
+    }
+    let _e104 = phi_197_;
+    onEnd = _e104;
+    let _e105 = onEnd;
+    if !(_e105) {
+        let _e107 = crp;
+        param_2 = floor(_e107);
+        let _e109 = Rand((&param_2));
+        ang = ((f32(i32((_e109 * 4f))) * 0.5f) * 3.1415927f);
+        let _e115 = mrp;
+        param_3 = (_e115 - vec2<f32>(0.5f, 0.5f));
+        let _e117 = ang;
+        param_4 = _e117;
+        let _e118 = Rotate((&param_3), (&param_4));
+        mrp = (vec2<f32>(0.5f, 0.5f) + _e118);
+    }
+    let _e120 = onEnd;
+    phi_229_ = _e120;
+    if !(_e120) {
+        let _e122 = crp;
+        param_5 = floor(_e122);
+        let _e124 = Rand((&param_5));
+        phi_229_ = (_e124 > 0.5f);
+    }
+    let _e127 = phi_229_;
+    if _e127 {
+        let _e128 = mrp;
+        param_6 = _e128;
+        let _e129 = getToColor((&param_6));
+        return _e129;
+    } else {
+        let _e130 = mrp;
+        param_7 = _e130;
+        let _e131 = getFromColor((&param_7));
+        return _e131;
+    }
+}
+
+fn main_1() {
+    var param_8: vec2<f32>;
+
+    let _e25 = _uv_1;
+    param_8 = _e25;
+    let _e26 = transition((&param_8));
+    _fragColor = _e26;
+    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/Overexposure.wgsl

@@ -0,0 +1,102 @@
+// Overexposure — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Overexposure.glsl
+// Author: Ben Zhang
+// License: MIT
+// Description: A crossfade through a washed-out, overexposed white
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    strength: 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 from_m: f32;
+    var to_m: f32;
+
+    let _e22 = (*uv_2);
+    param = _e22;
+    let _e23 = getFromColor((&param));
+    from_ = _e23;
+    let _e24 = (*uv_2);
+    param_1 = _e24;
+    let _e25 = getToColor((&param_1));
+    to = _e25;
+    let _e27 = uniforms.progress;
+    let _e30 = uniforms.progress;
+    let _e34 = uniforms.strength;
+    from_m = ((1f - _e27) + (sin((3.1415927f * _e30)) * _e34));
+    let _e38 = uniforms.progress;
+    let _e40 = uniforms.progress;
+    let _e44 = uniforms.strength;
+    to_m = (_e38 + (sin((3.1415927f * _e40)) * _e44));
+    let _e48 = from_[0u];
+    let _e50 = from_[3u];
+    let _e52 = from_m;
+    let _e55 = to[0u];
+    let _e57 = to[3u];
+    let _e59 = to_m;
+    let _e63 = from_[1u];
+    let _e65 = from_[3u];
+    let _e67 = from_m;
+    let _e70 = to[1u];
+    let _e72 = to[3u];
+    let _e74 = to_m;
+    let _e78 = from_[2u];
+    let _e80 = from_[3u];
+    let _e82 = from_m;
+    let _e85 = to[2u];
+    let _e87 = to[3u];
+    let _e89 = to_m;
+    let _e93 = from_[3u];
+    let _e95 = to[3u];
+    let _e97 = uniforms.progress;
+    return vec4<f32>((((_e48 * _e50) * _e52) + ((_e55 * _e57) * _e59)), (((_e63 * _e65) * _e67) + ((_e70 * _e72) * _e74)), (((_e78 * _e80) * _e82) + ((_e85 * _e87) * _e89)), mix(_e93, _e95, _e97));
+}
+
+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/PolkaDotsCurtain.wgsl

@@ -0,0 +1,83 @@
+// PolkaDotsCurtain — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/PolkaDotsCurtain.glsl
+// Author: bobylito
+// License: MIT
+// Description: The incoming image appears through growing polka dots
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    dots: f32,
+    center: 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 _e18 = (*uv)[0u];
+    let _e20 = (*uv)[1u];
+    let _e23 = textureSampleLevel(_from, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e18 = (*uv_1)[0u];
+    let _e20 = (*uv_1)[1u];
+    let _e23 = textureSampleLevel(_to, _sampler, vec2<f32>(_e18, (1f - _e20)), 0f);
+    return _e23;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var nextImage: bool;
+    var local: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e21 = (*uv_2);
+    let _e23 = uniforms.dots;
+    let _e28 = uniforms.progress;
+    let _e29 = (*uv_2);
+    let _e31 = uniforms.center;
+    nextImage = (distance(fract((_e21 * _e23)), vec2<f32>(0.5f, 0.5f)) < (_e28 / distance(_e29, _e31)));
+    let _e35 = nextImage;
+    if _e35 {
+        let _e36 = (*uv_2);
+        param = _e36;
+        let _e37 = getToColor((&param));
+        local = _e37;
+    } else {
+        let _e38 = (*uv_2);
+        param_1 = _e38;
+        let _e39 = getFromColor((&param_1));
+        local = _e39;
+    }
+    let _e40 = local;
+    return _e40;
+}
+
+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;
+}