gl-transitions 1.74.0 → 1.76.0

package/msl/ButterflyWaveScrawler.metal

@@ -0,0 +1,190 @@
+// ButterflyWaveScrawler — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ButterflyWaveScrawler.glsl
+// Author: mandubian
+// License: MIT
+// Description: Wavy, color-separated ripples scramble the outgoing image into the incoming one
+// 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 amplitude;
+    float waves;
+    float colorSeparation;
+};
+
+float compute(
+    thread metal::float2& p,
+    thread float& progress,
+    thread metal::float2& center,
+    constant Uniforms& uniforms
+) {
+    metal::float2 o = {};
+    metal::float2 h = {};
+    float theta = {};
+    float s = {};
+    float s2_ = {};
+    metal::float2 _e31 = p;
+    float _e32 = progress;
+    float _e34 = uniforms.amplitude;
+    metal::float2 _e38 = center;
+    o = (_e31 * metal::sin(_e32 * _e34)) - _e38;
+    h = metal::float2(1.0, 0.0);
+    metal::float2 _e40 = o;
+    metal::float2 _e41 = h;
+    float _e45 = uniforms.waves;
+    theta = metal::acos(metal::dot(_e40, _e41)) * _e45;
+    float _e47 = theta;
+    s = metal::sin(((2.0 * _e47) - 3.1415927) / 24.0);
+    float _e52 = s;
+    float _e53 = s;
+    s2_ = _e52 * _e53;
+    float _e55 = theta;
+    float _e58 = theta;
+    float _e63 = s2_;
+    float _e64 = s2_;
+    float _e66 = s;
+    return ((metal::exp(metal::cos(_e55)) - (2.0 * metal::cos(4.0 * _e58))) + ((_e63 * _e64) * _e66)) / 10.0;
+}
+
+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 param_1 = {};
+    metal::float2 p_1 = {};
+    float inv = {};
+    float disp = {};
+    metal::float2 param_2 = {};
+    float param_3 = {};
+    metal::float2 param_4 = {};
+    metal::float4 texTo = {};
+    metal::float2 param_5 = {};
+    metal::float4 texFrom = {};
+    metal::float2 param_6 = {};
+    metal::float2 param_7 = {};
+    metal::float2 param_8 = {};
+    float _e39 = uniforms.progress;
+    if (_e39 <= 0.0) {
+        metal::float2 _e41 = uv_2;
+        param = _e41;
+        metal::float4 _e42 = getFromColor(param, _from, _sampler);
+        return _e42;
+    }
+    float _e44 = uniforms.progress;
+    if (_e44 >= 1.0) {
+        metal::float2 _e46 = uv_2;
+        param_1 = _e46;
+        metal::float4 _e47 = getToColor(param_1, _sampler, _to);
+        return _e47;
+    }
+    metal::float2 _e48 = uv_2;
+    p_1 = _e48;
+    float _e50 = uniforms.progress;
+    inv = 1.0 - _e50;
+    metal::float2 _e52 = p_1;
+    param_2 = _e52;
+    float _e54 = uniforms.progress;
+    param_3 = _e54;
+    param_4 = metal::float2(0.5, 0.5);
+    float _e55 = compute(param_2, param_3, param_4, uniforms);
+    disp = _e55;
+    metal::float2 _e56 = p_1;
+    float _e57 = inv;
+    float _e58 = disp;
+    param_5 = _e56 + metal::float2(_e57 * _e58);
+    metal::float4 _e62 = getToColor(param_5, _sampler, _to);
+    texTo = _e62;
+    metal::float2 _e63 = p_1;
+    float _e65 = uniforms.progress;
+    float _e66 = disp;
+    float _e69 = uniforms.colorSeparation;
+    param_6 = _e63 + metal::float2((_e65 * _e66) * (1.0 - _e69));
+    metal::float4 _e74 = getFromColor(param_6, _from, _sampler);
+    metal::float2 _e76 = p_1;
+    float _e78 = uniforms.progress;
+    float _e79 = disp;
+    param_7 = _e76 + metal::float2(_e78 * _e79);
+    metal::float4 _e83 = getFromColor(param_7, _from, _sampler);
+    metal::float2 _e85 = p_1;
+    float _e87 = uniforms.progress;
+    float _e88 = disp;
+    float _e91 = uniforms.colorSeparation;
+    param_8 = _e85 + metal::float2((_e87 * _e88) * (1.0 + _e91));
+    metal::float4 _e96 = getFromColor(param_8, _from, _sampler);
+    texFrom = metal::float4(_e74.x, _e83.y, _e96.z, 1.0);
+    metal::float4 _e99 = texTo;
+    float _e101 = uniforms.progress;
+    metal::float4 _e103 = texFrom;
+    float _e104 = inv;
+    return (_e99 * _e101) + (_e103 * _e104);
+}
+
+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_9 = {};
+    metal::float2 _e24 = _uv_1;
+    param_9 = _e24;
+    metal::float4 _e25 = transition(param_9, _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/CircleCrop.metal

@@ -0,0 +1,117 @@
+// CircleCrop — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CircleCrop.glsl
+// Author: fkuteken
+// 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;
+    char _pad2[8];
+    metal::float4 bgcolor;
+};
+
+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& p,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 ratio2_ = {};
+    float s = {};
+    float dist = {};
+    metal::float4 local = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e24 = uniforms.ratio;
+    ratio2_ = metal::float2(1.0, 1.0 / _e24);
+    float _e28 = uniforms.progress;
+    s = metal::pow(2.0 * metal::abs(_e28 - 0.5), 3.0);
+    metal::float2 _e33 = p;
+    metal::float2 _e36 = ratio2_;
+    dist = metal::length((_e33 - metal::float2(0.5)) * _e36);
+    float _e40 = uniforms.progress;
+    if (_e40 < 0.5) {
+        metal::float2 _e42 = p;
+        param = _e42;
+        metal::float4 _e43 = getFromColor(param, _from, _sampler);
+        local = _e43;
+    } else {
+        metal::float2 _e44 = p;
+        param_1 = _e44;
+        metal::float4 _e45 = getToColor(param_1, _sampler, _to);
+        local = _e45;
+    }
+    metal::float4 _e46 = local;
+    metal::float4 _e48 = uniforms.bgcolor;
+    float _e49 = s;
+    float _e50 = dist;
+    return metal::mix(_e46, _e48, metal::float4(metal::step(_e49, _e50)));
+}
+
+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/ColourDistance.metal

