gl-transitions 1.74.0 → 1.76.0

package/msl/squareswire.metal

@@ -0,0 +1,144 @@
+// squareswire — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/squareswire.glsl
+// Author: gre
+// License: MIT
+// Description: Squares grow along a diagonal sweep to reveal the incoming image
+// 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::int2 squares;
+    metal::float2 direction;
+    float smoothness;
+    char _pad5[4];
+};
+
+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& p,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 v = {};
+    float d = {};
+    float offset = {};
+    float pr = {};
+    metal::float2 squarep = {};
+    metal::float2 squaremin = {};
+    metal::float2 squaremax = {};
+    float a = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e29 = uniforms.direction;
+    v = metal::normalize(_e29);
+    float _e32 = v[0u];
+    float _e35 = v[1u];
+    metal::float2 _e38 = v;
+    v = _e38 / metal::float2(metal::abs(_e32) + metal::abs(_e35));
+    float _e42 = v[0u];
+    float _e45 = v[1u];
+    d = (_e42 * 0.5) + (_e45 * 0.5);
+    float _e49 = uniforms.smoothness;
+    offset = _e49;
+    float _e50 = offset;
+    float _e53 = v[0u];
+    float _e55 = p[0u];
+    float _e58 = v[1u];
+    float _e60 = p[1u];
+    float _e63 = d;
+    float _e66 = uniforms.progress;
+    float _e67 = offset;
+    pr = metal::smoothstep(-(_e50), 0.0, ((_e53 * _e55) + (_e58 * _e60)) - ((_e63 - 0.5) + (_e66 * (1.0 + _e67))));
+    metal::float2 _e73 = p;
+    metal::int2 _e75 = uniforms.squares;
+    squarep = metal::fract(_e73 * static_cast<metal::float2>(_e75));
+    float _e79 = pr;
+    squaremin = metal::float2(_e79 / 2.0);
+    float _e82 = pr;
+    squaremax = metal::float2(1.0 - (_e82 / 2.0));
+    float _e87 = uniforms.progress;
+    float _e91 = squaremin[0u];
+    float _e93 = squarep[0u];
+    float _e97 = squaremin[1u];
+    float _e99 = squarep[1u];
+    float _e103 = squarep[0u];
+    float _e105 = squaremax[0u];
+    float _e109 = squarep[1u];
+    float _e111 = squaremax[1u];
+    a = ((((1.0 - metal::step(_e87, 0.0)) * metal::step(_e91, _e93)) * metal::step(_e97, _e99)) * metal::step(_e103, _e105)) * metal::step(_e109, _e111);
+    metal::float2 _e114 = p;
+    param = _e114;
+    metal::float4 _e115 = getFromColor(param, _from, _sampler);
+    metal::float2 _e116 = p;
+    param_1 = _e116;
+    metal::float4 _e117 = getToColor(param_1, _sampler, _to);
+    float _e118 = a;
+    return metal::mix(_e115, _e117, metal::float4(_e118));
+}
+
+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/squeeze.metal

