gl-transitions 1.74.0 → 1.76.0

package/wgsl/fadegrayscale.wgsl

@@ -0,0 +1,93 @@
+// fadegrayscale — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadegrayscale.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade through grayscale
+// 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 grayscale(color: ptr<function, vec3<f32>>) -> vec3<f32> {
+    let _e18 = (*color)[0u];
+    let _e21 = (*color)[1u];
+    let _e25 = (*color)[2u];
+    return vec3((((0.2126f * _e18) + (0.7152f * _e21)) + (0.0722f * _e25)));
+}
+
+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(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var fc: vec4<f32>;
+    var param: vec2<f32>;
+    var tc: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec3<f32>;
+    var param_3: vec3<f32>;
+
+    let _e23 = (*uv_2);
+    param = _e23;
+    let _e24 = getFromColor((&param));
+    fc = _e24;
+    let _e25 = (*uv_2);
+    param_1 = _e25;
+    let _e26 = getToColor((&param_1));
+    tc = _e26;
+    let _e27 = fc;
+    param_2 = _e27.xyz;
+    let _e29 = grayscale((&param_2));
+    let _e34 = fc;
+    let _e36 = uniforms.intensity;
+    let _e39 = uniforms.progress;
+    let _e43 = tc;
+    param_3 = _e43.xyz;
+    let _e45 = grayscale((&param_3));
+    let _e50 = tc;
+    let _e52 = uniforms.intensity;
+    let _e54 = uniforms.progress;
+    let _e59 = uniforms.progress;
+    return mix(mix(vec4<f32>(_e29.x, _e29.y, _e29.z, 1f), _e34, vec4(smoothstep((1f - _e36), 0f, _e39))), mix(vec4<f32>(_e45.x, _e45.y, _e45.z, 1f), _e50, vec4(smoothstep(_e52, 1f, _e54))), vec4(_e59));
+}
+
+fn main_1() {
+    var param_4: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_4 = _e17;
+    let _e18 = transition((&param_4));
+    _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/flyeye.wgsl

@@ -0,0 +1,105 @@
+// flyeye — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/flyeye.glsl
+// Author: gre
+// License: MIT
+// Description: The image breaks into a fly's-eye grid of lenses with color separation
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    size: f32,
+    zoom: f32,
+    colorSeparation: 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 _e17 = (*uv)[0u];
+    let _e19 = (*uv)[1u];
+    let _e22 = textureSampleLevel(_from, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn getToColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e17 = (*uv_1)[0u];
+    let _e19 = (*uv_1)[1u];
+    let _e22 = textureSampleLevel(_to, _sampler, vec2<f32>(_e17, (1f - _e19)), 0f);
+    return _e22;
+}
+
+fn transition(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var inv: f32;
+    var disp: vec2<f32>;
+    var texTo: vec4<f32>;
+    var param: vec2<f32>;
+    var texFrom: vec4<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+
+    let _e25 = uniforms.progress;
+    inv = (1f - _e25);
+    let _e28 = uniforms.size;
+    let _e30 = uniforms.zoom;
+    let _e32 = (*p)[0u];
+    let _e36 = uniforms.zoom;
+    let _e38 = (*p)[1u];
+    disp = (vec2<f32>(cos((_e30 * _e32)), sin((_e36 * _e38))) * _e28);
+    let _e43 = (*p);
+    let _e44 = inv;
+    let _e45 = disp;
+    param = (_e43 + (_e45 * _e44));
+    let _e48 = getToColor((&param));
+    texTo = _e48;
+    let _e49 = (*p);
+    let _e51 = uniforms.progress;
+    let _e52 = disp;
+    let _e55 = uniforms.colorSeparation;
+    param_1 = (_e49 + ((_e52 * _e51) * (1f - _e55)));
+    let _e59 = getFromColor((&param_1));
+    let _e61 = (*p);
+    let _e63 = uniforms.progress;
+    let _e64 = disp;
+    param_2 = (_e61 + (_e64 * _e63));
+    let _e67 = getFromColor((&param_2));
+    let _e69 = (*p);
+    let _e71 = uniforms.progress;
+    let _e72 = disp;
+    let _e75 = uniforms.colorSeparation;
+    param_3 = (_e69 + ((_e72 * _e71) * (1f + _e75)));
+    let _e79 = getFromColor((&param_3));
+    texFrom = vec4<f32>(_e59.x, _e67.y, _e79.z, 1f);
+    let _e82 = texTo;
+    let _e84 = uniforms.progress;
+    let _e86 = texFrom;
+    let _e87 = inv;
+    return ((_e82 * _e84) + (_e86 * _e87));
+}
+
+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/fragment.wgsl

@@ -0,0 +1,227 @@
+// fragment — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fragment.glsl
+// Author: lbl
+// License: MIT
+// Description: The outgoing image shatters into fragments that fly away
+// 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 random(par: ptr<function, vec2<f32>>) -> f32 {
+    let _e25 = (*par);
+    return fract((sin(dot(_e25, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn random2(par_1: ptr<function, vec2<f32>>) -> vec2<f32> {
+    var rand: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e28 = (*par_1);
+    param = _e28;
+    let _e29 = random((&param));
+    rand = _e29;
+    let _e30 = rand;
+    let _e31 = (*par_1);
+    let _e32 = rand;
+    param_1 = (_e31 + vec2(_e32));
+    let _e35 = random((&param_1));
+    return vec2<f32>(_e30, _e35);
+}
+
+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 param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var time: f32;
+    var i: i32;
+    var point: array<vec2<f32>, 10>;
+    var param_4: vec2<f32>;
+    var col: vec4<f32>;
+    var param_5: vec2<f32>;
+    var i_1: i32;
+    var dir: vec2<f32>;
+    var param_6: vec2<f32>;
+    var v: f32;
+    var param_7: vec2<f32>;
+    var ofst: vec2<f32>;
+    var U: vec2<f32>;
+    var dist_i: f32;
+    var closest: bool;
+    var j: i32;
+    var param_8: vec2<f32>;
+    var phi_199_: bool;
+    var phi_206_: bool;
+    var phi_213_: bool;
+
+    let _e45 = uniforms.progress;
+    if (_e45 <= 0f) {
+        let _e47 = (*uv_2);
+        param_2 = _e47;
+        let _e48 = getFromColor((&param_2));
+        return _e48;
+    }
+    let _e50 = uniforms.progress;
+    if (_e50 >= 1f) {
+        let _e52 = (*uv_2);
+        param_3 = _e52;
+        let _e53 = getToColor((&param_3));
+        return _e53;
+    }
+    let _e55 = uniforms.progress;
+    time = (_e55 * 8f);
+    i = 0i;
+    loop {
+        let _e57 = i;
+        if (_e57 < 10i) {
+            let _e59 = i;
+            let _e60 = i;
+            param_4 = vec2(f32(_e60));
+            let _e63 = random2((&param_4));
+            point[_e59] = _e63;
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e65 = i;
+            i = (_e65 + 1i);
+        }
+    }
+    let _e67 = (*uv_2);
+    param_5 = _e67;
+    let _e68 = getToColor((&param_5));
+    col = _e68;
+    i_1 = 0i;
+    loop {
+        let _e69 = i_1;
+        if (_e69 < 10i) {
+            let _e71 = i_1;
+            let _e73 = i_1;
+            param_6 = vec2<f32>(f32(_e71), (f32(_e73) + 11f));
+            let _e77 = random2((&param_6));
+            dir = normalize(_e77);
+            let _e79 = dir;
+            param_7 = _e79;
+            let _e80 = random((&param_7));
+            v = ((1f + (_e80 * 0.5f)) * 0.2f);
+            let _e84 = dir;
+            let _e85 = time;
+            let _e89 = v;
+            ofst = ((_e84 * clamp((_e85 - 0.5f), 0f, 8f)) * _e89);
+            let _e91 = (*uv_2);
+            let _e92 = ofst;
+            U = (_e91 - _e92);
+            let _e95 = U[0u];
+            let _e96 = (_e95 < 0f);
+            phi_199_ = _e96;
+            if !(_e96) {
+                let _e99 = U[0u];
+                phi_199_ = (_e99 > 1f);
+            }
+            let _e102 = phi_199_;
+            phi_206_ = _e102;
+            if !(_e102) {
+                let _e105 = U[1u];
+                phi_206_ = (_e105 < 0f);
+            }
+            let _e108 = phi_206_;
+            phi_213_ = _e108;
+            if !(_e108) {
+                let _e111 = U[1u];
+                phi_213_ = (_e111 > 1f);
+            }
+            let _e114 = phi_213_;
+            if _e114 {
+                continue;
+            }
+            let _e115 = U;
+            let _e116 = i_1;
+            let _e118 = point[_e116];
+            dist_i = distance(_e115, _e118);
+            closest = true;
+            j = 0i;
+            loop {
+                let _e120 = j;
+                if (_e120 < 10i) {
+                    let _e122 = U;
+                    let _e123 = j;
+                    let _e125 = point[_e123];
+                    let _e127 = dist_i;
+                    if (distance(_e122, _e125) < _e127) {
+                        closest = false;
+                        break;
+                    }
+                    continue;
+                } else {
+                    break;
+                }
+                continuing {
+                    let _e129 = j;
+                    j = (_e129 + 1i);
+                }
+            }
+            let _e131 = closest;
+            if _e131 {
+                let _e132 = U;
+                param_8 = _e132;
+                let _e133 = getFromColor((&param_8));
+                col = _e133;
+                break;
+            }
+            continue;
+        } else {
+            break;
+        }
+        continuing {
+            let _e134 = i_1;
+            i_1 = (_e134 + 1i);
+        }
+    }
+    let _e136 = col;
+    return _e136;
+}
+
+fn main_1() {
+    var param_9: vec2<f32>;
+
+    let _e25 = _uv_1;
+    param_9 = _e25;
+    let _e26 = transition((&param_9));
+    _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/heart.wgsl

@@ -0,0 +1,103 @@
+// heart — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/heart.glsl
+// Author: gre
+// License: MIT
+// Description: A heart shape grows from the center to reveal the incoming image
+// 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 inHeart(p: ptr<function, vec2<f32>>, center: ptr<function, vec2<f32>>, size: ptr<function, f32>) -> f32 {
+    var o: vec2<f32>;
+    var a: f32;
+
+    let _e21 = (*size);
+    if (_e21 == 0f) {
+        return 0f;
+    }
+    let _e23 = (*p);
+    let _e24 = (*center);
+    let _e26 = (*size);
+    o = ((_e23 - _e24) / vec2((1.6f * _e26)));
+    let _e31 = o[0u];
+    let _e33 = o[0u];
+    let _e36 = o[1u];
+    let _e38 = o[1u];
+    a = (((_e31 * _e33) + (_e36 * _e38)) - 0.3f);
+    let _e42 = a;
+    let _e43 = a;
+    let _e45 = a;
+    let _e48 = o[0u];
+    let _e50 = o[0u];
+    let _e53 = o[1u];
+    let _e56 = o[1u];
+    let _e59 = o[1u];
+    return step(((_e42 * _e43) * _e45), ((((_e48 * _e50) * _e53) * _e56) * _e59));
+}
+
+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(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var param_3: vec2<f32>;
+    var param_4: f32;
+
+    let _e22 = (*uv_2);
+    param = _e22;
+    let _e23 = getFromColor((&param));
+    let _e24 = (*uv_2);
+    param_1 = _e24;
+    let _e25 = getToColor((&param_1));
+    let _e26 = (*uv_2);
+    param_2 = _e26;
+    param_3 = vec2<f32>(0.5f, 0.4f);
+    let _e28 = uniforms.progress;
+    param_4 = _e28;
+    let _e29 = inHeart((&param_2), (&param_3), (&param_4));
+    return mix(_e23, _e25, vec4(_e29));
+}
+
+fn main_1() {
+    var param_5: vec2<f32>;
+
+    let _e17 = _uv_1;
+    param_5 = _e17;
+    let _e18 = transition((&param_5));
+    _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;
+}