gl-transitions 1.74.0 → 1.76.0

package/msl/ZoomRigthWipe.metal

@@ -0,0 +1,152 @@
+// ZoomRigthWipe — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ZoomRigthWipe.glsl
+// Author: Handk
+// License: MIT
+// Description: Zooms into the outgoing image, then the incoming one wipes in from left to right
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+    float zoom_quickness;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e17 = uv[0u];
+    float _e19 = uv[1u];
+    metal::float4 _e22 = _to.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e17 = uv_1[0u];
+    float _e19 = uv_1[1u];
+    metal::float4 _e22 = _from.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float2 zoom(
+    thread metal::float2& uv_2,
+    thread float& amount
+) {
+    float _e17 = amount;
+    if (_e17 < 0.5) {
+        metal::float2 _e19 = uv_2;
+        float _e22 = amount;
+        return metal::float2(0.5) + ((_e19 - metal::float2(0.5)) * (1.0 - _e22));
+    } else {
+        metal::float2 _e27 = uv_2;
+        float _e30 = amount;
+        return metal::float2(0.5) + ((_e27 - metal::float2(0.5)) * _e30);
+    }
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_3,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float nQuick = {};
+    metal::float4 c = {};
+    metal::float2 param = {};
+    float param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 p = {};
+    metal::float4 d = {};
+    metal::float2 param_4 = {};
+    metal::float4 e = {};
+    metal::float2 param_5 = {};
+    metal::float4 f = {};
+    float _e29 = uniforms.zoom_quickness;
+    nQuick = metal::clamp(_e29, 0.0, 0.5);
+    float _e32 = uniforms.progress;
+    if (_e32 < 0.5) {
+        float _e34 = nQuick;
+        float _e36 = uniforms.progress;
+        metal::float2 _e38 = uv_3;
+        param = _e38;
+        param_1 = metal::smoothstep(0.0, _e34, _e36);
+        metal::float2 _e39 = zoom(param, param_1);
+        param_2 = _e39;
+        metal::float4 _e40 = getFromColor(param_2, _from, _sampler);
+        metal::float2 _e41 = uv_3;
+        param_3 = _e41;
+        metal::float4 _e42 = getToColor(param_3, _sampler, _to);
+        float _e44 = uniforms.progress;
+        c = metal::mix(_e40, _e42, metal::float4(metal::step(0.5, _e44)));
+        metal::float4 _e48 = c;
+        return _e48;
+    } else {
+        metal::float2 _e49 = uv_3;
+        p = _e49 / metal::float2(1.0, 1.0);
+        metal::float2 _e51 = p;
+        param_4 = _e51;
+        metal::float4 _e52 = getFromColor(param_4, _from, _sampler);
+        d = _e52;
+        metal::float2 _e53 = p;
+        param_5 = _e53;
+        metal::float4 _e54 = getToColor(param_5, _sampler, _to);
+        e = _e54;
+        metal::float4 _e55 = d;
+        metal::float4 _e56 = e;
+        float _e58 = p[0u];
+        float _e61 = uniforms.progress;
+        f = metal::mix(_e55, _e56, metal::float4(metal::step(0.0 + _e58, (_e61 - 0.5) * 2.0)));
+        metal::float4 _e67 = f;
+        return _e67;
+    }
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_6 = {};
+    metal::float2 _e16 = _uv_1;
+    param_6 = _e16;
+    metal::float4 _e17 = transition(param_6, _from, _sampler, _to, uniforms);
+    _fragColor = _e17;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/angular.metal

@@ -0,0 +1,111 @@
+// angular — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/angular.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: A wipe that sweeps around the center from a starting angle
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+    float startingAngle;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e18 = uv[0u];
+    float _e20 = uv[1u];
+    metal::float4 _e23 = _to.sample(_sampler, metal::float2(_e18, 1.0 - _e20), metal::level(0.0));
+    return _e23;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e18 = uv_1[0u];
+    float _e20 = uv_1[1u];
+    metal::float4 _e23 = _from.sample(_sampler, metal::float2(_e18, 1.0 - _e20), metal::level(0.0));
+    return _e23;
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float offset = {};
+    float angle = {};
+    float normalizedAngle = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e23 = uniforms.startingAngle;
+    offset = (_e23 * 3.1415927) / 180.0;
+    float _e27 = uv_2[1u];
+    float _e30 = uv_2[0u];
+    float _e33 = offset;
+    angle = metal::atan2(_e27 - 0.5, _e30 - 0.5) + _e33;
+    float _e35 = angle;
+    normalizedAngle = (_e35 + 3.1415927) / 6.2831855;
+    float _e38 = normalizedAngle;
+    float _e39 = normalizedAngle;
+    normalizedAngle = _e38 - metal::floor(_e39);
+    metal::float2 _e42 = uv_2;
+    param = _e42;
+    metal::float4 _e43 = getFromColor(param, _from, _sampler);
+    metal::float2 _e44 = uv_2;
+    param_1 = _e44;
+    metal::float4 _e45 = getToColor(param_1, _sampler, _to);
+    float _e46 = normalizedAngle;
+    float _e48 = uniforms.progress;
+    return metal::mix(_e43, _e45, metal::float4(metal::step(_e46, _e48)));
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_2 = {};
+    metal::float2 _e17 = _uv_1;
+    param_2 = _e17;
+    metal::float4 _e18 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e18;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/burn.metal

@@ -0,0 +1,103 @@
+// burn — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/burn.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade that brightens toward a color in the middle
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+    char _pad2[8];
+    metal::float3 color;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e14 = uv[0u];
+    float _e16 = uv[1u];
+    metal::float4 _e19 = _to.sample(_sampler, metal::float2(_e14, 1.0 - _e16), metal::level(0.0));
+    return _e19;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e14 = uv_1[0u];
+    float _e16 = uv_1[1u];
+    metal::float4 _e19 = _from.sample(_sampler, metal::float2(_e14, 1.0 - _e16), metal::level(0.0));
+    return _e19;
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e15 = uv_2;
+    param = _e15;
+    metal::float4 _e16 = getFromColor(param, _from, _sampler);
+    float _e18 = uniforms.progress;
+    metal::float3 _e20 = uniforms.color;
+    metal::float3 _e21 = _e20 * _e18;
+    metal::float2 _e27 = uv_2;
+    param_1 = _e27;
+    metal::float4 _e28 = getToColor(param_1, _sampler, _to);
+    float _e30 = uniforms.progress;
+    metal::float3 _e33 = uniforms.color;
+    metal::float3 _e34 = _e33 * (1.0 - _e30);
+    float _e41 = uniforms.progress;
+    return metal::mix(_e16 + metal::float4(_e21.x, _e21.y, _e21.z, 1.0), _e28 + metal::float4(_e34.x, _e34.y, _e34.z, 1.0), metal::float4(_e41));
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_2 = {};
+    metal::float2 _e13 = _uv_1;
+    param_2 = _e13;
+    metal::float4 _e14 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e14;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/burn0.metal

@@ -0,0 +1,236 @@
+// burn0 — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/burn0.glsl
+// Author: liubailin2020@gmail.com
+// License: MIT
+// Description: The outgoing image burns away in noisy, glowing patches
+// Bindings and uniform layout: see the gl-transitions package README
+
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct Uniforms {
+    float progress;
+    float ratio;
+    char _pad2[8];
+    metal::float3 burnColor;
+};
+
+float random(
+    thread metal::float2& st
+) {
+    metal::float2 _e28 = st;
+    return metal::fract(metal::sin(metal::dot(_e28, metal::float2(12.9898, 78.233))) * 43758.547);
+}
+
+float noise(
+    thread metal::float2& st_1
+) {
+    metal::float2 i = {};
+    metal::float2 f = {};
+    float a = {};
+    metal::float2 param = {};
+    float b = {};
+    metal::float2 param_1 = {};
+    float c = {};
+    metal::float2 param_2 = {};
+    float d = {};
+    metal::float2 param_3 = {};
+    metal::float2 u = {};
+    metal::float2 _e39 = st_1;
+    i = metal::floor(_e39);
+    metal::float2 _e41 = st_1;
+    f = metal::fract(_e41);
+    metal::float2 _e43 = i;
+    param = _e43;
+    float _e44 = random(param);
+    a = _e44;
+    metal::float2 _e45 = i;
+    param_1 = _e45 + metal::float2(1.0, 0.0);
+    float _e47 = random(param_1);
+    b = _e47;
+    metal::float2 _e48 = i;
+    param_2 = _e48 + metal::float2(0.0, 1.0);
+    float _e50 = random(param_2);
+    c = _e50;
+    metal::float2 _e51 = i;
+    param_3 = _e51 + metal::float2(1.0, 1.0);
+    float _e53 = random(param_3);
+    d = _e53;
+    metal::float2 _e54 = f;
+    metal::float2 _e55 = f;
+    metal::float2 _e57 = f;
+    u = (_e54 * _e55) * (metal::float2(3.0) - (_e57 * 2.0));
+    float _e62 = a;
+    float _e63 = b;
+    float _e65 = u[0u];
+    float _e67 = c;
+    float _e68 = a;
+    float _e71 = u[1u];
+    float _e74 = u[0u];
+    float _e78 = d;
+    float _e79 = b;
+    float _e82 = u[0u];
+    float _e85 = u[1u];
+    return (metal::mix(_e62, _e63, _e65) + (((_e67 - _e68) * _e71) * (1.0 - _e74))) + (((_e78 - _e79) * _e82) * _e85);
+}
+
+float fbm(
+    thread metal::float2& st_2
+) {
+    float value = {};
+    float amplitude = {};
+    int i_1 = {};
+    metal::float2 param_4 = {};
+    value = 0.0;
+    amplitude = 0.5;
+    i_1 = 0;
+    uint2 loop_bound = uint2(4294967295u);
+    bool loop_init = true;
+    while(true) {
+        if (metal::all(loop_bound == uint2(0u))) { break; }
+        loop_bound -= uint2(loop_bound.y == 0u, 1u);
+        if (!loop_init) {
+            int _e44 = i_1;
+            i_1 = as_type<int>(as_type<uint>(_e44) + as_type<uint>(1));
+        }
+        loop_init = false;
+        int _e32 = i_1;
+        if (_e32 < 4) {
+            float _e34 = amplitude;
+            metal::float2 _e35 = st_2;
+            param_4 = _e35;
+            float _e36 = noise(param_4);
+            float _e38 = value;
+            value = _e38 + (_e34 * _e36);
+            metal::float2 _e40 = st_2;
+            st_2 = _e40 * 2.0;
+            float _e42 = amplitude;
+            amplitude = _e42 * 0.5;
+            continue;
+        } else {
+            break;
+        }
+    }
+    float _e46 = value;
+    return _e46;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e29 = uv[0u];
+    float _e31 = uv[1u];
+    metal::float4 _e34 = _to.sample(_sampler, metal::float2(_e29, 1.0 - _e31), metal::level(0.0));
+    return _e34;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e29 = uv_1[0u];
+    float _e31 = uv_1[1u];
+    metal::float4 _e34 = _from.sample(_sampler, metal::float2(_e29, 1.0 - _e31), metal::level(0.0));
+    return _e34;
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 param_5 = {};
+    metal::float2 param_6 = {};
+    metal::float4 from = {};
+    metal::float2 param_7 = {};
+    metal::float4 to = {};
+    metal::float2 param_8 = {};
+    float n = {};
+    metal::float2 param_9 = {};
+    float l = {};
+    float edge = {};
+    float _e39 = uniforms.progress;
+    if (_e39 <= 0.0) {
+        metal::float2 _e41 = uv_2;
+        param_5 = _e41;
+        metal::float4 _e42 = getFromColor(param_5, _from, _sampler);
+        return _e42;
+    }
+    float _e44 = uniforms.progress;
+    if (_e44 >= 1.0) {
+        metal::float2 _e46 = uv_2;
+        param_6 = _e46;
+        metal::float4 _e47 = getToColor(param_6, _sampler, _to);
+        return _e47;
+    }
+    metal::float2 _e48 = uv_2;
+    param_7 = _e48;
+    metal::float4 _e49 = getFromColor(param_7, _from, _sampler);
+    from = _e49;
+    metal::float2 _e50 = uv_2;
+    param_8 = _e50;
+    metal::float4 _e51 = getToColor(param_8, _sampler, _to);
+    to = _e51;
+    metal::float2 _e52 = uv_2;
+    param_9 = _e52 * 4.0;
+    float _e54 = fbm(param_9);
+    n = _e54;
+    float _e56 = uniforms.progress;
+    float _e58 = uniforms.progress;
+    float _e60 = n;
+    l = metal::smoothstep(_e56, _e58 + 0.05, _e60);
+    float _e62 = l;
+    float _e64 = l;
+    edge = ((1.0 - _e62) * _e64) * 5.0;
+    metal::float4 _e67 = to;
+    metal::float4 _e68 = from;
+    float _e69 = l;
+    metal::float3 _e73 = uniforms.burnColor;
+    float _e78 = edge;
+    return metal::mix(_e67, _e68, metal::float4(_e69)) + (metal::float4(_e73.x, _e73.y, _e73.z, 0.0) * _e78);
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_10 = {};
+    metal::float2 _e28 = _uv_1;
+    param_10 = _e28;
+    metal::float4 _e29 = transition(param_10, _from, _sampler, _to, uniforms);
+    _fragColor = _e29;
+    return;
+}
+
+struct main_Input {
+    metal::float2 _uv [[user(loc0), center_perspective]];
+};
+struct main_Output {
+    metal::float4 member [[color(0)]];
+};
+fragment main_Output main_(
+  main_Input varyings [[stage_in]]
+, metal::texture2d<float, metal::access::sample> _from [[texture(0)]]
+, metal::sampler _sampler [[sampler(0)]]
+, metal::texture2d<float, metal::access::sample> _to [[texture(1)]]
+, constant Uniforms& uniforms [[buffer(0)]]
+) {
+    metal::float4 _fragColor = {};
+    metal::float2 _uv_1 = {};
+    const auto _uv = varyings._uv;
+    _uv_1 = _uv;
+    main_1(_from, _sampler, _to, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}