gl-transitions 1.74.0 → 1.76.0

package/wgsl/PuzzleRight.wgsl

@@ -0,0 +1,230 @@
+// PuzzleRight — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/PuzzleRight.glsl
+// Author: JustKirillS
+// License: MIT
+// Description: The image splits into a grid of tiles that flip one by one to the incoming image
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: f32,
+    size: vec2<i32>,
+    pause: f32,
+    dividerWidth: 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 _e24 = (*uv)[0u];
+    let _e26 = (*uv)[1u];
+    let _e29 = textureSampleLevel(_to, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn rand(co: ptr<function, vec2<f32>>) -> f32 {
+    let _e23 = (*co);
+    return fract((sin(dot(_e23, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
+}
+
+fn getFromColor(uv_1: ptr<function, vec2<f32>>) -> vec4<f32> {
+    let _e24 = (*uv_1)[0u];
+    let _e26 = (*uv_1)[1u];
+    let _e29 = textureSampleLevel(_from, _sampler, vec2<f32>(_e24, (1f - _e26)), 0f);
+    return _e29;
+}
+
+fn getDelta(p: ptr<function, vec2<f32>>) -> f32 {
+    var rectangleSize: vec2<f32>;
+    var rectanglePos: vec2<f32>;
+    var top: f32;
+    var bottom: f32;
+    var left: f32;
+    var right: f32;
+    var minX: f32;
+    var minY: f32;
+
+    let _e32 = uniforms.size;
+    rectangleSize = (vec2(1f) / vec2<f32>(_e32));
+    let _e37 = uniforms.size;
+    let _e39 = (*p);
+    rectanglePos = floor((vec2<f32>(_e37) * _e39));
+    let _e43 = rectangleSize[1u];
+    let _e45 = rectanglePos[1u];
+    top = (_e43 * (_e45 + 1f));
+    let _e49 = rectangleSize[1u];
+    let _e51 = rectanglePos[1u];
+    bottom = (_e49 * _e51);
+    let _e54 = rectangleSize[0u];
+    let _e56 = rectanglePos[0u];
+    left = (_e54 * _e56);
+    let _e59 = rectangleSize[0u];
+    let _e61 = rectanglePos[0u];
+    right = (_e59 * (_e61 + 1f));
+    let _e65 = (*p)[0u];
+    let _e66 = left;
+    let _e70 = (*p)[0u];
+    let _e71 = right;
+    minX = min(abs((_e65 - _e66)), abs((_e70 - _e71)));
+    let _e76 = (*p)[1u];
+    let _e77 = top;
+    let _e81 = (*p)[1u];
+    let _e82 = bottom;
+    minY = min(abs((_e76 - _e77)), abs((_e81 - _e82)));
+    let _e86 = minX;
+    let _e87 = minY;
+    return min(_e86, _e87);
+}
+
+fn transition(uv_2: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var currentProg: f32;
+    var a: f32;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+    var param_2: vec2<f32>;
+    var currentProg_1: f32;
+    var rectanglePos_1: vec2<f32>;
+    var r: f32;
+    var param_3: vec2<f32>;
+    var cp: f32;
+    var rectangleSize_1: f32;
+    var delta: f32;
+    var offset: f32;
+    var p_1: vec2<f32>;
+    var a_1: vec4<f32>;
+    var param_4: vec2<f32>;
+    var b: vec4<f32>;
+    var param_5: vec2<f32>;
+    var s: f32;
+    var currentProg_2: f32;
+    var a_2: f32;
+    var param_6: vec2<f32>;
+    var param_7: vec2<f32>;
+
+    let _e47 = uniforms.progress;
+    let _e49 = uniforms.pause;
+    if (_e47 < _e49) {
+        let _e52 = uniforms.progress;
+        let _e54 = uniforms.pause;
+        currentProg = (_e52 / _e54);
+        a = 1f;
+        let _e56 = (*uv_2);
+        param = _e56;
+        let _e57 = getDelta((&param));
+        let _e59 = uniforms.dividerWidth;
+        if (_e57 < _e59) {
+            let _e61 = currentProg;
+            a = (1f - _e61);
+        }
+        let _e63 = (*uv_2);
+        param_1 = _e63;
+        let _e64 = getFromColor((&param_1));
+        let _e65 = a;
+        return mix(vec4<f32>(0f, 0f, 0f, 1f), _e64, vec4(_e65));
+    } else {
+        let _e69 = uniforms.progress;
+        let _e71 = uniforms.pause;
+        if (_e69 < (1f - _e71)) {
+            let _e74 = (*uv_2);
+            param_2 = _e74;
+            let _e75 = getDelta((&param_2));
+            let _e77 = uniforms.dividerWidth;
+            if (_e75 < _e77) {
+                return vec4<f32>(0f, 0f, 0f, 1f);
+            }
+            let _e80 = uniforms.progress;
+            let _e82 = uniforms.pause;
+            let _e85 = uniforms.pause;
+            currentProg_1 = ((_e80 - _e82) / (1f - (_e85 * 2f)));
+            let _e90 = uniforms.size;
+            let _e92 = (*uv_2);
+            rectanglePos_1 = floor((vec2<f32>(_e90) * _e92));
+            let _e95 = rectanglePos_1;
+            param_3 = _e95;
+            let _e96 = rand((&param_3));
+            r = (_e96 - 0.1f);
+            let _e98 = r;
+            let _e100 = currentProg_1;
+            cp = smoothstep(0f, (1f - _e98), _e100);
+            let _e104 = uniforms.size[0u];
+            rectangleSize_1 = (1f / f32(_e104));
+            let _e108 = rectanglePos_1[0u];
+            let _e109 = rectangleSize_1;
+            delta = (_e108 * _e109);
+            let _e111 = rectangleSize_1;
+            let _e113 = delta;
+            offset = ((_e111 / 2f) + _e113);
+            let _e115 = (*uv_2);
+            p_1 = _e115;
+            let _e117 = p_1[0u];
+            let _e118 = offset;
+            let _e120 = cp;
+            let _e125 = offset;
+            p_1[0u] = ((((_e117 - _e118) / abs((_e120 - 0.5f))) * 0.5f) + _e125);
+            let _e128 = p_1;
+            param_4 = _e128;
+            let _e129 = getFromColor((&param_4));
+            a_1 = _e129;
+            let _e130 = p_1;
+            param_5 = _e130;
+            let _e131 = getToColor((&param_5));
+            b = _e131;
+            let _e134 = uniforms.size[0u];
+            let _e137 = (*uv_2)[0u];
+            let _e138 = delta;
+            let _e143 = cp;
+            s = step(abs(((f32(_e134) * (_e137 - _e138)) - 0.5f)), abs((_e143 - 0.5f)));
+            let _e147 = b;
+            let _e148 = a_1;
+            let _e149 = cp;
+            let _e154 = s;
+            let _e155 = (mix(_e147, _e148, vec4(step(_e149, 0.5f))).xyz * _e154);
+            return vec4<f32>(_e155.x, _e155.y, _e155.z, 1f);
+        } else {
+            let _e161 = uniforms.progress;
+            let _e164 = uniforms.pause;
+            let _e167 = uniforms.pause;
+            currentProg_2 = (((_e161 - 1f) + _e164) / _e167);
+            a_2 = 1f;
+            let _e169 = (*uv_2);
+            param_6 = _e169;
+            let _e170 = getDelta((&param_6));
+            let _e172 = uniforms.dividerWidth;
+            if (_e170 < _e172) {
+                let _e174 = currentProg_2;
+                a_2 = _e174;
+            }
+            let _e175 = (*uv_2);
+            param_7 = _e175;
+            let _e176 = getToColor((&param_7));
+            let _e177 = a_2;
+            return mix(vec4<f32>(0f, 0f, 0f, 1f), _e176, vec4(_e177));
+        }
+    }
+}
+
+fn main_1() {
+    var param_8: vec2<f32>;
+
+    let _e23 = _uv_1;
+    param_8 = _e23;
+    let _e24 = transition((&param_8));
+    _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/Radial.wgsl

@@ -0,0 +1,74 @@
+// Radial — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Radial.glsl
+// Author: Xaychru
+// License: MIT
+// Description: A radial wipe that sweeps around the center like a clock hand
+// Bindings and uniform layout: see the gl-transitions package README
+
+struct Uniforms {
+    progress: f32,
+    ratio: 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 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(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var rp: vec2<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e20 = (*p);
+    rp = ((_e20 * 2f) - vec2(1f));
+    let _e24 = (*p);
+    param = _e24;
+    let _e25 = getToColor((&param));
+    let _e26 = (*p);
+    param_1 = _e26;
+    let _e27 = getFromColor((&param_1));
+    let _e29 = uniforms.smoothness;
+    let _e31 = rp[1u];
+    let _e33 = rp[0u];
+    let _e36 = uniforms.progress;
+    return mix(_e25, _e27, vec4(smoothstep(0f, _e29, (atan2(_e31, _e33) - (((_e36 - 0.5f) * 3.1415927f) * 2.5f)))));
+}
+
+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/Rectangle.wgsl

@@ -0,0 +1,100 @@
+// Rectangle — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rectangle.glsl
+// Author: martiniti
+// License: MIT
+// Description: A rectangle grows from the center to cover the outgoing image, then shrinks to reveal the incoming one
+// 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 _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(p: ptr<function, vec2<f32>>) -> vec4<f32> {
+    var s: f32;
+    var sq: vec2<f32>;
+    var bl: vec2<f32>;
+    var dist: f32;
+    var tr: vec2<f32>;
+    var local: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e28 = uniforms.progress;
+    s = pow((2f * abs((_e28 - 0.5f))), 3f);
+    let _e33 = (*p);
+    sq = (_e33 / vec2<f32>(1f, 1f));
+    let _e36 = uniforms.progress;
+    let _e41 = sq;
+    bl = step(vec2(abs((1f - (2f * _e36)))), (_e41 + vec2(0.25f)));
+    let _e46 = bl[0u];
+    let _e48 = bl[1u];
+    dist = (_e46 * _e48);
+    let _e51 = uniforms.progress;
+    let _e56 = sq;
+    tr = step(vec2(abs((1f - (2f * _e51)))), (vec2(1.25f) - _e56));
+    let _e61 = tr[0u];
+    let _e64 = tr[1u];
+    let _e66 = dist;
+    dist = (_e66 * ((1f * _e61) * _e64));
+    let _e69 = uniforms.progress;
+    if (_e69 < 0.5f) {
+        let _e71 = (*p);
+        param = _e71;
+        let _e72 = getFromColor((&param));
+        local = _e72;
+    } else {
+        let _e73 = (*p);
+        param_1 = _e73;
+        let _e74 = getToColor((&param_1));
+        local = _e74;
+    }
+    let _e75 = local;
+    let _e77 = uniforms.bgcolor;
+    let _e78 = s;
+    let _e79 = dist;
+    return mix(_e75, _e77, vec4(step(_e78, _e79)));
+}
+
+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/RectangleCrop.wgsl

@@ -0,0 +1,98 @@
+// RectangleCrop — WGSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RectangleCrop.glsl
+// Author: martiniti
+// License: MIT
+// Description: The outgoing image shrinks into a small rectangle over a background color, then the incoming one grows 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 _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 s: f32;
+    var q: vec2<f32>;
+    var bl: vec2<f32>;
+    var tr: vec2<f32>;
+    var dist: f32;
+    var local: vec4<f32>;
+    var param: vec2<f32>;
+    var param_1: vec2<f32>;
+
+    let _e28 = uniforms.progress;
+    s = pow((2f * abs((_e28 - 0.5f))), 3f);
+    let _e33 = (*uv_2);
+    q = (_e33 / vec2<f32>(1f, 1f));
+    let _e36 = uniforms.progress;
+    let _e42 = q;
+    bl = step(vec2((1f - (2f * abs((_e36 - 0.5f))))), (_e42 + vec2(0.25f)));
+    let _e47 = uniforms.progress;
+    let _e53 = q;
+    tr = step(vec2((1f - (2f * abs((_e47 - 0.5f))))), (vec2(1.25f) - _e53));
+    let _e58 = bl[0u];
+    let _e60 = bl[1u];
+    let _e63 = tr[0u];
+    let _e66 = tr[1u];
+    dist = length((1f - (((_e58 * _e60) * _e63) * _e66)));
+    let _e71 = uniforms.progress;
+    if (_e71 < 0.5f) {
+        let _e73 = (*uv_2);
+        param = _e73;
+        let _e74 = getFromColor((&param));
+        local = _e74;
+    } else {
+        let _e75 = (*uv_2);
+        param_1 = _e75;
+        let _e76 = getToColor((&param_1));
+        local = _e76;
+    }
+    let _e77 = local;
+    let _e79 = uniforms.bgcolor;
+    let _e80 = s;
+    let _e81 = dist;
+    return mix(_e77, _e79, vec4(step(_e80, _e81)));
+}
+
+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;
+}