gl-transitions 1.74.0 → 1.76.0

package/wgsl/directionalwipe.wgsl

@@ -0,0 +1,91 @@
+// directionalwipe — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directionalwipe.glsl
+// Author: gre
+// License: MIT
+// Description: A soft-edged diagonal wipe
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    direction: vec2<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 _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.progress;
+    let _e46 = uniforms.smoothness;
+    let _e49 = v[0u];
+    let _e51 = (*uv_2)[0u];
+    let _e54 = v[1u];
+    let _e56 = (*uv_2)[1u];
+    let _e59 = d;
+    let _e62 = uniforms.progress;
+    let _e64 = uniforms.smoothness;
+    m = ((1f - step(_e42, 0f)) * (1f - smoothstep(-(_e46), 0f, (((_e49 * _e51) + (_e54 * _e56)) - ((_e59 - 0.5f) + (_e62 * (1f + _e64)))))));
+    let _e72 = (*uv_2);
+    param = _e72;
+    let _e73 = getFromColor((&param));
+    let _e74 = (*uv_2);
+    param_1 = _e74;
+    let _e75 = getToColor((&param_1));
+    let _e76 = m;
+    return mix(_e73, _e75, vec4(_e76));
+}
+
+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/displacement.wgsl

@@ -0,0 +1,96 @@
+// displacement — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/displacement.glsl
+// Author: Travis Fischer
+// License: MIT
+// Description: A crossfade in which a displacement map (an extra grayscale texture) warps both images
+// 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(4) 
+var displacementMap: 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 _texture_displacementMap(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e15 = (*uv_2)[0u];
+    let _e17 = (*uv_2)[1u];
+    let _e20 = textureSampleLevel(displacementMap, _sampler, vec2<f32>(_e15, (1f - _e17)), 0f);
+    return _e20;
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var displacement: f32;
+    var param: vec2<f32>;
+    var uvFrom: vec2<f32>;
+    var uvTo: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e20 = (*uv_3);
+    param = _e20;
+    let _e21 = _texture_displacementMap((&param));
+    let _e24 = uniforms.strength;
+    displacement = (_e21.x * _e24);
+    let _e27 = (*uv_3)[0u];
+    let _e29 = uniforms.progress;
+    let _e30 = displacement;
+    let _e34 = (*uv_3)[1u];
+    uvFrom = vec2<f32>((_e27 + (_e29 * _e30)), _e34);
+    let _e37 = (*uv_3)[0u];
+    let _e39 = uniforms.progress;
+    let _e41 = displacement;
+    let _e45 = (*uv_3)[1u];
+    uvTo = vec2<f32>((_e37 - ((1f - _e39) * _e41)), _e45);
+    let _e47 = uvFrom;
+    param_1 = _e47;
+    let _e48 = getFromColor((&param_1));
+    let _e49 = uvTo;
+    param_2 = _e49;
+    let _e50 = getToColor((&param_2));
+    let _e52 = uniforms.progress;
+    return mix(_e48, _e50, vec4(_e52));
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e14 = _uv_1;
+    param_3 = _e14;
+    let _e15 = transition((&param_3));
+    _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/dissolve.wgsl

@@ -0,0 +1,116 @@
+// dissolve — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/dissolve.glsl
+// Author: hjm1fb
+// License: MIT
+// Description: The incoming image spreads over the outgoing one with a hot, glowing edge
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    uLineWidth: f32,
+    uSpreadClr: vec3<f32>,
+    uHotClr: vec3<f32>,
+    uPow: f32,
+    uIntensity: 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 _e26 = (*uv)[0u];
+    let _e28 = (*uv)[1u];
+    let _e31 = textureSampleLevel(_to, _sampler, vec2<f32>(_e26, (1f - _e28)), 0f);
+    return _e31;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e26 = (*uv_1)[0u];
+    let _e28 = (*uv_1)[1u];
+    let _e31 = textureSampleLevel(_from, _sampler, vec2<f32>(_e26, (1f - _e28)), 0f);
+    return _e31;
+}
+
+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 burn: f32;
+    var show: f32;
+    var outColor: vec4<f32>;
+    var factor: f32;
+    var burnColor: vec3<f32>;
+    var finalRGB: vec3<f32>;
+
+    let _e35 = (*uv_2);
+    param = _e35;
+    let _e36 = getFromColor((&param));
+    from_ = _e36;
+    let _e37 = (*uv_2);
+    param_1 = _e37;
+    let _e38 = getToColor((&param_1));
+    to = _e38;
+    let _e40 = from_[0u];
+    let _e43 = from_[1u];
+    let _e47 = from_[2u];
+    burn = (0.5f + (0.5f * (((0.299f * _e40) + (0.587f * _e43)) + (0.114f * _e47))));
+    let _e52 = burn;
+    let _e54 = uniforms.progress;
+    show = (_e52 - _e54);
+    let _e56 = show;
+    if (_e56 < 0.001f) {
+        let _e58 = to;
+        outColor = _e58;
+    } else {
+        let _e60 = uniforms.uLineWidth;
+        let _e61 = show;
+        factor = (1f - smoothstep(0f, _e60, _e61));
+        let _e65 = uniforms.uSpreadClr;
+        let _e67 = uniforms.uHotClr;
+        let _e68 = factor;
+        burnColor = mix(_e65, _e67, vec3(_e68));
+        let _e71 = burnColor;
+        let _e73 = uniforms.uPow;
+        let _e77 = uniforms.uIntensity;
+        burnColor = (pow(_e71, vec3(_e73)) * _e77);
+        let _e79 = from_;
+        let _e81 = burnColor;
+        let _e82 = factor;
+        let _e84 = uniforms.progress;
+        finalRGB = mix(_e79.xyz, _e81, vec3((_e82 * step(0.0001f, _e84))));
+        let _e89 = finalRGB;
+        let _e91 = from_[3u];
+        let _e92 = (_e89 * _e91);
+        let _e94 = from_[3u];
+        outColor = vec4<f32>(_e92.x, _e92.y, _e92.z, _e94);
+    }
+    let _e99 = outColor;
+    return _e99;
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e25 = _uv_1;
+    param_2 = _e25;
+    let _e26 = transition((&param_2));
+    _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/doorway.wgsl

