gl-transitions 1.74.0 → 1.76.0

package/msl/doorway.metal

@@ -0,0 +1,210 @@
+// doorway — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/doorway.glsl
+// Author: gre
+// License: MIT
+// Description: The outgoing image opens like double doors as the incoming one comes forward, 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 reflection;
+    float perspective;
+    float depth;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e30 = uv[0u];
+    float _e32 = uv[1u];
+    metal::float4 _e35 = _to.sample(_sampler, metal::float2(_e30, 1.0 - _e32), metal::level(0.0));
+    return _e35;
+}
+
+bool inBounds(
+    thread metal::float2& p
+) {
+    bool phi_83_ = {};
+    metal::float2 _e29 = p;
+    bool _e31 = metal::all(metal::float2(0.0, 0.0) < _e29);
+    phi_83_ = _e31;
+    if (_e31) {
+        metal::float2 _e32 = p;
+        phi_83_ = metal::all(_e32 < metal::float2(1.0, 1.0));
+    }
+    bool _e36 = phi_83_;
+    return _e36;
+}
+
+metal::float2 project(
+    thread metal::float2& p_1
+) {
+    metal::float2 _e29 = p_1;
+    return (_e29 * metal::float2(1.0, -1.2)) + metal::float2(0.0, -0.02);
+}
+
+metal::float4 bgColor(
+    thread metal::float2& p_2,
+    thread metal::float2& pto,
+    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 = {};
+    c = metal::float4(0.0, 0.0, 0.0, 1.0);
+    metal::float2 _e34 = pto;
+    param = _e34;
+    metal::float2 _e35 = project(param);
+    pto = _e35;
+    metal::float2 _e36 = pto;
+    param_1 = _e36;
+    bool _e37 = inBounds(param_1);
+    if (_e37) {
+        metal::float2 _e38 = pto;
+        param_2 = _e38;
+        metal::float4 _e39 = getToColor(param_2, _sampler, _to);
+        float _e41 = uniforms.reflection;
+        float _e43 = pto[1u];
+        metal::float4 _e48 = c;
+        c = _e48 + metal::mix(metal::float4(0.0, 0.0, 0.0, 1.0), _e39, metal::float4(_e41 * metal::mix(1.0, 0.0, _e43)));
+    }
+    metal::float4 _e50 = c;
+    return _e50;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e30 = uv_1[0u];
+    float _e32 = uv_1[1u];
+    metal::float4 _e35 = _from.sample(_sampler, metal::float2(_e30, 1.0 - _e32), metal::level(0.0));
+    return _e35;
+}
+
+metal::float4 transition(
+    thread metal::float2& p_3,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 pfr = {};
+    metal::float2 pto_1 = {};
+    float middleSlit = {};
+    float d = {};
+    float size = {};
+    metal::float2 param_3 = {};
+    metal::float2 param_4 = {};
+    metal::float2 param_5 = {};
+    metal::float2 param_6 = {};
+    metal::float2 param_7 = {};
+    metal::float2 param_8 = {};
+    pfr = metal::float2(-1.0, -1.0);
+    pto_1 = metal::float2(-1.0, -1.0);
+    float _e41 = p_3[0u];
+    float _e46 = uniforms.progress;
+    middleSlit = (2.0 * metal::abs(_e41 - 0.5)) - _e46;
+    float _e48 = middleSlit;
+    if (_e48 > 0.0) {
+        metal::float2 _e50 = p_3;
+        float _e52 = p_3[0u];
+        float _e56 = uniforms.progress;
+        pfr = _e50 + (metal::float2(0.5 * _e56, 0.0) * ((_e52 > 0.5) ? -1.0 : 1.0));
+        float _e62 = uniforms.perspective;
+        float _e64 = uniforms.progress;
+        float _e66 = middleSlit;
+        d = 1.0 / (1.0 + ((_e62 * _e64) * (1.0 - _e66)));
+        float _e71 = d;
+        float _e74 = pfr[1u];
+        pfr[1u] = _e74 - (_e71 / 2.0);
+        float _e77 = d;
+        float _e79 = pfr[1u];
+        pfr[1u] = _e79 * _e77;
+        float _e82 = d;
+        float _e85 = pfr[1u];
+        pfr[1u] = _e85 + (_e82 / 2.0);
+    }
+    float _e89 = uniforms.depth;
+    float _e91 = uniforms.progress;
+    size = metal::mix(1.0, _e89, 1.0 - _e91);
+    metal::float2 _e94 = p_3;
+    float _e96 = size;
+    pto_1 = ((_e94 + metal::float2(-0.5, -0.5)) * metal::float2(_e96)) + metal::float2(0.5, 0.5);
+    metal::float2 _e100 = pfr;
+    param_3 = _e100;
+    bool _e101 = inBounds(param_3);
+    if (_e101) {
+        metal::float2 _e102 = pfr;
+        param_4 = _e102;
+        metal::float4 _e103 = getFromColor(param_4, _from, _sampler);
+        return _e103;
+    } else {
+        metal::float2 _e104 = pto_1;
+        param_5 = _e104;
+        bool _e105 = inBounds(param_5);
+        if (_e105) {
+            metal::float2 _e106 = pto_1;
+            param_6 = _e106;
+            metal::float4 _e107 = getToColor(param_6, _sampler, _to);
+            return _e107;
+        } else {
+            metal::float2 _e108 = p_3;
+            param_7 = _e108;
+            metal::float2 _e109 = pto_1;
+            param_8 = _e109;
+            metal::float4 _e110 = bgColor(param_7, param_8, _sampler, _to, uniforms);
+            return _e110;
+        }
+    }
+}
+
+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 _e29 = _uv_1;
+    param_9 = _e29;
+    metal::float4 _e30 = transition(param_9, _from, _sampler, _to, uniforms);
+    _fragColor = _e30;
+    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/fade.metal