@@ -0,0 +1,133 @@
+// squeeze — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/squeeze.glsl
+// Author: gre
+// License: MIT
+// Description: The outgoing image is squeezed into a line with color separation, 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;
+    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& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float y = {};
+    metal::float2 param = {};
+    metal::float2 fp = {};
+    metal::float2 off = {};
+    metal::float4 c = {};
+    metal::float2 param_1 = {};
+    metal::float4 cn = {};
+    metal::float2 param_2 = {};
+    metal::float4 cp = {};
+    metal::float2 param_3 = {};
+    float _e27 = uv_2[1u];
+    float _e30 = uniforms.progress;
+    y = 0.5 + ((_e27 - 0.5) / (1.0 - _e30));
+    float _e34 = y;
+    float _e36 = y;
+    if ((_e34 < 0.0) || (_e36 > 1.0)) {
+        metal::float2 _e39 = uv_2;
+        param = _e39;
+        metal::float4 _e40 = getToColor(param, _sampler, _to);
+        return _e40;
+    } else {
+        float _e42 = uv_2[0u];
+        float _e43 = y;
+        fp = metal::float2(_e42, _e43);
+        float _e46 = uniforms.progress;
+        float _e48 = uniforms.colorSeparation;
+        off = metal::float2(0.0, _e48) * _e46;
+        metal::float2 _e51 = fp;
+        param_1 = _e51;
+        metal::float4 _e52 = getFromColor(param_1, _from, _sampler);
+        c = _e52;
+        metal::float2 _e53 = fp;
+        metal::float2 _e54 = off;
+        param_2 = _e53 - _e54;
+        metal::float4 _e56 = getFromColor(param_2, _from, _sampler);
+        cn = _e56;
+        metal::float2 _e57 = fp;
+        metal::float2 _e58 = off;
+        param_3 = _e57 + _e58;
+        metal::float4 _e60 = getFromColor(param_3, _from, _sampler);
+        cp = _e60;
+        float _e62 = cn[0u];
+        float _e64 = c[1u];
+        float _e66 = cp[2u];
+        float _e68 = c[3u];
+        return metal::float4(_e62, _e64, _e66, _e68);
+    }
+}
+
+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 };
+}

package/msl/static_wipe.metal

@@ -0,0 +1,147 @@
+// static_wipe — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/static_wipe.glsl
+// Author: Ben Lucas
+// License: MIT
+// Description: A wipe from top to bottom with a band of TV static at its edge
+// 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 u_transitionUpToDown;
+    float u_max_static_span;
+};
+
+float rnd(
+    thread metal::float2& st
+) {
+    metal::float2 _e20 = st;
+    return metal::fract(metal::sin(metal::dot(_e20, metal::float2(10.0, 70.0))) * 12345.545);
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e21 = uv[0u];
+    float _e23 = uv[1u];
+    metal::float4 _e26 = _to.sample(_sampler, metal::float2(_e21, 1.0 - _e23), metal::level(0.0));
+    return _e26;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e21 = uv_1[0u];
+    float _e23 = uv_1[1u];
+    metal::float4 _e26 = _from.sample(_sampler, metal::float2(_e21, 1.0 - _e23), metal::level(0.0));
+    return _e26;
+}
+
+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 span = {};
+    float transitionEdge = {};
+    float local = {};
+    float mixRatio = {};
+    metal::float4 transitionMix = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float noiseEnvelope = {};
+    metal::float4 noise = {};
+    metal::float2 param_2 = {};
+    float _e31 = uniforms.u_max_static_span;
+    float _e33 = uniforms.progress;
+    span = _e31 * metal::pow(metal::sin(3.1415927 * _e33), 0.5);
+    int _e39 = uniforms.u_transitionUpToDown;
+    if (_e39 != 0) {
+        float _e42 = uv_2[1u];
+        local = 1.0 - _e42;
+    } else {
+        float _e45 = uv_2[1u];
+        local = _e45;
+    }
+    float _e46 = local;
+    transitionEdge = _e46;
+    float _e48 = uniforms.progress;
+    float _e49 = transitionEdge;
+    mixRatio = 1.0 - metal::step(_e48, _e49);
+    metal::float2 _e52 = uv_2;
+    param = _e52;
+    metal::float4 _e53 = getFromColor(param, _from, _sampler);
+    metal::float2 _e54 = uv_2;
+    param_1 = _e54;
+    metal::float4 _e55 = getToColor(param_1, _sampler, _to);
+    float _e56 = mixRatio;
+    transitionMix = metal::mix(_e53, _e55, metal::float4(_e56));
+    float _e60 = uniforms.progress;
+    float _e61 = span;
+    float _e64 = uniforms.progress;
+    float _e65 = transitionEdge;
+    float _e68 = uniforms.progress;
+    float _e70 = uniforms.progress;
+    float _e71 = span;
+    float _e73 = transitionEdge;
+    noiseEnvelope = metal::smoothstep(_e60 - _e61, _e64, _e65) * (1.0 - metal::smoothstep(_e68, _e70 + _e71, _e73));
+    metal::float2 _e77 = uv_2;
+    float _e79 = uniforms.progress;
+    param_2 = _e77 * (1.0 + _e79);
+    float _e82 = rnd(param_2);
+    metal::float3 _e83 = metal::float3(_e82);
+    noise = metal::float4(_e83.x, _e83.y, _e83.z, 1.0);
+    metal::float4 _e88 = transitionMix;
+    metal::float4 _e89 = noise;
+    float _e90 = noiseEnvelope;
+    return metal::mix(_e88, _e89, metal::float4(_e90));
+}
+
+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 _e20 = _uv_1;
+    param_3 = _e20;
+    metal::float4 _e21 = transition(param_3, _from, _sampler, _to, uniforms);
+    _fragColor = _e21;
+    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/swap.metal

