gl-transitions 1.74.0 → 1.76.0

package/msl/directionalwarp.metal

@@ -0,0 +1,121 @@
+// directionalwarp — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directionalwarp.glsl
+// Author: pschroen
+// License: MIT
+// Description: A diagonal wipe with a warped, smeared edge
+// 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 direction;
+};
+
+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
+) {
+    metal::float2 v = {};
+    float d = {};
+    float m = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e22 = uniforms.direction;
+    v = metal::normalize(_e22);
+    float _e25 = v[0u];
+    float _e28 = v[1u];
+    metal::float2 _e31 = v;
+    v = _e31 / metal::float2(metal::abs(_e25) + metal::abs(_e28));
+    float _e35 = v[0u];
+    float _e38 = v[1u];
+    d = (_e35 * 0.5) + (_e38 * 0.5);
+    float _e42 = uniforms.smoothness;
+    float _e45 = v[0u];
+    float _e47 = uv_2[0u];
+    float _e50 = v[1u];
+    float _e52 = uv_2[1u];
+    float _e55 = d;
+    float _e58 = uniforms.progress;
+    float _e60 = uniforms.smoothness;
+    m = 1.0 - metal::smoothstep(-(_e42), 0.0, ((_e45 * _e47) + (_e50 * _e52)) - ((_e55 - 0.5) + (_e58 * (1.0 + _e60))));
+    metal::float2 _e67 = uv_2;
+    float _e70 = m;
+    param = ((_e67 - metal::float2(0.5)) * (1.0 - _e70)) + metal::float2(0.5);
+    metal::float4 _e75 = getFromColor(param, _from, _sampler);
+    metal::float2 _e76 = uv_2;
+    float _e79 = m;
+    param_1 = ((_e76 - metal::float2(0.5)) * _e79) + metal::float2(0.5);
+    metal::float4 _e83 = getToColor(param_1, _sampler, _to);
+    float _e84 = m;
+    return metal::mix(_e75, _e83, metal::float4(_e84));
+}
+
+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/directionalwipe.metal

@@ -0,0 +1,120 @@
+// directionalwipe — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/directionalwipe.glsl
+// Author: gre
+// License: MIT
+// Description: A soft-edged diagonal wipe
+// 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::float2 direction;
+    float smoothness;
+    char _pad4[4];
+};
+
+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
+) {
+    metal::float2 v = {};
+    float d = {};
+    float m = {};
+    metal::float2 param = {};
+    metal::float2 param_1 = {};
+    metal::float2 _e22 = uniforms.direction;
+    v = metal::normalize(_e22);
+    float _e25 = v[0u];
+    float _e28 = v[1u];
+    metal::float2 _e31 = v;
+    v = _e31 / metal::float2(metal::abs(_e25) + metal::abs(_e28));
+    float _e35 = v[0u];
+    float _e38 = v[1u];
+    d = (_e35 * 0.5) + (_e38 * 0.5);
+    float _e42 = uniforms.progress;
+    float _e46 = uniforms.smoothness;
+    float _e49 = v[0u];
+    float _e51 = uv_2[0u];
+    float _e54 = v[1u];
+    float _e56 = uv_2[1u];
+    float _e59 = d;
+    float _e62 = uniforms.progress;
+    float _e64 = uniforms.smoothness;
+    m = (1.0 - metal::step(_e42, 0.0)) * (1.0 - metal::smoothstep(-(_e46), 0.0, ((_e49 * _e51) + (_e54 * _e56)) - ((_e59 - 0.5) + (_e62 * (1.0 + _e64)))));
+    metal::float2 _e72 = uv_2;
+    param = _e72;
+    metal::float4 _e73 = getFromColor(param, _from, _sampler);
+    metal::float2 _e74 = uv_2;
+    param_1 = _e74;
+    metal::float4 _e75 = getToColor(param_1, _sampler, _to);
+    float _e76 = m;
+    return metal::mix(_e73, _e75, metal::float4(_e76));
+}
+
+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/displacement.metal

