gl-transitions 1.74.0 → 1.76.0

package/msl/RectangleCrop.metal

@@ -0,0 +1,127 @@
+// RectangleCrop — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/RectangleCrop.glsl
+// Author: martiniti
+// License: MIT
+// Description: The outgoing image shrinks into a small rectangle over a background color, then the incoming one grows 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 _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
+) {
+    float s = {};
+    metal::float2 q = {};
+    metal::float2 bl = {};
+    metal::float2 tr = {};
+    float dist = {};
+    metal::float4 local = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e28 = uniforms.progress;
+    s = metal::pow(2.0 * metal::abs(_e28 - 0.5), 3.0);
+    metal::float2 _e33 = uv_2;
+    q = _e33 / metal::float2(1.0, 1.0);
+    float _e36 = uniforms.progress;
+    metal::float2 _e42 = q;
+    bl = metal::step(metal::float2(1.0 - (2.0 * metal::abs(_e36 - 0.5))), _e42 + metal::float2(0.25));
+    float _e47 = uniforms.progress;
+    metal::float2 _e53 = q;
+    tr = metal::step(metal::float2(1.0 - (2.0 * metal::abs(_e47 - 0.5))), metal::float2(1.25) - _e53);
+    float _e58 = bl[0u];
+    float _e60 = bl[1u];
+    float _e63 = tr[0u];
+    float _e66 = tr[1u];
+    dist = metal::abs(1.0 - (((_e58 * _e60) * _e63) * _e66));
+    float _e71 = uniforms.progress;
+    if (_e71 < 0.5) {
+        metal::float2 _e73 = uv_2;
+        param = _e73;
+        metal::float4 _e74 = getFromColor(param, _from, _sampler);
+        local = _e74;
+    } else {
+        metal::float2 _e75 = uv_2;
+        param_1 = _e75;
+        metal::float4 _e76 = getToColor(param_1, _sampler, _to);
+        local = _e76;
+    }
+    metal::float4 _e77 = local;
+    metal::float4 _e79 = uniforms.bgcolor;
+    float _e80 = s;
+    float _e81 = dist;
+    return metal::mix(_e77, _e79, metal::float4(metal::step(_e80, _e81)));
+}
+
+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/Revolve_Left.metal

