gl-transitions 1.74.0 → 1.76.0

package/msl/LeftRight.metal

@@ -0,0 +1,138 @@
+// LeftRight — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LeftRight.glsl
+// Author: zhmy
+// License: MIT
+// Description: The outgoing image shrinks away to the left while the incoming one slides in from the 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;
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e24 = uv[0u];
+    float _e26 = uv[1u];
+    metal::float4 _e29 = _from.sample(_sampler, metal::float2(_e24, 1.0 - _e26), metal::level(0.0));
+    return _e29;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e24 = uv_1[0u];
+    float _e26 = uv_1[1u];
+    metal::float4 _e29 = _to.sample(_sampler, metal::float2(_e24, 1.0 - _e26), metal::level(0.0));
+    return _e29;
+}
+
+bool inBounds(
+    thread metal::float2& p
+) {
+    bool phi_74_ = {};
+    metal::float2 _e23 = p;
+    bool _e25 = metal::all(metal::float2(0.0, 0.0) < _e23);
+    phi_74_ = _e25;
+    if (_e25) {
+        metal::float2 _e26 = p;
+        phi_74_ = metal::all(_e26 < metal::float2(1.0, 1.0));
+    }
+    bool _e30 = phi_74_;
+    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 spto = {};
+    float size = {};
+    metal::float2 spfr = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    spto = metal::float2(-1.0, -1.0);
+    float _e31 = uniforms.progress;
+    size = metal::mix(1.0, 3.0, _e31 * 0.2);
+    metal::float2 _e34 = uv_2;
+    float _e36 = size;
+    spto = ((_e34 + metal::float2(-0.5, -0.5)) * metal::float2(_e36)) + metal::float2(0.5, 0.5);
+    metal::float2 _e40 = uv_2;
+    float _e42 = uniforms.progress;
+    spfr = _e40 - metal::float2(1.0 - _e42, 0.0);
+    metal::float2 _e46 = spfr;
+    param = _e46;
+    bool _e47 = inBounds(param);
+    if (_e47) {
+        metal::float2 _e48 = spfr;
+        param_1 = _e48;
+        metal::float4 _e49 = getToColor(param_1, _sampler, _to);
+        return _e49;
+    } else {
+        metal::float2 _e50 = spto;
+        param_2 = _e50;
+        bool _e51 = inBounds(param_2);
+        if (_e51) {
+            metal::float2 _e52 = spto;
+            param_3 = _e52;
+            metal::float4 _e53 = getFromColor(param_3, _from, _sampler);
+            float _e55 = uniforms.progress;
+            return _e53 * (1.0 - _e55);
+        } else {
+            return metal::float4(0.0, 0.0, 0.0, 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_4 = {};
+    metal::float2 _e23 = _uv_1;
+    param_4 = _e23;
+    metal::float4 _e24 = transition(param_4, _from, _sampler, _to, uniforms);
+    _fragColor = _e24;
+    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/LinearBlur.metal

@@ -0,0 +1,169 @@
+// LinearBlur — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/LinearBlur.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade through a blur
+// 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 intensity;
+};
+
+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::float4 c1_ = {};
+    metal::float4 c2_ = {};
+    float disp = {};
+    int xi = {};
+    float x = {};
+    int yi = {};
+    float y = {};
+    metal::float2 v = {};
+    float d = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    c1_ = metal::float4(0.0, 0.0, 0.0, 0.0);
+    c2_ = metal::float4(0.0, 0.0, 0.0, 0.0);
+    float _e31 = uniforms.intensity;
+    float _e33 = uniforms.progress;
+    disp = _e31 * (0.5 - metal::abs(0.5 - _e33));
+    xi = 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 _e71 = xi;
+            xi = as_type<int>(as_type<uint>(_e71) + as_type<uint>(1));
+        }
+        loop_init = false;
+        int _e37 = xi;
+        if (_e37 < 6) {
+            int _e39 = xi;
+            x = (static_cast<float>(_e39) / 6.0) - 0.5;
+            yi = 0;
+            uint2 loop_bound_1 = uint2(4294967295u);
+            bool loop_init_1 = true;
+            while(true) {
+                if (metal::all(loop_bound_1 == uint2(0u))) { break; }
+                loop_bound_1 -= uint2(loop_bound_1.y == 0u, 1u);
+                if (!loop_init_1) {
+                    int _e69 = yi;
+                    yi = as_type<int>(as_type<uint>(_e69) + as_type<uint>(1));
+                }
+                loop_init_1 = false;
+                int _e43 = yi;
+                if (_e43 < 6) {
+                    int _e45 = yi;
+                    y = (static_cast<float>(_e45) / 6.0) - 0.5;
+                    float _e49 = x;
+                    float _e50 = y;
+                    v = metal::float2(_e49, _e50);
+                    float _e52 = disp;
+                    d = _e52;
+                    metal::float2 _e53 = uv_2;
+                    float _e54 = d;
+                    metal::float2 _e55 = v;
+                    param = _e53 + (_e55 * _e54);
+                    metal::float4 _e58 = getFromColor(param, _from, _sampler);
+                    metal::float4 _e59 = c1_;
+                    c1_ = _e59 + _e58;
+                    metal::float2 _e61 = uv_2;
+                    float _e62 = d;
+                    metal::float2 _e63 = v;
+                    param_1 = _e61 + (_e63 * _e62);
+                    metal::float4 _e66 = getToColor(param_1, _sampler, _to);
+                    metal::float4 _e67 = c2_;
+                    c2_ = _e67 + _e66;
+                    continue;
+                } else {
+                    break;
+                }
+            }
+            continue;
+        } else {
+            break;
+        }
+    }
+    metal::float4 _e73 = c1_;
+    c1_ = _e73 / metal::float4(36.0);
+    metal::float4 _e76 = c2_;
+    c2_ = _e76 / metal::float4(36.0);
+    metal::float4 _e79 = c1_;
+    metal::float4 _e80 = c2_;
+    float _e82 = uniforms.progress;
+    return metal::mix(_e79, _e80, metal::float4(_e82));
+}
+
+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/Mosaic.metal

