gl-transitions 1.74.0 → 1.76.0

package/msl/ripple.metal

@@ -0,0 +1,113 @@
+// ripple — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/ripple.glsl
+// Author: gre
+// License: MIT
+// Description: Ripples spread from the center while crossfading
+// 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 speed;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e19 = uv[0u];
+    float _e21 = uv[1u];
+    metal::float4 _e24 = _to.sample(_sampler, metal::float2(_e19, 1.0 - _e21), metal::level(0.0));
+    return _e24;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e19 = uv_1[0u];
+    float _e21 = uv_1[1u];
+    metal::float4 _e24 = _from.sample(_sampler, metal::float2(_e19, 1.0 - _e21), metal::level(0.0));
+    return _e24;
+}
+
+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 dir = {};
+    float dist = {};
+    metal::float2 offset = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e23 = uv_2;
+    dir = _e23 - metal::float2(0.5, 0.5);
+    metal::float2 _e25 = dir;
+    dist = metal::length(_e25);
+    metal::float2 _e27 = dir;
+    float _e29 = uniforms.progress;
+    float _e30 = dist;
+    float _e33 = uniforms.amplitude;
+    float _e36 = uniforms.progress;
+    float _e38 = uniforms.speed;
+    float _e47 = uniforms.progress;
+    offset = ((_e27 * (metal::sin(((_e29 * _e30) * _e33) - (_e36 * _e38)) + 0.5)) / metal::float2(30.0)) * _e47;
+    metal::float2 _e49 = uv_2;
+    metal::float2 _e50 = offset;
+    param = _e49 + _e50;
+    metal::float4 _e52 = getFromColor(param, _from, _sampler);
+    metal::float2 _e53 = uv_2;
+    param_1 = _e53;
+    metal::float4 _e54 = getToColor(param_1, _sampler, _to);
+    float _e56 = uniforms.progress;
+    return metal::mix(_e52, _e54, metal::float4(metal::smoothstep(0.2, 1.0, _e56)));
+}
+
+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 _e18 = _uv_1;
+    param_2 = _e18;
+    metal::float4 _e19 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e19;
+    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/rotateTransition.metal