@@ -0,0 +1,110 @@
+// ColourDistance — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ColourDistance.glsl
+// Author: P-Seebauer
+// License: MIT
+// Description: Pixels switch to the incoming image in order of how close their colors are
+// 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 power;
+};
+
+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& p,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float4 fTex = {};
+    metal::float2 param = {};
+    metal::float4 tTex = {};
+    metal::float2 param_1 = {};
+    float m = {};
+    metal::float2 _e18 = p;
+    param = _e18;
+    metal::float4 _e19 = getFromColor(param, _from, _sampler);
+    fTex = _e19;
+    metal::float2 _e20 = p;
+    param_1 = _e20;
+    metal::float4 _e21 = getToColor(param_1, _sampler, _to);
+    tTex = _e21;
+    metal::float4 _e22 = fTex;
+    metal::float4 _e23 = tTex;
+    float _e26 = uniforms.progress;
+    m = metal::step(metal::distance(_e22, _e23), _e26);
+    metal::float4 _e28 = fTex;
+    metal::float4 _e29 = tTex;
+    float _e30 = m;
+    metal::float4 _e33 = tTex;
+    float _e35 = uniforms.progress;
+    float _e37 = uniforms.power;
+    return metal::mix(metal::mix(_e28, _e29, metal::float4(_e30)), _e33, metal::float4(metal::pow(_e35, _e37)));
+}
+
+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/CrazyParametricFun.metal

@@ -0,0 +1,139 @@
+// CrazyParametricFun — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/CrazyParametricFun.glsl
+// Author: mandubian
+// License: MIT
+// Description: The outgoing image is pulled along a parametric curve into a psychedelic swirl
+// 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 a;
+    float b;
+    float amplitude;
+    float smoothness;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e21 = uv[0u];
+    float _e23 = uv[1u];
+    metal::float4 _e26 = _to.sample(_sampler, metal::float2(_e21, 1.0 - _e23), metal::level(0.0));
+    return _e26;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e21 = uv_1[0u];
+    float _e23 = uv_1[1u];
+    metal::float4 _e26 = _from.sample(_sampler, metal::float2(_e21, 1.0 - _e23), metal::level(0.0));
+    return _e26;
+}
+
+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 p = {};
+    metal::float2 dir = {};
+    float dist = {};
+    float x = {};
+    float y = {};
+    metal::float2 offset = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e28 = uv_2;
+    p = _e28 / metal::float2(1.0, 1.0);
+    metal::float2 _e30 = p;
+    dir = _e30 - metal::float2(0.5, 0.5);
+    metal::float2 _e32 = dir;
+    dist = metal::length(_e32);
+    float _e35 = uniforms.a;
+    float _e37 = uniforms.b;
+    float _e40 = uniforms.progress;
+    float _e44 = uniforms.b;
+    float _e46 = uniforms.progress;
+    float _e48 = uniforms.a;
+    float _e50 = uniforms.b;
+    x = ((_e35 - _e37) * metal::cos(_e40)) + (_e44 * metal::cos(_e46 * ((_e48 / _e50) - 1.0)));
+    float _e58 = uniforms.a;
+    float _e60 = uniforms.b;
+    float _e63 = uniforms.progress;
+    float _e67 = uniforms.b;
+    float _e69 = uniforms.progress;
+    float _e71 = uniforms.a;
+    float _e73 = uniforms.b;
+    y = ((_e58 - _e60) * metal::sin(_e63)) - (_e67 * metal::sin(_e69 * ((_e71 / _e73) - 1.0)));
+    metal::float2 _e80 = dir;
+    float _e82 = uniforms.progress;
+    float _e83 = dist;
+    float _e86 = uniforms.amplitude;
+    float _e88 = x;
+    float _e92 = uniforms.progress;
+    float _e93 = dist;
+    float _e96 = uniforms.amplitude;
+    float _e98 = y;
+    float _e104 = uniforms.smoothness;
+    offset = (_e80 * metal::float2(metal::sin(((_e82 * _e83) * _e86) * _e88), metal::sin(((_e92 * _e93) * _e96) * _e98))) / metal::float2(_e104);
+    metal::float2 _e107 = p;
+    metal::float2 _e108 = offset;
+    param = _e107 + _e108;
+    metal::float4 _e110 = getFromColor(param, _from, _sampler);
+    metal::float2 _e111 = p;
+    param_1 = _e111;
+    metal::float4 _e112 = getToColor(param_1, _sampler, _to);
+    float _e114 = uniforms.progress;
+    return metal::mix(_e110, _e112, metal::float4(metal::smoothstep(0.2, 1.0, _e114)));
+}
+
+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 _e20 = _uv_1;
+    param_2 = _e20;
+    metal::float4 _e21 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e21;
+    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 };
+}