gl-transitions 1.74.0 → 1.76.0

package/msl/coord-from-in.metal

@@ -0,0 +1,111 @@
+// coord-from-in — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/coord-from-in.glsl
+// Author: haiyoucuv
+// License: MIT
+// Description: A crossfade in which the colors of one image displace the other
+// 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 _e13 = uv[0u];
+    float _e15 = uv[1u];
+    metal::float4 _e18 = _from.sample(_sampler, metal::float2(_e13, 1.0 - _e15), metal::level(0.0));
+    return _e18;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e13 = uv_1[0u];
+    float _e15 = uv_1[1u];
+    metal::float4 _e18 = _to.sample(_sampler, metal::float2(_e13, 1.0 - _e15), metal::level(0.0));
+    return _e18;
+}
+
+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 coordTo = {};
+    metal::float2 param = {};
+    metal::float4 coordFrom = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 _e18 = uv_2;
+    param = _e18;
+    metal::float4 _e19 = getToColor(param, _sampler, _to);
+    coordTo = _e19;
+    metal::float2 _e20 = uv_2;
+    param_1 = _e20;
+    metal::float4 _e21 = getFromColor(param_1, _from, _sampler);
+    coordFrom = _e21;
+    metal::float2 _e22 = uv_2;
+    metal::float4 _e23 = coordTo;
+    float _e26 = uniforms.progress;
+    param_2 = metal::mix(_e22, _e23.xy, metal::float2(_e26));
+    metal::float4 _e29 = getFromColor(param_2, _from, _sampler);
+    metal::float4 _e30 = coordFrom;
+    metal::float2 _e32 = uv_2;
+    float _e34 = uniforms.progress;
+    param_3 = metal::mix(_e30.xy, _e32, metal::float2(_e34));
+    metal::float4 _e37 = getToColor(param_3, _sampler, _to);
+    float _e39 = uniforms.progress;
+    return metal::mix(_e29, _e37, metal::float4(_e39));
+}
+
+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 _e12 = _uv_1;
+    param_4 = _e12;
+    metal::float4 _e13 = transition(param_4, _from, _sampler, _to, uniforms);
+    _fragColor = _e13;
+    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/crosshatch.metal

@@ -0,0 +1,126 @@
+// crosshatch — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/crosshatch.glsl
+// Author: pthrasher
+// License: MIT
+// Description: The incoming image appears through a crosshatch of lines spreading from the center
+// 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 threshold;
+    float fadeEdge;
+};
+
+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;
+}
+
+float rand(
+    thread metal::float2& co
+) {
+    metal::float2 _e19 = co;
+    return metal::fract(metal::sin(metal::dot(_e19, metal::float2(12.9898, 78.233))) * 43758.547);
+}
+
+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
+) {
+    float dist = {};
+    float r = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 _e26 = uniforms.center;
+    metal::float2 _e27 = p;
+    float _e30 = uniforms.threshold;
+    dist = metal::distance(_e26, _e27) / _e30;
+    float _e33 = uniforms.progress;
+    float _e35 = p[1u];
+    param = metal::float2(_e35, 0.0);
+    float _e37 = rand(param);
+    float _e39 = p[0u];
+    param_1 = metal::float2(0.0, _e39);
+    float _e41 = rand(param_1);
+    r = _e33 - metal::min(_e37, _e41);
+    metal::float2 _e44 = p;
+    param_2 = _e44;
+    metal::float4 _e45 = getFromColor(param_2, _from, _sampler);
+    metal::float2 _e46 = p;
+    param_3 = _e46;
+    metal::float4 _e47 = getToColor(param_3, _sampler, _to);
+    float _e48 = dist;
+    float _e49 = r;
+    float _e52 = uniforms.fadeEdge;
+    float _e55 = uniforms.progress;
+    float _e59 = uniforms.fadeEdge;
+    float _e61 = uniforms.progress;
+    return metal::mix(_e45, _e47, metal::float4(metal::mix(0.0, metal::mix(metal::step(_e48, _e49), 1.0, metal::smoothstep(1.0 - _e52, 1.0, _e55)), metal::smoothstep(0.0, _e59, _e61))));
+}
+
+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 _e19 = _uv_1;
+    param_4 = _e19;
+    metal::float4 _e20 = transition(param_4, _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/crosswarp.metal

@@ -0,0 +1,103 @@
+// crosswarp — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/crosswarp.glsl
+// Author: Eke Péter <peterekepeter@gmail.com>
+// License: MIT
+// Description: The outgoing image zooms in while the incoming one zooms out into place, sweeping from right to left
+// 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 _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& p,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float x = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e18 = uniforms.progress;
+    x = _e18;
+    float _e19 = x;
+    float _e22 = p[0u];
+    x = metal::smoothstep(0.0, 1.0, ((_e19 * 2.0) + _e22) - 1.0);
+    metal::float2 _e26 = p;
+    float _e29 = x;
+    param = ((_e26 - metal::float2(0.5)) * (1.0 - _e29)) + metal::float2(0.5);
+    metal::float4 _e34 = getFromColor(param, _from, _sampler);
+    metal::float2 _e35 = p;
+    float _e38 = x;
+    param_1 = ((_e35 - metal::float2(0.5)) * _e38) + metal::float2(0.5);
+    metal::float4 _e42 = getToColor(param_1, _sampler, _to);
+    float _e43 = x;
+    return metal::mix(_e34, _e42, metal::float4(_e43));
+}
+
+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 };
+}

