gl-transitions 1.74.0 → 1.76.0

package/msl/cannabisleaf.metal

@@ -0,0 +1,120 @@
+// cannabisleaf — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/cannabisleaf.glsl
+// Author: @Flexi23
+// License: MIT
+// Description: A cannabis-leaf shape grows from the center to reveal the incoming image
+// 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;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e25 = uv[0u];
+    float _e27 = uv[1u];
+    metal::float4 _e30 = _to.sample(_sampler, metal::float2(_e25, 1.0 - _e27), metal::level(0.0));
+    return _e30;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e25 = uv_1[0u];
+    float _e27 = uv_1[1u];
+    metal::float4 _e30 = _from.sample(_sampler, metal::float2(_e25, 1.0 - _e27), metal::level(0.0));
+    return _e30;
+}
+
+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 leaf_uv = {};
+    float r = {};
+    float o = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    float _e31 = uniforms.progress;
+    if (_e31 == 0.0) {
+        metal::float2 _e33 = uv_2;
+        param = _e33;
+        metal::float4 _e34 = getFromColor(param, _from, _sampler);
+        return _e34;
+    }
+    metal::float2 _e35 = uv_2;
+    float _e40 = uniforms.progress;
+    leaf_uv = ((_e35 - metal::float2(0.5, 0.5)) / metal::float2(10.0)) / metal::float2(metal::pow(_e40, 3.5));
+    float _e45 = leaf_uv[1u];
+    leaf_uv[1u] = _e45 + 0.35;
+    r = 0.18;
+    float _e49 = leaf_uv[1u];
+    float _e51 = leaf_uv[0u];
+    o = metal::atan2(_e49, _e51);
+    metal::float2 _e53 = uv_2;
+    param_1 = _e53;
+    metal::float4 _e54 = getFromColor(param_1, _from, _sampler);
+    metal::float2 _e55 = uv_2;
+    param_2 = _e55;
+    metal::float4 _e56 = getToColor(param_2, _sampler, _to);
+    metal::float2 _e57 = leaf_uv;
+    float _e60 = r;
+    float _e61 = o;
+    float _e65 = o;
+    float _e71 = o;
+    float _e77 = o;
+    return metal::mix(_e54, _e56, metal::float4(1.0 - metal::step((1.0 - metal::length(_e57)) + ((((_e60 * (1.0 + metal::sin(_e61))) * (1.0 + (0.9 * metal::cos(8.0 * _e65)))) * (1.0 + (0.1 * metal::cos(24.0 * _e71)))) * (0.9 + (0.05 * metal::cos(200.0 * _e77)))), 1.0)));
+}
+
+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_3 = {};
+    metal::float2 _e24 = _uv_1;
+    param_3 = _e24;
+    metal::float4 _e25 = transition(param_3, _from, _sampler, _to, uniforms);
+    _fragColor = _e25;
+    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/chessboard.metal

@@ -0,0 +1,144 @@
+// chessboard — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/chessboard.glsl
+// Author: lql
+// License: MIT
+// Description: A chessboard pattern of squares reveals the incoming image
+// 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 grid_num;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e16 = uv[0u];
+    float _e18 = uv[1u];
+    metal::float4 _e21 = _to.sample(_sampler, metal::float2(_e16, 1.0 - _e18), metal::level(0.0));
+    return _e21;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e16 = uv_1[0u];
+    float _e18 = uv_1[1u];
+    metal::float4 _e21 = _from.sample(_sampler, metal::float2(_e16, 1.0 - _e18), metal::level(0.0));
+    return _e21;
+}
+
+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 st = {};
+    metal::float2 idx = {};
+    metal::float2 grid = {};
+    metal::float4 a = {};
+    metal::float2 param = {};
+    metal::float4 b = {};
+    metal::float2 param_1 = {};
+    float checker = {};
+    float mixFactor = {};
+    float local = {};
+    float local_1 = {};
+    metal::float2 _e26 = uv_2;
+    float _e28 = uniforms.grid_num;
+    st = _e26 * _e28;
+    metal::float2 _e30 = st;
+    idx = metal::floor(_e30);
+    metal::float2 _e32 = st;
+    grid = metal::fract(_e32);
+    metal::float2 _e34 = uv_2;
+    param = _e34;
+    metal::float4 _e35 = getFromColor(param, _from, _sampler);
+    a = _e35;
+    metal::float2 _e36 = uv_2;
+    param_1 = _e36;
+    metal::float4 _e37 = getToColor(param_1, _sampler, _to);
+    b = _e37;
+    float _e39 = idx[0u];
+    float _e41 = idx[1u];
+    float _e42 = _e39 + _e41;
+    checker = _e42 - (metal::floor(_e42 / 2.0) * 2.0);
+    float _e48 = uniforms.progress;
+    if (_e48 <= 0.5) {
+        float _e50 = checker;
+        if (_e50 > 0.5) {
+            float _e53 = grid[0u];
+            float _e55 = uniforms.progress;
+            local = metal::step(_e53, _e55 * 2.0);
+        } else {
+            local = 0.0;
+        }
+        float _e58 = local;
+        mixFactor = _e58;
+    } else {
+        float _e59 = checker;
+        if (_e59 < 0.5) {
+            float _e62 = grid[0u];
+            float _e64 = uniforms.progress;
+            local_1 = metal::step(_e62, (_e64 - 0.5) * 2.0);
+        } else {
+            local_1 = 1.0;
+        }
+        float _e68 = local_1;
+        mixFactor = _e68;
+    }
+    metal::float4 _e69 = a;
+    metal::float4 _e70 = b;
+    float _e71 = mixFactor;
+    return metal::mix(_e69, _e70, metal::float4(_e71));
+}
+
+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 _e15 = _uv_1;
+    param_2 = _e15;
+    metal::float4 _e16 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e16;
+    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/circle.metal

