gl-transitions 1.74.0 → 1.76.0

package/msl/morph.metal

@@ -0,0 +1,131 @@
+// morph — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/morph.glsl
+// Author: paniq
+// License: MIT
+// Description: A crossfade in which each image is displaced by the other's colors, like a morph
+// 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 strength;
+};
+
+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& p,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float4 ca = {};
+    metal::float2 param = {};
+    metal::float4 cb = {};
+    metal::float2 param_1 = {};
+    metal::float2 oa = {};
+    metal::float2 ob = {};
+    metal::float2 oc = {};
+    float w0_ = {};
+    float w1_ = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    metal::float2 _e27 = p;
+    param = _e27;
+    metal::float4 _e28 = getFromColor(param, _from, _sampler);
+    ca = _e28;
+    metal::float2 _e29 = p;
+    param_1 = _e29;
+    metal::float4 _e30 = getToColor(param_1, _sampler, _to);
+    cb = _e30;
+    metal::float4 _e31 = ca;
+    float _e34 = ca[2u];
+    oa = (((_e31.xy + metal::float2(_e34)) * 0.5) * 2.0) - metal::float2(1.0);
+    metal::float4 _e41 = cb;
+    float _e44 = cb[2u];
+    ob = (((_e41.xy + metal::float2(_e44)) * 0.5) * 2.0) - metal::float2(1.0);
+    metal::float2 _e51 = oa;
+    metal::float2 _e52 = ob;
+    float _e56 = uniforms.strength;
+    oc = metal::mix(_e51, _e52, metal::float2(0.5)) * _e56;
+    float _e59 = uniforms.progress;
+    w0_ = _e59;
+    float _e60 = w0_;
+    w1_ = 1.0 - _e60;
+    metal::float2 _e62 = p;
+    metal::float2 _e63 = oc;
+    float _e64 = w0_;
+    param_2 = _e62 + (_e63 * _e64);
+    metal::float4 _e67 = getFromColor(param_2, _from, _sampler);
+    metal::float2 _e68 = p;
+    metal::float2 _e69 = oc;
+    float _e70 = w1_;
+    param_3 = _e68 - (_e69 * _e70);
+    metal::float4 _e73 = getToColor(param_3, _sampler, _to);
+    float _e75 = uniforms.progress;
+    return metal::mix(_e67, _e73, metal::float4(_e75));
+}
+
+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/mosaic_transition.metal

@@ -0,0 +1,137 @@
+// mosaic_transition — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/mosaic_transition.glsl
+// Author: YueDev
+// License: MIT
+// Description: Both images break into mosaic blocks that blend, then sharpen into 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 mosaicNum;
+};
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e16 = uv[0u];
+    float _e18 = uv[1u];
+    metal::float4 _e21 = _to.sample(_sampler, metal::float2(_e16, 1.0 - _e18), metal::level(0.0));
+    return _e21;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e16 = uv_1[0u];
+    float _e18 = uv_1[1u];
+    metal::float4 _e21 = _from.sample(_sampler, metal::float2(_e16, 1.0 - _e18), metal::level(0.0));
+    return _e21;
+}
+
+metal::float2 getMosaicUV(
+    thread metal::float2& uv_2,
+    constant Uniforms& uniforms
+) {
+    float mosaicWidth = {};
+    float mX = {};
+    float mY = {};
+    float _e19 = uniforms.mosaicNum;
+    float _e22 = uniforms.progress;
+    float _e24 = uniforms.progress;
+    mosaicWidth = (2.0 / _e19) * metal::min(_e22, 1.0 - _e24);
+    float _e29 = uv_2[0u];
+    float _e30 = mosaicWidth;
+    mX = metal::floor(_e29 / _e30) + 0.5;
+    float _e35 = uv_2[1u];
+    float _e36 = mosaicWidth;
+    mY = metal::floor(_e35 / _e36) + 0.5;
+    float _e40 = mX;
+    float _e41 = mosaicWidth;
+    float _e43 = mY;
+    float _e44 = mosaicWidth;
+    return metal::float2(_e40 * _e41, _e43 * _e44);
+}
+
+metal::float4 transition(
+    thread metal::float2& uv_3,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    constant Uniforms& uniforms
+) {
+    metal::float2 mosaicUV = {};
+    metal::float2 local = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    float _e21 = uniforms.progress;
+    float _e23 = uniforms.progress;
+    if (metal::min(_e21, 1.0 - _e23) == 0.0) {
+        metal::float2 _e27 = uv_3;
+        local = _e27;
+    } else {
+        metal::float2 _e28 = uv_3;
+        param = _e28;
+        metal::float2 _e29 = getMosaicUV(param, uniforms);
+        local = _e29;
+    }
+    metal::float2 _e30 = local;
+    mosaicUV = _e30;
+    metal::float2 _e31 = mosaicUV;
+    param_1 = _e31;
+    metal::float4 _e32 = getFromColor(param_1, _from, _sampler);
+    metal::float2 _e33 = mosaicUV;
+    param_2 = _e33;
+    metal::float4 _e34 = getToColor(param_2, _sampler, _to);
+    float _e36 = uniforms.progress;
+    float _e38 = uniforms.progress;
+    return metal::mix(_e32, _e34, metal::float4(_e36 * _e38));
+}
+
+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 _e15 = _uv_1;
+    param_3 = _e15;
+    metal::float4 _e16 = transition(param_3, _from, _sampler, _to, uniforms);
+    _fragColor = _e16;
+    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/multiply_blend.metal