package/msl/cube.metal

@@ -0,0 +1,259 @@
+// cube — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/cube.glsl
+// Author: gre
+// License: MIT
+// Description: The two images are faces of a rotating 3D cube, with a floor reflection
+// 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 persp;
+    float unzoom;
+    float reflection;
+    float floating;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e27 = uv[0u];
+    float _e29 = uv[1u];
+    metal::float4 _e32 = _to.sample(_sampler, metal::float2(_e27, 1.0 - _e29), metal::level(0.0));
+    return _e32;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e27 = uv_1[0u];
+    float _e29 = uv_1[1u];
+    metal::float4 _e32 = _from.sample(_sampler, metal::float2(_e27, 1.0 - _e29), metal::level(0.0));
+    return _e32;
+}
+
+bool inBounds(
+    thread metal::float2& p
+) {
+    bool phi_109_ = {};
+    metal::float2 _e26 = p;
+    bool _e28 = metal::all(metal::float2(0.0, 0.0) < _e26);
+    phi_109_ = _e28;
+    if (_e28) {
+        metal::float2 _e29 = p;
+        phi_109_ = metal::all(_e29 < metal::float2(1.0, 1.0));
+    }
+    bool _e33 = phi_109_;
+    return _e33;
+}
+
+metal::float2 project(
+    thread metal::float2& p_1,
+    constant Uniforms& uniforms
+) {
+    metal::float2 _e26 = p_1;
+    float _e29 = uniforms.floating;
+    return (_e26 * metal::float2(1.0, -1.2)) + metal::float2(0.0, -(_e29) / 100.0);
+}
+
+metal::float4 bgColor(
+    thread metal::float2& p_2,
+    thread metal::float2& pfr,
+    thread metal::float2& pto,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float4 c = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 param_4 = {};
+    metal::float2 param_5 = {};
+    c = metal::float4(0.0, 0.0, 0.0, 1.0);
+    metal::float2 _e35 = pfr;
+    param = _e35;
+    metal::float2 _e36 = project(param, uniforms);
+    pfr = _e36;
+    metal::float2 _e37 = pfr;
+    param_1 = _e37;
+    bool _e38 = inBounds(param_1);
+    if (_e38) {
+        metal::float2 _e39 = pfr;
+        param_2 = _e39;
+        metal::float4 _e40 = getFromColor(param_2, _from, _sampler);
+        float _e42 = uniforms.reflection;
+        float _e44 = pfr[1u];
+        metal::float4 _e49 = c;
+        c = _e49 + metal::mix(metal::float4(0.0, 0.0, 0.0, 0.0), _e40, metal::float4(_e42 * metal::mix(1.0, 0.0, _e44)));
+    }
+    metal::float2 _e51 = pto;
+    param_3 = _e51;
+    metal::float2 _e52 = project(param_3, uniforms);
+    pto = _e52;
+    metal::float2 _e53 = pto;
+    param_4 = _e53;
+    bool _e54 = inBounds(param_4);
+    if (_e54) {
+        metal::float2 _e55 = pto;
+        param_5 = _e55;
+        metal::float4 _e56 = getToColor(param_5, _sampler, _to);
+        float _e58 = uniforms.reflection;
+        float _e60 = pto[1u];
+        metal::float4 _e65 = c;
+        c = _e65 + metal::mix(metal::float4(0.0, 0.0, 0.0, 0.0), _e56, metal::float4(_e58 * metal::mix(1.0, 0.0, _e60)));
+    }
+    metal::float4 _e67 = c;
+    return _e67;
+}
+
+metal::float2 xskew(
+    thread metal::float2& p_3,
+    thread float& persp,
+    thread float& center
+) {
+    float x = {};
+    float _e30 = p_3[0u];
+    float _e32 = p_3[0u];
+    float _e34 = center;
+    x = metal::mix(_e30, 1.0 - _e32, _e34);
+    float _e36 = x;
+    float _e38 = p_3[1u];
+    float _e39 = persp;
+    float _e42 = x;
+    float _e45 = persp;
+    float _e47 = x;
+    float _e52 = center;
+    float _e57 = center;
+    float _e60 = center;
+    float _e66 = center;
+    return ((metal::float2(_e36, (_e38 - ((0.5 * (1.0 - _e39)) * _e42)) / (1.0 + ((_e45 - 1.0) * _e47))) - metal::float2(0.5 - metal::abs(_e52 - 0.5), 0.0)) * metal::float2((0.5 / metal::abs(_e57 - 0.5)) * ((_e60 < 0.5) ? 1.0 : -1.0), 1.0)) + metal::float2((_e66 < 0.5) ? 0.0 : 1.0, 0.0);
+}
+
+metal::float4 transition(
+    thread metal::float2& op,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float uz = {};
+    metal::float2 p_4 = {};
+    metal::float2 fromP = {};
+    metal::float2 param_6 = {};
+    float param_7 = {};
+    float param_8 = {};
+    metal::float2 toP = {};
+    metal::float2 param_9 = {};
+    float param_10 = {};
+    float param_11 = {};
+    metal::float2 param_12 = {};
+    metal::float2 param_13 = {};
+    metal::float2 param_14 = {};
+    metal::float2 param_15 = {};
+    metal::float2 param_16 = {};
+    metal::float2 param_17 = {};
+    metal::float2 param_18 = {};
+    float _e44 = uniforms.unzoom;
+    float _e47 = uniforms.progress;
+    uz = (_e44 * 2.0) * (0.5 - metal::abs(0.5 - _e47));
+    float _e51 = uz;
+    float _e54 = uz;
+    metal::float2 _e56 = op;
+    p_4 = metal::float2(-(_e51) * 0.5) + (_e56 * (1.0 + _e54));
+    metal::float2 _e60 = p_4;
+    float _e62 = uniforms.progress;
+    float _e66 = uniforms.progress;
+    float _e71 = uniforms.progress;
+    float _e73 = uniforms.persp;
+    param_6 = (_e60 - metal::float2(_e62, 0.0)) / metal::float2(1.0 - _e66, 1.0);
+    param_7 = 1.0 - metal::mix(_e71, 0.0, _e73);
+    param_8 = 0.0;
+    metal::float2 _e76 = xskew(param_6, param_7, param_8);
+    fromP = _e76;
+    metal::float2 _e77 = p_4;
+    float _e79 = uniforms.progress;
+    float _e83 = uniforms.progress;
+    float _e86 = uniforms.persp;
+    param_9 = _e77 / metal::float2(_e79, 1.0);
+    param_10 = metal::mix(metal::pow(_e83, 2.0), 1.0, _e86);
+    param_11 = 1.0;
+    metal::float2 _e88 = xskew(param_9, param_10, param_11);
+    toP = _e88;
+    metal::float2 _e89 = fromP;
+    param_12 = _e89;
+    bool _e90 = inBounds(param_12);
+    if (_e90) {
+        metal::float2 _e91 = fromP;
+        param_13 = _e91;
+        metal::float4 _e92 = getFromColor(param_13, _from, _sampler);
+        return _e92;
+    } else {
+        metal::float2 _e93 = toP;
+        param_14 = _e93;
+        bool _e94 = inBounds(param_14);
+        if (_e94) {
+            metal::float2 _e95 = toP;
+            param_15 = _e95;
+            metal::float4 _e96 = getToColor(param_15, _sampler, _to);
+            return _e96;
+        }
+    }
+    metal::float2 _e97 = op;
+    param_16 = _e97;
+    metal::float2 _e98 = fromP;
+    param_17 = _e98;
+    metal::float2 _e99 = toP;
+    param_18 = _e99;
+    metal::float4 _e100 = bgColor(param_16, param_17, param_18, _from, _sampler, _to, uniforms);
+    return _e100;
+}
+
+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_19 = {};
+    metal::float2 _e26 = _uv_1;
+    param_19 = _e26;
+    metal::float4 _e27 = transition(param_19, _from, _sampler, _to, uniforms);
+    _fragColor = _e27;
+    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/directional-easing.metal

