react-native-webrtc-kaleidoscope 2.0.0 → 2.1.0

package/ios/KaleidoscopeModule/shaders/corporate-blobs.metalsrc

@@ -0,0 +1,221 @@
+#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 float3& uBlobColor1 [[buffer(0)]], constant float3& uBlobColor2 [[buffer(1)]], constant float3& uBlobColor3 [[buffer(2)]], constant float3& uBlobColor4 [[buffer(3)]], constant float3& uBlobColor5 [[buffer(4)]], constant float3& uBlobColor6 [[buffer(5)]], constant float3& uBlobColor7 [[buffer(6)]], constant float3& uBlobColor8 [[buffer(7)]], constant float& uEdgePull [[buffer(8)]], constant float& uCenterClear [[buffer(9)]], constant float& uTime [[buffer(10)]], constant float& uScale [[buffer(11)]], constant float& uEdgeSoftness [[buffer(12)]], constant float2& uResolution [[buffer(13)]], constant float& uMotionSpeed [[buffer(14)]], constant float& uMotionAmount [[buffer(15)]], constant float& uGlobalAlpha [[buffer(16)]], constant float3& uColor [[buffer(17)]])
+{
+    main0_out out = {};
+    float2 _665 = (in.vUv * 2.0) - float2(1.0);
+    float2 _1463 = _665;
+    _1463.x = _665.x * (uResolution.x / uResolution.y);
+    float3 _1479;
+    float _1480;
+    _1480 = 0.0;
+    _1479 = float3(0.0);
+    float3 _848;
+    float _854;
+    for (int _1478 = 0; _1478 < 8; _1480 = _854, _1479 = _848, _1478++)
+    {
+        float _694 = float(_1478);
+        float3 _1481;
+        float _1482;
+        float _1483;
+        float _1484;
+        float _1485;
+        float _1486;
+        float _1487;
+        float2 _1488;
+        do
+        {
+            if (_694 < 0.5)
+            {
+                _1488 = float2(-1.17999994754791259765625, -0.550000011920928955078125);
+                _1487 = 0.62000000476837158203125;
+                _1486 = 0.4799999892711639404296875;
+                _1485 = 0.2199999988079071044921875;
+                _1484 = 0.14000000059604644775390625;
+                _1483 = 0.100000001490116119384765625;
+                _1482 = 0.0;
+                _1481 = uBlobColor1;
+                break;
+            }
+            if (_694 < 1.5)
+            {
+                _1488 = float2(1.12000000476837158203125, -0.3499999940395355224609375);
+                _1487 = 0.660000026226043701171875;
+                _1486 = 0.4000000059604644775390625;
+                _1485 = 0.180000007152557373046875;
+                _1484 = 0.12999999523162841796875;
+                _1483 = 1.0;
+                _1482 = 1.0;
+                _1481 = uBlobColor2;
+                break;
+            }
+            if (_694 < 2.5)
+            {
+                _1488 = float2(0.949999988079071044921875, 0.87999999523162841796875);
+                _1487 = 0.579999983310699462890625;
+                _1486 = 0.439999997615814208984375;
+                _1485 = 0.20000000298023223876953125;
+                _1484 = 0.14000000059604644775390625;
+                _1483 = 2.2000000476837158203125;
+                _1482 = 2.0;
+                _1481 = uBlobColor3;
+                break;
+            }
+            if (_694 < 3.5)
+            {
+                _1488 = float2(-0.980000019073486328125, 0.819999992847442626953125);
+                _1487 = 0.560000002384185791015625;
+                _1486 = 0.37999999523162841796875;
+                _1485 = 0.1599999964237213134765625;
+                _1484 = 0.119999997317790985107421875;
+                _1483 = 0.699999988079071044921875;
+                _1482 = 3.0;
+                _1481 = uBlobColor4;
+                break;
+            }
+            if (_694 < 4.5)
+            {
+                _1488 = float2(1.2799999713897705078125, 0.2800000011920928955078125);
+                _1487 = 0.5;
+                _1486 = 0.3400000035762786865234375;
+                _1485 = 0.23999999463558197021484375;
+                _1484 = 0.10999999940395355224609375;
+                _1483 = 1.7999999523162841796875;
+                _1482 = 4.0;
+                _1481 = uBlobColor5;
+                break;
+            }
+            if (_694 < 5.5)
+            {
+                _1488 = float2(-0.25, -1.12000000476837158203125);
+                _1487 = 0.540000021457672119140625;
+                _1486 = 0.36000001430511474609375;
+                _1485 = 0.189999997615814208984375;
+                _1484 = 0.10999999940395355224609375;
+                _1483 = 2.599999904632568359375;
+                _1482 = 5.0;
+                _1481 = uBlobColor6;
+                break;
+            }
+            if (_694 < 6.5)
+            {
+                _1488 = float2(-1.2999999523162841796875, 0.100000001490116119384765625);
+                _1487 = 0.4799999892711639404296875;
+                _1486 = 0.300000011920928955078125;
+                _1485 = 0.17000000178813934326171875;
+                _1484 = 0.119999997317790985107421875;
+                _1483 = 0.4000000059604644775390625;
+                _1482 = 6.0;
+                _1481 = uBlobColor7;
+                break;
+            }
+            _1488 = float2(0.2800000011920928955078125, 1.17999994754791259765625);
+            _1487 = 0.519999980926513671875;
+            _1486 = 0.300000011920928955078125;
+            _1485 = 0.14000000059604644775390625;
+            _1484 = 0.100000001490116119384765625;
+            _1483 = 0.89999997615814208984375;
+            _1482 = 7.0;
+            _1481 = uBlobColor8;
+            break;
+        } while(false);
+        float _711 = ((uTime * _1485) * uMotionSpeed) + (_694 * 4.13700008392333984375);
+        float2 _1469 = _1488;
+        _1469.x = (_1488.x + ((sin((_711 * 0.4099999964237213134765625) + (_694 * 1.7000000476837158203125)) * _1484) * uMotionAmount)) + (((sin((_711 * 0.189999997615814208984375) + (_694 * 3.099999904632568359375)) * _1484) * uMotionAmount) * 0.449999988079071044921875);
+        float _769 = _711 * 0.17000000178813934326171875;
+        float2 _1475 = _1469;
+        _1475.y = (_1488.y + (((cos((_711 * 0.3300000131130218505859375) + (_694 * 2.2999999523162841796875)) * _1484) * uMotionAmount) * 0.75)) + (((sin(_769 + (_694 * 4.400000095367431640625)) * _1484) * uMotionAmount) * 0.3499999940395355224609375);
+        float2 _937 = normalize(_1475 + float2(9.9999997473787516355514526367188e-05));
+        float _970 = ((uTime * 0.4199999868869781494140625) * (0.64999997615814208984375 + (_1485 * 1.35000002384185791015625))) + (_694 * 2.73099994659423828125);
+        float _1032 = _1483 + (sin(((uTime * 0.10999999940395355224609375) * (0.60000002384185791015625 + _1485)) + (_1482 * 3.0)) * 0.119999997317790985107421875);
+        float _1069 = sin(_1032);
+        float _1071 = cos(_1032);
+        float2 _1038 = (float2x2(float2(_1071, -_1069), float2(_1069, _1071)) * (_1463 - ((_1475 + (_937 * uEdgePull)) + ((_937 * (1.0 - smoothstep(uCenterClear, uCenterClear + 0.3499999940395355224609375, length(_1475)))) * 0.3400000035762786865234375)))) / float2(1.0 + (0.14000000059604644775390625 * sin(_1482 * 1.90999996662139892578125)), 1.0 + (0.14000000059604644775390625 * cos(_1482 * 2.36999988555908203125)));
+        float _1043 = atan2(_1038.y, _1038.x);
+        float _1489;
+        if (_1482 < 0.5)
+        {
+            _1489 = ((1.0 + (0.115000002086162567138671875 * sin(((_1043 * 2.0) + 0.20000000298023223876953125) + (_711 * 0.20000000298023223876953125)))) + (0.07500000298023223876953125 * sin(((_1043 * 3.0) - 1.10000002384185791015625) - (_711 * 0.12999999523162841796875)))) + (0.0350000001490116119384765625 * sin(((_1043 * 5.0) + 2.0) + (_711 * 0.0900000035762786865234375)));
+        }
+        else
+        {
+            float _1490;
+            if (_1482 < 1.5)
+            {
+                _1490 = ((1.0 + (0.0900000035762786865234375 * sin(((_1043 * 2.0) - 0.800000011920928955078125) + (_711 * 0.180000007152557373046875)))) + (0.104999996721744537353515625 * sin(((_1043 * 3.0) + 0.699999988079071044921875) - (_711 * 0.100000001490116119384765625)))) + (0.02999999932944774627685546875 * sin(((_1043 * 6.0) - 1.5) + (_711 * 0.07999999821186065673828125)));
+            }
+            else
+            {
+                float _1491;
+                if (_1482 < 2.5)
+                {
+                    _1491 = ((1.0 + (0.12999999523162841796875 * sin(((_1043 * 2.0) + 1.10000002384185791015625) + (_711 * 0.1599999964237213134765625)))) + (0.0599999986588954925537109375 * sin(((_1043 * 4.0) - 0.300000011920928955078125) - (_711 * 0.119999997317790985107421875)))) + (0.04500000178813934326171875 * sin(((_1043 * 5.0) + 2.7999999523162841796875) + (_711 * 0.070000000298023223876953125)));
+                }
+                else
+                {
+                    float _1492;
+                    if (_1482 < 3.5)
+                    {
+                        _1492 = ((1.0 + (0.07999999821186065673828125 * sin(((_1043 * 2.0) + 2.2999999523162841796875) + (_711 * 0.14000000059604644775390625)))) + (0.119999997317790985107421875 * sin(((_1043 * 3.0) - 0.4000000059604644775390625) - (_711 * 0.10999999940395355224609375)))) + (0.039999999105930328369140625 * sin(((_1043 * 7.0) + 1.10000002384185791015625) + (_711 * 0.0599999986588954925537109375)));
+                    }
+                    else
+                    {
+                        float _1493;
+                        if (_1482 < 4.5)
+                        {
+                            _1493 = ((1.0 + (0.0350000001490116119384765625 * sin(((_1043 * 2.0) + 0.100000001490116119384765625) + (_711 * 0.119999997317790985107421875)))) + (0.02999999932944774627685546875 * sin(((_1043 * 3.0) + 1.7999999523162841796875) - (_711 * 0.0900000035762786865234375)))) + (0.0199999995529651641845703125 * sin(((_1043 * 5.0) - 0.89999997615814208984375) + (_711 * 0.0500000007450580596923828125)));
+                        }
+                        else
+                        {
+                            float _1494;
+                            if (_1482 < 5.5)
+                            {
+                                _1494 = ((1.0 + (0.14499999582767486572265625 * sin(((_1043 * 2.0) - 1.2999999523162841796875) + _769))) + (0.070000000298023223876953125 * sin(((_1043 * 3.0) + 2.400000095367431640625) - (_711 * 0.10999999940395355224609375)))) + (0.0350000001490116119384765625 * sin(((_1043 * 5.0) + 0.20000000298023223876953125) + (_711 * 0.07999999821186065673828125)));
+                            }
+                            else
+                            {
+                                float _1495;
+                                if (_1482 < 6.5)
+                                {
+                                    _1495 = ((1.0 + (0.04500000178813934326171875 * sin(((_1043 * 2.0) + 1.7000000476837158203125) + (_711 * 0.100000001490116119384765625)))) + (0.0350000001490116119384765625 * sin(((_1043 * 4.0) - 2.099999904632568359375) - (_711 * 0.07999999821186065673828125)))) + (0.02500000037252902984619140625 * sin(((_1043 * 6.0) + 0.5) + (_711 * 0.0500000007450580596923828125)));
+                                }
+                                else
+                                {
+                                    _1495 = ((1.0 + (0.17000000178813934326171875 * sin(((_1043 * 2.0) + 2.7999999523162841796875) + (_711 * 0.20000000298023223876953125)))) + (0.0900000035762786865234375 * sin(((_1043 * 3.0) - 1.89999997615814208984375) - (_711 * 0.1500000059604644775390625)))) + (0.054999999701976776123046875 * sin(((_1043 * 5.0) + 0.800000011920928955078125) + (_711 * 0.0900000035762786865234375)));
+                                }
+                                _1494 = _1495;
+                            }
+                            _1493 = _1494;
+                        }
+                        _1492 = _1493;
+                    }
+                    _1491 = _1492;
+                }
+                _1490 = _1491;
+            }
+            _1489 = _1490;
+        }
+        float _1055 = (((_1487 * fast::max(0.0500000007450580596923828125, 1.0 + ((sin(_970) + (sin((_970 * 0.4699999988079071044921875) + (_694 * 5.13000011444091796875)) * 0.449999988079071044921875)) * 0.100000001490116119384765625))) * uScale) * 0.5) * _1489;
+        float _1062 = 1.0 - smoothstep(_1055, _1055 + uEdgeSoftness, length(_1038));
+        float _840 = (_1062 * _1486) * uGlobalAlpha;
+        float _845 = 1.0 - _1480;
+        _848 = _1479 + ((((_1481 * pow(_1062, 1.35000002384185791015625)) + ((_1481 * (_1062 * (1.0 - smoothstep(0.449999988079071044921875, 1.0, _1062)))) * 0.180000007152557373046875)) * _840) * _845);
+        _854 = _1480 + (_840 * _845);
+    }
+    out.oColor = float4(_1479 * uColor, _1480);
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/fireflies.metalsrc

@@ -0,0 +1,44 @@
+#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& uSpeed [[buffer(0)]], constant float2& uResolution [[buffer(1)]], constant float& uTime [[buffer(2)]], constant float& uTwinkle [[buffer(3)]], constant float& uGlowSize [[buffer(4)]], constant float& uDotSize [[buffer(5)]], constant float3& uColor [[buffer(6)]])
+{
+    main0_out out = {};
+    float _94 = uResolution.x / uResolution.y;
+    float2 _298 = in.vUv;
+    _298.x = in.vUv.x * _94;
+    float _303;
+    float3 _304;
+    _304 = float3(0.0);
+    _303 = 0.0;
+    for (int _302 = 0; _302 < 36; )
+    {
+        float _120 = float(_302);
+        float _249 = uTime * uSpeed;
+        float2 _265 = fract(float2(fract(sin(_120 * 12.69999980926513671875) * 43758.546875), fract(sin(_120 * 31.299999237060546875) * 43758.546875)) + (float2(sin(_249 + (fract(sin(_120 * 5.099999904632568359375) * 43758.546875) * 6.28318023681640625)), cos((_249 * 0.730000019073486328125) + (fract(sin(_120 * 9.69999980926513671875) * 43758.546875) * 6.28318023681640625))) * 0.119999997317790985107421875));
+        float2 _301 = _265;
+        _301.x = _265.x * _94;
+        float _141 = length(_298 - _301);
+        float _159 = 0.5 + (0.5 * sin((uTime * uTwinkle) + (fract(sin(_120 * 17.1000003814697265625) * 43758.546875) * 6.28318023681640625)));
+        float _191 = ((_159 * _159) * sqrt(_159)) * ((exp(((-_141) * _141) / (uGlowSize * uGlowSize)) * 0.550000011920928955078125) + (smoothstep(uDotSize, 0.0, _141) * 1.39999997615814208984375));
+        _304 += (uColor * _191);
+        _303 += (_191 * 0.550000011920928955078125);
+        _302++;
+        continue;
+    }
+    out.oColor = float4(fast::clamp(_304, float3(0.0), float3(1.0)), fast::clamp(_303, 0.0, 1.0));
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/godrays.metalsrc

@@ -0,0 +1,46 @@
+#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& uResolution [[buffer(0)]], constant float& uTime [[buffer(1)]], constant float& uFadeDistance [[buffer(2)]], constant float& uTopGlow [[buffer(3)]], constant float& uWobbleSpeed [[buffer(4)]], constant float& uWobbleAmount [[buffer(5)]], constant float& uRayCount [[buffer(6)]], constant float& uRaySpeed [[buffer(7)]], constant float& uRaySoftness [[buffer(8)]], constant float& uRayIntensity [[buffer(9)]], constant float3& uLightColor [[buffer(10)]])
+{
+    main0_out out = {};
+    float _133 = in.vUv.y - 1.0;
+    float2 _155 = float2(in.vUv.y * 3.0, uTime * uWobbleSpeed);
+    float2 _271 = floor(_155);
+    float2 _273 = fract(_155);
+    float2 _281 = (_273 * _273) * (float2(3.0) - (_273 * 2.0));
+    float _283 = _271.x;
+    float _285 = _271.y;
+    float _286 = _285 * 57.0;
+    float _291 = _283 + 1.0;
+    float _302 = (_285 + 1.0) * 57.0;
+    float _317 = _281.x;
+    float _169 = ((((in.vUv.x - 0.5) * (uResolution.x / uResolution.y)) + 0.5) + ((mix(mix(fract(sin(_283 + _286) * 43758.546875), fract(sin(_291 + _286) * 43758.546875), _317), mix(fract(sin(_283 + _302) * 43758.546875), fract(sin(_291 + _302) * 43758.546875), _317), _281.y) - 0.5) * uWobbleAmount)) * uRayCount;
+    float _175 = uTime * uRaySpeed;
+    float2 _217 = float2(in.vUv.x * 10.0, (in.vUv.y * 4.0) - (uTime * 0.300000011920928955078125));
+    float2 _364 = floor(_217);
+    float2 _366 = fract(_217);
+    float2 _374 = (_366 * _366) * (float2(3.0) - (_366 * 2.0));
+    float _376 = _364.x;
+    float _378 = _364.y;
+    float _379 = _378 * 57.0;
+    float _384 = _376 + 1.0;
+    float _395 = (_378 + 1.0) * 57.0;
+    float _410 = _374.x;
+    float _240 = fast::clamp(uRayIntensity * (((pow((((sin(_169 + _175) * 0.64999997615814208984375) + (sin((_169 * 1.730000019073486328125) - (_175 * 0.699999988079071044921875)) * 0.3499999940395355224609375)) * 0.5) + 0.5, uRaySoftness) * mix(0.75, 1.25, mix(mix(fract(sin(_376 + _379) * 43758.546875), fract(sin(_384 + _379) * 43758.546875), _410), mix(fract(sin(_376 + _395) * 43758.546875), fract(sin(_384 + _395) * 43758.546875), _410), _374.y))) * exp(_133 * uFadeDistance)) + (exp(_133 * 8.0) * uTopGlow)), 0.0, 1.0);
+    out.oColor = float4(uLightColor * _240, _240);
+    return out;
+}
+

package/ios/KaleidoscopeModule/shaders/light-beams-and-motes.metalsrc

@@ -0,0 +1,316 @@
+#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];
+    }
+};
+
+constant float2 _2239 = {};
+
+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& uSpeed [[buffer(1)]], constant float& uBeamSoftness [[buffer(2)]], constant float& uBeam1On [[buffer(3)]], constant spvUnsafeArray<float2, 4>& uBeam1Poly [[buffer(4)]], constant float& uBeam2On [[buffer(8)]], constant spvUnsafeArray<float2, 4>& uBeam2Poly [[buffer(9)]], constant float& uBeam3On [[buffer(13)]], constant spvUnsafeArray<float2, 4>& uBeam3Poly [[buffer(14)]], constant float3& uBeam1Color [[buffer(18)]], constant float3& uBeam2Color [[buffer(19)]], constant float3& uBeam3Color [[buffer(20)]], constant float& uBeam1Alpha [[buffer(21)]], constant float& uBeam2Alpha [[buffer(22)]], constant float& uBeam3Alpha [[buffer(23)]], constant float& uMoteCount [[buffer(24)]], constant float& uGlowSize [[buffer(25)]], constant float& uMoteAlpha [[buffer(26)]], constant float& uOverlayAlpha [[buffer(27)]])
+{
+    main0_out out = {};
+    bool _894 = uBeam1On > 0.5;
+    float _2136;
+    if (_894)
+    {
+        float2 _985 = uBeam1Poly[1] - uBeam1Poly[0];
+        float2 _988 = uBeam1Poly[3] - uBeam1Poly[1];
+        float2 _991 = uBeam1Poly[2] - uBeam1Poly[3];
+        float2 _994 = uBeam1Poly[0] - uBeam1Poly[2];
+        float _1011 = (_985.x * (in.vUv.y - uBeam1Poly[0].y)) - (_985.y * (in.vUv.x - uBeam1Poly[0].x));
+        float _1028 = (_988.x * (in.vUv.y - uBeam1Poly[1].y)) - (_988.y * (in.vUv.x - uBeam1Poly[1].x));
+        float _1045 = (_991.x * (in.vUv.y - uBeam1Poly[3].y)) - (_991.y * (in.vUv.x - uBeam1Poly[3].x));
+        float _1062 = (_994.x * (in.vUv.y - uBeam1Poly[2].y)) - (_994.y * (in.vUv.x - uBeam1Poly[2].x));
+        float _1064 = -uBeamSoftness;
+        float _1123 = uTime * uSpeed;
+        _2136 = fast::max(((smoothstep(_1064, uBeamSoftness, -_1011) * smoothstep(_1064, uBeamSoftness, -_1028)) * smoothstep(_1064, uBeamSoftness, -_1045)) * smoothstep(_1064, uBeamSoftness, -_1062), ((smoothstep(_1064, uBeamSoftness, _1011) * smoothstep(_1064, uBeamSoftness, _1028)) * smoothstep(_1064, uBeamSoftness, _1045)) * smoothstep(_1064, uBeamSoftness, _1062)) * mix(0.64999997615814208984375, 1.0, (0.550000011920928955078125 + (0.449999988079071044921875 * sin((((in.vUv.x * 7.0) + (in.vUv.y * 4.0)) + (_1123 * 0.0599999986588954925537109375)) + 1.0))) * (0.75 + (0.25 * sin((((in.vUv.x * 23.0) - (in.vUv.y * 11.0)) + (_1123 * 0.10999999940395355224609375)) + 2.7000000476837158203125))));
+    }
+    else
+    {
+        _2136 = 0.0;
+    }
+    bool _901 = uBeam2On > 0.5;
+    float _2138;
+    if (_901)
+    {
+        float2 _1198 = uBeam2Poly[1] - uBeam2Poly[0];
+        float2 _1201 = uBeam2Poly[3] - uBeam2Poly[1];
+        float2 _1204 = uBeam2Poly[2] - uBeam2Poly[3];
+        float2 _1207 = uBeam2Poly[0] - uBeam2Poly[2];
+        float _1224 = (_1198.x * (in.vUv.y - uBeam2Poly[0].y)) - (_1198.y * (in.vUv.x - uBeam2Poly[0].x));
+        float _1241 = (_1201.x * (in.vUv.y - uBeam2Poly[1].y)) - (_1201.y * (in.vUv.x - uBeam2Poly[1].x));
+        float _1258 = (_1204.x * (in.vUv.y - uBeam2Poly[3].y)) - (_1204.y * (in.vUv.x - uBeam2Poly[3].x));
+        float _1275 = (_1207.x * (in.vUv.y - uBeam2Poly[2].y)) - (_1207.y * (in.vUv.x - uBeam2Poly[2].x));
+        float _1277 = -uBeamSoftness;
+        float _1336 = uTime * uSpeed;
+        _2138 = fast::max(((smoothstep(_1277, uBeamSoftness, -_1224) * smoothstep(_1277, uBeamSoftness, -_1241)) * smoothstep(_1277, uBeamSoftness, -_1258)) * smoothstep(_1277, uBeamSoftness, -_1275), ((smoothstep(_1277, uBeamSoftness, _1224) * smoothstep(_1277, uBeamSoftness, _1241)) * smoothstep(_1277, uBeamSoftness, _1258)) * smoothstep(_1277, uBeamSoftness, _1275)) * mix(0.64999997615814208984375, 1.0, (0.550000011920928955078125 + (0.449999988079071044921875 * sin((((in.vUv.x * 7.0) + (in.vUv.y * 4.0)) + (_1336 * 0.0599999986588954925537109375)) + 8.0))) * (0.75 + (0.25 * sin((((in.vUv.x * 23.0) - (in.vUv.y * 11.0)) + (_1336 * 0.10999999940395355224609375)) + 21.6000003814697265625))));
+    }
+    else
+    {
+        _2138 = 0.0;
+    }
+    bool _908 = uBeam3On > 0.5;
+    float _2140;
+    if (_908)
+    {
+        float2 _1411 = uBeam3Poly[1] - uBeam3Poly[0];
+        float2 _1414 = uBeam3Poly[3] - uBeam3Poly[1];
+        float2 _1417 = uBeam3Poly[2] - uBeam3Poly[3];
+        float2 _1420 = uBeam3Poly[0] - uBeam3Poly[2];
+        float _1437 = (_1411.x * (in.vUv.y - uBeam3Poly[0].y)) - (_1411.y * (in.vUv.x - uBeam3Poly[0].x));
+        float _1454 = (_1414.x * (in.vUv.y - uBeam3Poly[1].y)) - (_1414.y * (in.vUv.x - uBeam3Poly[1].x));
+        float _1471 = (_1417.x * (in.vUv.y - uBeam3Poly[3].y)) - (_1417.y * (in.vUv.x - uBeam3Poly[3].x));
+        float _1488 = (_1420.x * (in.vUv.y - uBeam3Poly[2].y)) - (_1420.y * (in.vUv.x - uBeam3Poly[2].x));
+        float _1490 = -uBeamSoftness;
+        float _1549 = uTime * uSpeed;
+        _2140 = fast::max(((smoothstep(_1490, uBeamSoftness, -_1437) * smoothstep(_1490, uBeamSoftness, -_1454)) * smoothstep(_1490, uBeamSoftness, -_1471)) * smoothstep(_1490, uBeamSoftness, -_1488), ((smoothstep(_1490, uBeamSoftness, _1437) * smoothstep(_1490, uBeamSoftness, _1454)) * smoothstep(_1490, uBeamSoftness, _1471)) * smoothstep(_1490, uBeamSoftness, _1488)) * mix(0.64999997615814208984375, 1.0, (0.550000011920928955078125 + (0.449999988079071044921875 * sin((((in.vUv.x * 7.0) + (in.vUv.y * 4.0)) + (_1549 * 0.0599999986588954925537109375)) + 14.0))) * (0.75 + (0.25 * sin((((in.vUv.x * 23.0) - (in.vUv.y * 11.0)) + (_1549 * 0.10999999940395355224609375)) + 37.799999237060546875))));
+    }
+    else
+    {
+        _2140 = 0.0;
+    }
+    float _918 = (_2136 + _2138) + _2140;
+    float3 _933 = (((uBeam1Color * _2136) + (uBeam2Color * _2138)) + (uBeam3Color * _2140)) / float3(fast::max(_918, 9.9999997473787516355514526367188e-05));
+    float _944 = ((_2136 * uBeam1Alpha) + (_2138 * uBeam2Alpha)) + (_2140 * uBeam3Alpha);
+    float3 _807 = _933 * _944;
+    float _811 = _944 * 0.449999988079071044921875;
+    float3 _2213;
+    float _2215;
+    do
+    {
+        float _1629 = (uBeam1On + uBeam2On) + uBeam3On;
+        if (_1629 < 0.5)
+        {
+            _2215 = _811;
+            _2213 = _807;
+            break;
+        }
+        float _1636 = fast::clamp(uBeamSoftness * 2.0, 0.02999999932944774627685546875, 0.3499999940395355224609375);
+        int _2149;
+        float _2150;
+        float3 _2193;
+        float _2200;
+        _2200 = _811;
+        _2193 = _807;
+        _2150 = 0.0;
+        _2149 = 0;
+        float3 _1885;
+        float _1903;
+        float _2248;
+        for (; _2149 < 128; _2200 = _1903, _2193 = _1885, _2150 = _2248, _2149++)
+        {
+            float _1643 = float(_2149);
+            if (_1643 >= uMoteCount)
+            {
+                break;
+            }
+            float _1650 = _1643 * 91.73000335693359375;
+            float2 _2162;
+            float2 _2168;
+            float2 _2174;
+            float2 _2180;
+            float3 _2186;
+            if (_894)
+            {
+                bool _1658 = abs(-_2150) < 0.5;
+                float2 _2163;
+                float2 _2169;
+                float2 _2175;
+                float2 _2181;
+                if (_1658)
+                {
+                    _2181 = uBeam1Poly[3];
+                    _2175 = uBeam1Poly[2];
+                    _2169 = uBeam1Poly[1];
+                    _2163 = uBeam1Poly[0];
+                }
+                else
+                {
+                    _2181 = float2(0.0);
+                    _2175 = float2(0.0);
+                    _2169 = float2(0.0);
+                    _2163 = float2(0.0);
+                }
+                _2186 = select(float3(0.0), uBeam1Color, bool3(_1658));
+                _2180 = _2181;
+                _2174 = _2175;
+                _2168 = _2169;
+                _2162 = _2163;
+            }
+            else
+            {
+                _2186 = float3(0.0);
+                _2180 = float2(0.0);
+                _2174 = float2(0.0);
+                _2168 = float2(0.0);
+                _2162 = float2(0.0);
+            }
+            float _2243 = float(_894);
+            float _2156;
+            float2 _2161;
+            float2 _2167;
+            float2 _2173;
+            float2 _2179;
+            float3 _2185;
+            if (_901)
+            {
+                bool _1680 = abs(_2243 - _2150) < 0.5;
+                float2 _2164;
+                float2 _2170;
+                float2 _2176;
+                float2 _2182;
+                if (_1680)
+                {
+                    _2182 = uBeam2Poly[3];
+                    _2176 = uBeam2Poly[2];
+                    _2170 = uBeam2Poly[1];
+                    _2164 = uBeam2Poly[0];
+                }
+                else
+                {
+                    _2182 = _2180;
+                    _2176 = _2174;
+                    _2170 = _2168;
+                    _2164 = _2162;
+                }
+                _2185 = select(_2186, uBeam2Color, bool3(_1680));
+                _2179 = _2182;
+                _2173 = _2176;
+                _2167 = _2170;
+                _2161 = _2164;
+                _2156 = _2243 + 1.0;
+            }
+            else
+            {
+                _2185 = _2186;
+                _2179 = _2180;
+                _2173 = _2174;
+                _2167 = _2168;
+                _2161 = _2162;
+                _2156 = _2243;
+            }
+            float2 _2160;
+            float2 _2166;
+            float2 _2172;
+            float2 _2178;
+            float3 _2184;
+            if (_908)
+            {
+                bool _1702 = abs(_2156 - _2150) < 0.5;
+                float2 _2165;
+                float2 _2171;
+                float2 _2177;
+                float2 _2183;
+                if (_1702)
+                {
+                    _2183 = uBeam3Poly[3];
+                    _2177 = uBeam3Poly[2];
+                    _2171 = uBeam3Poly[1];
+                    _2165 = uBeam3Poly[0];
+                }
+                else
+                {
+                    _2183 = _2179;
+                    _2177 = _2173;
+                    _2171 = _2167;
+                    _2165 = _2161;
+                }
+                _2184 = select(_2185, uBeam3Color, bool3(_1702));
+                _2178 = _2183;
+                _2172 = _2177;
+                _2166 = _2171;
+                _2160 = _2165;
+            }
+            else
+            {
+                _2184 = _2185;
+                _2178 = _2179;
+                _2172 = _2173;
+                _2166 = _2167;
+                _2160 = _2161;
+            }
+            float _1921 = fract(sin(_1650 + 3.0) * 43758.546875);
+            float _1721 = mix(0.001300000003539025783538818359375, 0.004800000227987766265869140625, _1921);
+            float _1725 = mix(0.449999988079071044921875, 1.35000002384185791015625, fract(sin(_1650 + 5.0) * 43758.546875));
+            float _1728 = uTime * uSpeed;
+            float _1730 = _1728 * _1725;
+            float2 _2118 = _2239;
+            _2118.x = (fract(sin(_1650 + 11.1700000762939453125) * 43758.546875) + (sin((_1730 * 0.1019999980926513671875) + _1650) * 0.064999997615814208984375)) + (sin((_1730 * 0.2339999973773956298828125) + (_1643 * 37.609302520751953125)) * 0.02999999932944774627685546875);
+            float2 _2124 = _2118;
+            _2124.y = (fract(sin(_1650 + 47.8300018310546875) * 43758.546875) + (((_1728 * 0.01200000010430812835693359375) * _1725) * 6.0)) + (sin((_1730 * 0.14400000870227813720703125) + (_1643 * 33.94010162353515625)) * 0.0357499979436397552490234375);
+            float2 _1789 = (fract(_2124) * (1.0 + (2.0 * _1636))) - float2(_1636);
+            float _1793 = _1789.x;
+            float2 _1794 = float2(_1793);
+            float _1803 = _1789.y;
+            float _1958 = length(in.vUv - mix(mix(_2160, _2166, _1794), mix(_2172, _2178, _1794), float2(_1803)));
+            float _1961 = _1958 / _1721;
+            float _1966 = exp((-_1961) * _1961);
+            float _1977 = _1958 / (_1721 * 0.4199999868869781494140625);
+            float _1982 = exp((-_1977) * _1977);
+            float _1993 = _1958 / (_1721 * uGlowSize);
+            float _1998 = exp((-_1993) * _1993);
+            float _1862 = ((mix(0.1500000059604644775390625, 1.0, _1921) * (0.7200000286102294921875 + (0.2800000011920928955078125 * sin((_1728 * mix(0.2199999988079071044921875, 0.949999988079071044921875, fract(sin(_1650 + 9.0) * 43758.546875))) + _1650)))) * (((smoothstep(0.0, _1636, _1793) * smoothstep(0.0, _1636, 1.0 - _1793)) * smoothstep(0.0, _1636, _1803)) * smoothstep(0.0, _1636, 1.0 - _1803))) * uMoteAlpha;
+            _1885 = ((_2193 + (((_2184 * _1998) * _1862) * 0.119999997317790985107421875)) + (((_2184 * _1966) * _1862) * 0.36000001430511474609375)) + (((float3(1.0) * _1982) * _1862) * 0.100000001490116119384765625);
+            _1903 = ((_2200 + ((_1998 * _1862) * 0.02999999932944774627685546875)) + ((_1966 * _1862) * 0.104999996721744537353515625)) + ((_1982 * _1862) * 0.10999999940395355224609375);
+            float _1905 = _2150 + 1.0;
+            _2248 = (_1905 >= _1629) ? 0.0 : _1905;
+        }
+        _2215 = _2200;
+        _2213 = _2193;
+        break;
+    } while(false);
+    float _845 = (_918 * _918) * (0.60000002384185791015625 + (0.4000000059604644775390625 * sin(((in.vUv.x * 8.0) + (in.vUv.y * 5.0)) + ((uTime * uSpeed) * 0.07999999821186065673828125))));
+    out.oColor = float4(_2213 + ((_933 * _845) * 0.017999999225139617919921875), fast::clamp((_2215 + (_845 * 0.00999999977648258209228515625)) * uOverlayAlpha, 0.0, 1.0));
+    return out;
+}
+