@@ -0,0 +1,95 @@
+// fade — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fade.glsl
+// Author: gre
+// License: MIT
+// Description: A linear crossfade between the two images
+// 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 _e13 = uv[0u];
+    float _e15 = uv[1u];
+    metal::float4 _e18 = _to.sample(_sampler, metal::float2(_e13, 1.0 - _e15), metal::level(0.0));
+    return _e18;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e13 = uv_1[0u];
+    float _e15 = uv_1[1u];
+    metal::float4 _e18 = _from.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::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e14 = uv_2;
+    param = _e14;
+    metal::float4 _e15 = getFromColor(param, _from, _sampler);
+    metal::float2 _e16 = uv_2;
+    param_1 = _e16;
+    metal::float4 _e17 = getToColor(param_1, _sampler, _to);
+    float _e19 = uniforms.progress;
+    return metal::mix(_e15, _e17, metal::float4(_e19));
+}
+
+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 _e12 = _uv_1;
+    param_2 = _e12;
+    metal::float4 _e13 = transition(param_2, _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/fadecolor.metal

@@ -0,0 +1,104 @@
+// fadecolor — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadecolor.glsl
+// Author: gre
+// License: MIT
+// Description: A fade through a solid color, black by default
+// 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::packed_float3 color;
+    float colorPhase;
+};
+
+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& 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::float3 _e17 = uniforms.color;
+    metal::float2 _e22 = uv_2;
+    param = _e22;
+    metal::float4 _e23 = getFromColor(param, _from, _sampler);
+    float _e25 = uniforms.colorPhase;
+    float _e28 = uniforms.progress;
+    metal::float3 _e33 = uniforms.color;
+    metal::float2 _e38 = uv_2;
+    param_1 = _e38;
+    metal::float4 _e39 = getToColor(param_1, _sampler, _to);
+    float _e41 = uniforms.colorPhase;
+    float _e43 = uniforms.progress;
+    float _e48 = uniforms.progress;
+    return metal::mix(metal::mix(metal::float4(_e17.x, _e17.y, _e17.z, 1.0), _e23, metal::float4(metal::smoothstep(1.0 - _e25, 0.0, _e28))), metal::mix(metal::float4(_e33.x, _e33.y, _e33.z, 1.0), _e39, metal::float4(metal::smoothstep(_e41, 1.0, _e43))), metal::float4(_e48));
+}
+
+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/fadegrayscale.metal