@@ -0,0 +1,111 @@
+// directional-easing — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directional-easing.glsl
+// Author: Max Plotnikov
+// License: MIT
+// Description: Like Directional, with an eased movement
+// 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 direction;
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e15 = uv[0u];
+    float _e17 = uv[1u];
+    metal::float4 _e20 = _from.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e15 = uv_1[0u];
+    float _e17 = uv_1[1u];
+    metal::float4 _e20 = _to.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
+) {
+    float easing = {};
+    metal::float2 p = {};
+    metal::float2 f = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e20 = uniforms.progress;
+    float _e23 = uniforms.progress;
+    easing = metal::sqrt((2.0 - _e20) * _e23);
+    metal::float2 _e26 = uv_2;
+    float _e27 = easing;
+    metal::float2 _e29 = uniforms.direction;
+    p = _e26 + (metal::sign(_e29) * _e27);
+    metal::float2 _e33 = p;
+    f = metal::fract(_e33);
+    metal::float2 _e35 = f;
+    param = _e35;
+    metal::float4 _e36 = getToColor(param, _sampler, _to);
+    metal::float2 _e37 = f;
+    param_1 = _e37;
+    metal::float4 _e38 = getFromColor(param_1, _from, _sampler);
+    float _e40 = p[1u];
+    float _e43 = p[1u];
+    float _e47 = p[0u];
+    float _e51 = p[0u];
+    return metal::mix(_e36, _e38, metal::float4(((metal::step(0.0, _e40) * metal::step(_e43, 1.0)) * metal::step(0.0, _e47)) * metal::step(_e51, 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_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 };
+}