gl-transitions 1.74.0 → 1.76.0

package/wgsl/CircleCrop.wgsl

@@ -0,0 +1,88 @@
+// CircleCrop — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CircleCrop.glsl
+// Author: fkuteken
+// License: MIT
+// Description: The outgoing image closes into a circle over a background color, then the incoming one opens from it
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    bgcolor: vec4<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(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var ratio2_: vec2<f32>;
+    var s: f32;
+    var dist: f32;
+    var local: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e24 = uniforms.ratio;
+    ratio2_ = vec2<f32>(1f, (1f / _e24));
+    let _e28 = uniforms.progress;
+    s = pow((2f * abs((_e28 - 0.5f))), 3f);
+    let _e33 = (*p);
+    let _e36 = ratio2_;
+    dist = length(((_e33 - vec2(0.5f)) * _e36));
+    let _e40 = uniforms.progress;
+    if (_e40 < 0.5f) {
+        let _e42 = (*p);
+        param = _e42;
+        let _e43 = getFromColor((&param));
+        local = _e43;
+    } else {
+        let _e44 = (*p);
+        param_1 = _e44;
+        let _e45 = getToColor((&param_1));
+        local = _e45;
+    }
+    let _e46 = local;
+    let _e48 = uniforms.bgcolor;
+    let _e49 = s;
+    let _e50 = dist;
+    return mix(_e46, _e48, vec4(step(_e49, _e50)));
+}
+
+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/ColourDistance.wgsl

@@ -0,0 +1,82 @@
+// ColourDistance — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ColourDistance.glsl
+// Author: P-Seebauer
+// License: MIT
+// Description: Pixels switch to the incoming image in order of how close their colors are
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    power: 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(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var fTex: vec4<f32>;
+    var param: vec2<f32>;
+    var tTex: vec4<f32>;
+    var param_1: vec2<f32>;
+    var m: f32;
+
+    let _e18 = (*p);
+    param = _e18;
+    let _e19 = getFromColor((&param));
+    fTex = _e19;
+    let _e20 = (*p);
+    param_1 = _e20;
+    let _e21 = getToColor((&param_1));
+    tTex = _e21;
+    let _e22 = fTex;
+    let _e23 = tTex;
+    let _e26 = uniforms.progress;
+    m = step(distance(_e22, _e23), _e26);
+    let _e28 = fTex;
+    let _e29 = tTex;
+    let _e30 = m;
+    let _e33 = tTex;
+    let _e35 = uniforms.progress;
+    let _e37 = uniforms.power;
+    return mix(mix(_e28, _e29, vec4(_e30)), _e33, vec4(pow(_e35, _e37)));
+}
+
+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;
+}

package/wgsl/CrazyParametricFun.wgsl

@@ -0,0 +1,111 @@
+// CrazyParametricFun — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrazyParametricFun.glsl
+// Author: mandubian
+// License: MIT
+// Description: The outgoing image is pulled along a parametric curve into a psychedelic swirl
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    a: f32,
+    b: f32,
+    amplitude: f32,
+    smoothness: 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 _e21 = (*uv)[0u];
+    let _e23 = (*uv)[1u];
+    let _e26 = textureSampleLevel(_to, _sampler, vec2<f32>(_e21, (1f - _e23)), 0f);
+    return _e26;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e21 = (*uv_1)[0u];
+    let _e23 = (*uv_1)[1u];
+    let _e26 = textureSampleLevel(_from, _sampler, vec2<f32>(_e21, (1f - _e23)), 0f);
+    return _e26;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var p: vec2<f32>;
+    var dir: vec2<f32>;
+    var dist: f32;
+    var x: f32;
+    var y: f32;
+    var offset: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e28 = (*uv_2);
+    p = (_e28 / vec2<f32>(1f, 1f));
+    let _e30 = p;
+    dir = (_e30 - vec2<f32>(0.5f, 0.5f));
+    let _e32 = dir;
+    dist = length(_e32);
+    let _e35 = uniforms.a;
+    let _e37 = uniforms.b;
+    let _e40 = uniforms.progress;
+    let _e44 = uniforms.b;
+    let _e46 = uniforms.progress;
+    let _e48 = uniforms.a;
+    let _e50 = uniforms.b;
+    x = (((_e35 - _e37) * cos(_e40)) + (_e44 * cos((_e46 * ((_e48 / _e50) - 1f)))));
+    let _e58 = uniforms.a;
+    let _e60 = uniforms.b;
+    let _e63 = uniforms.progress;
+    let _e67 = uniforms.b;
+    let _e69 = uniforms.progress;
+    let _e71 = uniforms.a;
+    let _e73 = uniforms.b;
+    y = (((_e58 - _e60) * sin(_e63)) - (_e67 * sin((_e69 * ((_e71 / _e73) - 1f)))));
+    let _e80 = dir;
+    let _e82 = uniforms.progress;
+    let _e83 = dist;
+    let _e86 = uniforms.amplitude;
+    let _e88 = x;
+    let _e92 = uniforms.progress;
+    let _e93 = dist;
+    let _e96 = uniforms.amplitude;
+    let _e98 = y;
+    let _e104 = uniforms.smoothness;
+    offset = ((_e80 * vec2<f32>(sin((((_e82 * _e83) * _e86) * _e88)), sin((((_e92 * _e93) * _e96) * _e98)))) / vec2(_e104));
+    let _e107 = p;
+    let _e108 = offset;
+    param = (_e107 + _e108);
+    let _e110 = getFromColor((&param));
+    let _e111 = p;
+    param_1 = _e111;
+    let _e112 = getToColor((&param_1));
+    let _e114 = uniforms.progress;
+    return mix(_e110, _e112, vec4(smoothstep(0.2f, 1f, _e114)));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e20 = _uv_1;
+    param_2 = _e20;
+    let _e21 = transition((&param_2));
+    _fragColor = _e21;
+    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/CrossZoom.wgsl

