gl-transitions 1.74.0 → 1.76.0

package/msl/Slides.metal

@@ -0,0 +1,244 @@
+// Slides — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/Slides.glsl
+// Author: Mark Craig
+// License: MIT
+// Description: The outgoing image slides out, or the incoming one slides in, toward an edge, a corner or the center
+// 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 type;
+    int In;
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e23 = uv[0u];
+    float _e25 = uv[1u];
+    metal::float4 _e28 = _from.sample(_sampler, metal::float2(_e23, 1.0 - _e25), metal::level(0.0));
+    return _e28;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e23 = uv_1[0u];
+    float _e25 = uv_1[1u];
+    metal::float4 _e28 = _to.sample(_sampler, metal::float2(_e23, 1.0 - _e25), metal::level(0.0));
+    return _e28;
+}
+
+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 uv0_ = {};
+    float rad = {};
+    float local = {};
+    float xc1_ = {};
+    float yc1_ = {};
+    metal::float2 uv2_ = {};
+    metal::float4 local_1 = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float4 local_2 = {};
+    metal::float2 param_2 = {};
+    metal::float2 param_3 = {};
+    bool phi_193_ = {};
+    bool phi_200_ = {};
+    bool phi_209_ = {};
+    metal::float2 _e34 = uv_2;
+    uv0_ = _e34;
+    int _e36 = uniforms.In;
+    if (_e36 != 0) {
+        float _e39 = uniforms.progress;
+        local = _e39;
+    } else {
+        float _e41 = uniforms.progress;
+        local = 1.0 - _e41;
+    }
+    float _e43 = local;
+    rad = _e43;
+    int _e45 = uniforms.type;
+    if (_e45 == 0) {
+        float _e47 = rad;
+        xc1_ = 0.5 - (_e47 / 2.0);
+        yc1_ = 0.0;
+    } else {
+        int _e51 = uniforms.type;
+        if (_e51 == 1) {
+            float _e53 = rad;
+            xc1_ = 1.0 - _e53;
+            float _e55 = rad;
+            yc1_ = 0.5 - (_e55 / 2.0);
+        } else {
+            int _e59 = uniforms.type;
+            if (_e59 == 2) {
+                float _e61 = rad;
+                xc1_ = 0.5 - (_e61 / 2.0);
+                float _e64 = rad;
+                yc1_ = 1.0 - _e64;
+            } else {
+                int _e67 = uniforms.type;
+                if (_e67 == 3) {
+                    xc1_ = 0.0;
+                    float _e69 = rad;
+                    yc1_ = 0.5 - (_e69 / 2.0);
+                } else {
+                    int _e73 = uniforms.type;
+                    if (_e73 == 4) {
+                        float _e75 = rad;
+                        xc1_ = 1.0 - _e75;
+                        yc1_ = 0.0;
+                    } else {
+                        int _e78 = uniforms.type;
+                        if (_e78 == 5) {
+                            float _e80 = rad;
+                            xc1_ = 1.0 - _e80;
+                            float _e82 = rad;
+                            yc1_ = 1.0 - _e82;
+                        } else {
+                            int _e85 = uniforms.type;
+                            if (_e85 == 6) {
+                                xc1_ = 0.0;
+                                float _e87 = rad;
+                                yc1_ = 1.0 - _e87;
+                            } else {
+                                int _e90 = uniforms.type;
+                                if (_e90 == 7) {
+                                    xc1_ = 0.0;
+                                    yc1_ = 0.0;
+                                } else {
+                                    int _e93 = uniforms.type;
+                                    if (_e93 == 8) {
+                                        float _e95 = rad;
+                                        xc1_ = 0.5 - (_e95 / 2.0);
+                                        float _e98 = rad;
+                                        yc1_ = 0.5 - (_e98 / 2.0);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    float _e102 = uv_2[1u];
+    uv_2[1u] = 1.0 - _e102;
+    float _e106 = uv_2[0u];
+    float _e107 = xc1_;
+    bool _e108 = _e106 >= _e107;
+    phi_193_ = _e108;
+    if (_e108) {
+        float _e110 = uv_2[0u];
+        float _e111 = xc1_;
+        float _e112 = rad;
+        phi_193_ = _e110 <= (_e111 + _e112);
+    }
+    bool _e116 = phi_193_;
+    phi_200_ = _e116;
+    if (_e116) {
+        float _e118 = uv_2[1u];
+        float _e119 = yc1_;
+        phi_200_ = _e118 >= _e119;
+    }
+    bool _e122 = phi_200_;
+    phi_209_ = _e122;
+    if (_e122) {
+        float _e124 = uv_2[1u];
+        float _e125 = yc1_;
+        float _e126 = rad;
+        phi_209_ = _e124 <= (_e125 + _e126);
+    }
+    bool _e130 = phi_209_;
+    if (_e130) {
+        float _e132 = uv_2[0u];
+        float _e133 = xc1_;
+        float _e135 = rad;
+        float _e138 = uv_2[1u];
+        float _e139 = yc1_;
+        float _e141 = rad;
+        uv2_ = metal::float2((_e132 - _e133) / _e135, 1.0 - ((_e138 - _e139) / _e141));
+        int _e146 = uniforms.In;
+        if (_e146 != 0) {
+            metal::float2 _e148 = uv2_;
+            param = _e148;
+            metal::float4 _e149 = getToColor(param, _sampler, _to);
+            local_1 = _e149;
+        } else {
+            metal::float2 _e150 = uv2_;
+            param_1 = _e150;
+            metal::float4 _e151 = getFromColor(param_1, _from, _sampler);
+            local_1 = _e151;
+        }
+        metal::float4 _e152 = local_1;
+        return _e152;
+    }
+    int _e154 = uniforms.In;
+    if (_e154 != 0) {
+        metal::float2 _e156 = uv0_;
+        param_2 = _e156;
+        metal::float4 _e157 = getFromColor(param_2, _from, _sampler);
+        local_2 = _e157;
+    } else {
+        metal::float2 _e158 = uv0_;
+        param_3 = _e158;
+        metal::float4 _e159 = getToColor(param_3, _sampler, _to);
+        local_2 = _e159;
+    }
+    metal::float4 _e160 = local_2;
+    return _e160;
+}
+
+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 _e22 = _uv_1;
+    param_4 = _e22;
+    metal::float4 _e23 = transition(param_4, _from, _sampler, _to, uniforms);
+    _fragColor = _e23;
+    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/StarWipe.metal

@@ -0,0 +1,204 @@
+// StarWipe — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StarWipe.glsl
+// Author: Ben Lucas
+// License: MIT
+// Description: A growing star reveals 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 border_thickness;
+    float star_rotation;
+    metal::float4 border_color;
+    metal::float2 star_center;
+    char _pad6[8];
+};
+
+metal::float4 getFromColor(
+    thread metal::float2& uv,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e23 = uv[0u];
+    float _e25 = uv[1u];
+    metal::float4 _e28 = _from.sample(_sampler, metal::float2(_e23, 1.0 - _e25), metal::level(0.0));
+    return _e28;
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv_1,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e23 = uv_1[0u];
+    float _e25 = uv_1[1u];
+    metal::float4 _e28 = _to.sample(_sampler, metal::float2(_e23, 1.0 - _e25), metal::level(0.0));
+    return _e28;
+}
+
+metal::float2 rotate(
+    thread metal::float2& v,
+    thread float& theta
+) {
+    float cosTheta = {};
+    float sinTheta = {};
+    float _e25 = theta;
+    cosTheta = metal::cos(_e25);
+    float _e27 = theta;
+    sinTheta = metal::sin(_e27);
+    float _e29 = cosTheta;
+    float _e31 = v[0u];
+    float _e33 = sinTheta;
+    float _e35 = v[1u];
+    float _e38 = sinTheta;
+    float _e40 = v[0u];
+    float _e42 = cosTheta;
+    float _e44 = v[1u];
+    return metal::float2((_e29 * _e31) - (_e33 * _e35), (_e38 * _e40) + (_e42 * _e44));
+}
+
+bool inStar(
+    thread metal::float2& uv_2,
+    thread metal::float2& center,
+    thread float& radius,
+    constant Uniforms& uniforms
+) {
+    metal::float2 uv_centered = {};
+    metal::float2 param = {};
+    float param_1 = {};
+    float theta_1 = {};
+    metal::float2 uv_rotated = {};
+    metal::float2 param_2 = {};
+    float param_3 = {};
+    float slope = {};
+    metal::float2 _e32 = uv_2;
+    metal::float2 _e33 = center;
+    uv_centered = _e32 - _e33;
+    float _e36 = uniforms.star_rotation;
+    metal::float2 _e38 = uv_centered;
+    param = _e38;
+    param_1 = _e36 * 1.2566371;
+    metal::float2 _e39 = rotate(param, param_1);
+    uv_centered = _e39;
+    float _e41 = uv_centered[1u];
+    float _e43 = uv_centered[0u];
+    theta_1 = metal::atan2(_e41, _e43) + 3.1415927;
+    float _e46 = theta_1;
+    metal::float2 _e51 = uv_centered;
+    param_2 = _e51;
+    param_3 = -1.2566371 * (metal::floor(_e46 / 1.2566371) + 0.5);
+    metal::float2 _e52 = rotate(param_2, param_3);
+    uv_rotated = _e52;
+    slope = 0.3;
+    float _e54 = uv_rotated[1u];
+    if (_e54 > 0.0) {
+        float _e56 = radius;
+        float _e58 = uv_rotated[0u];
+        float _e59 = slope;
+        float _e63 = uv_rotated[1u];
+        return (_e56 + (_e58 * _e59)) > _e63;
+    } else {
+        float _e65 = radius;
+        float _e68 = uv_rotated[0u];
+        float _e69 = slope;
+        float _e73 = uv_rotated[1u];
+        return (-(_e65) - (_e68 * _e69)) < _e73;
+    }
+}
+
+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
+) {
+    float progressScaled = {};
+    metal::float2 param_4 = {};
+    metal::float2 param_5 = {};
+    float param_6 = {};
+    metal::float2 param_7 = {};
+    metal::float2 param_8 = {};
+    metal::float2 param_9 = {};
+    float param_10 = {};
+    metal::float2 param_11 = {};
+    float _e32 = uniforms.border_thickness;
+    float _e36 = uniforms.progress;
+    float _e39 = uniforms.border_thickness;
+    progressScaled = (((2.0 * _e32) + 1.0) * _e36) - _e39;
+    metal::float2 _e41 = uv_3;
+    param_4 = _e41;
+    metal::float2 _e43 = uniforms.star_center;
+    param_5 = _e43;
+    float _e44 = progressScaled;
+    param_6 = _e44;
+    bool _e45 = inStar(param_4, param_5, param_6, uniforms);
+    if (_e45) {
+        metal::float2 _e46 = uv_3;
+        param_7 = _e46;
+        metal::float4 _e47 = getToColor(param_7, _sampler, _to);
+        return _e47;
+    } else {
+        float _e48 = progressScaled;
+        float _e50 = uniforms.border_thickness;
+        metal::float2 _e52 = uv_3;
+        param_8 = _e52;
+        metal::float2 _e54 = uniforms.star_center;
+        param_9 = _e54;
+        param_10 = _e48 + _e50;
+        bool _e55 = inStar(param_8, param_9, param_10, uniforms);
+        if (_e55) {
+            metal::float4 _e57 = uniforms.border_color;
+            return _e57;
+        } else {
+            metal::float2 _e58 = uv_3;
+            param_11 = _e58;
+            metal::float4 _e59 = getFromColor(param_11, _from, _sampler);
+            return _e59;
+        }
+    }
+}
+
+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_12 = {};
+    metal::float2 _e22 = _uv_1;
+    param_12 = _e22;
+    metal::float4 _e23 = transition(param_12, _from, _sampler, _to, uniforms);
+    _fragColor = _e23;
+    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/StaticFade.metal

@@ -0,0 +1,193 @@
+// StaticFade — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/StaticFade.glsl
+// Author: Ben Lucas
+// License: MIT
+// Description: Cuts to the incoming image halfway, hidden behind a burst of TV static
+// 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 n_noise_pixels;
+    float static_luminosity;
+};
+
+float rnd(
+    thread metal::float2& st
+) {
+    metal::float2 _e25 = st;
+    return metal::fract(metal::sin(metal::dot(_e25, metal::float2(10.530234, 70.23493))) * 12345.545);
+}
+
+float staticIntensity(
+    thread float& t
+) {
+    float transitionProgress = {};
+    float transformedThreshold = {};
+    float _e27 = t;
+    transitionProgress = metal::abs(2.0 * (_e27 - 0.5));
+    float _e31 = transitionProgress;
+    transformedThreshold = (1.2 * (1.0 - _e31)) - 0.1;
+    float _e35 = transformedThreshold;
+    return metal::min(1.0, _e35);
+}
+
+metal::float4 staticNoise(
+    thread metal::float2& st_1,
+    thread float& offset,
+    thread float& luminosity
+) {
+    float staticR = {};
+    metal::float2 param = {};
+    float staticG = {};
+    metal::float2 param_1 = {};
+    float staticB = {};
+    metal::float2 param_2 = {};
+    float _e33 = luminosity;
+    metal::float2 _e34 = st_1;
+    float _e35 = offset;
+    float _e37 = offset;
+    param = _e34 * metal::float2(_e35 * 2.0, _e37 * 3.0);
+    float _e41 = rnd(param);
+    staticR = _e33 * _e41;
+    float _e43 = luminosity;
+    metal::float2 _e44 = st_1;
+    float _e45 = offset;
+    float _e47 = offset;
+    param_1 = _e44 * metal::float2(_e45 * 3.0, _e47 * 5.0);
+    float _e51 = rnd(param_1);
+    staticG = _e43 * _e51;
+    float _e53 = luminosity;
+    metal::float2 _e54 = st_1;
+    float _e55 = offset;
+    float _e57 = offset;
+    param_2 = _e54 * metal::float2(_e55 * 5.0, _e57 * 7.0);
+    float _e61 = rnd(param_2);
+    staticB = _e53 * _e61;
+    float _e63 = staticR;
+    float _e64 = staticG;
+    float _e65 = staticB;
+    return metal::float4(_e63, _e64, _e65, 1.0);
+}
+
+metal::float4 getToColor(
+    thread metal::float2& uv,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to
+) {
+    float _e26 = uv[0u];
+    float _e28 = uv[1u];
+    metal::float4 _e31 = _to.sample(_sampler, metal::float2(_e26, 1.0 - _e28), metal::level(0.0));
+    return _e31;
+}
+
+metal::float4 getFromColor(
+    thread metal::float2& uv_1,
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler
+) {
+    float _e26 = uv_1[0u];
+    float _e28 = uv_1[1u];
+    metal::float4 _e31 = _from.sample(_sampler, metal::float2(_e26, 1.0 - _e28), metal::level(0.0));
+    return _e31;
+}
+
+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 baseMix = {};
+    metal::float4 transitionMix = {};
+    metal::float2 param_3 = {};
+    metal::float2 param_4 = {};
+    metal::float2 uvStatic = {};
+    metal::float4 staticColor = {};
+    metal::float2 param_5 = {};
+    float param_6 = {};
+    float param_7 = {};
+    float staticThresh = {};
+    float param_8 = {};
+    float staticMix = {};
+    metal::float2 param_9 = {};
+    float _e39 = uniforms.progress;
+    baseMix = metal::step(0.5, _e39);
+    metal::float2 _e41 = uv_2;
+    param_3 = _e41;
+    metal::float4 _e42 = getFromColor(param_3, _from, _sampler);
+    metal::float2 _e43 = uv_2;
+    param_4 = _e43;
+    metal::float4 _e44 = getToColor(param_4, _sampler, _to);
+    float _e45 = baseMix;
+    transitionMix = metal::mix(_e42, _e44, metal::float4(_e45));
+    metal::float2 _e48 = uv_2;
+    float _e50 = uniforms.n_noise_pixels;
+    float _e54 = uniforms.n_noise_pixels;
+    uvStatic = metal::floor(_e48 * _e50) / metal::float2(_e54);
+    metal::float2 _e57 = uvStatic;
+    param_5 = _e57;
+    float _e59 = uniforms.progress;
+    param_6 = _e59;
+    float _e61 = uniforms.static_luminosity;
+    param_7 = _e61;
+    metal::float4 _e62 = staticNoise(param_5, param_6, param_7);
+    staticColor = _e62;
+    float _e64 = uniforms.progress;
+    param_8 = _e64;
+    float _e65 = staticIntensity(param_8);
+    staticThresh = _e65;
+    metal::float2 _e66 = uvStatic;
+    param_9 = _e66;
+    float _e67 = rnd(param_9);
+    float _e68 = staticThresh;
+    staticMix = metal::step(_e67, _e68);
+    metal::float4 _e70 = transitionMix;
+    metal::float4 _e71 = staticColor;
+    float _e72 = staticMix;
+    return metal::mix(_e70, _e71, metal::float4(_e72));
+}
+
+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_10 = {};
+    metal::float2 _e25 = _uv_1;
+    param_10 = _e25;
+    metal::float4 _e26 = transition(param_10, _from, _sampler, _to, uniforms);
+    _fragColor = _e26;
+    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 };
+}