gl-transitions 1.74.0 → 1.76.0

package/wgsl/luminance_melt.wgsl

@@ -0,0 +1,299 @@
+// luminance_melt — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/luminance_melt.glsl
+// Author: 0gust1
+// License: MIT
+// Description: The outgoing image melts away in noisy vertical streaks, depending on its brightness
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    direction: i32,
+    l_threshold: f32,
+    above: 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 luminance(color: ptr<function, vec4<f32>>) -> f32 {
+    let _e44 = (*color)[0u];
+    let _e47 = (*color)[1u];
+    let _e51 = (*color)[2u];
+    return (((_e44 * 0.299f) + (_e47 * 0.587f)) + (_e51 * 0.114f));
+}
+
+fn rand(co: ptr<function, vec2<f32>>) -> f32 {
+    let _e43 = (*co);
+    return fract((sin(dot(_e43, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn mod289_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {
+    let _e43 = (*x);
+    let _e44 = (*x);
+    return (_e43 - (floor((_e44 * 0.0034602077f)) * 289f));
+}
+
+fn permute(x_1: ptr<function, vec3<f32>>) -> vec3<f32> {
+    var param: vec3<f32>;
+
+    let _e44 = (*x_1);
+    let _e48 = (*x_1);
+    param = (((_e44 * 34f) + vec3(1f)) * _e48);
+    let _e50 = mod289_u0028_vf3_u003b((&param));
+    return _e50;
+}
+
+fn mod289_u0028_vf2_u003b(x_2: ptr<function, vec2<f32>>) -> vec2<f32> {
+    let _e43 = (*x_2);
+    let _e44 = (*x_2);
+    return (_e43 - (floor((_e44 * 0.0034602077f)) * 289f));
+}
+
+fn snoise(v: ptr<function, vec2<f32>>) -> f32 {
+    var i: vec2<f32>;
+    var x0_: vec2<f32>;
+    var i1_: vec2<f32>;
+    var x12_: vec4<f32>;
+    var param_1: vec2<f32>;
+    var p: vec3<f32>;
+    var param_2: vec3<f32>;
+    var param_3: vec3<f32>;
+    var m: vec3<f32>;
+    var x_3: vec3<f32>;
+    var h: vec3<f32>;
+    var ox: vec3<f32>;
+    var a0_: vec3<f32>;
+    var g: vec3<f32>;
+
+    let _e57 = (*v);
+    let _e58 = (*v);
+    i = floor((_e57 + vec2(dot(_e58, vec2<f32>(0.36602542f, 0.36602542f)))));
+    let _e63 = (*v);
+    let _e64 = i;
+    let _e66 = i;
+    x0_ = ((_e63 - _e64) + vec2(dot(_e66, vec2<f32>(0.21132487f, 0.21132487f))));
+    let _e71 = x0_[0u];
+    let _e73 = x0_[1u];
+    i1_ = select(vec2<f32>(0f, 1f), vec2<f32>(1f, 0f), vec2((_e71 > _e73)));
+    let _e77 = x0_;
+    x12_ = (_e77.xyxy + vec4<f32>(0.21132487f, 0.21132487f, -0.57735026f, -0.57735026f));
+    let _e80 = i1_;
+    let _e81 = x12_;
+    let _e83 = (_e81.xy - _e80);
+    x12_[0u] = _e83.x;
+    x12_[1u] = _e83.y;
+    let _e88 = i;
+    param_1 = _e88;
+    let _e89 = mod289_u0028_vf2_u003b((&param_1));
+    i = _e89;
+    let _e91 = i[1u];
+    let _e93 = i1_[1u];
+    param_2 = (vec3(_e91) + vec3<f32>(0f, _e93, 1f));
+    let _e97 = permute((&param_2));
+    let _e99 = i[0u];
+    let _e103 = i1_[0u];
+    param_3 = ((_e97 + vec3(_e99)) + vec3<f32>(0f, _e103, 1f));
+    let _e106 = permute((&param_3));
+    p = _e106;
+    let _e107 = x0_;
+    let _e108 = x0_;
+    let _e110 = x12_;
+    let _e112 = x12_;
+    let _e115 = x12_;
+    let _e117 = x12_;
+    m = max((vec3(0.5f) - vec3<f32>(dot(_e107, _e108), dot(_e110.xy, _e112.xy), dot(_e115.zw, _e117.zw))), vec3(0f));
+    let _e125 = m;
+    let _e126 = m;
+    m = (_e125 * _e126);
+    let _e128 = m;
+    let _e129 = m;
+    m = (_e128 * _e129);
+    let _e131 = p;
+    x_3 = ((fract((_e131 * vec3<f32>(0.024390243f, 0.024390243f, 0.024390243f))) * 2f) - vec3(1f));
+    let _e137 = x_3;
+    h = (abs(_e137) - vec3(0.5f));
+    let _e141 = x_3;
+    ox = floor((_e141 + vec3(0.5f)));
+    let _e145 = x_3;
+    let _e146 = ox;
+    a0_ = (_e145 - _e146);
+    let _e148 = a0_;
+    let _e149 = a0_;
+    let _e151 = h;
+    let _e152 = h;
+    let _e158 = m;
+    m = (_e158 * (vec3(1.7928429f) - (((_e148 * _e149) + (_e151 * _e152)) * 0.85373473f)));
+    let _e161 = a0_[0u];
+    let _e163 = x0_[0u];
+    let _e166 = h[0u];
+    let _e168 = x0_[1u];
+    g[0u] = ((_e161 * _e163) + (_e166 * _e168));
+    let _e172 = a0_;
+    let _e174 = x12_;
+    let _e177 = h;
+    let _e179 = x12_;
+    let _e182 = ((_e172.yz * _e174.xz) + (_e177.yz * _e179.yw));
+    g[1u] = _e182.x;
+    g[2u] = _e182.y;
+    let _e187 = m;
+    let _e188 = g;
+    return (130f * dot(_e187, _e188));
+}
+
+fn getToColor(uv: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e44 = (*uv)[0u];
+    let _e46 = (*uv)[1u];
+    let _e49 = textureSampleLevel(_to, _sampler, vec2<f32>(_e44, (1f - _e46)), 0f);
+    return _e49;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e44 = (*uv_1)[0u];
+    let _e46 = (*uv_1)[1u];
+    let _e49 = textureSampleLevel(_from, _sampler, vec2<f32>(_e44, (1f - _e46)), 0f);
+    return _e49;
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var center: vec2<f32>;
+    var p_1: vec2<f32>;
+    var param_4: vec2<f32>;
+    var param_5: vec2<f32>;
+    var x_4: f32;
+    var dist: f32;
+    var param_6: vec2<f32>;
+    var r: f32;
+    var param_7: vec2<f32>;
+    var m_1: f32;
+    var param_8: vec2<f32>;
+    var param_9: vec4<f32>;
+    var local: f32;
+    var param_10: vec2<f32>;
+    var param_11: vec4<f32>;
+    var local_1: f32;
+    var param_12: vec2<f32>;
+    var param_13: vec2<f32>;
+    var phi_392_: bool;
+    var phi_420_: bool;
+
+    let _e62 = uniforms.direction;
+    center = vec2<f32>(1f, select(0f, 1f, (_e62 != 0i)));
+    let _e66 = (*uv_2);
+    p_1 = (_e66 / vec2<f32>(1f, 1f));
+    let _e69 = uniforms.progress;
+    if (_e69 == 0f) {
+        let _e71 = p_1;
+        param_4 = _e71;
+        let _e72 = getFromColor((&param_4));
+        return _e72;
+    } else {
+        let _e74 = uniforms.progress;
+        if (_e74 == 1f) {
+            let _e76 = p_1;
+            param_5 = _e76;
+            let _e77 = getToColor((&param_5));
+            return _e77;
+        } else {
+            let _e79 = uniforms.progress;
+            x_4 = _e79;
+            let _e80 = center;
+            let _e81 = p_1;
+            let _e84 = uniforms.progress;
+            let _e86 = p_1[0u];
+            param_6 = vec2<f32>(_e86, 0f);
+            let _e88 = snoise((&param_6));
+            dist = (distance(_e80, _e81) - (_e84 * exp(_e88)));
+            let _e92 = x_4;
+            let _e94 = p_1[0u];
+            param_7 = vec2<f32>(_e94, 0.1f);
+            let _e96 = rand((&param_7));
+            r = (_e92 - _e96);
+            let _e99 = uniforms.above;
+            if (_e99 != 0i) {
+                let _e101 = dist;
+                let _e102 = r;
+                let _e103 = (_e101 <= _e102);
+                phi_392_ = _e103;
+                if _e103 {
+                    let _e104 = p_1;
+                    param_8 = _e104;
+                    let _e105 = getFromColor((&param_8));
+                    param_9 = _e105;
+                    let _e106 = luminance((&param_9));
+                    let _e108 = uniforms.l_threshold;
+                    phi_392_ = (_e106 > _e108);
+                }
+                let _e111 = phi_392_;
+                if _e111 {
+                    local = 1f;
+                } else {
+                    let _e113 = uniforms.progress;
+                    let _e115 = uniforms.progress;
+                    let _e118 = uniforms.progress;
+                    local = ((_e113 * _e115) * _e118);
+                }
+                let _e120 = local;
+                m_1 = _e120;
+            } else {
+                let _e121 = dist;
+                let _e122 = r;
+                let _e123 = (_e121 <= _e122);
+                phi_420_ = _e123;
+                if _e123 {
+                    let _e124 = p_1;
+                    param_10 = _e124;
+                    let _e125 = getFromColor((&param_10));
+                    param_11 = _e125;
+                    let _e126 = luminance((&param_11));
+                    let _e128 = uniforms.l_threshold;
+                    phi_420_ = (_e126 < _e128);
+                }
+                let _e131 = phi_420_;
+                if _e131 {
+                    local_1 = 1f;
+                } else {
+                    let _e133 = uniforms.progress;
+                    let _e135 = uniforms.progress;
+                    let _e138 = uniforms.progress;
+                    local_1 = ((_e133 * _e135) * _e138);
+                }
+                let _e140 = local_1;
+                m_1 = _e140;
+            }
+            let _e141 = p_1;
+            param_12 = _e141;
+            let _e142 = getFromColor((&param_12));
+            let _e143 = p_1;
+            param_13 = _e143;
+            let _e144 = getToColor((&param_13));
+            let _e145 = m_1;
+            return mix(_e142, _e144, vec4(_e145));
+        }
+    }
+}
+
+fn main_1() {
+    var param_14: vec2<f32>;
+
+    let _e43 = _uv_1;
+    param_14 = _e43;
+    let _e44 = transition((&param_14));
+    _fragColor = _e44;
+    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/morph.wgsl

@@ -0,0 +1,103 @@
+// morph — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/morph.glsl
+// Author: paniq
+// License: MIT
+// Description: A crossfade in which each image is displaced by the other's colors, like a morph
+// 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(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var ca: vec4<f32>;
+    var param: vec2<f32>;
+    var cb: vec4<f32>;
+    var param_1: vec2<f32>;
+    var oa: vec2<f32>;
+    var ob: vec2<f32>;
+    var oc: vec2<f32>;
+    var w0_: f32;
+    var w1_: f32;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    let _e27 = (*p);
+    param = _e27;
+    let _e28 = getFromColor((&param));
+    ca = _e28;
+    let _e29 = (*p);
+    param_1 = _e29;
+    let _e30 = getToColor((&param_1));
+    cb = _e30;
+    let _e31 = ca;
+    let _e34 = ca[2u];
+    oa = ((((_e31.xy + vec2(_e34)) * 0.5f) * 2f) - vec2(1f));
+    let _e41 = cb;
+    let _e44 = cb[2u];
+    ob = ((((_e41.xy + vec2(_e44)) * 0.5f) * 2f) - vec2(1f));
+    let _e51 = oa;
+    let _e52 = ob;
+    let _e56 = uniforms.strength;
+    oc = (mix(_e51, _e52, vec2(0.5f)) * _e56);
+    let _e59 = uniforms.progress;
+    w0_ = _e59;
+    let _e60 = w0_;
+    w1_ = (1f - _e60);
+    let _e62 = (*p);
+    let _e63 = oc;
+    let _e64 = w0_;
+    param_2 = (_e62 + (_e63 * _e64));
+    let _e67 = getFromColor((&param_2));
+    let _e68 = (*p);
+    let _e69 = oc;
+    let _e70 = w1_;
+    param_3 = (_e68 - (_e69 * _e70));
+    let _e73 = getToColor((&param_3));
+    let _e75 = uniforms.progress;
+    return mix(_e67, _e73, vec4(_e75));
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e16 = _uv_1;
+    param_4 = _e16;
+    let _e17 = transition((&param_4));
+    _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/mosaic_transition.wgsl

@@ -0,0 +1,107 @@
+// mosaic_transition — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/mosaic_transition.glsl
+// Author: YueDev
+// License: MIT
+// Description: Both images break into mosaic blocks that blend, then sharpen into the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    mosaicNum: 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 _e16 = (*uv)[0u];
+    let _e18 = (*uv)[1u];
+    let _e21 = textureSampleLevel(_to, _sampler, vec2<f32>(_e16, (1f - _e18)), 0f);
+    return _e21;
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e16 = (*uv_1)[0u];
+    let _e18 = (*uv_1)[1u];
+    let _e21 = textureSampleLevel(_from, _sampler, vec2<f32>(_e16, (1f - _e18)), 0f);
+    return _e21;
+}
+
+fn getMosaicUV(uv_2: ptr<function, vec2<f32>>) -> vec2<f32> {
+    var mosaicWidth: f32;
+    var mX: f32;
+    var mY: f32;
+
+    let _e19 = uniforms.mosaicNum;
+    let _e22 = uniforms.progress;
+    let _e24 = uniforms.progress;
+    mosaicWidth = ((2f / _e19) * min(_e22, (1f - _e24)));
+    let _e29 = (*uv_2)[0u];
+    let _e30 = mosaicWidth;
+    mX = (floor((_e29 / _e30)) + 0.5f);
+    let _e35 = (*uv_2)[1u];
+    let _e36 = mosaicWidth;
+    mY = (floor((_e35 / _e36)) + 0.5f);
+    let _e40 = mX;
+    let _e41 = mosaicWidth;
+    let _e43 = mY;
+    let _e44 = mosaicWidth;
+    return vec2<f32>((_e40 * _e41), (_e43 * _e44));
+}
+
+fn transition(uv_3: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var mosaicUV: vec2<f32>;
+    var local: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+
+    let _e21 = uniforms.progress;
+    let _e23 = uniforms.progress;
+    if (min(_e21, (1f - _e23)) == 0f) {
+        let _e27 = (*uv_3);
+        local = _e27;
+    } else {
+        let _e28 = (*uv_3);
+        param = _e28;
+        let _e29 = getMosaicUV((&param));
+        local = _e29;
+    }
+    let _e30 = local;
+    mosaicUV = _e30;
+    let _e31 = mosaicUV;
+    param_1 = _e31;
+    let _e32 = getFromColor((&param_1));
+    let _e33 = mosaicUV;
+    param_2 = _e33;
+    let _e34 = getToColor((&param_2));
+    let _e36 = uniforms.progress;
+    let _e38 = uniforms.progress;
+    return mix(_e32, _e34, vec4((_e36 * _e38)));
+}
+
+fn main_1() {
+    var param_3: vec2<f32>;
+
+    let _e15 = _uv_1;
+    param_3 = _e15;
+    let _e16 = transition((&param_3));
+    _fragColor = _e16;
+    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/multiply_blend.wgsl

@@ -0,0 +1,96 @@
+// multiply_blend — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/multiply_blend.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: A crossfade through the multiplied blend of both 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 blend(a: ptr<function, vec4<f32>>, b: ptr<function, vec4<f32>>) -> vec4<f32> {
+    let _e15 = (*a);
+    let _e16 = (*b);
+    return (_e15 * _e16);
+}
+
+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 blended: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec4<f32>;
+    var param_3: vec4<f32>;
+    var param_4: vec2<f32>;
+    var param_5: vec2<f32>;
+
+    let _e21 = (*uv_2);
+    param = _e21;
+    let _e22 = getFromColor((&param));
+    let _e23 = (*uv_2);
+    param_1 = _e23;
+    let _e24 = getToColor((&param_1));
+    param_2 = _e22;
+    param_3 = _e24;
+    let _e25 = blend((&param_2), (&param_3));
+    blended = _e25;
+    let _e27 = uniforms.progress;
+    if (_e27 < 0.5f) {
+        let _e29 = (*uv_2);
+        param_4 = _e29;
+        let _e30 = getFromColor((&param_4));
+        let _e31 = blended;
+        let _e33 = uniforms.progress;
+        return mix(_e30, _e31, vec4((2f * _e33)));
+    } else {
+        let _e37 = blended;
+        let _e38 = (*uv_2);
+        param_5 = _e38;
+        let _e39 = getToColor((&param_5));
+        let _e41 = uniforms.progress;
+        return mix(_e37, _e39, vec4(((2f * _e41) - 1f)));
+    }
+}
+
+fn main_1() {
+    var param_6: vec2<f32>;
+
+    let _e14 = _uv_1;
+    param_6 = _e14;
+    let _e15 = transition((&param_6));
+    _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;
+}