@@ -0,0 +1,129 @@
+// displacement — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/displacement.glsl
+// Author: Travis Fischer
+// License: MIT
+// Description: A crossfade in which a displacement map (an extra grayscale texture) warps 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;
+    float strength;
+};
+
+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 _texture_displacementMap(
+    thread metal::float2& uv_2,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> displacementMap
+) {
+    float _e15 = uv_2[0u];
+    float _e17 = uv_2[1u];
+    metal::float4 _e20 = displacementMap.sample(_sampler, metal::float2(_e15, 1.0 - _e17), metal::level(0.0));
+    return _e20;
+}
+
+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,
+    metal::texture2d<float, metal::access::sample> displacementMap,
+    constant Uniforms& uniforms
+) {
+    float displacement = {};
+    metal::float2 param = {};
+    metal::float2 uvFrom = {};
+    metal::float2 uvTo = {};
+    metal::float2 param_1 = {};
+    metal::float2 param_2 = {};
+    metal::float2 _e20 = uv_3;
+    param = _e20;
+    metal::float4 _e21 = _texture_displacementMap(param, _sampler, displacementMap);
+    float _e24 = uniforms.strength;
+    displacement = _e21.x * _e24;
+    float _e27 = uv_3[0u];
+    float _e29 = uniforms.progress;
+    float _e30 = displacement;
+    float _e34 = uv_3[1u];
+    uvFrom = metal::float2(_e27 + (_e29 * _e30), _e34);
+    float _e37 = uv_3[0u];
+    float _e39 = uniforms.progress;
+    float _e41 = displacement;
+    float _e45 = uv_3[1u];
+    uvTo = metal::float2(_e37 - ((1.0 - _e39) * _e41), _e45);
+    metal::float2 _e47 = uvFrom;
+    param_1 = _e47;
+    metal::float4 _e48 = getFromColor(param_1, _from, _sampler);
+    metal::float2 _e49 = uvTo;
+    param_2 = _e49;
+    metal::float4 _e50 = getToColor(param_2, _sampler, _to);
+    float _e52 = uniforms.progress;
+    return metal::mix(_e48, _e50, metal::float4(_e52));
+}
+
+void main_1(
+    metal::texture2d<float, metal::access::sample> _from,
+    metal::sampler _sampler,
+    metal::texture2d<float, metal::access::sample> _to,
+    metal::texture2d<float, metal::access::sample> displacementMap,
+    constant Uniforms& uniforms,
+    thread metal::float4& _fragColor,
+    thread metal::float2& _uv_1
+) {
+    metal::float2 param_3 = {};
+    metal::float2 _e14 = _uv_1;
+    param_3 = _e14;
+    metal::float4 _e15 = transition(param_3, _from, _sampler, _to, displacementMap, 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)]]
+, metal::texture2d<float, metal::access::sample> displacementMap [[texture(2)]]
+, 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, displacementMap, uniforms, _fragColor, _uv_1);
+    metal::float4 _e3 = _fragColor;
+    return main_Output { _e3 };
+}

package/msl/dissolve.metal

@@ -0,0 +1,146 @@
+// dissolve — MSL, generated from https://github.com/gl-transitions/gl-transitions/blob/master/transitions/dissolve.glsl
+// Author: hjm1fb
+// License: MIT
+// Description: The incoming image spreads over the outgoing one with a hot, glowing edge
+// 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 uLineWidth;
+    char _pad3[4];
+    metal::float3 uSpreadClr;
+    metal::packed_float3 uHotClr;
+    float uPow;
+    float uIntensity;
+    char _pad7[12];
+};
+
+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
+) {
+    metal::float4 from = {};
+    metal::float2 param = {};
+    metal::float4 to = {};
+    metal::float2 param_1 = {};
+    float burn = {};
+    float show = {};
+    metal::float4 outColor = {};
+    float factor = {};
+    metal::float3 burnColor = {};
+    metal::float3 finalRGB = {};
+    metal::float2 _e35 = uv_2;
+    param = _e35;
+    metal::float4 _e36 = getFromColor(param, _from, _sampler);
+    from = _e36;
+    metal::float2 _e37 = uv_2;
+    param_1 = _e37;
+    metal::float4 _e38 = getToColor(param_1, _sampler, _to);
+    to = _e38;
+    float _e40 = from[0u];
+    float _e43 = from[1u];
+    float _e47 = from[2u];
+    burn = 0.5 + (0.5 * (((0.299 * _e40) + (0.587 * _e43)) + (0.114 * _e47)));
+    float _e52 = burn;
+    float _e54 = uniforms.progress;
+    show = _e52 - _e54;
+    float _e56 = show;
+    if (_e56 < 0.001) {
+        metal::float4 _e58 = to;
+        outColor = _e58;
+    } else {
+        float _e60 = uniforms.uLineWidth;
+        float _e61 = show;
+        factor = 1.0 - metal::smoothstep(0.0, _e60, _e61);
+        metal::float3 _e65 = uniforms.uSpreadClr;
+        metal::float3 _e67 = uniforms.uHotClr;
+        float _e68 = factor;
+        burnColor = metal::mix(_e65, _e67, metal::float3(_e68));
+        metal::float3 _e71 = burnColor;
+        float _e73 = uniforms.uPow;
+        float _e77 = uniforms.uIntensity;
+        burnColor = metal::pow(_e71, metal::float3(_e73)) * _e77;
+        metal::float4 _e79 = from;
+        metal::float3 _e81 = burnColor;
+        float _e82 = factor;
+        float _e84 = uniforms.progress;
+        finalRGB = metal::mix(_e79.xyz, _e81, metal::float3(_e82 * metal::step(0.0001, _e84)));
+        metal::float3 _e89 = finalRGB;
+        float _e91 = from[3u];
+        metal::float3 _e92 = _e89 * _e91;
+        float _e94 = from[3u];
+        outColor = metal::float4(_e92.x, _e92.y, _e92.z, _e94);
+    }
+    metal::float4 _e99 = outColor;
+    return _e99;
+}
+
+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 _e25 = _uv_1;
+    param_2 = _e25;
+    metal::float4 _e26 = transition(param_2, _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 };
+}