@@ -0,0 +1,123 @@
+// fadegrayscale — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/fadegrayscale.glsl
+// Author: gre
+// License: MIT
+// Description: A crossfade through grayscale
+// 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::float3 grayscale(
+    thread metal::float3& color
+) {
+    float _e18 = color[0u];
+    float _e21 = color[1u];
+    float _e25 = color[2u];
+    return metal::float3(((0.2126 * _e18) + (0.7152 * _e21)) + (0.0722 * _e25));
+}
+
+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& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float4 fc = {};
+    metal::float2 param = {};
+    metal::float4 tc = {};
+    metal::float2 param_1 = {};
+    metal::float3 param_2 = {};
+    metal::float3 param_3 = {};
+    metal::float2 _e23 = uv_2;
+    param = _e23;
+    metal::float4 _e24 = getFromColor(param, _from, _sampler);
+    fc = _e24;
+    metal::float2 _e25 = uv_2;
+    param_1 = _e25;
+    metal::float4 _e26 = getToColor(param_1, _sampler, _to);
+    tc = _e26;
+    metal::float4 _e27 = fc;
+    param_2 = _e27.xyz;
+    metal::float3 _e29 = grayscale(param_2);
+    metal::float4 _e34 = fc;
+    float _e36 = uniforms.intensity;
+    float _e39 = uniforms.progress;
+    metal::float4 _e43 = tc;
+    param_3 = _e43.xyz;
+    metal::float3 _e45 = grayscale(param_3);
+    metal::float4 _e50 = tc;
+    float _e52 = uniforms.intensity;
+    float _e54 = uniforms.progress;
+    float _e59 = uniforms.progress;
+    return metal::mix(metal::mix(metal::float4(_e29.x, _e29.y, _e29.z, 1.0), _e34, metal::float4(metal::smoothstep(1.0 - _e36, 0.0, _e39))), metal::mix(metal::float4(_e45.x, _e45.y, _e45.z, 1.0), _e50, metal::float4(metal::smoothstep(_e52, 1.0, _e54))), metal::float4(_e59));
+}
+
+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 _e17 = _uv_1;
+    param_4 = _e17;
+    metal::float4 _e18 = transition(param_4, _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/flyeye.metal

@@ -0,0 +1,133 @@
+// flyeye — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/flyeye.glsl
+// Author: gre
+// License: MIT
+// Description: The image breaks into a fly's-eye grid of lenses with color separation
+// 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 size;
+    float zoom;
+    float colorSeparation;
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e17 = uv[0u];
+    float _e19 = uv[1u];
+    metal::float4 _e22 = _from.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e17 = uv_1[0u];
+    float _e19 = uv_1[1u];
+    metal::float4 _e22 = _to.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+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 inv = {};
+    metal::float2 disp = {};
+    metal::float4 texTo = {};
+    metal::float2 param = {};
+    metal::float4 texFrom = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    float _e25 = uniforms.progress;
+    inv = 1.0 - _e25;
+    float _e28 = uniforms.size;
+    float _e30 = uniforms.zoom;
+    float _e32 = p[0u];
+    float _e36 = uniforms.zoom;
+    float _e38 = p[1u];
+    disp = metal::float2(metal::cos(_e30 * _e32), metal::sin(_e36 * _e38)) * _e28;
+    metal::float2 _e43 = p;
+    float _e44 = inv;
+    metal::float2 _e45 = disp;
+    param = _e43 + (_e45 * _e44);
+    metal::float4 _e48 = getToColor(param, _sampler, _to);
+    texTo = _e48;
+    metal::float2 _e49 = p;
+    float _e51 = uniforms.progress;
+    metal::float2 _e52 = disp;
+    float _e55 = uniforms.colorSeparation;
+    param_1 = _e49 + ((_e52 * _e51) * (1.0 - _e55));
+    metal::float4 _e59 = getFromColor(param_1, _from, _sampler);
+    metal::float2 _e61 = p;
+    float _e63 = uniforms.progress;
+    metal::float2 _e64 = disp;
+    param_2 = _e61 + (_e64 * _e63);
+    metal::float4 _e67 = getFromColor(param_2, _from, _sampler);
+    metal::float2 _e69 = p;
+    float _e71 = uniforms.progress;
+    metal::float2 _e72 = disp;
+    float _e75 = uniforms.colorSeparation;
+    param_3 = _e69 + ((_e72 * _e71) * (1.0 + _e75));
+    metal::float4 _e79 = getFromColor(param_3, _from, _sampler);
+    texFrom = metal::float4(_e59.x, _e67.y, _e79.z, 1.0);
+    metal::float4 _e82 = texTo;
+    float _e84 = uniforms.progress;
+    metal::float4 _e86 = texFrom;
+    float _e87 = inv;
+    return (_e82 * _e84) + (_e86 * _e87);
+}
+
+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 _e16 = _uv_1;
+    param_4 = _e16;
+    metal::float4 _e17 = transition(param_4, _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 };
+}