gl-transitions 1.74.0 → 1.76.0

package/msl/tangentMotionBlur.metal

@@ -0,0 +1,583 @@
+// tangentMotionBlur — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/tangentMotionBlur.glsl
+// Author: chenkai
+// License: MIT
+// Description: The outgoing image is flung away along a curve with motion blur
+// 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 _e36 = uv[0u];
+    float _e38 = uv[1u];
+    metal::float4 _e41 = _to.sample(_sampler, metal::float2(_e36, 1.0 - _e38), metal::level(0.0));
+    return _e41;
+}
+
+float rand(
+    thread metal::float2& co
+) {
+    metal::float2 _e35 = co;
+    return metal::fract(metal::sin(metal::dot(_e35, metal::float2(12.9898, 78.233))) * 43758.547);
+}
+
+metal::float4 motionBlurTo(
+    thread metal::float2& _st,
+    thread metal::float2& speed,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    metal::float2 texCoord = {};
+    metal::float3 color = {};
+    float total = {};
+    float offset = {};
+    metal::float2 param = {};
+    float t = {};
+    float percent = {};
+    float weight = {};
+    metal::float2 newuv = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e46 = _st;
+    texCoord = _e46 / metal::float2(1.0, 1.0);
+    color = metal::float3(0.0, 0.0, 0.0);
+    total = 0.0;
+    metal::float2 _e48 = _st;
+    param = _e48;
+    float _e49 = rand(param);
+    offset = _e49;
+    t = 0.0;
+    uint2 loop_bound = uint2(4294967295u);
+    bool loop_init = true;
+    while(true) {
+        if (metal::all(loop_bound == uint2(0u))) { break; }
+        loop_bound -= uint2(loop_bound.y == 0u, 1u);
+        if (!loop_init) {
+            float _e79 = t;
+            t = _e79 + 1.0;
+        }
+        loop_init = false;
+        float _e50 = t;
+        if (_e50 <= 20.0) {
+            float _e52 = t;
+            float _e53 = offset;
+            percent = (_e52 + _e53) / 20.0;
+            float _e56 = percent;
+            float _e57 = percent;
+            float _e58 = percent;
+            weight = 4.0 * (_e56 - (_e57 * _e58));
+            metal::float2 _e62 = texCoord;
+            metal::float2 _e63 = speed;
+            float _e64 = percent;
+            newuv = _e62 + (_e63 * _e64);
+            metal::float2 _e67 = newuv;
+            newuv = metal::fract(_e67);
+            metal::float2 _e69 = newuv;
+            param_1 = _e69;
+            metal::float4 _e70 = getToColor(param_1, _sampler, _to);
+            float _e72 = weight;
+            metal::float3 _e74 = color;
+            color = _e74 + (_e70.xyz * _e72);
+            float _e76 = weight;
+            float _e77 = total;
+            total = _e77 + _e76;
+            continue;
+        } else {
+            break;
+        }
+    }
+    metal::float3 _e81 = color;
+    float _e82 = total;
+    metal::float3 _e84 = _e81 / metal::float3(_e82);
+    return metal::float4(_e84.x, _e84.y, _e84.z, 1.0);
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e36 = uv_1[0u];
+    float _e38 = uv_1[1u];
+    metal::float4 _e41 = _from.sample(_sampler, metal::float2(_e36, 1.0 - _e38), metal::level(0.0));
+    return _e41;
+}
+
+metal::float4 motionBlurFrom(
+    thread metal::float2& _st_1,
+    thread metal::float2& speed_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    metal::float2 texCoord_1 = {};
+    metal::float3 color_1 = {};
+    float total_1 = {};
+    float offset_1 = {};
+    metal::float2 param_2 = {};
+    float t_1 = {};
+    float percent_1 = {};
+    float weight_1 = {};
+    metal::float2 newuv_1 = {};
+    metal::float2 param_3 = {};
+    metal::float2 _e46 = _st_1;
+    texCoord_1 = _e46 / metal::float2(1.0, 1.0);
+    color_1 = metal::float3(0.0, 0.0, 0.0);
+    total_1 = 0.0;
+    metal::float2 _e48 = _st_1;
+    param_2 = _e48;
+    float _e49 = rand(param_2);
+    offset_1 = _e49;
+    t_1 = 0.0;
+    uint2 loop_bound_1 = uint2(4294967295u);
+    bool loop_init_1 = true;
+    while(true) {
+        if (metal::all(loop_bound_1 == uint2(0u))) { break; }
+        loop_bound_1 -= uint2(loop_bound_1.y == 0u, 1u);
+        if (!loop_init_1) {
+            float _e79 = t_1;
+            t_1 = _e79 + 1.0;
+        }
+        loop_init_1 = false;
+        float _e50 = t_1;
+        if (_e50 <= 20.0) {
+            float _e52 = t_1;
+            float _e53 = offset_1;
+            percent_1 = (_e52 + _e53) / 20.0;
+            float _e56 = percent_1;
+            float _e57 = percent_1;
+            float _e58 = percent_1;
+            weight_1 = 4.0 * (_e56 - (_e57 * _e58));
+            metal::float2 _e62 = texCoord_1;
+            metal::float2 _e63 = speed_1;
+            float _e64 = percent_1;
+            newuv_1 = _e62 + (_e63 * _e64);
+            metal::float2 _e67 = newuv_1;
+            newuv_1 = metal::fract(_e67);
+            metal::float2 _e69 = newuv_1;
+            param_3 = _e69;
+            metal::float4 _e70 = getFromColor(param_3, _from, _sampler);
+            float _e72 = weight_1;
+            metal::float3 _e74 = color_1;
+            color_1 = _e74 + (_e70.xyz * _e72);
+            float _e76 = weight_1;
+            float _e77 = total_1;
+            total_1 = _e77 + _e76;
+            continue;
+        } else {
+            break;
+        }
+    }
+    metal::float3 _e81 = color_1;
+    float _e82 = total_1;
+    metal::float3 _e84 = _e81 / metal::float3(_e82);
+    return metal::float4(_e84.x, _e84.y, _e84.z, 1.0);
+}
+
+metal::float2 rotateUv(
+    thread metal::float2& uv_2,
+    thread float& angle,
+    thread metal::float2& anchor,
+    thread float& zDirection
+) {
+    float s = {};
+    float c = {};
+    metal::float2x2 m = {};
+    metal::float2 _e41 = uv_2;
+    metal::float2 _e42 = anchor;
+    uv_2 = _e41 - _e42;
+    float _e44 = angle;
+    s = metal::sin(_e44);
+    float _e46 = angle;
+    c = metal::cos(_e46);
+    float _e48 = c;
+    float _e49 = s;
+    float _e51 = s;
+    float _e52 = c;
+    m = metal::float2x2(metal::float2(_e48, -(_e49)), metal::float2(_e51, _e52));
+    metal::float2x2 _e56 = m;
+    metal::float2 _e57 = uv_2;
+    uv_2 = _e56 * _e57;
+    metal::float2 _e59 = anchor;
+    metal::float2 _e60 = uv_2;
+    uv_2 = _e60 + _e59;
+    metal::float2 _e62 = uv_2;
+    return _e62;
+}
+
+float normpdf(
+    thread float& x
+) {
+    float d = {};
+    float _e36 = x;
+    d = _e36 - 0.5;
+    float _e38 = d;
+    float _e40 = d;
+    return metal::exp((-20.0 * _e38) * _e40);
+}
+
+float C(
+    thread float& aA1_
+) {
+    float _e35 = aA1_;
+    return 3.0 * _e35;
+}
+
+float B(
+    thread float& aA1_1,
+    thread float& aA2_
+) {
+    float _e36 = aA2_;
+    float _e38 = aA1_1;
+    return (3.0 * _e36) - (6.0 * _e38);
+}
+
+float A(
+    thread float& aA1_2,
+    thread float& aA2_1
+) {
+    float _e36 = aA2_1;
+    float _e39 = aA1_2;
+    return (1.0 - (3.0 * _e36)) + (3.0 * _e39);
+}
+
+float CalcBezier(
+    thread float& aT,
+    thread float& aA1_3,
+    thread float& aA2_2
+) {
+    float param_4 = {};
+    float param_5 = {};
+    float param_6 = {};
+    float param_7 = {};
+    float param_8 = {};
+    float _e42 = aA1_3;
+    param_4 = _e42;
+    float _e43 = aA2_2;
+    param_5 = _e43;
+    float _e44 = A(param_4, param_5);
+    float _e45 = aT;
+    float _e47 = aA1_3;
+    param_6 = _e47;
+    float _e48 = aA2_2;
+    param_7 = _e48;
+    float _e49 = B(param_6, param_7);
+    float _e51 = aT;
+    float _e53 = aA1_3;
+    param_8 = _e53;
+    float _e54 = C(param_8);
+    float _e56 = aT;
+    return ((((_e44 * _e45) + _e49) * _e51) + _e54) * _e56;
+}
+
+float GetSlope(
+    thread float& aT_1,
+    thread float& aA1_4,
+    thread float& aA2_3
+) {
+    float param_9 = {};
+    float param_10 = {};
+    float param_11 = {};
+    float param_12 = {};
+    float param_13 = {};
+    float _e42 = aA1_4;
+    param_9 = _e42;
+    float _e43 = aA2_3;
+    param_10 = _e43;
+    float _e44 = A(param_9, param_10);
+    float _e46 = aT_1;
+    float _e48 = aT_1;
+    float _e50 = aA1_4;
+    param_11 = _e50;
+    float _e51 = aA2_3;
+    param_12 = _e51;
+    float _e52 = B(param_11, param_12);
+    float _e54 = aT_1;
+    float _e57 = aA1_4;
+    param_13 = _e57;
+    float _e58 = C(param_13);
+    return ((((3.0 * _e44) * _e46) * _e48) + ((2.0 * _e52) * _e54)) + _e58;
+}
+
+float GetTForX(
+    thread float& aX,
+    thread float& mX1_,
+    thread float& mX2_
+) {
+    float aGuessT = {};
+    int i = {};
+    float currentSlope = {};
+    float param_14 = {};
+    float param_15 = {};
+    float param_16 = {};
+    float currentX = {};
+    float param_17 = {};
+    float param_18 = {};
+    float param_19 = {};
+    float _e47 = aX;
+    aGuessT = _e47;
+    i = 0;
+    uint2 loop_bound_2 = uint2(4294967295u);
+    bool loop_init_2 = true;
+    while(true) {
+        if (metal::all(loop_bound_2 == uint2(0u))) { break; }
+        loop_bound_2 -= uint2(loop_bound_2.y == 0u, 1u);
+        if (!loop_init_2) {
+            int _e68 = i;
+            i = as_type<int>(as_type<uint>(_e68) + as_type<uint>(1));
+        }
+        loop_init_2 = false;
+        int _e48 = i;
+        if (_e48 < 4) {
+            float _e50 = aGuessT;
+            param_14 = _e50;
+            float _e51 = mX1_;
+            param_15 = _e51;
+            float _e52 = mX2_;
+            param_16 = _e52;
+            float _e53 = GetSlope(param_14, param_15, param_16);
+            currentSlope = _e53;
+            float _e54 = currentSlope;
+            if (_e54 == 0.0) {
+                float _e56 = aGuessT;
+                return _e56;
+            }
+            float _e57 = aGuessT;
+            param_17 = _e57;
+            float _e58 = mX1_;
+            param_18 = _e58;
+            float _e59 = mX2_;
+            param_19 = _e59;
+            float _e60 = CalcBezier(param_17, param_18, param_19);
+            float _e61 = aX;
+            currentX = _e60 - _e61;
+            float _e63 = currentX;
+            float _e64 = currentSlope;
+            float _e66 = aGuessT;
+            aGuessT = _e66 - (_e63 / _e64);
+            continue;
+        } else {
+            break;
+        }
+    }
+    float _e70 = aGuessT;
+    return _e70;
+}
+
+float KeySpline(
+    thread float& aX_1,
+    thread float& mX1_1,
+    thread float& mY1_,
+    thread float& mX2_1,
+    thread float& mY2_
+) {
+    float param_20 = {};
+    float param_21 = {};
+    float param_22 = {};
+    float param_23 = {};
+    float param_24 = {};
+    float param_25 = {};
+    float _e45 = mX1_1;
+    float _e46 = mY1_;
+    float _e48 = mX2_1;
+    float _e49 = mY2_;
+    if ((_e45 == _e46) && (_e48 == _e49)) {
+        float _e52 = aX_1;
+        return _e52;
+    }
+    float _e53 = aX_1;
+    param_20 = _e53;
+    float _e54 = mX1_1;
+    param_21 = _e54;
+    float _e55 = mX2_1;
+    param_22 = _e55;
+    float _e56 = GetTForX(param_20, param_21, param_22);
+    param_23 = _e56;
+    float _e57 = mY1_;
+    param_24 = _e57;
+    float _e58 = mY2_;
+    param_25 = _e58;
+    float _e59 = CalcBezier(param_23, param_24, param_25);
+    return _e59;
+}
+
+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 myst = {};
+    float animationTime = {};
+    float easingTime = {};
+    float param_26 = {};
+    float param_27 = {};
+    float param_28 = {};
+    float param_29 = {};
+    float param_30 = {};
+    float blur = {};
+    float param_31 = {};
+    float r = {};
+    float rotation = {};
+    metal::float2 mystCurrent = {};
+    metal::float2 param_32 = {};
+    float param_33 = {};
+    metal::float2 param_34 = {};
+    float param_35 = {};
+    float timeInterval = {};
+    metal::float2 mystNext = {};
+    metal::float2 param_36 = {};
+    float param_37 = {};
+    metal::float2 param_38 = {};
+    float param_39 = {};
+    metal::float2 speed_2 = {};
+    metal::float2 param_40 = {};
+    metal::float2 param_41 = {};
+    metal::float2 param_42 = {};
+    metal::float2 param_43 = {};
+    metal::float2 _e63 = uv_3;
+    myst = _e63;
+    float _e65 = uniforms.progress;
+    animationTime = _e65;
+    float _e66 = animationTime;
+    param_26 = _e66;
+    param_27 = 0.68;
+    param_28 = 0.01;
+    param_29 = 0.17;
+    param_30 = 0.98;
+    float _e67 = KeySpline(param_26, param_27, param_28, param_29, param_30);
+    easingTime = _e67;
+    float _e68 = easingTime;
+    param_31 = _e68;
+    float _e69 = normpdf(param_31);
+    blur = _e69;
+    r = 0.0;
+    rotation = 3.14159;
+    float _e70 = easingTime;
+    if (_e70 <= 0.5) {
+        float _e72 = rotation;
+        float _e73 = easingTime;
+        r = _e72 * _e73;
+    } else {
+        float _e75 = rotation;
+        float _e77 = rotation;
+        float _e78 = easingTime;
+        r = -(_e75) + (_e77 * _e78);
+    }
+    metal::float2 _e81 = myst;
+    mystCurrent = _e81;
+    float _e83 = uniforms.ratio;
+    float _e86 = mystCurrent[1u];
+    mystCurrent[1u] = _e86 * (1.0 / _e83);
+    metal::float2 _e89 = mystCurrent;
+    param_32 = _e89;
+    float _e90 = r;
+    param_33 = _e90;
+    param_34 = metal::float2(1.0, 0.0);
+    param_35 = -1.0;
+    metal::float2 _e91 = rotateUv(param_32, param_33, param_34, param_35);
+    mystCurrent = _e91;
+    float _e93 = uniforms.ratio;
+    float _e95 = mystCurrent[1u];
+    mystCurrent[1u] = _e95 * _e93;
+    timeInterval = 0.0334;
+    float _e98 = easingTime;
+    if (_e98 <= 0.5) {
+        float _e100 = rotation;
+        float _e101 = easingTime;
+        float _e102 = timeInterval;
+        r = _e100 * (_e101 + _e102);
+    } else {
+        float _e105 = rotation;
+        float _e107 = rotation;
+        float _e108 = easingTime;
+        float _e109 = timeInterval;
+        r = -(_e105) + (_e107 * (_e108 + _e109));
+    }
+    metal::float2 _e113 = myst;
+    mystNext = _e113;
+    float _e115 = uniforms.ratio;
+    float _e118 = mystNext[1u];
+    mystNext[1u] = _e118 * (1.0 / _e115);
+    metal::float2 _e121 = mystNext;
+    param_36 = _e121;
+    float _e122 = r;
+    param_37 = _e122;
+    param_38 = metal::float2(1.0, 0.0);
+    param_39 = -1.0;
+    metal::float2 _e123 = rotateUv(param_36, param_37, param_38, param_39);
+    mystNext = _e123;
+    float _e125 = uniforms.ratio;
+    float _e127 = mystNext[1u];
+    mystNext[1u] = _e127 * _e125;
+    metal::float2 _e130 = mystNext;
+    metal::float2 _e131 = mystCurrent;
+    float _e133 = timeInterval;
+    float _e136 = blur;
+    speed_2 = (((_e130 - _e131) / metal::float2(_e133)) * _e136) * 0.5;
+    float _e139 = easingTime;
+    if (_e139 <= 0.5) {
+        metal::float2 _e141 = mystCurrent;
+        param_40 = _e141;
+        metal::float2 _e142 = speed_2;
+        param_41 = _e142;
+        metal::float4 _e143 = motionBlurFrom(param_40, param_41, _from, _sampler);
+        return _e143;
+    } else {
+        metal::float2 _e144 = mystCurrent;
+        param_42 = _e144;
+        metal::float2 _e145 = speed_2;
+        param_43 = _e145;
+        metal::float4 _e146 = motionBlurTo(param_42, param_43, _sampler, _to);
+        return _e146;
+    }
+}
+
+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_44 = {};
+    metal::float2 _e35 = _uv_1;
+    param_44 = _e35;
+    metal::float4 _e36 = transition(param_44, _from, _sampler, _to, uniforms);
+    _fragColor = _e36;
+    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 };
+}