@@ -0,0 +1,212 @@
+// Mosaic — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Mosaic.glsl
+// Author: Xaychru
+// License: MIT
+// Description: The view pans across a mosaic of rotated tiles from both images and settles on 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;
+    int endx;
+    int endy;
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e26 = uv[0u];
+    float _e28 = uv[1u];
+    metal::float4 _e31 = _from.sample(_sampler, metal::float2(_e26, 1.0 - _e28), metal::level(0.0));
+    return _e31;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e26 = uv_1[0u];
+    float _e28 = uv_1[1u];
+    metal::float4 _e31 = _to.sample(_sampler, metal::float2(_e26, 1.0 - _e28), metal::level(0.0));
+    return _e31;
+}
+
+metal::float2 Rotate(
+    thread metal::float2& v,
+    thread float& a
+) {
+    metal::float2x2 rm = {};
+    float _e27 = a;
+    float _e29 = a;
+    float _e32 = a;
+    float _e34 = a;
+    rm = metal::float2x2(metal::float2(metal::cos(_e27), -(metal::sin(_e29))), metal::float2(metal::sin(_e32), metal::cos(_e34)));
+    metal::float2x2 _e39 = rm;
+    metal::float2 _e40 = v;
+    return _e39 * _e40;
+}
+
+float Rand(
+    thread metal::float2& v_1
+) {
+    metal::float2 _e25 = v_1;
+    return metal::fract(metal::sin(metal::dot(_e25, metal::float2(12.9898, 78.233))) * 43758.547);
+}
+
+float CosInterpolation(
+    thread float& x
+) {
+    float _e25 = x;
+    return (-(metal::cos(_e25 * 3.1415927)) / 2.0) + 0.5;
+}
+
+int naga_f2i32(float value) {
+    return static_cast<int>(metal::clamp(value, -2147483600.0, 2147483500.0));
+}
+
+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 rp = {};
+    float rpr = {};
+    float z = {};
+    float az = {};
+    float param = {};
+    float param_1 = {};
+    metal::float2 mrp = {};
+    metal::float2 crp = {};
+    bool onEnd = {};
+    float ang = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    float param_4 = {};
+    metal::float2 param_5 = {};
+    metal::float2 param_6 = {};
+    metal::float2 param_7 = {};
+    bool phi_197_ = {};
+    bool phi_229_ = {};
+    metal::float2 _e42 = uv_2;
+    p = (_e42 / metal::float2(1.0, 1.0)) - metal::float2(0.5);
+    metal::float2 _e46 = p;
+    rp = _e46;
+    float _e48 = uniforms.progress;
+    rpr = (_e48 * 2.0) - 1.0;
+    float _e51 = rpr;
+    float _e52 = rpr;
+    z = -(((_e51 * _e52) * 2.0)) + 3.0;
+    float _e57 = z;
+    az = metal::abs(_e57);
+    float _e59 = az;
+    metal::float2 _e60 = rp;
+    rp = _e60 * _e59;
+    int _e63 = uniforms.endx;
+    int _e67 = uniforms.endy;
+    float _e72 = uniforms.progress;
+    param = _e72;
+    float _e73 = CosInterpolation(param);
+    float _e75 = uniforms.progress;
+    param_1 = _e75;
+    float _e76 = CosInterpolation(param_1);
+    metal::float2 _e80 = rp;
+    rp = _e80 + metal::mix(metal::float2(0.5, 0.5), metal::float2(static_cast<float>(_e63) + 0.5, static_cast<float>(_e67) + 0.5), metal::float2(_e73 * _e76));
+    metal::float2 _e82 = rp;
+    metal::float2 _e83 = metal::float2(1.0);
+    mrp = _e82 - (metal::floor(_e82 / _e83) * _e83);
+    metal::float2 _e88 = rp;
+    crp = _e88;
+    float _e90 = crp[0u];
+    int _e94 = uniforms.endx;
+    bool _e95 = naga_f2i32(metal::floor(_e90)) == _e94;
+    phi_197_ = _e95;
+    if (_e95) {
+        float _e97 = crp[1u];
+        int _e101 = uniforms.endy;
+        phi_197_ = naga_f2i32(metal::floor(_e97)) == _e101;
+    }
+    bool _e104 = phi_197_;
+    onEnd = _e104;
+    bool _e105 = onEnd;
+    if (!(_e105)) {
+        metal::float2 _e107 = crp;
+        param_2 = metal::floor(_e107);
+        float _e109 = Rand(param_2);
+        ang = (static_cast<float>(naga_f2i32(_e109 * 4.0)) * 0.5) * 3.1415927;
+        metal::float2 _e115 = mrp;
+        param_3 = _e115 - metal::float2(0.5, 0.5);
+        float _e117 = ang;
+        param_4 = _e117;
+        metal::float2 _e118 = Rotate(param_3, param_4);
+        mrp = metal::float2(0.5, 0.5) + _e118;
+    }
+    bool _e120 = onEnd;
+    phi_229_ = _e120;
+    if (!(_e120)) {
+        metal::float2 _e122 = crp;
+        param_5 = metal::floor(_e122);
+        float _e124 = Rand(param_5);
+        phi_229_ = _e124 > 0.5;
+    }
+    bool _e127 = phi_229_;
+    if (_e127) {
+        metal::float2 _e128 = mrp;
+        param_6 = _e128;
+        metal::float4 _e129 = getToColor(param_6, _sampler, _to);
+        return _e129;
+    } else {
+        metal::float2 _e130 = mrp;
+        param_7 = _e130;
+        metal::float4 _e131 = getFromColor(param_7, _from, _sampler);
+        return _e131;
+    }
+}
+
+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_8 = {};
+    metal::float2 _e25 = _uv_1;
+    param_8 = _e25;
+    metal::float4 _e26 = transition(param_8, _from, _sampler, _to, uniforms);
+    _fragColor = _e26;
+    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/Overexposure.metal

