react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

package/ios/KaleidoscopeModule/shaders/GENERATIVE.txt

@@ -0,0 +1,9 @@
+anamorphic-lensflare
+clouds
+corporate-blobs
+fireflies
+godrays
+light-beams-and-motes
+nebula
+plasma
+simianlights

package/ios/KaleidoscopeModule/shaders/SHADERS.txt

@@ -1,6 +1,17 @@
-blur.frag
-composite.frag
+anamorphic-lensflare.frag
+clouds.frag
+composite-blit.frag
+composite-blur.frag
+composite-camera.frag
+composite-image.frag
+composite-masked.frag
+composite-subject.frag
+corporate-blobs.frag
+fireflies.frag
+godrays.frag
+light-beams-and-motes.frag
 nebula.frag
 passthrough.vert
+plasma.frag
 simianlights.frag
 transform.frag

package/ios/KaleidoscopeModule/shaders/anamorphic-lensflare.metalsrc

@@ -0,0 +1,47 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant float& uTime [[buffer(0)]], constant float& uFlareX [[buffer(1)]], constant float& uFlareY [[buffer(2)]], constant float3& uWarmColor [[buffer(3)]], constant float3& uBlueColor [[buffer(4)]], constant float& uStreakWidth [[buffer(5)]], constant float& uStreakLength [[buffer(6)]], constant float3& uPinkColor [[buffer(7)]], constant float& uGhostStrength [[buffer(8)]], constant float& uIntensity [[buffer(9)]])
+{
+    main0_out out = {};
+    float _86 = uFlareX + (sin(uTime * 0.180000007152557373046875) * 0.100000001490116119384765625);
+    float2 _89 = float2(_86, uFlareY);
+    float _430 = length(in.vUv - _89);
+    float _438 = exp((_430 * (-45.4545440673828125)) * (_430 * 45.4545440673828125));
+    float _454 = exp((_430 * (-10.5263156890869140625)) * (_430 * 10.5263156890869140625));
+    float _470 = exp((_430 * (-3.5714285373687744140625)) * (_430 * 3.5714285373687744140625));
+    float _173 = 0.85000002384185791015625 + (0.1500000059604644775390625 * sin((uTime * 0.699999988079071044921875) + (in.vUv.x * 8.0)));
+    float _480 = abs(in.vUv.y - uFlareY);
+    float _491 = -abs(in.vUv.x - _86);
+    float _497 = exp((-_480) * uStreakWidth) * exp(_491 * uStreakLength);
+    float _524 = exp(_480 * (-70.0)) * exp(_491 * (uStreakLength * 0.64999997615814208984375));
+    float2 _229 = _89 + float2(0.0, 0.01200000010430812835693359375);
+    float _551 = exp(abs(in.vUv.y - _229.y) * (-260.0)) * exp((-abs(in.vUv.x - _229.x)) * (uStreakLength * 0.699999988079071044921875));
+    float2 _243 = _89 - float2(0.0, 0.00999999977648258209228515625);
+    float _578 = exp(abs(in.vUv.y - _243.y) * (-240.0)) * exp((-abs(in.vUv.x - _243.x)) * (uStreakLength * 0.800000011920928955078125));
+    float2 _280 = float2(0.5) - _89;
+    float _586 = length(in.vUv - (_89 + (_280 * 0.449999988079071044921875)));
+    float _594 = exp((_586 * (-14.28571414947509765625)) * (_586 * 14.28571414947509765625));
+    float _602 = length(in.vUv - (_89 + (_280 * 0.85000002384185791015625)));
+    float _610 = exp((_602 * (-8.695652008056640625)) * (_602 * 8.695652008056640625));
+    float _618 = length(in.vUv - (_89 + (_280 * 1.2799999713897705078125)));
+    float _626 = exp((_618 * (-18.1818180084228515625)) * (_618 * 18.1818180084228515625));
+    float _634 = length(in.vUv - (_89 - (_280 * 0.3499999940395355224609375)));
+    float _642 = exp((_634 * (-10.5263156890869140625)) * (_634 * 10.5263156890869140625));
+    float _404 = uIntensity * (0.9700000286102294921875 + (0.02999999932944774627685546875 * sin(uTime * 2.099999904632568359375)));
+    out.oColor = float4(((((((((((((float3(1.0) * _438) * 1.7999999523162841796875) + ((uWarmColor * _454) * 0.949999988079071044921875)) + ((uBlueColor * _470) * 0.1599999964237213134765625)) + (((uWarmColor * _497) * 1.14999997615814208984375) * _173)) + (((uBlueColor * _524) * 0.2599999904632568359375) * _173)) + ((uBlueColor * _551) * 0.2199999988079071044921875)) + ((uPinkColor * _578) * 0.1599999964237213134765625)) + (((uPinkColor * _594) * 0.180000007152557373046875) * uGhostStrength)) + (((uBlueColor * _610) * 0.1500000059604644775390625) * uGhostStrength)) + (((uWarmColor * _626) * 0.2199999988079071044921875) * uGhostStrength)) + (((uBlueColor * _642) * 0.100000001490116119384765625) * uGhostStrength)) * _404, fast::clamp(((((((((((_438 * 0.449999988079071044921875) + (_454 * 0.2199999988079071044921875)) + (_470 * 0.04500000178813934326171875)) + (_497 * 0.180000007152557373046875)) + (_524 * 0.054999999701976776123046875)) + ((_551 + _578) * 0.0350000001490116119384765625)) + ((_594 * 0.039999999105930328369140625) * uGhostStrength)) + ((_610 * 0.0350000001490116119384765625) * uGhostStrength)) + ((_626 * 0.0500000007450580596923828125) * uGhostStrength)) + ((_642 * 0.02999999932944774627685546875) * uGhostStrength)) * _404, 0.0, 1.0));
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/clouds.metalsrc

@@ -0,0 +1,185 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant float& uTime [[buffer(0)]], constant float& uCloudSpeed [[buffer(1)]], constant float& uCloudScale [[buffer(2)]], constant float& uCoverage [[buffer(3)]], constant float& uSoftness [[buffer(4)]], constant float2& uResolution [[buffer(5)]], constant float3& uSkyLowColor [[buffer(6)]], constant float3& uSkyHighColor [[buffer(7)]], constant float& uStepSize [[buffer(8)]], constant float3& uCloudDarkColor [[buffer(9)]], constant float3& uCloudLightColor [[buffer(10)]], constant float& uDensity [[buffer(11)]], constant float& uExposure [[buffer(12)]])
+{
+    main0_out out = {};
+    float2 _258 = in.vUv * uResolution;
+    float3 _277 = normalize(float3((_258 - (uResolution * 0.5)) / float2(uResolution.y), 1.5));
+    float _280 = _277.y;
+    int _864;
+    float _865;
+    float _877;
+    float3 _883;
+    _883 = float3(0.0);
+    _877 = 0.0;
+    _865 = fract(sin(dot(_258, float2(127.09999847412109375, 311.70001220703125))) * 43758.546875) * uStepSize;
+    _864 = 0;
+    float _385;
+    float _891;
+    float3 _898;
+    float3 _899;
+    float _900;
+    for (;;)
+    {
+        if (_864 < 48)
+        {
+            float3 _316 = float3(0.0, 1.2000000476837158203125, -4.0) + (_277 * _865);
+            bool _319 = _280 > 0.0;
+            bool _325;
+            if (_319)
+            {
+                _325 = _316.y >= 3.0;
+            }
+            else
+            {
+                _325 = _319;
+            }
+            if (_325)
+            {
+                _900 = _877;
+                _898 = _883;
+                break;
+            }
+            bool _331 = _280 < 0.0;
+            bool _337;
+            if (_331)
+            {
+                _337 = _316.y <= 0.0;
+            }
+            else
+            {
+                _337 = _331;
+            }
+            if (_337)
+            {
+                _900 = _877;
+                _898 = _883;
+                break;
+            }
+            float _872;
+            do
+            {
+                float _444 = uTime * uCloudSpeed;
+                float3 _451 = _316 + float3(_444, 0.0, _444 * 0.3499999940395355224609375);
+                float _453 = _451.y;
+                bool _454 = _453 <= 0.0;
+                bool _461;
+                if (!_454)
+                {
+                    _461 = _453 >= 3.0;
+                }
+                else
+                {
+                    _461 = _454;
+                }
+                if (_461)
+                {
+                    _872 = 0.0;
+                    break;
+                }
+                int _867;
+                float _868;
+                float _870;
+                float3 _871;
+                _871 = _451 * uCloudScale;
+                _870 = 0.5;
+                _868 = 0.0;
+                _867 = 0;
+                for (; _867 < 5; )
+                {
+                    float3 _527 = floor(_871);
+                    float3 _529 = fract(_871);
+                    float3 _537 = (_529 * _529) * (float3(3.0) - (_529 * 2.0));
+                    float3 _591 = fract((_527 * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _593 = _591.x;
+                    float _595 = _591.y;
+                    float _598 = _591.z;
+                    float3 _618 = fract(((_527 + float3(1.0, 0.0, 0.0)) * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _620 = _618.x;
+                    float _622 = _618.y;
+                    float _625 = _618.z;
+                    float _545 = _537.x;
+                    float3 _645 = fract(((_527 + float3(0.0, 1.0, 0.0)) * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _647 = _645.x;
+                    float _649 = _645.y;
+                    float _652 = _645.z;
+                    float3 _672 = fract(((_527 + float3(1.0, 1.0, 0.0)) * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _674 = _672.x;
+                    float _676 = _672.y;
+                    float _679 = _672.z;
+                    float _557 = _537.y;
+                    float3 _699 = fract(((_527 + float3(0.0, 0.0, 1.0)) * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _701 = _699.x;
+                    float _703 = _699.y;
+                    float _706 = _699.z;
+                    float3 _726 = fract(((_527 + float3(1.0, 0.0, 1.0)) * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _728 = _726.x;
+                    float _730 = _726.y;
+                    float _733 = _726.z;
+                    float3 _753 = fract(((_527 + float3(0.0, 1.0, 1.0)) * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _755 = _753.x;
+                    float _757 = _753.y;
+                    float _760 = _753.z;
+                    float3 _780 = fract(((_527 + float3(1.0)) * 0.31830990314483642578125) + float3(0.100000001490116119384765625)) * 17.0;
+                    float _782 = _780.x;
+                    float _784 = _780.y;
+                    float _787 = _780.z;
+                    float _502 = _870 * mix(mix(mix(fract(((_593 * _595) * _598) * ((_593 + _595) + _598)), fract(((_620 * _622) * _625) * ((_620 + _622) + _625)), _545), mix(fract(((_647 * _649) * _652) * ((_647 + _649) + _652)), fract(((_674 * _676) * _679) * ((_674 + _676) + _679)), _545), _557), mix(mix(fract(((_701 * _703) * _706) * ((_701 + _703) + _706)), fract(((_728 * _730) * _733) * ((_728 + _730) + _733)), _545), mix(fract(((_755 * _757) * _760) * ((_755 + _757) + _760)), fract(((_782 * _784) * _787) * ((_782 + _784) + _787)), _545), _557), _537.z);
+                    _871 *= 2.0299999713897705078125;
+                    _870 *= 0.5;
+                    _868 += _502;
+                    _867++;
+                    continue;
+                }
+                _872 = smoothstep(uCoverage, uCoverage + uSoftness, _868) * (smoothstep(0.0, 0.699999988079071044921875, _453) * smoothstep(3.0, 1.2000000476837158203125, _453));
+                break;
+            } while(false);
+            if (_872 > 0.00999999977648258209228515625)
+            {
+                float _368 = _872 * uDensity;
+                float _370 = 1.0 - _877;
+                _899 = _883 + ((mix(uCloudDarkColor, uCloudLightColor, float3(smoothstep(0.4000000059604644775390625, 2.7999999523162841796875, _316.y))) * _370) * _368);
+                _891 = _877 + (_370 * _368);
+            }
+            else
+            {
+                _899 = _883;
+                _891 = _877;
+            }
+            _385 = _865 + uStepSize;
+            if (_891 > 0.949999988079071044921875)
+            {
+                _900 = _891;
+                _898 = _899;
+                break;
+            }
+            _883 = _899;
+            _877 = _891;
+            _865 = _385;
+            _864++;
+            continue;
+        }
+        else
+        {
+            _900 = _877;
+            _898 = _883;
+            break;
+        }
+    }
+    out.oColor = float4(pow(mix(mix(uSkyLowColor, uSkyHighColor, float3(fast::clamp((_280 * 0.5) + 0.5, 0.0, 1.0))), _898, float3(_900)) * uExposure, float3(0.89999997615814208984375)), 1.0);
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/composite-blit.metalsrc

@@ -0,0 +1,22 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant float2& uContentUvScale [[buffer(0)]], constant float2& uContentUvOffset [[buffer(1)]], texture2d<float> uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]])
+{
+    main0_out out = {};
+    out.oColor = uTex.sample(uTexSmplr, ((in.vUv * uContentUvScale) + uContentUvOffset));
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/composite-blur.metalsrc

@@ -0,0 +1,93 @@
+#pragma clang diagnostic ignored "-Wmissing-prototypes"
+#pragma clang diagnostic ignored "-Wmissing-braces"
+
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+template<typename T, size_t Num>
+struct spvUnsafeArray
+{
+    T elements[Num ? Num : 1];
+    
+    thread T& operator [] (size_t pos) thread
+    {
+        return elements[pos];
+    }
+    constexpr const thread T& operator [] (size_t pos) const thread
+    {
+        return elements[pos];
+    }
+    
+    device T& operator [] (size_t pos) device
+    {
+        return elements[pos];
+    }
+    constexpr const device T& operator [] (size_t pos) const device
+    {
+        return elements[pos];
+    }
+    
+    constexpr const constant T& operator [] (size_t pos) const constant
+    {
+        return elements[pos];
+    }
+    
+    threadgroup T& operator [] (size_t pos) threadgroup
+    {
+        return elements[pos];
+    }
+    constexpr const threadgroup T& operator [] (size_t pos) const threadgroup
+    {
+        return elements[pos];
+    }
+};
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant float& uSigma [[buffer(0)]], constant float2& uDir [[buffer(1)]], texture2d<float> uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]])
+{
+    main0_out out = {};
+    float _15 = (2.0 * uSigma) * uSigma;
+    float _138;
+    _138 = 0.0;
+    float _62;
+    spvUnsafeArray<float, 7> w;
+    for (int _137 = 0; _137 < 7; _138 = _62, _137++)
+    {
+        float _38 = float(_137);
+        w[_137] = exp((-(_38 * _38)) / _15);
+        float _142;
+        if (_137 == 0)
+        {
+            _142 = w[_137];
+        }
+        else
+        {
+            _142 = 2.0 * w[_137];
+        }
+        _62 = _138 + _142;
+    }
+    float _69 = uSigma * 0.25;
+    float4 _140;
+    _140 = uTex.sample(uTexSmplr, in.vUv) * (w[0] / _138);
+    for (int _139 = 1; _139 < 7; )
+    {
+        float2 _105 = (uDir * float(_139)) * _69;
+        _140 = (_140 + (uTex.sample(uTexSmplr, (in.vUv + _105)) * (w[_139] / _138))) + (uTex.sample(uTexSmplr, (in.vUv - _105)) * (w[_139] / _138));
+        _139++;
+        continue;
+    }
+    out.oColor = _140;
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/composite-camera.metalsrc

@@ -0,0 +1,22 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], texture2d<float> uCamera [[texture(0)]], sampler uCameraSmplr [[sampler(0)]])
+{
+    main0_out out = {};
+    out.oColor = float4(uCamera.sample(uCameraSmplr, in.vUv).xyz, 1.0);
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/composite-image.metalsrc

@@ -0,0 +1,24 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant float2& uCoverScale [[buffer(0)]], texture2d<float> uTex [[texture(0)]], sampler uTexSmplr [[sampler(0)]])
+{
+    main0_out out = {};
+    float4 _31 = uTex.sample(uTexSmplr, (((in.vUv - float2(0.5)) * uCoverScale) + float2(0.5)));
+    float _41 = _31.w;
+    out.oColor = float4(_31.xyz * _41, _41);
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/composite-masked.metalsrc

@@ -0,0 +1,22 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant float2& uMaskUvScale [[buffer(0)]], constant float2& uMaskUvOffset [[buffer(1)]], constant float& uMaskHi [[buffer(2)]], constant float& uMaskLo [[buffer(3)]], texture2d<float> uTex [[texture(0)]], texture2d<float> uMask [[texture(1)]], sampler uTexSmplr [[sampler(0)]], sampler uMaskSmplr [[sampler(1)]])
+{
+    main0_out out = {};
+    out.oColor = uTex.sample(uTexSmplr, in.vUv) * fast::clamp(smoothstep(uMaskLo, fast::max(uMaskHi, uMaskLo + 0.001000000047497451305389404296875), uMask.sample(uMaskSmplr, ((in.vUv * uMaskUvScale) + uMaskUvOffset)).x), 0.0, 1.0);
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/composite-subject.metalsrc

@@ -0,0 +1,23 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using namespace metal;
+
+struct main0_out
+{
+    float4 oColor [[color(0)]];
+};
+
+struct main0_in
+{
+    float2 vUv [[user(locn0)]];
+};
+
+fragment main0_out main0(main0_in in [[stage_in]], constant float2& uMaskUvScale [[buffer(0)]], constant float2& uMaskUvOffset [[buffer(1)]], constant float& uMaskHi [[buffer(2)]], constant float& uMaskLo [[buffer(3)]], texture2d<float> uCamera [[texture(0)]], texture2d<float> uMask [[texture(1)]], sampler uCameraSmplr [[sampler(0)]], sampler uMaskSmplr [[sampler(1)]])
+{
+    main0_out out = {};
+    float _54 = fast::clamp(smoothstep(uMaskLo, fast::max(uMaskHi, uMaskLo + 0.001000000047497451305389404296875), uMask.sample(uMaskSmplr, ((in.vUv * uMaskUvScale) + uMaskUvOffset)).x), 0.0, 1.0);
+    out.oColor = float4(uCamera.sample(uCameraSmplr, in.vUv).xyz * _54, _54);
+    return out;
+}
+