@@ -0,0 +1,116 @@
+// rotateTransition — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/rotateTransition.glsl
+// Author: haiyoucuv
+// License: MIT
+// Description: The images spin around the center while crossfading
+// 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 _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::float2 rotate2D(
+    thread metal::float2& uv_2,
+    thread float& angle
+) {
+    metal::float2 _e16 = uv_2;
+    float _e17 = angle;
+    float _e19 = angle;
+    float _e22 = angle;
+    float _e24 = angle;
+    return _e16 * metal::float2x2(metal::float2(metal::cos(_e17), -(metal::sin(_e19))), metal::float2(metal::sin(_e22), metal::cos(_e24)));
+}
+
+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
+) {
+    metal::float2 p = {};
+    metal::float2 param = {};
+    float param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 _e20 = uv_3;
+    float _e24 = uniforms.progress;
+    param = _e20 - metal::float2(0.5);
+    param_1 = (_e24 * 3.1415925) * 2.0;
+    metal::float2 _e27 = rotate2D(param, param_1);
+    p = metal::fract(_e27 + metal::float2(0.5));
+    metal::float2 _e31 = p;
+    param_2 = _e31;
+    metal::float4 _e32 = getFromColor(param_2, _from, _sampler);
+    metal::float2 _e33 = p;
+    param_3 = _e33;
+    metal::float4 _e34 = getToColor(param_3, _sampler, _to);
+    float _e36 = uniforms.progress;
+    return metal::mix(_e32, _e34, metal::float4(_e36));
+}
+
+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_4 = {};
+    metal::float2 _e15 = _uv_1;
+    param_4 = _e15;
+    metal::float4 _e16 = transition(param_4, _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/rotate_scale_fade.metal

@@ -0,0 +1,167 @@
+// rotate_scale_fade — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/rotate_scale_fade.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: The outgoing image spins and zooms while fading to the incoming one, over a background color
+// 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;
+    float rotations;
+    float scale;
+    char _pad5[8];
+    metal::float4 backColor;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e20 = uv[0u];
+    float _e22 = uv[1u];
+    metal::float4 _e25 = _to.sample(_sampler, metal::float2(_e20, 1.0 - _e22), metal::level(0.0));
+    return _e25;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e20 = uv_1[0u];
+    float _e22 = uv_1[1u];
+    metal::float4 _e25 = _from.sample(_sampler, metal::float2(_e20, 1.0 - _e22), metal::level(0.0));
+    return _e25;
+}
+
+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 difference = {};
+    metal::float2 dir = {};
+    float dist = {};
+    float angle = {};
+    float c = {};
+    float s = {};
+    float currentScale = {};
+    metal::float2 rotatedDir = {};
+    metal::float2 rotatedUv = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    bool phi_144_ = {};
+    bool phi_151_ = {};
+    bool phi_158_ = {};
+    metal::float2 _e30 = uv_2;
+    metal::float2 _e32 = uniforms.center;
+    difference = _e30 - _e32;
+    metal::float2 _e34 = difference;
+    dir = metal::normalize(_e34);
+    metal::float2 _e36 = difference;
+    dist = metal::length(_e36);
+    float _e39 = uniforms.rotations;
+    float _e42 = uniforms.progress;
+    angle = (6.2831855 * _e39) * _e42;
+    float _e44 = angle;
+    c = metal::cos(_e44);
+    float _e46 = angle;
+    s = metal::sin(_e46);
+    float _e49 = uniforms.scale;
+    float _e51 = uniforms.progress;
+    currentScale = metal::mix(_e49, 1.0, 2.0 * metal::abs(_e51 - 0.5));
+    float _e57 = dir[0u];
+    float _e58 = c;
+    float _e61 = dir[1u];
+    float _e62 = s;
+    float _e66 = dir[0u];
+    float _e67 = s;
+    float _e70 = dir[1u];
+    float _e71 = c;
+    rotatedDir = metal::float2((_e57 * _e58) - (_e61 * _e62), (_e66 * _e67) + (_e70 * _e71));
+    metal::float2 _e76 = uniforms.center;
+    metal::float2 _e77 = rotatedDir;
+    float _e78 = dist;
+    float _e80 = currentScale;
+    rotatedUv = _e76 + ((_e77 * _e78) / metal::float2(_e80));
+    float _e85 = rotatedUv[0u];
+    bool _e86 = _e85 < 0.0;
+    phi_144_ = _e86;
+    if (!(_e86)) {
+        float _e89 = rotatedUv[0u];
+        phi_144_ = _e89 > 1.0;
+    }
+    bool _e92 = phi_144_;
+    phi_151_ = _e92;
+    if (!(_e92)) {
+        float _e95 = rotatedUv[1u];
+        phi_151_ = _e95 < 0.0;
+    }
+    bool _e98 = phi_151_;
+    phi_158_ = _e98;
+    if (!(_e98)) {
+        float _e101 = rotatedUv[1u];
+        phi_158_ = _e101 > 1.0;
+    }
+    bool _e104 = phi_158_;
+    if (_e104) {
+        metal::float4 _e106 = uniforms.backColor;
+        return _e106;
+    }
+    metal::float2 _e107 = rotatedUv;
+    param = _e107;
+    metal::float4 _e108 = getFromColor(param, _from, _sampler);
+    metal::float2 _e109 = rotatedUv;
+    param_1 = _e109;
+    metal::float4 _e110 = getToColor(param_1, _sampler, _to);
+    float _e112 = uniforms.progress;
+    return metal::mix(_e108, _e110, metal::float4(_e112));
+}
+
+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 _e19 = _uv_1;
+    param_2 = _e19;
+    metal::float4 _e20 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e20;
+    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/scale-in.metal