@@ -0,0 +1,127 @@
+// multiply_blend — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/multiply_blend.glsl
+// Author: Fernando Kuteken
+// License: MIT
+// Description: A crossfade through the multiplied blend of both 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 blend(
+    thread metal::float4& a,
+    thread metal::float4& b
+) {
+    metal::float4 _e15 = a;
+    metal::float4 _e16 = b;
+    return _e15 * _e16;
+}
+
+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::float4 blended = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float4 param_2 = {};
+    metal::float4 param_3 = {};
+    metal::float2 param_4 = {};
+    metal::float2 param_5 = {};
+    metal::float2 _e21 = uv_2;
+    param = _e21;
+    metal::float4 _e22 = getFromColor(param, _from, _sampler);
+    metal::float2 _e23 = uv_2;
+    param_1 = _e23;
+    metal::float4 _e24 = getToColor(param_1, _sampler, _to);
+    param_2 = _e22;
+    param_3 = _e24;
+    metal::float4 _e25 = blend(param_2, param_3);
+    blended = _e25;
+    float _e27 = uniforms.progress;
+    if (_e27 < 0.5) {
+        metal::float2 _e29 = uv_2;
+        param_4 = _e29;
+        metal::float4 _e30 = getFromColor(param_4, _from, _sampler);
+        metal::float4 _e31 = blended;
+        float _e33 = uniforms.progress;
+        return metal::mix(_e30, _e31, metal::float4(2.0 * _e33));
+    } else {
+        metal::float4 _e37 = blended;
+        metal::float2 _e38 = uv_2;
+        param_5 = _e38;
+        metal::float4 _e39 = getToColor(param_5, _sampler, _to);
+        float _e41 = uniforms.progress;
+        return metal::mix(_e37, _e39, metal::float4((2.0 * _e41) - 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_6 = {};
+    metal::float2 _e14 = _uv_1;
+    param_6 = _e14;
+    metal::float4 _e15 = transition(param_6, _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/old_tv_lost_signal.metal

@@ -0,0 +1,172 @@
+// old_tv_lost_signal — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/old_tv_lost_signal.glsl
+// Author: mernking (gitlab.com/Godswork)
+// License: MIT
+// Description: A crossfade with drifting tracking lines and tearing, like a TV losing its signal
+// 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 hash(
+    thread metal::float2& p
+) {
+    metal::float2 _e26 = p;
+    return metal::fract(metal::sin(metal::dot(_e26, metal::float2(127.1, 311.7))) * 43758.547);
+}
+
+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::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
+) {
+    float p_1 = {};
+    float strength = {};
+    metal::float2 tv = {};
+    metal::float4 fromColor = {};
+    metal::float2 param = {};
+    metal::float4 toColor = {};
+    metal::float2 param_1 = {};
+    metal::float4 color = {};
+    float lineY = {};
+    float noise = {};
+    metal::float2 param_2 = {};
+    float line = {};
+    float drift = {};
+    metal::float4 shiftedFrom = {};
+    metal::float2 param_3 = {};
+    metal::float4 shiftedTo = {};
+    metal::float2 param_4 = {};
+    metal::float4 lineColor = {};
+    float scan = {};
+    float _e46 = uniforms.progress;
+    p_1 = _e46;
+    float _e47 = p_1;
+    strength = metal::sin(_e47 * 3.1415927);
+    metal::float2 _e50 = uv_2;
+    tv = _e50;
+    metal::float2 _e51 = tv;
+    param = _e51;
+    metal::float4 _e52 = getFromColor(param, _from, _sampler);
+    fromColor = _e52;
+    metal::float2 _e53 = tv;
+    param_1 = _e53;
+    metal::float4 _e54 = getToColor(param_1, _sampler, _to);
+    toColor = _e54;
+    metal::float4 _e55 = fromColor;
+    metal::float4 _e56 = toColor;
+    float _e57 = p_1;
+    color = metal::mix(_e55, _e56, metal::float4(_e57));
+    float _e61 = tv[1u];
+    lineY = metal::floor(_e61 * 120.0);
+    float _e64 = lineY;
+    float _e65 = p_1;
+    param_2 = metal::float2(_e64, _e65 * 20.0);
+    float _e68 = hash(param_2);
+    noise = _e68;
+    float _e69 = noise;
+    line = metal::step(0.92, _e69);
+    float _e72 = tv[1u];
+    float _e74 = p_1;
+    float _e79 = strength;
+    drift = (metal::sin((_e72 * 30.0) + (_e74 * 10.0)) * 0.02) * _e79;
+    metal::float2 _e81 = tv;
+    float _e82 = drift;
+    param_3 = _e81 + metal::float2(_e82, 0.0);
+    metal::float4 _e85 = getFromColor(param_3, _from, _sampler);
+    shiftedFrom = _e85;
+    metal::float2 _e86 = tv;
+    float _e87 = drift;
+    param_4 = _e86 + metal::float2(_e87, 0.0);
+    metal::float4 _e90 = getToColor(param_4, _sampler, _to);
+    shiftedTo = _e90;
+    metal::float4 _e91 = shiftedFrom;
+    metal::float4 _e92 = shiftedTo;
+    float _e93 = p_1;
+    lineColor = metal::mix(_e91, _e92, metal::float4(_e93));
+    metal::float4 _e96 = color;
+    metal::float4 _e97 = lineColor;
+    float _e98 = line;
+    float _e99 = strength;
+    color = metal::mix(_e96, _e97, metal::float4(_e98 * _e99));
+    float _e104 = tv[1u];
+    scan = metal::sin(_e104 * 900.0) * 0.03;
+    float _e108 = scan;
+    float _e109 = strength;
+    metal::float4 _e111 = color;
+    metal::float3 _e114 = _e111.xyz - metal::float3(_e108 * _e109);
+    color[0u] = _e114.x;
+    color[1u] = _e114.y;
+    color[2u] = _e114.z;
+    metal::float4 _e121 = color;
+    return _e121;
+}
+
+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 };
+}