@@ -0,0 +1,363 @@
+// Revolve_Left — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Revolve_Left.glsl
+// Author: bread
+// License: MIT
+// Description: The outgoing image swirls and zooms with motion blur 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;
+    metal::float2 center;
+    float direction;
+    float maxRotation;
+    float peakZoom;
+    float swirl;
+    float barrel;
+    float motionBlur;
+    float switchStart;
+    float switchEnd;
+    float shadow;
+    char _pad12[4];
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e48 = uv[0u];
+    float _e50 = uv[1u];
+    metal::float4 _e53 = _to.sample(_sampler, metal::float2(_e48, 1.0 - _e50), metal::level(0.0));
+    return _e53;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e48 = uv_1[0u];
+    float _e50 = uv_1[1u];
+    metal::float4 _e53 = _from.sample(_sampler, metal::float2(_e48, 1.0 - _e50), metal::level(0.0));
+    return _e53;
+}
+
+metal::float2 rotate2(
+    thread metal::float2& p,
+    thread float& a
+) {
+    float s = {};
+    float c = {};
+    float _e50 = a;
+    s = metal::sin(_e50);
+    float _e52 = a;
+    c = metal::cos(_e52);
+    float _e54 = c;
+    float _e56 = p[0u];
+    float _e58 = s;
+    float _e60 = p[1u];
+    float _e63 = s;
+    float _e65 = p[0u];
+    float _e67 = c;
+    float _e69 = p[1u];
+    return metal::float2((_e54 * _e56) - (_e58 * _e60), (_e63 * _e65) + (_e67 * _e69));
+}
+
+float sat(
+    thread float& x
+) {
+    float _e47 = x;
+    return metal::clamp(_e47, 0.0, 1.0);
+}
+
+float ease(
+    thread float& x_1
+) {
+    float param = {};
+    float _e48 = x_1;
+    param = _e48;
+    float _e49 = sat(param);
+    x_1 = _e49;
+    float _e50 = x_1;
+    float _e51 = x_1;
+    float _e53 = x_1;
+    return (_e50 * _e51) * (3.0 - (2.0 * _e53));
+}
+
+float revolveEnvelope(
+    thread float& t
+) {
+    float rise = {};
+    float param_1 = {};
+    float fall = {};
+    float param_2 = {};
+    float _e51 = t;
+    param_1 = (_e51 - 0.1) / 0.33;
+    float _e54 = ease(param_1);
+    rise = _e54;
+    float _e55 = t;
+    param_2 = (_e55 - 0.43) / 0.29;
+    float _e58 = ease(param_2);
+    fall = 1.0 - _e58;
+    float _e60 = rise;
+    float _e61 = fall;
+    return _e60 * _e61;
+}
+
+metal::float2 warpUv(
+    thread metal::float2& uv_2,
+    thread float& t_1,
+    constant Uniforms& uniforms
+) {
+    float e = {};
+    float param_3 = {};
+    metal::float2 p_1 = {};
+    float r = {};
+    float edgeSpin = {};
+    float coreSpin = {};
+    float param_4 = {};
+    float visibleAngle = {};
+    metal::float2 param_5 = {};
+    float param_6 = {};
+    float sc = {};
+    float rr = {};
+    float _e60 = t_1;
+    param_3 = _e60;
+    float _e61 = revolveEnvelope(param_3);
+    e = _e61;
+    metal::float2 _e62 = uv_2;
+    metal::float2 _e64 = uniforms.center;
+    p_1 = _e62 - _e64;
+    float _e67 = uniforms.ratio;
+    float _e69 = p_1[0u];
+    p_1[0u] = _e69 * _e67;
+    metal::float2 _e72 = p_1;
+    r = metal::length(_e72);
+    float _e75 = uniforms.maxRotation;
+    float _e76 = e;
+    edgeSpin = _e75 * _e76;
+    float _e79 = uniforms.swirl;
+    float _e80 = e;
+    float _e82 = r;
+    param_4 = _e82 / 0.96;
+    float _e84 = sat(param_4);
+    coreSpin = (_e79 * _e80) * metal::pow(1.0 - _e84, 1.55);
+    float _e89 = uniforms.direction;
+    float _e90 = edgeSpin;
+    float _e91 = coreSpin;
+    visibleAngle = _e89 * (_e90 + _e91);
+    float _e94 = visibleAngle;
+    metal::float2 _e96 = p_1;
+    param_5 = _e96;
+    param_6 = -(_e94);
+    metal::float2 _e97 = rotate2(param_5, param_6);
+    p_1 = _e97;
+    float _e99 = uniforms.peakZoom;
+    float _e101 = e;
+    sc = 1.0 + ((_e99 - 1.0) * metal::pow(_e101, 0.85));
+    float _e105 = sc;
+    metal::float2 _e106 = p_1;
+    p_1 = _e106 / metal::float2(_e105);
+    metal::float2 _e109 = p_1;
+    rr = metal::length(_e109);
+    float _e112 = uniforms.barrel;
+    float _e113 = e;
+    float _e115 = rr;
+    float _e117 = rr;
+    metal::float2 _e121 = p_1;
+    p_1 = _e121 * (1.0 + ((((_e112 * _e113) * _e115) * _e117) * 2.8));
+    float _e124 = uniforms.ratio;
+    float _e126 = p_1[0u];
+    p_1[0u] = _e126 / _e124;
+    metal::float2 _e129 = p_1;
+    metal::float2 _e131 = uniforms.center;
+    return metal::clamp(_e129 + _e131, metal::float2(0.001, 0.001), metal::float2(0.999, 0.999));
+}
+
+metal::float4 sampleRevolve(
+    thread metal::float2& uv_3,
+    thread float& t_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 p_2 = {};
+    metal::float2 param_7 = {};
+    float param_8 = {};
+    float reveal = {};
+    metal::float2 param_9 = {};
+    metal::float2 param_10 = {};
+    metal::float2 _e54 = uv_3;
+    param_7 = _e54;
+    float _e55 = t_2;
+    param_8 = _e55;
+    metal::float2 _e56 = warpUv(param_7, param_8, uniforms);
+    p_2 = _e56;
+    float _e58 = uniforms.switchStart;
+    float _e60 = uniforms.switchEnd;
+    float _e61 = t_2;
+    reveal = metal::smoothstep(_e58, _e60, _e61);
+    metal::float2 _e63 = p_2;
+    param_9 = _e63;
+    metal::float4 _e64 = getFromColor(param_9, _from, _sampler);
+    metal::float2 _e65 = p_2;
+    param_10 = _e65;
+    metal::float4 _e66 = getToColor(param_10, _sampler, _to);
+    float _e67 = reveal;
+    return metal::mix(_e64, _e66, metal::float4(_e67));
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_4,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 param_11 = {};
+    metal::float2 param_12 = {};
+    float e_1 = {};
+    float param_13 = {};
+    float span = {};
+    metal::float4 color = {};
+    float total = {};
+    int i = {};
+    float x_2 = {};
+    float w = {};
+    float t_3 = {};
+    float param_14 = {};
+    metal::float2 param_15 = {};
+    float param_16 = {};
+    metal::float2 q = {};
+    float vignette = {};
+    float _e64 = uniforms.progress;
+    if (_e64 <= 0.0) {
+        metal::float2 _e66 = uv_4;
+        param_11 = _e66;
+        metal::float4 _e67 = getFromColor(param_11, _from, _sampler);
+        return _e67;
+    }
+    float _e69 = uniforms.progress;
+    if (_e69 >= 1.0) {
+        metal::float2 _e71 = uv_4;
+        param_12 = _e71;
+        metal::float4 _e72 = getToColor(param_12, _sampler, _to);
+        return _e72;
+    }
+    float _e74 = uniforms.progress;
+    param_13 = _e74;
+    float _e75 = revolveEnvelope(param_13);
+    e_1 = _e75;
+    float _e77 = uniforms.motionBlur;
+    float _e79 = e_1;
+    span = (0.06 * _e77) * _e79;
+    color = metal::float4(0.0, 0.0, 0.0, 0.0);
+    total = 0.0;
+    i = -8;
+    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 _e110 = i;
+            i = as_type<int>(as_type<uint>(_e110) + as_type<uint>(1));
+        }
+        loop_init = false;
+        int _e81 = i;
+        if (_e81 <= 8) {
+            int _e83 = i;
+            x_2 = static_cast<float>(_e83) / 8.0;
+            float _e86 = x_2;
+            w = 1.0 - metal::abs(_e86);
+            float _e89 = w;
+            float _e90 = w;
+            w = (_e89 * _e90) + 0.01;
+            float _e94 = uniforms.progress;
+            float _e95 = x_2;
+            float _e96 = span;
+            param_14 = _e94 + (_e95 * _e96);
+            float _e99 = sat(param_14);
+            t_3 = _e99;
+            metal::float2 _e100 = uv_4;
+            param_15 = _e100;
+            float _e101 = t_3;
+            param_16 = _e101;
+            metal::float4 _e102 = sampleRevolve(param_15, param_16, _from, _sampler, _to, uniforms);
+            float _e103 = w;
+            metal::float4 _e105 = color;
+            color = _e105 + (_e102 * _e103);
+            float _e107 = w;
+            float _e108 = total;
+            total = _e108 + _e107;
+            continue;
+        } else {
+            break;
+        }
+    }
+    float _e112 = total;
+    metal::float4 _e113 = color;
+    color = _e113 / metal::float4(_e112);
+    metal::float2 _e116 = uv_4;
+    q = _e116 - metal::float2(0.5, 0.5);
+    float _e119 = uniforms.ratio;
+    float _e121 = q[0u];
+    q[0u] = _e121 * _e119;
+    float _e125 = uniforms.shadow;
+    float _e126 = e_1;
+    metal::float2 _e128 = q;
+    vignette = 1.0 - ((_e125 * _e126) * metal::smoothstep(0.35, 0.95, metal::length(_e128)));
+    float _e133 = vignette;
+    metal::float4 _e134 = color;
+    metal::float3 _e136 = _e134.xyz * _e133;
+    color[0u] = _e136.x;
+    color[1u] = _e136.y;
+    color[2u] = _e136.z;
+    metal::float4 _e143 = color;
+    return _e143;
+}
+
+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_17 = {};
+    metal::float2 _e47 = _uv_1;
+    param_17 = _e47;
+    metal::float4 _e48 = transition(param_17, _from, _sampler, _to, uniforms);
+    _fragColor = _e48;
+    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/Rolls.metal