@@ -0,0 +1,115 @@
+// circle — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/circle.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: The outgoing image closes into a circle over a background color, then the incoming one opens from it
+// 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;
+    metal::float2 center;
+    metal::float3 backColor;
+};
+
+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::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 distance = {};
+    float radius = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e20 = uv_2;
+    metal::float2 _e22 = uniforms.center;
+    distance = metal::length(_e20 - _e22);
+    float _e26 = uniforms.progress;
+    radius = 2.828427 * metal::abs(_e26 - 0.5);
+    float _e30 = distance;
+    float _e31 = radius;
+    if (_e30 > _e31) {
+        metal::float3 _e34 = uniforms.backColor;
+        return metal::float4(_e34.x, _e34.y, _e34.z, 1.0);
+    } else {
+        float _e40 = uniforms.progress;
+        if (_e40 < 0.5) {
+            metal::float2 _e42 = uv_2;
+            param = _e42;
+            metal::float4 _e43 = getFromColor(param, _from, _sampler);
+            return _e43;
+        } else {
+            metal::float2 _e44 = uv_2;
+            param_1 = _e44;
+            metal::float4 _e45 = getToColor(param_1, _sampler, _to);
+            return _e45;
+        }
+    }
+}
+
+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 _e16 = _uv_1;
+    param_2 = _e16;
+    metal::float4 _e17 = transition(param_2, _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/circleopen.metal

@@ -0,0 +1,124 @@
+// circleopen — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/circleopen.glsl
+// Author: gre
+// License: MIT
+// Description: A soft-edged circle opens from the center to reveal the incoming image
+// 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 smoothness;
+    int opening;
+};
+
+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 x = {};
+    float local = {};
+    float m = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float local_1 = {};
+    int _e24 = uniforms.opening;
+    if (_e24 != 0) {
+        float _e27 = uniforms.progress;
+        local = _e27;
+    } else {
+        float _e29 = uniforms.progress;
+        local = 1.0 - _e29;
+    }
+    float _e31 = local;
+    x = _e31;
+    float _e33 = uniforms.smoothness;
+    metal::float2 _e35 = uv_2;
+    float _e38 = x;
+    float _e40 = uniforms.smoothness;
+    m = metal::smoothstep(-(_e33), 0.0, (1.4142135 * metal::distance(metal::float2(0.5, 0.5), _e35)) - (_e38 * (1.0 + _e40)));
+    metal::float2 _e45 = uv_2;
+    param = _e45;
+    metal::float4 _e46 = getFromColor(param, _from, _sampler);
+    metal::float2 _e47 = uv_2;
+    param_1 = _e47;
+    metal::float4 _e48 = getToColor(param_1, _sampler, _to);
+    int _e50 = uniforms.opening;
+    if (_e50 != 0) {
+        float _e52 = m;
+        local_1 = 1.0 - _e52;
+    } else {
+        float _e54 = m;
+        local_1 = _e54;
+    }
+    float _e55 = local_1;
+    return metal::mix(_e46, _e48, metal::float4(_e55));
+}
+
+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/colorphase.metal

@@ -0,0 +1,106 @@
+// colorphase — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/colorphase.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade in which each color channel changes at a different time
+// 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::float4 fromStep;
+    metal::float4 toStep;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e15 = uv[0u];
+    float _e17 = uv[1u];
+    metal::float4 _e20 = _to.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e15 = uv_1[0u];
+    float _e17 = uv_1[1u];
+    metal::float4 _e20 = _from.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+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::float4 a = {};
+    metal::float2 param = {};
+    metal::float4 b = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e18 = uv_2;
+    param = _e18;
+    metal::float4 _e19 = getFromColor(param, _from, _sampler);
+    a = _e19;
+    metal::float2 _e20 = uv_2;
+    param_1 = _e20;
+    metal::float4 _e21 = getToColor(param_1, _sampler, _to);
+    b = _e21;
+    metal::float4 _e22 = a;
+    metal::float4 _e23 = b;
+    metal::float4 _e25 = uniforms.fromStep;
+    metal::float4 _e27 = uniforms.toStep;
+    float _e29 = uniforms.progress;
+    return metal::mix(_e22, _e23, metal::smoothstep(_e25, _e27, metal::float4(_e29)));
+}
+
+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 _e14 = _uv_1;
+    param_2 = _e14;
+    metal::float4 _e15 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e15;
+    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 };
+}