gl-transitions 1.74.0 → 1.76.0

package/msl/undulatingBurnOut.metal

@@ -0,0 +1,217 @@
+// undulatingBurnOut — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/undulatingBurnOut.glsl
+// Author: pthrasher
+// License: MIT
+// Description: A circle with a wavy edge burns out from the center 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;
+    float smoothness;
+    char _pad3[4];
+    metal::float2 center;
+    char _pad4[8];
+    metal::float3 color;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e37 = uv[0u];
+    float _e39 = uv[1u];
+    metal::float4 _e42 = _to.sample(_sampler, metal::float2(_e37, 1.0 - _e39), metal::level(0.0));
+    return _e42;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e37 = uv_1[0u];
+    float _e39 = uv_1[1u];
+    metal::float4 _e42 = _from.sample(_sampler, metal::float2(_e37, 1.0 - _e39), metal::level(0.0));
+    return _e42;
+}
+
+float getGradient(
+    thread float& r,
+    thread float& dist,
+    constant Uniforms& uniforms
+) {
+    float d = {};
+    float _e38 = r;
+    float _e39 = dist;
+    d = _e38 - _e39;
+    float _e42 = uniforms.smoothness;
+    float _e44 = r;
+    float _e45 = dist;
+    float _e47 = uniforms.smoothness;
+    float _e52 = d;
+    float _e55 = d;
+    float _e57 = d;
+    return metal::mix(metal::smoothstep(-(_e42), 0.0, _e44 - (_e45 * (1.0 + _e47))), -1.0 - metal::step(0.005, _e52), metal::step(-0.005, _e55) * metal::step(_e57, 0.01));
+}
+
+float quadraticInOut(
+    thread float& t
+) {
+    float p = {};
+    float local = {};
+    float _e38 = t;
+    float _e40 = t;
+    p = (2.0 * _e38) * _e40;
+    float _e42 = t;
+    if (_e42 < 0.5) {
+        float _e44 = p;
+        local = _e44;
+    } else {
+        float _e45 = p;
+        float _e47 = t;
+        local = (-(_e45) + (4.0 * _e47)) - 1.0;
+    }
+    float _e51 = local;
+    return _e51;
+}
+
+float getWave(
+    thread metal::float2& p_1,
+    constant Uniforms& uniforms
+) {
+    metal::float2 _p = {};
+    float rads = {};
+    float degs = {};
+    metal::float2 range = {};
+    metal::float2 domain = {};
+    float ratio = {};
+    float x = {};
+    float magnitude = {};
+    float offset = {};
+    float ease_degs = {};
+    float param = {};
+    float deg_wave_pos = {};
+    metal::float2 _e48 = p_1;
+    metal::float2 _e50 = uniforms.center;
+    _p = _e48 - _e50;
+    float _e53 = _p[1u];
+    float _e55 = _p[0u];
+    rads = metal::atan2(_e53, _e55);
+    float _e57 = rads;
+    degs = ((_e57) * 57.295779513082322865) + 180.0;
+    range = metal::float2(0.0, 94.24778);
+    domain = metal::float2(0.0, 360.0);
+    ratio = 0.2617994;
+    float _e60 = degs;
+    float _e61 = ratio;
+    degs = _e60 * _e61;
+    float _e64 = uniforms.progress;
+    x = _e64;
+    float _e65 = x;
+    magnitude = metal::mix(0.02, 0.09, metal::smoothstep(0.0, 1.0, _e65));
+    float _e68 = x;
+    offset = metal::mix(40.0, 30.0, metal::smoothstep(0.0, 1.0, _e68));
+    float _e71 = degs;
+    param = metal::sin(_e71);
+    float _e73 = quadraticInOut(param);
+    ease_degs = _e73;
+    float _e74 = ease_degs;
+    float _e75 = magnitude;
+    float _e77 = x;
+    float _e78 = offset;
+    deg_wave_pos = (_e74 * _e75) * metal::sin(_e77 * _e78);
+    float _e82 = x;
+    float _e84 = uniforms.smoothness;
+    float _e86 = x;
+    float _e91 = deg_wave_pos;
+    return (_e82 - (metal::max(_e84, 0.01) * (1.0 - metal::smoothstep(0.0, 0.1, _e86)))) + _e91;
+}
+
+metal::float4 transition(
+    thread metal::float2& p_2,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    float dist_1 = {};
+    float m = {};
+    metal::float2 param_1 = {};
+    float param_2 = {};
+    float param_3 = {};
+    metal::float4 cfrom = {};
+    metal::float2 param_4 = {};
+    metal::float4 cto = {};
+    metal::float2 param_5 = {};
+    metal::float2 _e46 = uniforms.center;
+    metal::float2 _e47 = p_2;
+    dist_1 = metal::distance(_e46, _e47);
+    metal::float2 _e49 = p_2;
+    param_1 = _e49;
+    float _e50 = getWave(param_1, uniforms);
+    param_2 = _e50;
+    float _e51 = dist_1;
+    param_3 = _e51;
+    float _e52 = getGradient(param_2, param_3, uniforms);
+    m = _e52;
+    metal::float2 _e53 = p_2;
+    param_4 = _e53;
+    metal::float4 _e54 = getFromColor(param_4, _from, _sampler);
+    cfrom = _e54;
+    metal::float2 _e55 = p_2;
+    param_5 = _e55;
+    metal::float4 _e56 = getToColor(param_5, _sampler, _to);
+    cto = _e56;
+    metal::float4 _e57 = cfrom;
+    metal::float4 _e58 = cto;
+    float _e59 = m;
+    metal::float4 _e62 = cfrom;
+    metal::float3 _e64 = uniforms.color;
+    float _e71 = m;
+    return metal::mix(metal::mix(_e57, _e58, metal::float4(_e59)), metal::mix(_e62, metal::float4(_e64.x, _e64.y, _e64.z, 1.0), metal::float4(0.75)), metal::float4(metal::step(_e71, -2.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_6 = {};
+    metal::float2 _e36 = _uv_1;
+    param_6 = _e36;
+    metal::float4 _e37 = transition(param_6, _from, _sampler, _to, uniforms);
+    _fragColor = _e37;
+    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/wind.metal

@@ -0,0 +1,131 @@
+// wind — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wind.glsl
+// Author: gre
+// License: MIT
+// Description: A ragged left-to-right wipe, as if the image was blown away by the wind
+// 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;
+    int reversed;
+};
+
+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;
+}
+
+float rand(
+    thread metal::float2& co
+) {
+    metal::float2 _e18 = co;
+    return metal::fract(metal::sin(metal::dot(_e18, metal::float2(12.9898, 78.233))) * 43758.547);
+}
+
+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 x = {};
+    float local = {};
+    float r = {};
+    metal::float2 param = {};
+    float m = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    int _e26 = uniforms.reversed;
+    if (_e26 != 0) {
+        float _e29 = uv_2[0u];
+        local = 1.0 - _e29;
+    } else {
+        float _e32 = uv_2[0u];
+        local = _e32;
+    }
+    float _e33 = local;
+    x = _e33;
+    float _e35 = uv_2[1u];
+    param = metal::float2(0.0, _e35);
+    float _e37 = rand(param);
+    r = _e37;
+    float _e39 = uniforms.size;
+    float _e41 = x;
+    float _e43 = uniforms.size;
+    float _e47 = uniforms.size;
+    float _e48 = r;
+    float _e52 = uniforms.progress;
+    float _e54 = uniforms.size;
+    m = metal::smoothstep(0.0, -(_e39), ((_e41 * (1.0 - _e43)) + (_e47 * _e48)) - (_e52 * (1.0 + _e54)));
+    metal::float2 _e59 = uv_2;
+    param_1 = _e59;
+    metal::float4 _e60 = getFromColor(param_1, _from, _sampler);
+    metal::float2 _e61 = uv_2;
+    param_2 = _e61;
+    metal::float4 _e62 = getToColor(param_2, _sampler, _to);
+    float _e63 = m;
+    return metal::mix(_e60, _e62, metal::float4(_e63));
+}
+
+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 _e18 = _uv_1;
+    param_3 = _e18;
+    metal::float4 _e19 = transition(param_3, _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/windowblinds.metal

@@ -0,0 +1,107 @@
+// windowblinds — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/windowblinds.glsl
+// Author: Fabien Benetou
+// License: MIT
+// Description: A crossfade through horizontal window blinds
+// 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 _e17 = uv[0u];
+    float _e19 = uv[1u];
+    metal::float4 _e22 = _to.sample(_sampler, metal::float2(_e17, 1.0 - _e19), metal::level(0.0));
+    return _e22;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e17 = uv_1[0u];
+    float _e19 = uv_1[1u];
+    metal::float4 _e22 = _from.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 t = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e20 = uniforms.progress;
+    t = _e20;
+    float _e22 = uv_2[1u];
+    float _e25 = uniforms.progress;
+    float _e27 = metal::floor((_e22 * 100.0) * _e25);
+    if ((_e27 - (metal::floor(_e27 / 2.0) * 2.0)) == 0.0) {
+        float _e33 = t;
+        t = _e33 * 1.5;
+    }
+    metal::float2 _e35 = uv_2;
+    param = _e35;
+    metal::float4 _e36 = getFromColor(param, _from, _sampler);
+    metal::float2 _e37 = uv_2;
+    param_1 = _e37;
+    metal::float4 _e38 = getToColor(param_1, _sampler, _to);
+    float _e39 = t;
+    float _e41 = uniforms.progress;
+    float _e43 = uniforms.progress;
+    return metal::mix(_e36, _e38, metal::float4(metal::mix(_e39, _e41, metal::smoothstep(0.8, 1.0, _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 _e16 = _uv_1;
+    param_2 = _e16;
+    metal::float4 _e17 = transition(param_2, _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/windowslice.metal

@@ -0,0 +1,108 @@
+// windowslice — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/windowslice.glsl
+// Author: gre
+// License: MIT
+// Description: The incoming image appears through vertical slices that widen
+// 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 count;
+    float smoothness;
+};
+
+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 pr = {};
+    float s = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    float _e19 = uniforms.smoothness;
+    float _e22 = p[0u];
+    float _e24 = uniforms.progress;
+    float _e26 = uniforms.smoothness;
+    pr = metal::smoothstep(-(_e19), 0.0, _e22 - (_e24 * (1.0 + _e26)));
+    float _e31 = pr;
+    float _e33 = uniforms.count;
+    float _e35 = p[0u];
+    s = metal::step(_e31, metal::fract(_e33 * _e35));
+    metal::float2 _e39 = p;
+    param = _e39;
+    metal::float4 _e40 = getFromColor(param, _from, _sampler);
+    metal::float2 _e41 = p;
+    param_1 = _e41;
+    metal::float4 _e42 = getToColor(param_1, _sampler, _to);
+    float _e43 = s;
+    return metal::mix(_e40, _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/wipeDown.metal

@@ -0,0 +1,105 @@
+// wipeDown — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/wipeDown.glsl
+// Author: Jake Nelson
+// License: MIT
+// Description: A hard-edged wipe from top to bottom
+// 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 _e14 = uv[0u];
+    float _e16 = uv[1u];
+    metal::float4 _e19 = _to.sample(_sampler, metal::float2(_e14, 1.0 - _e16), metal::level(0.0));
+    return _e19;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e14 = uv_1[0u];
+    float _e16 = uv_1[1u];
+    metal::float4 _e19 = _from.sample(_sampler, metal::float2(_e14, 1.0 - _e16), metal::level(0.0));
+    return _e19;
+}
+
+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 p = {};
+    metal::float4 a = {};
+    metal::float2 param = {};
+    metal::float4 b = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e18 = uv_2;
+    p = _e18 / metal::float2(1.0, 1.0);
+    metal::float2 _e20 = p;
+    param = _e20;
+    metal::float4 _e21 = getFromColor(param, _from, _sampler);
+    a = _e21;
+    metal::float2 _e22 = p;
+    param_1 = _e22;
+    metal::float4 _e23 = getToColor(param_1, _sampler, _to);
+    b = _e23;
+    metal::float4 _e24 = a;
+    metal::float4 _e25 = b;
+    float _e27 = p[1u];
+    float _e30 = uniforms.progress;
+    return metal::mix(_e24, _e25, metal::float4(metal::step(1.0 - _e27, _e30)));
+}
+
+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 _e13 = _uv_1;
+    param_2 = _e13;
+    metal::float4 _e14 = transition(param_2, _from, _sampler, _to, uniforms);
+    _fragColor = _e14;
+    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 };
+}