@@ -0,0 +1,174 @@
+// doorway — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/doorway.glsl
+// Author: gre
+// License: MIT
+// Description: The outgoing image opens like double doors as the incoming one comes forward, 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 _e30 = (*uv)[0u];
+    let _e32 = (*uv)[1u];
+    let _e35 = textureSampleLevel(_to, _sampler, vec2<f32>(_e30, (1f - _e32)), 0f);
+    return _e35;
+}
+
+fn inBounds(p: ptr<function, vec2<f32>>) -> bool {
+    var phi_83_: bool;
+
+    let _e29 = (*p);
+    let _e31 = all((vec2<f32>(0f, 0f) < _e29));
+    phi_83_ = _e31;
+    if _e31 {
+        let _e32 = (*p);
+        phi_83_ = all((_e32 < vec2<f32>(1f, 1f)));
+    }
+    let _e36 = phi_83_;
+    return _e36;
+}
+
+fn project(p_1: ptr<function, vec2<f32>>) -> vec2<f32> {
+    let _e29 = (*p_1);
+    return ((_e29 * vec2<f32>(1f, -1.2f)) + vec2<f32>(0f, -0.02f));
+}
+
+fn bgColor(p_2: 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>;
+
+    c = vec4<f32>(0f, 0f, 0f, 1f);
+    let _e34 = (*pto);
+    param = _e34;
+    let _e35 = project((&param));
+    (*pto) = _e35;
+    let _e36 = (*pto);
+    param_1 = _e36;
+    let _e37 = inBounds((&param_1));
+    if _e37 {
+        let _e38 = (*pto);
+        param_2 = _e38;
+        let _e39 = getToColor((&param_2));
+        let _e41 = uniforms.reflection;
+        let _e43 = (*pto)[1u];
+        let _e48 = c;
+        c = (_e48 + mix(vec4<f32>(0f, 0f, 0f, 1f), _e39, vec4((_e41 * mix(1f, 0f, _e43)))));
+    }
+    let _e50 = c;
+    return _e50;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e30 = (*uv_1)[0u];
+    let _e32 = (*uv_1)[1u];
+    let _e35 = textureSampleLevel(_from, _sampler, vec2<f32>(_e30, (1f - _e32)), 0f);
+    return _e35;
+}
+
+fn transition(p_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var pfr: vec2<f32>;
+    var pto_1: vec2<f32>;
+    var middleSlit: f32;
+    var d: f32;
+    var size: f32;
+    var param_3: vec2<f32>;
+    var param_4: vec2<f32>;
+    var param_5: vec2<f32>;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+    var param_8: vec2<f32>;
+
+    pfr = vec2<f32>(-1f, -1f);
+    pto_1 = vec2<f32>(-1f, -1f);
+    let _e41 = (*p_3)[0u];
+    let _e46 = uniforms.progress;
+    middleSlit = ((2f * abs((_e41 - 0.5f))) - _e46);
+    let _e48 = middleSlit;
+    if (_e48 > 0f) {
+        let _e50 = (*p_3);
+        let _e52 = (*p_3)[0u];
+        let _e56 = uniforms.progress;
+        pfr = (_e50 + (vec2<f32>((0.5f * _e56), 0f) * select(1f, -1f, (_e52 > 0.5f))));
+        let _e62 = uniforms.perspective;
+        let _e64 = uniforms.progress;
+        let _e66 = middleSlit;
+        d = (1f / (1f + ((_e62 * _e64) * (1f - _e66))));
+        let _e71 = d;
+        let _e74 = pfr[1u];
+        pfr[1u] = (_e74 - (_e71 / 2f));
+        let _e77 = d;
+        let _e79 = pfr[1u];
+        pfr[1u] = (_e79 * _e77);
+        let _e82 = d;
+        let _e85 = pfr[1u];
+        pfr[1u] = (_e85 + (_e82 / 2f));
+    }
+    let _e89 = uniforms.depth;
+    let _e91 = uniforms.progress;
+    size = mix(1f, _e89, (1f - _e91));
+    let _e94 = (*p_3);
+    let _e96 = size;
+    pto_1 = (((_e94 + vec2<f32>(-0.5f, -0.5f)) * vec2(_e96)) + vec2<f32>(0.5f, 0.5f));
+    let _e100 = pfr;
+    param_3 = _e100;
+    let _e101 = inBounds((&param_3));
+    if _e101 {
+        let _e102 = pfr;
+        param_4 = _e102;
+        let _e103 = getFromColor((&param_4));
+        return _e103;
+    } else {
+        let _e104 = pto_1;
+        param_5 = _e104;
+        let _e105 = inBounds((&param_5));
+        if _e105 {
+            let _e106 = pto_1;
+            param_6 = _e106;
+            let _e107 = getToColor((&param_6));
+            return _e107;
+        } else {
+            let _e108 = (*p_3);
+            param_7 = _e108;
+            let _e109 = pto_1;
+            param_8 = _e109;
+            let _e110 = bgColor((&param_7), (&param_8));
+            return _e110;
+        }
+    }
+}
+
+fn main_1() {
+    var param_9: vec2<f32>;
+
+    let _e29 = _uv_1;
+    param_9 = _e29;
+    let _e30 = transition((&param_9));
+    _fragColor = _e30;
+    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/fade.wgsl

@@ -0,0 +1,67 @@
+// fade — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fade.glsl
+// Author: gre
+// License: MIT
+// Description: A linear crossfade between the two images
+// 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 _e13 = (*uv)[0u];
+    let _e15 = (*uv)[1u];
+    let _e18 = textureSampleLevel(_to, _sampler, vec2<f32>(_e13, (1f - _e15)), 0f);
+    return _e18;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e13 = (*uv_1)[0u];
+    let _e15 = (*uv_1)[1u];
+    let _e18 = textureSampleLevel(_from, _sampler, vec2<f32>(_e13, (1f - _e15)), 0f);
+    return _e18;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e14 = (*uv_2);
+    param = _e14;
+    let _e15 = getFromColor((&param));
+    let _e16 = (*uv_2);
+    param_1 = _e16;
+    let _e17 = getToColor((&param_1));
+    let _e19 = uniforms.progress;
+    return mix(_e15, _e17, vec4(_e19));
+}
+
+fn main_1() {
+    var param_2: vec2<f32>;
+
+    let _e12 = _uv_1;
+    param_2 = _e12;
+    let _e13 = transition((&param_2));
+    _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/fadecolor.wgsl

@@ -0,0 +1,75 @@
+// fadecolor — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadecolor.glsl
+// Author: gre
+// License: MIT
+// Description: A fade through a solid color, black by default
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    color: vec3<f32>,
+    colorPhase: 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 param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e17 = uniforms.color;
+    let _e22 = (*uv_2);
+    param = _e22;
+    let _e23 = getFromColor((&param));
+    let _e25 = uniforms.colorPhase;
+    let _e28 = uniforms.progress;
+    let _e33 = uniforms.color;
+    let _e38 = (*uv_2);
+    param_1 = _e38;
+    let _e39 = getToColor((&param_1));
+    let _e41 = uniforms.colorPhase;
+    let _e43 = uniforms.progress;
+    let _e48 = uniforms.progress;
+    return mix(mix(vec4<f32>(_e17.x, _e17.y, _e17.z, 1f), _e23, vec4(smoothstep((1f - _e25), 0f, _e28))), mix(vec4<f32>(_e33.x, _e33.y, _e33.z, 1f), _e39, vec4(smoothstep(_e41, 1f, _e43))), vec4(_e48));
+}
+
+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;
+}