gl-transitions 1.74.0 → 1.76.0

package/msl/GridFlip.metal

@@ -0,0 +1,285 @@
+// GridFlip — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/GridFlip.glsl
+// Author: TimDonselaar
+// License: MIT
+// Description: The image splits into a grid of tiles that flip one by one to 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 size;
+    float pause;
+    float dividerWidth;
+    char _pad5[8];
+    metal::float4 bgcolor;
+    float randomness;
+    char _pad7[12];
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e24 = uv[0u];
+    float _e26 = uv[1u];
+    metal::float4 _e29 = _to.sample(_sampler, metal::float2(_e24, 1.0 - _e26), metal::level(0.0));
+    return _e29;
+}
+
+float rand(
+    thread metal::float2& co
+) {
+    metal::float2 _e23 = co;
+    return metal::fract(metal::sin(metal::dot(_e23, metal::float2(12.9898, 78.233))) * 43758.547);
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e24 = uv_1[0u];
+    float _e26 = uv_1[1u];
+    metal::float4 _e29 = _from.sample(_sampler, metal::float2(_e24, 1.0 - _e26), metal::level(0.0));
+    return _e29;
+}
+
+float getDividerSize_u0028_(
+    constant Uniforms& uniforms
+) {
+    metal::float2 rectangleSize = {};
+    metal::int2 _e24 = uniforms.size;
+    metal::int2 _e29 = uniforms.size;
+    rectangleSize = metal::float2(1.0 / static_cast<metal::float2>(_e24).x, 1.0 / static_cast<metal::float2>(_e29).y);
+    float _e35 = rectangleSize[0u];
+    float _e37 = rectangleSize[1u];
+    float _e40 = uniforms.dividerWidth;
+    return metal::min(_e35, _e37) * _e40;
+}
+
+float getDelta(
+    thread metal::float2& p,
+    constant Uniforms& uniforms
+) {
+    metal::float2 rectanglePos = {};
+    metal::float2 rectangleSize_1 = {};
+    float top = {};
+    float bottom = {};
+    float left = {};
+    float right = {};
+    float minX = {};
+    float minY = {};
+    metal::int2 _e32 = uniforms.size;
+    metal::float2 _e34 = p;
+    rectanglePos = metal::floor(static_cast<metal::float2>(_e32) * _e34);
+    metal::int2 _e38 = uniforms.size;
+    metal::int2 _e43 = uniforms.size;
+    rectangleSize_1 = metal::float2(1.0 / static_cast<metal::float2>(_e38).x, 1.0 / static_cast<metal::float2>(_e43).y);
+    float _e49 = rectangleSize_1[1u];
+    float _e51 = rectanglePos[1u];
+    top = _e49 * (_e51 + 1.0);
+    float _e55 = rectangleSize_1[1u];
+    float _e57 = rectanglePos[1u];
+    bottom = _e55 * _e57;
+    float _e60 = rectangleSize_1[0u];
+    float _e62 = rectanglePos[0u];
+    left = _e60 * _e62;
+    float _e65 = rectangleSize_1[0u];
+    float _e67 = rectanglePos[0u];
+    right = _e65 * (_e67 + 1.0);
+    float _e71 = p[0u];
+    float _e72 = left;
+    float _e76 = p[0u];
+    float _e77 = right;
+    minX = metal::min(metal::abs(_e71 - _e72), metal::abs(_e76 - _e77));
+    float _e82 = p[1u];
+    float _e83 = top;
+    float _e87 = p[1u];
+    float _e88 = bottom;
+    minY = metal::min(metal::abs(_e82 - _e83), metal::abs(_e87 - _e88));
+    float _e92 = minX;
+    float _e93 = minY;
+    return metal::min(_e92, _e93);
+}
+
+metal::float4 transition(
+    thread metal::float2& p_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float currentProg = {};
+    float a = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    float currentProg_1 = {};
+    metal::float2 q = {};
+    metal::float2 rectanglePos_1 = {};
+    float r = {};
+    metal::float2 param_3 = {};
+    float cp = {};
+    float rectangleSize_2 = {};
+    float delta = {};
+    float offset = {};
+    metal::float4 a_1 = {};
+    metal::float2 param_4 = {};
+    metal::float4 b = {};
+    metal::float2 param_5 = {};
+    float s = {};
+    float currentProg_2 = {};
+    float a_2 = {};
+    metal::float2 param_6 = {};
+    metal::float2 param_7 = {};
+    float _e47 = uniforms.progress;
+    float _e49 = uniforms.pause;
+    if (_e47 < _e49) {
+        float _e52 = uniforms.progress;
+        float _e54 = uniforms.pause;
+        currentProg = _e52 / _e54;
+        a = 1.0;
+        metal::float2 _e56 = p_1;
+        param = _e56;
+        float _e57 = getDelta(param, uniforms);
+        float _e58 = getDividerSize_u0028_(uniforms);
+        if (_e57 < _e58) {
+            float _e60 = currentProg;
+            a = 1.0 - _e60;
+        }
+        metal::float4 _e63 = uniforms.bgcolor;
+        metal::float2 _e64 = p_1;
+        param_1 = _e64;
+        metal::float4 _e65 = getFromColor(param_1, _from, _sampler);
+        float _e66 = a;
+        return metal::mix(_e63, _e65, metal::float4(_e66));
+    } else {
+        float _e70 = uniforms.progress;
+        float _e72 = uniforms.pause;
+        if (_e70 < (1.0 - _e72)) {
+            metal::float2 _e75 = p_1;
+            param_2 = _e75;
+            float _e76 = getDelta(param_2, uniforms);
+            float _e77 = getDividerSize_u0028_(uniforms);
+            if (_e76 < _e77) {
+                metal::float4 _e80 = uniforms.bgcolor;
+                return _e80;
+            } else {
+                float _e82 = uniforms.progress;
+                float _e84 = uniforms.pause;
+                float _e87 = uniforms.pause;
+                currentProg_1 = (_e82 - _e84) / (1.0 - (_e87 * 2.0));
+                metal::float2 _e91 = p_1;
+                q = _e91;
+                metal::int2 _e93 = uniforms.size;
+                metal::float2 _e95 = q;
+                rectanglePos_1 = metal::floor(static_cast<metal::float2>(_e93) * _e95);
+                metal::float2 _e98 = rectanglePos_1;
+                param_3 = _e98;
+                float _e99 = rand(param_3);
+                float _e101 = uniforms.randomness;
+                r = _e99 - _e101;
+                float _e103 = r;
+                float _e105 = currentProg_1;
+                cp = metal::smoothstep(0.0, 1.0 - _e103, _e105);
+                metal::int2 _e108 = uniforms.size;
+                rectangleSize_2 = 1.0 / static_cast<metal::float2>(_e108).x;
+                float _e113 = rectanglePos_1[0u];
+                float _e114 = rectangleSize_2;
+                delta = _e113 * _e114;
+                float _e116 = rectangleSize_2;
+                float _e118 = delta;
+                offset = (_e116 / 2.0) + _e118;
+                float _e121 = p_1[0u];
+                float _e122 = offset;
+                float _e124 = cp;
+                float _e129 = offset;
+                p_1[0u] = (((_e121 - _e122) / metal::abs(_e124 - 0.5)) * 0.5) + _e129;
+                metal::float2 _e132 = p_1;
+                param_4 = _e132;
+                metal::float4 _e133 = getFromColor(param_4, _from, _sampler);
+                a_1 = _e133;
+                metal::float2 _e134 = p_1;
+                param_5 = _e134;
+                metal::float4 _e135 = getToColor(param_5, _sampler, _to);
+                b = _e135;
+                metal::int2 _e137 = uniforms.size;
+                float _e141 = q[0u];
+                float _e142 = delta;
+                float _e147 = cp;
+                s = metal::step(metal::abs((static_cast<metal::float2>(_e137).x * (_e141 - _e142)) - 0.5), metal::abs(_e147 - 0.5));
+                metal::float4 _e152 = uniforms.bgcolor;
+                metal::float4 _e153 = b;
+                metal::float4 _e154 = a_1;
+                float _e155 = cp;
+                float _e159 = s;
+                return metal::mix(_e152, metal::mix(_e153, _e154, metal::float4(metal::step(_e155, 0.5))), metal::float4(_e159));
+            }
+        } else {
+            float _e163 = uniforms.progress;
+            float _e166 = uniforms.pause;
+            float _e169 = uniforms.pause;
+            currentProg_2 = ((_e163 - 1.0) + _e166) / _e169;
+            a_2 = 1.0;
+            metal::float2 _e171 = p_1;
+            param_6 = _e171;
+            float _e172 = getDelta(param_6, uniforms);
+            float _e173 = getDividerSize_u0028_(uniforms);
+            if (_e172 < _e173) {
+                float _e175 = currentProg_2;
+                a_2 = _e175;
+            }
+            metal::float4 _e177 = uniforms.bgcolor;
+            metal::float2 _e178 = p_1;
+            param_7 = _e178;
+            metal::float4 _e179 = getToColor(param_7, _sampler, _to);
+            float _e180 = a_2;
+            return metal::mix(_e177, _e179, metal::float4(_e180));
+        }
+    }
+}
+
+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 _e23 = _uv_1;
+    param_8 = _e23;
+    metal::float4 _e24 = transition(param_8, _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/HSVfade.metal

@@ -0,0 +1,161 @@
+// HSVfade — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HSVfade.glsl
+// Author: nwoeanhinnogaehr
+// License: MIT
+// Description: A crossfade through the HSV color space that cycles through hues
+// 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::float3 hsv2rgb(
+    thread metal::float3& c
+) {
+    metal::float3 p = {};
+    metal::float3 _e27 = c;
+    p = metal::abs((metal::fract(_e27.xxx + metal::float3(1.0, 0.6666667, 0.33333334)) * 6.0) - metal::float3(3.0, 3.0, 3.0));
+    float _e35 = c[2u];
+    metal::float3 _e36 = p;
+    float _e42 = c[1u];
+    return metal::mix(metal::float3(1.0, 1.0, 1.0), metal::clamp(_e36 - metal::float3(1.0, 1.0, 1.0), metal::float3(0.0), metal::float3(1.0)), metal::float3(_e42)) * _e35;
+}
+
+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::float3 rgb2hsv(
+    thread metal::float3& c_1
+) {
+    metal::float4 p_1 = {};
+    metal::float4 q = {};
+    float d = {};
+    metal::float3 _e29 = c_1;
+    metal::float2 _e30 = _e29.zy;
+    metal::float3 _e36 = c_1;
+    metal::float2 _e37 = _e36.yz;
+    float _e44 = c_1[2u];
+    float _e46 = c_1[1u];
+    p_1 = metal::mix(metal::float4(_e30.x, _e30.y, metal::float2(-1.0, 0.6666667).x, metal::float2(-1.0, 0.6666667).y), metal::float4(_e37.x, _e37.y, metal::float2(0.0, -0.33333334).x, metal::float2(0.0, -0.33333334).y), metal::float4(metal::step(_e44, _e46)));
+    metal::float4 _e50 = p_1;
+    metal::float3 _e51 = _e50.xyw;
+    float _e53 = c_1[0u];
+    float _e59 = c_1[0u];
+    metal::float4 _e60 = p_1;
+    metal::float3 _e61 = _e60.yzx;
+    float _e67 = p_1[0u];
+    float _e69 = c_1[0u];
+    q = metal::mix(metal::float4(_e51.x, _e51.y, _e51.z, _e53), metal::float4(_e59, _e61.x, _e61.y, _e61.z), metal::float4(metal::step(_e67, _e69)));
+    float _e74 = q[0u];
+    float _e76 = q[3u];
+    float _e78 = q[1u];
+    d = _e74 - metal::min(_e76, _e78);
+    float _e82 = q[2u];
+    float _e84 = q[3u];
+    float _e86 = q[1u];
+    float _e88 = d;
+    float _e94 = d;
+    float _e96 = q[0u];
+    float _e100 = q[0u];
+    return metal::float3(metal::abs(_e82 + ((_e84 - _e86) / ((6.0 * _e88) + 0.001))), _e94 / (_e96 + 0.001), _e100);
+}
+
+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;
+}
+
+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::float3 a = {};
+    metal::float2 param = {};
+    metal::float3 param_1 = {};
+    metal::float3 b = {};
+    metal::float2 param_2 = {};
+    metal::float3 param_3 = {};
+    metal::float3 m = {};
+    metal::float3 param_4 = {};
+    metal::float2 _e34 = uv_2;
+    param = _e34;
+    metal::float4 _e35 = getFromColor(param, _from, _sampler);
+    param_1 = _e35.xyz;
+    metal::float3 _e37 = rgb2hsv(param_1);
+    a = _e37;
+    metal::float2 _e38 = uv_2;
+    param_2 = _e38;
+    metal::float4 _e39 = getToColor(param_2, _sampler, _to);
+    param_3 = _e39.xyz;
+    metal::float3 _e41 = rgb2hsv(param_3);
+    b = _e41;
+    metal::float3 _e42 = a;
+    metal::float3 _e43 = b;
+    float _e45 = uniforms.progress;
+    m = metal::mix(_e42, _e43, metal::float3(_e45));
+    metal::float3 _e48 = m;
+    param_4 = _e48;
+    metal::float3 _e49 = hsv2rgb(param_4);
+    return metal::float4(_e49.x, _e49.y, _e49.z, 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_5 = {};
+    metal::float2 _e26 = _uv_1;
+    param_5 = _e26;
+    metal::float4 _e27 = transition(param_5, _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/HorizontalClose.metal

@@ -0,0 +1,100 @@
+// HorizontalClose — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HorizontalClose.glsl
+// Author: martiniti
+// License: MIT
+// Description: The incoming image closes in from the top and bottom edges toward the middle
+// 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& 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 param = {};
+    metal::float2 param_1 = {};
+    float _e18 = uv_2[1u];
+    float _e21 = uniforms.progress;
+    float _e27 = uniforms.progress;
+    s = (2.0 - metal::abs((_e18 - 0.5) / (_e21 - 1.0))) - (2.0 * _e27);
+    metal::float2 _e30 = uv_2;
+    param = _e30;
+    metal::float4 _e31 = getFromColor(param, _from, _sampler);
+    metal::float2 _e32 = uv_2;
+    param_1 = _e32;
+    metal::float4 _e33 = getToColor(param_1, _sampler, _to);
+    float _e34 = s;
+    return metal::mix(_e31, _e33, metal::float4(metal::smoothstep(0.5, 0.0, _e34)));
+}
+
+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/HorizontalOpen.metal

@@ -0,0 +1,103 @@
+// HorizontalOpen — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/HorizontalOpen.glsl
+// Author: martiniti
+// License: MIT
+// Description: The incoming image opens from a line in the middle toward the top and bottom edges
+// 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& uv_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float regress = {};
+    float s = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e19 = uniforms.progress;
+    regress = 1.0 - _e19;
+    float _e22 = uv_2[1u];
+    float _e24 = regress;
+    float _e29 = regress;
+    s = (2.0 - metal::abs((_e22 - 0.5) / (_e24 - 1.0))) - (2.0 * _e29);
+    metal::float2 _e32 = uv_2;
+    param = _e32;
+    metal::float4 _e33 = getFromColor(param, _from, _sampler);
+    metal::float2 _e34 = uv_2;
+    param_1 = _e34;
+    metal::float4 _e35 = getToColor(param_1, _sampler, _to);
+    float _e36 = s;
+    return metal::mix(_e33, _e35, metal::float4(metal::smoothstep(0.0, 0.5, _e36)));
+}
+
+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 };
+}