@@ -0,0 +1,111 @@
+// scale-in — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/scale-in.glsl
+// Author: haiyoucuv
+// License: MIT
+// Description: The incoming image scales in from the center while fading in
+// 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 _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 scale(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 param = {};
+    metal::float2 _e14 = uv_1;
+    float _e18 = uniforms.progress;
+    uv_1 = metal::float2(0.5) + ((_e14 - metal::float2(0.5)) * _e18);
+    metal::float2 _e22 = uv_1;
+    param = _e22;
+    metal::float4 _e23 = getToColor(param, _sampler, _to);
+    return _e23;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e14 = uv_2[0u];
+    float _e16 = uv_2[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_3,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 _e15 = uv_3;
+    param_1 = _e15;
+    metal::float4 _e16 = getFromColor(param_1, _from, _sampler);
+    metal::float2 _e17 = uv_3;
+    param_2 = _e17;
+    metal::float4 _e18 = scale(param_2, _sampler, _to, uniforms);
+    float _e20 = uniforms.progress;
+    return metal::mix(_e16, _e18, metal::float4(_e20));
+}
+
+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 _e13 = _uv_1;
+    param_3 = _e13;
+    metal::float4 _e14 = transition(param_3, _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/splitSlideInHorizontal.metal

@@ -0,0 +1,147 @@
+// splitSlideInHorizontal — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/splitSlideInHorizontal.glsl
+// Author: OllyOllyOlly
+// License: MIT
+// Description: The incoming image slides in as two halves moving horizontally in opposite directions
+// 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;
+    int reverse;
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e18 = uv[0u];
+    float _e20 = uv[1u];
+    metal::float4 _e23 = _from.sample(_sampler, metal::float2(_e18, 1.0 - _e20), metal::level(0.0));
+    return _e23;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e18 = uv_1[0u];
+    float _e20 = uv_1[1u];
+    metal::float4 _e23 = _to.sample(_sampler, metal::float2(_e18, 1.0 - _e20), metal::level(0.0));
+    return _e23;
+}
+
+bool inBounds(
+    thread metal::float2& p
+) {
+    bool phi_74_ = {};
+    metal::float2 _e17 = p;
+    bool _e19 = metal::all(metal::float2(0.0, 0.0) < _e17);
+    phi_74_ = _e19;
+    if (_e19) {
+        metal::float2 _e20 = p;
+        phi_74_ = metal::all(_e20 < metal::float2(1.0, 1.0));
+    }
+    bool _e24 = phi_74_;
+    return _e24;
+}
+
+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 modifier = {};
+    metal::float2 toP = {};
+    metal::float2 local = {};
+    metal::float2 fromP = {};
+    metal::float2 param = {};
+    metal::float4 local_1 = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    int _e26 = uniforms.reverse;
+    modifier = (_e26 != 0) ? -1.0 : 1.0;
+    float _e30 = uv_2[1u];
+    if (_e30 > 0.5) {
+        float _e33 = uv_2[0u];
+        float _e35 = uniforms.progress;
+        float _e36 = modifier;
+        float _e39 = modifier;
+        float _e42 = uv_2[1u];
+        local = metal::float2((_e33 - (_e35 * _e36)) + _e39, _e42);
+    } else {
+        float _e45 = uv_2[0u];
+        float _e47 = uniforms.progress;
+        float _e48 = modifier;
+        float _e51 = modifier;
+        float _e54 = uv_2[1u];
+        local = metal::float2((_e45 + (_e47 * _e48)) - _e51, _e54);
+    }
+    metal::float2 _e56 = local;
+    toP = _e56;
+    metal::float2 _e57 = uv_2;
+    fromP = _e57;
+    metal::float2 _e58 = toP;
+    param = _e58;
+    bool _e59 = inBounds(param);
+    if (_e59) {
+        metal::float2 _e60 = toP;
+        param_1 = _e60;
+        metal::float4 _e61 = getToColor(param_1, _sampler, _to);
+        local_1 = _e61;
+    } else {
+        metal::float2 _e62 = fromP;
+        param_2 = _e62;
+        metal::float4 _e63 = getFromColor(param_2, _from, _sampler);
+        local_1 = _e63;
+    }
+    metal::float4 _e64 = local_1;
+    return _e64;
+}
+
+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 _e17 = _uv_1;
+    param_3 = _e17;
+    metal::float4 _e18 = transition(param_3, _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 };
+}