@@ -0,0 +1,256 @@
+// swap — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/swap.glsl
+// Author: gre
+// License: MIT
+// Description: The two images swap places in 3D, 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 _e32 = uv[0u];
+    float _e34 = uv[1u];
+    metal::float4 _e37 = _to.sample(_sampler, metal::float2(_e32, 1.0 - _e34), metal::level(0.0));
+    return _e37;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e32 = uv_1[0u];
+    float _e34 = uv_1[1u];
+    metal::float4 _e37 = _from.sample(_sampler, metal::float2(_e32, 1.0 - _e34), metal::level(0.0));
+    return _e37;
+}
+
+bool inBounds(
+    thread metal::float2& p
+) {
+    bool phi_84_ = {};
+    metal::float2 _e31 = p;
+    bool _e33 = metal::all(metal::float2(0.0, 0.0) < _e31);
+    phi_84_ = _e33;
+    if (_e33) {
+        metal::float2 _e34 = p;
+        phi_84_ = metal::all(_e34 < metal::float2(1.0, 1.0));
+    }
+    bool _e38 = phi_84_;
+    return _e38;
+}
+
+metal::float2 project(
+    thread metal::float2& p_1
+) {
+    metal::float2 _e31 = p_1;
+    return (_e31 * metal::float2(1.0, -1.2)) + metal::float2(0.0, -0.02);
+}
+
+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 _e40 = pfr;
+    param = _e40;
+    metal::float2 _e41 = project(param);
+    pfr = _e41;
+    metal::float2 _e42 = pfr;
+    param_1 = _e42;
+    bool _e43 = inBounds(param_1);
+    if (_e43) {
+        metal::float2 _e44 = pfr;
+        param_2 = _e44;
+        metal::float4 _e45 = getFromColor(param_2, _from, _sampler);
+        float _e47 = uniforms.reflection;
+        float _e49 = pfr[1u];
+        metal::float4 _e54 = c;
+        c = _e54 + metal::mix(metal::float4(0.0, 0.0, 0.0, 1.0), _e45, metal::float4(_e47 * metal::mix(1.0, 0.0, _e49)));
+    }
+    metal::float2 _e56 = pto;
+    param_3 = _e56;
+    metal::float2 _e57 = project(param_3);
+    pto = _e57;
+    metal::float2 _e58 = pto;
+    param_4 = _e58;
+    bool _e59 = inBounds(param_4);
+    if (_e59) {
+        metal::float2 _e60 = pto;
+        param_5 = _e60;
+        metal::float4 _e61 = getToColor(param_5, _sampler, _to);
+        float _e63 = uniforms.reflection;
+        float _e65 = pto[1u];
+        metal::float4 _e70 = c;
+        c = _e70 + metal::mix(metal::float4(0.0, 0.0, 0.0, 1.0), _e61, metal::float4(_e63 * metal::mix(1.0, 0.0, _e65)));
+    }
+    metal::float4 _e72 = c;
+    return _e72;
+}
+
+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 pto_1 = {};
+    float size = {};
+    float persp = {};
+    metal::float2 pfr_1 = {};
+    metal::float2 param_6 = {};
+    metal::float2 param_7 = {};
+    metal::float2 param_8 = {};
+    metal::float2 param_9 = {};
+    metal::float2 param_10 = {};
+    metal::float2 param_11 = {};
+    metal::float2 param_12 = {};
+    metal::float2 param_13 = {};
+    metal::float2 param_14 = {};
+    metal::float2 param_15 = {};
+    metal::float2 param_16 = {};
+    pto_1 = metal::float2(-1.0, -1.0);
+    float _e47 = uniforms.depth;
+    float _e49 = uniforms.progress;
+    size = metal::mix(1.0, _e47, _e49);
+    float _e52 = uniforms.perspective;
+    float _e54 = uniforms.progress;
+    persp = _e52 * _e54;
+    metal::float2 _e56 = p_3;
+    float _e58 = size;
+    float _e60 = uniforms.perspective;
+    float _e62 = uniforms.progress;
+    float _e66 = size;
+    float _e67 = size;
+    float _e68 = persp;
+    float _e71 = p_3[0u];
+    pfr_1 = ((_e56 + metal::float2(-0.0, -0.5)) * metal::float2(_e58 / (1.0 - (_e60 * _e62)), _e66 / (1.0 - ((_e67 * _e68) * _e71)))) + metal::float2(0.0, 0.5);
+    float _e79 = uniforms.depth;
+    float _e81 = uniforms.progress;
+    size = metal::mix(1.0, _e79, 1.0 - _e81);
+    float _e85 = uniforms.perspective;
+    float _e87 = uniforms.progress;
+    persp = _e85 * (1.0 - _e87);
+    metal::float2 _e90 = p_3;
+    float _e92 = size;
+    float _e94 = uniforms.perspective;
+    float _e96 = uniforms.progress;
+    float _e101 = size;
+    float _e102 = size;
+    float _e103 = persp;
+    float _e106 = p_3[0u];
+    pto_1 = ((_e90 + metal::float2(-1.0, -0.5)) * metal::float2(_e92 / (1.0 - (_e94 * (1.0 - _e96))), _e101 / (1.0 - ((_e102 * _e103) * (0.5 - _e106))))) + metal::float2(1.0, 0.5);
+    float _e115 = uniforms.progress;
+    if (_e115 < 0.5) {
+        metal::float2 _e117 = pfr_1;
+        param_6 = _e117;
+        bool _e118 = inBounds(param_6);
+        if (_e118) {
+            metal::float2 _e119 = pfr_1;
+            param_7 = _e119;
+            metal::float4 _e120 = getFromColor(param_7, _from, _sampler);
+            return _e120;
+        }
+        metal::float2 _e121 = pto_1;
+        param_8 = _e121;
+        bool _e122 = inBounds(param_8);
+        if (_e122) {
+            metal::float2 _e123 = pto_1;
+            param_9 = _e123;
+            metal::float4 _e124 = getToColor(param_9, _sampler, _to);
+            return _e124;
+        }
+    }
+    metal::float2 _e125 = pto_1;
+    param_10 = _e125;
+    bool _e126 = inBounds(param_10);
+    if (_e126) {
+        metal::float2 _e127 = pto_1;
+        param_11 = _e127;
+        metal::float4 _e128 = getToColor(param_11, _sampler, _to);
+        return _e128;
+    }
+    metal::float2 _e129 = pfr_1;
+    param_12 = _e129;
+    bool _e130 = inBounds(param_12);
+    if (_e130) {
+        metal::float2 _e131 = pfr_1;
+        param_13 = _e131;
+        metal::float4 _e132 = getFromColor(param_13, _from, _sampler);
+        return _e132;
+    }
+    metal::float2 _e133 = p_3;
+    param_14 = _e133;
+    metal::float2 _e134 = pfr_1;
+    param_15 = _e134;
+    metal::float2 _e135 = pto_1;
+    param_16 = _e135;
+    metal::float4 _e136 = bgColor(param_14, param_15, param_16, _from, _sampler, _to, uniforms);
+    return _e136;
+}
+
+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 _e31 = _uv_1;
+    param_17 = _e31;
+    metal::float4 _e32 = transition(param_17, _from, _sampler, _to, uniforms);
+    _fragColor = _e32;
+    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 };
+}