@@ -0,0 +1,130 @@
+// Overexposure — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Overexposure.glsl
+// Author: Ben Zhang
+// License: MIT
+// Description: A crossfade through a washed-out, overexposed white
+// 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 strength;
+};
+
+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
+) {
+    metal::float4 from = {};
+    metal::float2 param = {};
+    metal::float4 to = {};
+    metal::float2 param_1 = {};
+    float from_m = {};
+    float to_m = {};
+    metal::float2 _e22 = uv_2;
+    param = _e22;
+    metal::float4 _e23 = getFromColor(param, _from, _sampler);
+    from = _e23;
+    metal::float2 _e24 = uv_2;
+    param_1 = _e24;
+    metal::float4 _e25 = getToColor(param_1, _sampler, _to);
+    to = _e25;
+    float _e27 = uniforms.progress;
+    float _e30 = uniforms.progress;
+    float _e34 = uniforms.strength;
+    from_m = (1.0 - _e27) + (metal::sin(3.1415927 * _e30) * _e34);
+    float _e38 = uniforms.progress;
+    float _e40 = uniforms.progress;
+    float _e44 = uniforms.strength;
+    to_m = _e38 + (metal::sin(3.1415927 * _e40) * _e44);
+    float _e48 = from[0u];
+    float _e50 = from[3u];
+    float _e52 = from_m;
+    float _e55 = to[0u];
+    float _e57 = to[3u];
+    float _e59 = to_m;
+    float _e63 = from[1u];
+    float _e65 = from[3u];
+    float _e67 = from_m;
+    float _e70 = to[1u];
+    float _e72 = to[3u];
+    float _e74 = to_m;
+    float _e78 = from[2u];
+    float _e80 = from[3u];
+    float _e82 = from_m;
+    float _e85 = to[2u];
+    float _e87 = to[3u];
+    float _e89 = to_m;
+    float _e93 = from[3u];
+    float _e95 = to[3u];
+    float _e97 = uniforms.progress;
+    return metal::float4(((_e48 * _e50) * _e52) + ((_e55 * _e57) * _e59), ((_e63 * _e65) * _e67) + ((_e70 * _e72) * _e74), ((_e78 * _e80) * _e82) + ((_e85 * _e87) * _e89), metal::mix(_e93, _e95, _e97));
+}
+
+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 };
+}