@@ -0,0 +1,209 @@
+// Rolls — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Rolls.glsl
+// Author: Mark Craig
+// License: MIT
+// Description: The outgoing image rolls away around a corner, revealing 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 type;
+    int RotDown;
+};
+
+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 iResolution = {};
+    float theta = {};
+    metal::float2 uvi = {};
+    float c1_ = {};
+    float s1_ = {};
+    metal::float2 uv2_ = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    bool phi_200_ = {};
+    bool phi_206_ = {};
+    bool phi_214_ = {};
+    float _e27 = uniforms.ratio;
+    iResolution = metal::float2(_e27, 1.0);
+    int _e30 = uniforms.type;
+    if (_e30 == 0) {
+        int _e33 = uniforms.RotDown;
+        float _e38 = uniforms.progress;
+        theta = (((_e33 != 0) ? 3.1415927 : -3.1415927) / 2.0) * _e38;
+        float _e41 = uv_2[0u];
+        uvi[0u] = 1.0 - _e41;
+        float _e45 = uv_2[1u];
+        uvi[1u] = _e45;
+    } else {
+        int _e48 = uniforms.type;
+        if (_e48 == 1) {
+            int _e51 = uniforms.RotDown;
+            float _e56 = uniforms.progress;
+            theta = (((_e51 != 0) ? 3.1415927 : -3.1415927) / 2.0) * _e56;
+            metal::float2 _e58 = uv_2;
+            uvi = _e58;
+        } else {
+            int _e60 = uniforms.type;
+            if (_e60 == 2) {
+                int _e63 = uniforms.RotDown;
+                float _e68 = uniforms.progress;
+                theta = (((_e63 != 0) ? -3.1415927 : 3.1415927) / 2.0) * _e68;
+                float _e71 = uv_2[0u];
+                uvi[0u] = _e71;
+                float _e74 = uv_2[1u];
+                uvi[1u] = 1.0 - _e74;
+            } else {
+                int _e78 = uniforms.type;
+                if (_e78 == 3) {
+                    int _e81 = uniforms.RotDown;
+                    float _e86 = uniforms.progress;
+                    theta = (((_e81 != 0) ? -3.1415927 : 3.1415927) / 2.0) * _e86;
+                    metal::float2 _e88 = uv_2;
+                    uvi = metal::float2(1.0) - _e88;
+                }
+            }
+        }
+    }
+    float _e91 = theta;
+    c1_ = metal::cos(_e91);
+    float _e93 = theta;
+    s1_ = metal::sin(_e93);
+    float _e96 = uvi[0u];
+    float _e98 = iResolution[0u];
+    float _e100 = c1_;
+    float _e103 = uvi[1u];
+    float _e105 = iResolution[1u];
+    float _e107 = s1_;
+    uv2_[0u] = ((_e96 * _e98) * _e100) - ((_e103 * _e105) * _e107);
+    float _e112 = uvi[0u];
+    float _e114 = iResolution[0u];
+    float _e116 = s1_;
+    float _e119 = uvi[1u];
+    float _e121 = iResolution[1u];
+    float _e123 = c1_;
+    uv2_[1u] = ((_e112 * _e114) * _e116) + ((_e119 * _e121) * _e123);
+    float _e128 = uv2_[0u];
+    bool _e129 = _e128 >= 0.0;
+    phi_200_ = _e129;
+    if (_e129) {
+        float _e131 = uv2_[0u];
+        float _e133 = iResolution[0u];
+        phi_200_ = _e131 <= _e133;
+    }
+    bool _e136 = phi_200_;
+    phi_206_ = _e136;
+    if (_e136) {
+        float _e138 = uv2_[1u];
+        phi_206_ = _e138 >= 0.0;
+    }
+    bool _e141 = phi_206_;
+    phi_214_ = _e141;
+    if (_e141) {
+        float _e143 = uv2_[1u];
+        float _e145 = iResolution[1u];
+        phi_214_ = _e143 <= _e145;
+    }
+    bool _e148 = phi_214_;
+    if (_e148) {
+        metal::float2 _e149 = iResolution;
+        metal::float2 _e150 = uv2_;
+        uv2_ = _e150 / _e149;
+        int _e153 = uniforms.type;
+        if (_e153 == 0) {
+            float _e156 = uv2_[0u];
+            uv2_[0u] = 1.0 - _e156;
+        } else {
+            int _e160 = uniforms.type;
+            if (_e160 == 2) {
+                float _e163 = uv2_[1u];
+                uv2_[1u] = 1.0 - _e163;
+            } else {
+                int _e167 = uniforms.type;
+                if (_e167 == 3) {
+                    metal::float2 _e169 = uv2_;
+                    uv2_ = metal::float2(1.0) - _e169;
+                }
+            }
+        }
+        metal::float2 _e172 = uv2_;
+        param = _e172;
+        metal::float4 _e173 = getFromColor(param, _from, _sampler);
+        return _e173;
+    }
+    metal::float2 _e174 = uv_2;
+    param_1 = _e174;
+    metal::float4 _e175 = getToColor(param_1, _sampler, _to);
+    return _e175;
+}
+
+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 };
+}