@@ -0,0 +1,219 @@
+// CrossZoom — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrossZoom.glsl
+// Author: rectalogic
+// License: MIT
+// Description: A crossfade through a strong zoom blur
+// 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 _e28 = (*uv)[0u];
+    let _e30 = (*uv)[1u];
+    let _e33 = textureSampleLevel(_to, _sampler, vec2<f32>(_e28, (1f - _e30)), 0f);
+    return _e33;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e28 = (*uv_1)[0u];
+    let _e30 = (*uv_1)[1u];
+    let _e33 = textureSampleLevel(_from, _sampler, vec2<f32>(_e28, (1f - _e30)), 0f);
+    return _e33;
+}
+
+fn crossFade(uv_2: ptr<function, vec2<f32>>, dissolve: ptr<function, f32>) -> vec4<f32> {
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e30 = (*uv_2);
+    param = _e30;
+    let _e31 = getFromColor((&param));
+    let _e32 = (*uv_2);
+    param_1 = _e32;
+    let _e33 = getToColor((&param_1));
+    let _e34 = (*dissolve);
+    return mix(_e31, _e33, vec4(_e34));
+}
+
+fn rand(co: ptr<function, vec2<f32>>) -> f32 {
+    let _e27 = (*co);
+    return fract((sin(dot(_e27, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn Sinusoidal_easeInOut(begin: ptr<function, f32>, change: ptr<function, f32>, duration: ptr<function, f32>, time: ptr<function, f32>) -> f32 {
+    let _e30 = (*change);
+    let _e33 = (*time);
+    let _e35 = (*duration);
+    let _e40 = (*begin);
+    return (((-(_e30) / 2f) * (cos(((3.1415927f * _e33) / _e35)) - 1f)) + _e40);
+}
+
+fn Exponential_easeInOut(begin_1: ptr<function, f32>, change_1: ptr<function, f32>, duration_1: ptr<function, f32>, time_1: ptr<function, f32>) -> f32 {
+    let _e30 = (*time_1);
+    if (_e30 == 0f) {
+        let _e32 = (*begin_1);
+        return _e32;
+    } else {
+        let _e33 = (*time_1);
+        let _e34 = (*duration_1);
+        if (_e33 == _e34) {
+            let _e36 = (*begin_1);
+            let _e37 = (*change_1);
+            return (_e36 + _e37);
+        }
+    }
+    let _e39 = (*time_1);
+    let _e40 = (*duration_1);
+    (*time_1) = (_e39 / (_e40 / 2f));
+    let _e43 = (*time_1);
+    if (_e43 < 1f) {
+        let _e45 = (*change_1);
+        let _e47 = (*time_1);
+        let _e52 = (*begin_1);
+        return (((_e45 / 2f) * pow(2f, (10f * (_e47 - 1f)))) + _e52);
+    }
+    let _e54 = (*change_1);
+    let _e56 = (*time_1);
+    let _e63 = (*begin_1);
+    return (((_e54 / 2f) * (-(pow(2f, (-10f * (_e56 - 1f)))) + 2f)) + _e63);
+}
+
+fn Linear_ease(begin_2: ptr<function, f32>, change_2: ptr<function, f32>, duration_2: ptr<function, f32>, time_2: ptr<function, f32>) -> f32 {
+    let _e30 = (*change_2);
+    let _e31 = (*time_2);
+    let _e33 = (*duration_2);
+    let _e35 = (*begin_2);
+    return (((_e30 * _e31) / _e33) + _e35);
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var texCoord: vec2<f32>;
+    var center: vec2<f32>;
+    var param_2: f32;
+    var param_3: f32;
+    var param_4: f32;
+    var param_5: f32;
+    var dissolve_1: f32;
+    var param_6: f32;
+    var param_7: f32;
+    var param_8: f32;
+    var param_9: f32;
+    var strength: f32;
+    var param_10: f32;
+    var param_11: f32;
+    var param_12: f32;
+    var param_13: f32;
+    var color: vec4<f32>;
+    var total: f32;
+    var toCenter: vec2<f32>;
+    var offset: f32;
+    var param_14: vec2<f32>;
+    var t: f32;
+    var percent: f32;
+    var weight: f32;
+    var param_15: vec2<f32>;
+    var param_16: f32;
+
+    let _e53 = (*uv_3);
+    texCoord = (_e53 / vec2<f32>(1f, 1f));
+    param_2 = 0.25f;
+    param_3 = 0.5f;
+    param_4 = 1f;
+    let _e56 = uniforms.progress;
+    param_5 = _e56;
+    let _e57 = Linear_ease((&param_2), (&param_3), (&param_4), (&param_5));
+    center = vec2<f32>(_e57, 0.5f);
+    param_6 = 0f;
+    param_7 = 1f;
+    param_8 = 1f;
+    let _e60 = uniforms.progress;
+    param_9 = _e60;
+    let _e61 = Exponential_easeInOut((&param_6), (&param_7), (&param_8), (&param_9));
+    dissolve_1 = _e61;
+    param_10 = 0f;
+    let _e63 = uniforms.strength;
+    param_11 = _e63;
+    param_12 = 0.5f;
+    let _e65 = uniforms.progress;
+    param_13 = _e65;
+    let _e66 = Sinusoidal_easeInOut((&param_10), (&param_11), (&param_12), (&param_13));
+    strength = _e66;
+    color = vec4<f32>(0f, 0f, 0f, 0f);
+    total = 0f;
+    let _e67 = center;
+    let _e68 = texCoord;
+    toCenter = (_e67 - _e68);
+    let _e70 = (*uv_3);
+    param_14 = _e70;
+    let _e71 = rand((&param_14));
+    offset = _e71;
+    t = 0f;
+    loop {
+        let _e72 = t;
+        if (_e72 <= 40f) {
+            let _e74 = t;
+            let _e75 = offset;
+            percent = ((_e74 + _e75) / 40f);
+            let _e78 = percent;
+            let _e79 = percent;
+            let _e80 = percent;
+            weight = (4f * (_e78 - (_e79 * _e80)));
+            let _e84 = texCoord;
+            let _e85 = toCenter;
+            let _e86 = percent;
+            let _e88 = strength;
+            param_15 = (_e84 + ((_e85 * _e86) * _e88));
+            let _e91 = dissolve_1;
+            param_16 = _e91;
+            let _e92 = crossFade((&param_15), (&param_16));
+            let _e93 = weight;
+            let _e95 = color;
+            color = (_e95 + (_e92 * _e93));
+            let _e97 = weight;
+            let _e98 = total;
+            total = (_e98 + _e97);
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e100 = t;
+            t = (_e100 + 1f);
+        }
+    }
+    let _e102 = color;
+    let _e103 = total;
+    return (_e102 / vec4(_e103));
+}
+
+fn main_1() {
+    var param_17: vec2<f32>;
+
+    let _e27 = _uv_1;
+    param_17 = _e27;
+    let _e28 = transition((&param_17));
+    _fragColor = _e28;
+    return;
+}
+
+@fragment 
+fn main(@location(0) _uv: vec2<f32>) -> @location(0) vec4<f32> {
+    _uv_1 = _uv;
+    main_1();
+    let _e3 = _fragColor;
+    return _e3;
+}