aboutsummaryrefslogtreecommitdiff
path: root/assets/shaders/generated/geodesic.glsl
diff options
context:
space:
mode:
authorhachem <im@hachem.wtf>2026-09-22 06:57:16 +0200
committerhachem <im@hachem.wtf>2026-09-22 06:57:16 +0200
commitd7c1ced08d5d78fcb239550404db4e67d4357a19 (patch)
tree9c0e218b096d138075cbf6a48e2562d33a8f94ed /assets/shaders/generated/geodesic.glsl
parent270eda6f558c972ec86ad0580f1d3d18afc83a94 (diff)
fix: windows supportHEADmain
Diffstat (limited to 'assets/shaders/generated/geodesic.glsl')
-rw-r--r--assets/shaders/generated/geodesic.glsl1854
1 files changed, 1854 insertions, 0 deletions
diff --git a/assets/shaders/generated/geodesic.glsl b/assets/shaders/generated/geodesic.glsl
new file mode 100644
index 0000000..5c5e069
--- /dev/null
+++ b/assets/shaders/generated/geodesic.glsl
@@ -0,0 +1,1854 @@
+#type vertex
+#version 410
+
+layout(location = 0) in vec2 input_position;
+layout(location = 1) in vec2 input_texCoord;
+layout(location = 0) out vec2 _v0;
+
+void main()
+{
+ gl_Position = vec4(input_position, 0.0, 1.0);
+ _v0 = input_texCoord;
+}
+
+
+#type fragment
+#version 410
+
+struct _Array_vector_float_4_16
+{
+ vec4 data[16];
+};
+
+struct _Array_float16
+{
+ float data[16];
+};
+
+const vec2 _1399[4] = vec2[](vec2(0.125, 0.375), vec2(0.375, -0.125), vec2(-0.125, -0.375), vec2(-0.375, 0.125));
+
+layout(std140) uniform Camera
+{
+ vec3 u_cam_pos;
+ float _pad0;
+ vec3 u_cam_right;
+ float _pad1;
+ vec3 u_cam_up;
+ float _pad2;
+ vec3 u_cam_forward;
+ float _pad3;
+ float u_tan_half_fov;
+ float u_aspect;
+ int u_moving;
+ int u_output_channel;
+ int u_raw_output;
+} cam;
+
+layout(std140) uniform Simulation
+{
+ int u_max_steps_moving;
+ int u_max_steps_static;
+ float u_early_exit_distance;
+ float u_time;
+} sim;
+
+layout(std140) uniform Disk
+{
+ float u_inner_radius;
+ float u_outer_radius;
+ float u_turbulence;
+ float u_thickness;
+ float u_brightness;
+ float u_temperature;
+} disk;
+
+layout(std140) uniform Objects
+{
+ int u_num_objects;
+ _Array_vector_float_4_16 u_obj_pos_radius;
+ _Array_vector_float_4_16 u_obj_color;
+ _Array_float16 u_mass;
+} obj;
+
+uniform samplerCube u_HDRIEnvironment;
+
+layout(location = 0) in vec2 _v0;
+layout(location = 0) out vec4 entryPointParam_fragmentMain;
+
+void main()
+{
+ bool _4918 = false;
+ bool _4023 = false;
+ bool _3148 = false;
+ bool _2258 = false;
+ do
+ {
+ if (cam.u_output_channel != 0)
+ {
+ float g = 0.0;
+ float Temit = 0.0;
+ bool hitDisk = false;
+ vec3 _1488 = normalize(((cam.u_cam_right * ((((2.0 * _v0.x) - 1.0) * cam.u_aspect) * cam.u_tan_half_fov)) - (cam.u_cam_up * ((1.0 - (2.0 * _v0.y)) * cam.u_tan_half_fov))) + cam.u_cam_forward);
+ float _1693 = length(cam.u_cam_pos);
+ float _1696 = acos(cam.u_cam_pos.z / _1693);
+ float _1698 = atan(cam.u_cam_pos.y, cam.u_cam_pos.x);
+ float _1699 = _1488.x;
+ float _1700 = _1488.y;
+ float _1701 = _1488.z;
+ float _1714 = (((sin(_1696) * cos(_1698)) * _1699) + ((sin(_1696) * sin(_1698)) * _1700)) + (cos(_1696) * _1701);
+ float _1728 = ((((cos(_1696) * cos(_1698)) * _1699) + ((cos(_1696) * sin(_1698)) * _1700)) - (sin(_1696) * _1701)) / _1693;
+ float _1738 = (((-sin(_1698)) * _1699) + (cos(_1698) * _1700)) / (_1693 * sin(_1696));
+ float _1745 = 1.0 - (12689999872.0 / _1693);
+ float _5541 = cam.u_cam_pos.x;
+ float _5542 = cam.u_cam_pos.y;
+ float _5543 = cam.u_cam_pos.z;
+ float _5544 = _1693;
+ float _5545 = _1696;
+ float _5546 = _1698;
+ float _5547 = _1714;
+ float _5548 = _1728;
+ float _5549 = _1738;
+ float _5550 = _1745 * sqrt(((_1714 * _1714) / _1745) + ((_1693 * _1693) * ((_1728 * _1728) + (((sin(_1696) * sin(_1696)) * _1738) * _1738))));
+ int _1450;
+ if (cam.u_moving != 0)
+ {
+ _1450 = sim.u_max_steps_moving;
+ }
+ else
+ {
+ _1450 = sim.u_max_steps_static;
+ }
+ if (_1450 <= 0)
+ {
+ if (cam.u_moving != 0)
+ {
+ _1450 = 12000;
+ }
+ else
+ {
+ _1450 = 8000;
+ }
+ }
+ float _1451;
+ if (sim.u_early_exit_distance > 0.0)
+ {
+ _1451 = sim.u_early_exit_distance;
+ }
+ else
+ {
+ _1451 = 1999999991808.0;
+ }
+ int _1452 = 0;
+ bool _1453;
+ bool _1454;
+ bool _1455;
+ vec3 _1456;
+ bool _1460;
+ bool _1766;
+ float _1767;
+ vec3 _1805;
+ vec3 _1915;
+ bool _1916;
+ float _1917;
+ vec3 _2019;
+ float _2020;
+ bool _2259;
+ for (;;)
+ {
+ if (!(_1452 < _1450))
+ {
+ _1453 = false;
+ _1456 = vec3(0.0);
+ _1454 = false;
+ _1455 = false;
+ break;
+ }
+ if (_5544 <= 12689999872.0)
+ {
+ _1453 = false;
+ _1456 = vec3(0.0);
+ _1454 = true;
+ _1455 = false;
+ break;
+ }
+ if (_5544 > _1451)
+ {
+ _1453 = true;
+ }
+ else
+ {
+ _1453 = _5544 > 1000000015047466219876688855040.0;
+ }
+ if (_1453)
+ {
+ _1453 = false;
+ _1456 = vec3(0.0);
+ _1454 = false;
+ _1455 = false;
+ break;
+ }
+ float _1547 = _5541;
+ float _1549 = _5542;
+ float _1551 = _5543;
+ vec3 _1552 = vec3(_1547, _1549, _1551);
+ float _5614 = _1549;
+ float _1774 = 0.0199999995529651641845703125 * max(_5544 - 19035000832.0, 0.0);
+ if (length(vec2(_1547, _1551)) < (disk.u_outer_radius * 3.0))
+ {
+ _1766 = abs(_5614) < (disk.u_thickness * 8.0);
+ }
+ else
+ {
+ _1766 = false;
+ }
+ if (_1766)
+ {
+ _1767 = min(_1774, disk.u_thickness);
+ }
+ else
+ {
+ _1767 = _1774;
+ }
+ float _1803 = clamp(_1767, 1000000.0, 20000000000.0);
+ float _5607 = _5549;
+ float _5606 = _5548;
+ float _5605 = _5547;
+ float _5604 = _5546;
+ float _5603 = _5545;
+ float _5602 = _5544;
+ float _1871 = 1.0 - (12689999872.0 / _5602);
+ float _1874 = _5550 / _1871;
+ vec3 _1875 = vec3(_5605, _5606, _5607);
+ float _1878 = (2.0 * _5602) * _5602;
+ float _1890 = sin(_5603);
+ vec3 _5640 = _1805;
+ _5640.x = ((((((-12689999872.0) / _1878) * _1871) * _1874) * _1874) + (((12689999872.0 / (_1878 * _1871)) * _5605) * _5605)) + (_5602 * ((_5606 * _5606) + (((_1890 * _1890) * _5607) * _5607)));
+ float _1898 = (-2.0) * _5605;
+ float _1901 = cos(_5603);
+ _5640.y = ((_1898 * _5606) / _5602) + (((_1890 * _1901) * _5607) * _5607);
+ _5640.z = ((_1898 * _5607) / _5602) - ((((2.0 * _1901) / _1890) * _5606) * _5607);
+ _1805 = _5640;
+ float _1815 = _5602 + (_1803 * _1875.x);
+ _5544 = _1815;
+ float _1821 = _5603 + (_1803 * _1875.y);
+ _5545 = _1821;
+ float _1827 = _5604 + (_1803 * _1875.z);
+ _5546 = _1827;
+ _5547 = _5605 + (_1803 * _5640.x);
+ _5548 = _5606 + (_1803 * _5640.y);
+ _5549 = _5607 + (_1803 * _5640.z);
+ float _1850 = (_1815 * sin(_1821)) * cos(_1827);
+ _5541 = _1850;
+ float _1855 = (_1815 * sin(_1821)) * sin(_1827);
+ _5542 = _1855;
+ float _1858 = _1815 * cos(_1821);
+ _5543 = _1858;
+ vec3 _1559 = vec3(_1850, _1855, _1858);
+ bool _1563 = (_1549 * _1855) < 0.0;
+ if (_1563)
+ {
+ _1454 = true;
+ }
+ else
+ {
+ _1454 = abs(_1855) <= disk.u_thickness;
+ }
+ if (_1454)
+ {
+ if (_1563)
+ {
+ _1456 = mix(_1552, _1559, vec3(_1549 / (_1549 - _1855)));
+ }
+ else
+ {
+ _1456 = _1559;
+ }
+ float _1583 = length(vec2(_1456.xz));
+ if (_1583 >= max(disk.u_inner_radius, 38070001664.0))
+ {
+ _1455 = _1583 <= disk.u_outer_radius;
+ }
+ else
+ {
+ _1455 = false;
+ }
+ if (_1455)
+ {
+ do
+ {
+ g = 0.0;
+ Temit = 0.0;
+ float _1924 = length(vec2(_1456.xz));
+ float _1927 = max(disk.u_inner_radius, 38070001664.0);
+ if (_1924 < _1927)
+ {
+ _1916 = true;
+ }
+ else
+ {
+ _1916 = _1924 > disk.u_outer_radius;
+ }
+ if (_1916)
+ {
+ _1915 = vec3(0.0);
+ break;
+ }
+ float _1938 = _1924 / _1927;
+ float _1947 = pow(max((1.0 - sqrt(1.0 / _1938)) / ((_1938 * _1938) * _1938), 0.0) * 17.5746936798095703125, 0.25);
+ float _1950 = disk.u_temperature * _1947;
+ float _1969 = sqrt(max(1.0 - (19035000832.0 / _1924), 0.0)) / max(1.0 - dot(normalize(cross(vec3(0.0, 1.0, 0.0), normalize(vec3(_1456.x, 0.0, _1456.z)))) * sqrt(6344999936.0 / max(_1924 - 12689999872.0, 1.0)), -normalize(_1559 - _1552)), 0.001000000047497451305389404296875);
+ g = _1969;
+ Temit = _1950;
+ float _2024 = clamp(_1969 * _1950, 1000.0, 40000.0) * 0.00999999977648258209228515625;
+ bool _2026 = _2024 <= 66.0;
+ if (_2026)
+ {
+ _2020 = 1.0;
+ }
+ else
+ {
+ _2020 = clamp(1.29293620586395263671875 * pow(_2024 - 60.0, -0.133204758167266845703125), 0.0, 1.0);
+ }
+ vec3 _5646 = _2019;
+ _5646.x = _2020;
+ _2019 = _5646;
+ if (_2026)
+ {
+ _2020 = clamp((0.390081584453582763671875 * log(_2024)) - 0.6318414211273193359375, 0.0, 1.0);
+ }
+ else
+ {
+ _2020 = clamp(1.129890918731689453125 * pow(_2024 - 60.0, -0.075514845550060272216796875), 0.0, 1.0);
+ }
+ vec3 _5648 = _2019;
+ _5648.y = _2020;
+ _2019 = _5648;
+ if (_2024 >= 66.0)
+ {
+ _2020 = 1.0;
+ }
+ else
+ {
+ if (_2024 <= 19.0)
+ {
+ _2020 = 0.0;
+ }
+ else
+ {
+ _2020 = clamp((0.54320681095123291015625 * log(_2024 - 10.0)) - 1.19625413417816162109375, 0.0, 1.0);
+ }
+ }
+ vec3 _5650 = _2019;
+ _5650.z = _2020;
+ _2019 = _5650;
+ float _1981 = (pow(_1947, 2.0) * pow(_1969, 4.0)) * (smoothstep(_1927, _1927 * 1.12000000476837158203125, _1924) * (1.0 - smoothstep(disk.u_outer_radius * 0.87999999523162841796875, disk.u_outer_radius, _1924)));
+ if (disk.u_turbulence > 0.0)
+ {
+ float _1991 = (sim.u_time * 0.300000011920928955078125) / sqrt(_1938);
+ float _1992 = cos(_1991);
+ float _1994 = sin(_1991);
+ vec3 _2064 = (vec3((_1456.x * _1992) - (_1456.z * _1994), 0.0, (_1456.x * _1994) + (_1456.z * _1992)) * 1.0000000133514319600180897396058e-10) * 3.0;
+ int _2065 = 0;
+ float _2066 = 0.5;
+ float _2067 = 0.0;
+ for (;;)
+ {
+ if (!(_2065 < 3))
+ {
+ break;
+ }
+ vec3 _2098 = floor(_2064);
+ vec3 _2099 = fract(_2064);
+ vec3 _2104 = (_2099 * _2099) * (vec3(3.0) - (_2099 * 2.0));
+ vec3 _2133 = fract(_2098 * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2139 = _2133 + vec3(dot(_2133, _2133.yxz + vec3(33.3300018310546875)));
+ vec3 _2149 = fract((_2098 + vec3(1.0, 0.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2155 = _2149 + vec3(dot(_2149, _2149.yxz + vec3(33.3300018310546875)));
+ vec3 _2165 = fract((_2098 + vec3(0.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2171 = _2165 + vec3(dot(_2165, _2165.yxz + vec3(33.3300018310546875)));
+ vec3 _2181 = fract((_2098 + vec3(1.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2187 = _2181 + vec3(dot(_2181, _2181.yxz + vec3(33.3300018310546875)));
+ vec3 _2197 = fract((_2098 + vec3(0.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2203 = _2197 + vec3(dot(_2197, _2197.yxz + vec3(33.3300018310546875)));
+ vec3 _2213 = fract((_2098 + vec3(1.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2219 = _2213 + vec3(dot(_2213, _2213.yxz + vec3(33.3300018310546875)));
+ vec3 _2229 = fract((_2098 + vec3(0.0, 1.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2235 = _2229 + vec3(dot(_2229, _2229.yxz + vec3(33.3300018310546875)));
+ vec3 _2245 = fract((_2098 + vec3(1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _2251 = _2245 + vec3(dot(_2245, _2245.yxz + vec3(33.3300018310546875)));
+ float _2120 = _2104.x;
+ float _2123 = _2104.y;
+ float _2080 = _2066;
+ float _2081 = _2080 * mix(mix(mix(fract((_2139.x + _2139.y) * _2139.z), fract((_2155.x + _2155.y) * _2155.z), _2120), mix(fract((_2171.x + _2171.y) * _2171.z), fract((_2187.x + _2187.y) * _2187.z), _2120), _2123), mix(mix(fract((_2203.x + _2203.y) * _2203.z), fract((_2219.x + _2219.y) * _2219.z), _2120), mix(fract((_2235.x + _2235.y) * _2235.z), fract((_2251.x + _2251.y) * _2251.z), _2120), _2123), _2104.z);
+ _2064 = (_2064 * 2.0) + vec3(100.0, 200.0, 300.0);
+ _2065++;
+ _2066 = _2080 * 0.5;
+ _2067 += _2081;
+ continue;
+ }
+ _1917 = _1981 * max(1.0 + (disk.u_turbulence * (_2067 - 0.5)), 0.0);
+ }
+ else
+ {
+ _1917 = _1981;
+ }
+ _1915 = (_5650 * _1917) * max(disk.u_brightness, 0.0);
+ break;
+ } while(false);
+ hitDisk = true;
+ _1453 = true;
+ _1456 = _1915;
+ _1454 = false;
+ _1455 = false;
+ break;
+ }
+ }
+ if ((_1452 - 5 * (_1452 / 5)) == 0)
+ {
+ float _5621 = _5541;
+ float _5622 = _5542;
+ float _5623 = _5543;
+ _2258 = false;
+ do
+ {
+ vec3 _2270 = vec3(_5621, _5622, _5623);
+ int _2260 = 0;
+ for (;;)
+ {
+ bool _2273_ladder_break = false;
+ do
+ {
+ if (!(_2260 < obj.u_num_objects))
+ {
+ _2273_ladder_break = true;
+ break;
+ }
+ vec3 _2289 = _2270 - obj.u_obj_pos_radius.data[_2260].xyz;
+ float _2290 = dot(_2289, _2289);
+ float _2291 = obj.u_obj_pos_radius.data[_2260].w * obj.u_obj_pos_radius.data[_2260].w;
+ if (_2290 > (_2291 * 4.0))
+ {
+ break;
+ }
+ if (_2290 <= _2291)
+ {
+ _2258 = true;
+ _2259 = true;
+ _2273_ladder_break = true;
+ break;
+ }
+ break;
+ } while(false);
+ if (_2273_ladder_break)
+ {
+ break;
+ }
+ _2260++;
+ continue;
+ }
+ if (_2258)
+ {
+ break;
+ }
+ _2258 = true;
+ _2259 = false;
+ break;
+ } while(false);
+ _1455 = _2259;
+ }
+ else
+ {
+ _1455 = false;
+ }
+ if (_1455)
+ {
+ _1453 = false;
+ _1456 = vec3(0.0);
+ _1454 = false;
+ _1455 = true;
+ break;
+ }
+ if (_5547 > 0.0)
+ {
+ _1460 = _5544 > 634500022272.0;
+ }
+ else
+ {
+ _1460 = false;
+ }
+ if (_1460)
+ {
+ _1453 = false;
+ _1456 = vec3(0.0);
+ _1454 = false;
+ _1455 = false;
+ break;
+ }
+ _1452++;
+ continue;
+ }
+ float value;
+ float valid;
+ if (cam.u_output_channel == 3)
+ {
+ value = length(cross(cam.u_cam_pos, normalize(((cam.u_cam_right * ((((2.0 * _v0.x) - 1.0) * cam.u_aspect) * cam.u_tan_half_fov)) - (cam.u_cam_up * ((1.0 - (2.0 * _v0.y)) * cam.u_tan_half_fov))) + cam.u_cam_forward))) * 7.8802207814643310257451958023012e-11;
+ valid = 1.0;
+ }
+ else
+ {
+ if (hitDisk)
+ {
+ value = 1.0;
+ }
+ else
+ {
+ value = 0.0;
+ }
+ if (cam.u_output_channel == 1)
+ {
+ valid = g;
+ }
+ else
+ {
+ valid = Temit;
+ }
+ float _1258 = value;
+ value = valid;
+ valid = _1258;
+ }
+ if (cam.u_raw_output != 0)
+ {
+ entryPointParam_fragmentMain = vec4(value, value, value, valid);
+ break;
+ }
+ if (valid < 0.5)
+ {
+ entryPointParam_fragmentMain = vec4(0.0, 0.0, 0.0, 1.0);
+ break;
+ }
+ float norm;
+ if (cam.u_output_channel == 1)
+ {
+ norm = value * 0.666666686534881591796875;
+ }
+ else
+ {
+ if (cam.u_output_channel == 2)
+ {
+ value *= 6.6666667407844215631484985351562e-05;
+ }
+ else
+ {
+ value *= 0.0333333350718021392822265625;
+ }
+ norm = value;
+ }
+ float _2326 = 4.0 * clamp(norm, 0.0, 1.0);
+ entryPointParam_fragmentMain = vec4(clamp(vec3(1.5 - abs(_2326 - 3.0), 1.5 - abs(_2326 - 2.0), 1.5 - abs(_2326 - 1.0)), vec3(0.0), vec3(1.0)), 1.0);
+ break;
+ }
+ if (cam.u_raw_output != 0)
+ {
+ vec3 _2378 = normalize(((cam.u_cam_right * ((((2.0 * _v0.x) - 1.0) * cam.u_aspect) * cam.u_tan_half_fov)) - (cam.u_cam_up * ((1.0 - (2.0 * _v0.y)) * cam.u_tan_half_fov))) + cam.u_cam_forward);
+ float _2583 = length(cam.u_cam_pos);
+ float _2586 = acos(cam.u_cam_pos.z / _2583);
+ float _2588 = atan(cam.u_cam_pos.y, cam.u_cam_pos.x);
+ float _2589 = _2378.x;
+ float _2590 = _2378.y;
+ float _2591 = _2378.z;
+ float _2604 = (((sin(_2586) * cos(_2588)) * _2589) + ((sin(_2586) * sin(_2588)) * _2590)) + (cos(_2586) * _2591);
+ float _2618 = ((((cos(_2586) * cos(_2588)) * _2589) + ((cos(_2586) * sin(_2588)) * _2590)) - (sin(_2586) * _2591)) / _2583;
+ float _2628 = (((-sin(_2588)) * _2589) + (cos(_2588) * _2590)) / (_2583 * sin(_2586));
+ float _2635 = 1.0 - (12689999872.0 / _2583);
+ float _5383 = cam.u_cam_pos.x;
+ float _5384 = cam.u_cam_pos.y;
+ float _5385 = cam.u_cam_pos.z;
+ float _5386 = _2583;
+ float _5387 = _2586;
+ float _5388 = _2588;
+ float _5389 = _2604;
+ float _5390 = _2618;
+ float _5391 = _2628;
+ float _5392 = _2635 * sqrt(((_2604 * _2604) / _2635) + ((_2583 * _2583) * ((_2618 * _2618) + (((sin(_2586) * sin(_2586)) * _2628) * _2628))));
+ vec4 _5453 = vec4(0.0);
+ vec3 _5454 = vec3(0.0);
+ int _2340;
+ if (cam.u_moving != 0)
+ {
+ _2340 = sim.u_max_steps_moving;
+ }
+ else
+ {
+ _2340 = sim.u_max_steps_static;
+ }
+ if (_2340 <= 0)
+ {
+ if (cam.u_moving != 0)
+ {
+ _2340 = 12000;
+ }
+ else
+ {
+ _2340 = 8000;
+ }
+ }
+ float _2341;
+ if (sim.u_early_exit_distance > 0.0)
+ {
+ _2341 = sim.u_early_exit_distance;
+ }
+ else
+ {
+ _2341 = 1999999991808.0;
+ }
+ int _2342 = 0;
+ bool _2343;
+ bool _2344;
+ bool _2345;
+ vec3 _2346;
+ bool _2350;
+ bool _2656;
+ float _2657;
+ vec3 _2695;
+ vec3 _2805;
+ bool _2806;
+ float _2807;
+ vec3 _2909;
+ float _2910;
+ bool _3149;
+ for (;;)
+ {
+ if (!(_2342 < _2340))
+ {
+ _2343 = false;
+ _2346 = vec3(0.0);
+ _2344 = false;
+ _2345 = false;
+ break;
+ }
+ if (_5386 <= 12689999872.0)
+ {
+ _2343 = false;
+ _2346 = vec3(0.0);
+ _2344 = true;
+ _2345 = false;
+ break;
+ }
+ if (_5386 > _2341)
+ {
+ _2343 = true;
+ }
+ else
+ {
+ _2343 = _5386 > 1000000015047466219876688855040.0;
+ }
+ if (_2343)
+ {
+ _2343 = false;
+ _2346 = vec3(0.0);
+ _2344 = false;
+ _2345 = false;
+ break;
+ }
+ float _2437 = _5383;
+ float _2439 = _5384;
+ float _2441 = _5385;
+ vec3 _2442 = vec3(_2437, _2439, _2441);
+ float _5459 = _2439;
+ float _2664 = 0.0199999995529651641845703125 * max(_5386 - 19035000832.0, 0.0);
+ if (length(vec2(_2437, _2441)) < (disk.u_outer_radius * 3.0))
+ {
+ _2656 = abs(_5459) < (disk.u_thickness * 8.0);
+ }
+ else
+ {
+ _2656 = false;
+ }
+ if (_2656)
+ {
+ _2657 = min(_2664, disk.u_thickness);
+ }
+ else
+ {
+ _2657 = _2664;
+ }
+ float _2693 = clamp(_2657, 1000000.0, 20000000000.0);
+ float _5449 = _5391;
+ float _5448 = _5390;
+ float _5447 = _5389;
+ float _5446 = _5388;
+ float _5445 = _5387;
+ float _5444 = _5386;
+ float _2761 = 1.0 - (12689999872.0 / _5444);
+ float _2764 = _5392 / _2761;
+ vec3 _2765 = vec3(_5447, _5448, _5449);
+ float _2768 = (2.0 * _5444) * _5444;
+ float _2780 = sin(_5445);
+ vec3 _5652 = _2695;
+ _5652.x = ((((((-12689999872.0) / _2768) * _2761) * _2764) * _2764) + (((12689999872.0 / (_2768 * _2761)) * _5447) * _5447)) + (_5444 * ((_5448 * _5448) + (((_2780 * _2780) * _5449) * _5449)));
+ float _2788 = (-2.0) * _5447;
+ float _2791 = cos(_5445);
+ _5652.y = ((_2788 * _5448) / _5444) + (((_2780 * _2791) * _5449) * _5449);
+ _5652.z = ((_2788 * _5449) / _5444) - ((((2.0 * _2791) / _2780) * _5448) * _5449);
+ _2695 = _5652;
+ float _2705 = _5444 + (_2693 * _2765.x);
+ _5386 = _2705;
+ float _2711 = _5445 + (_2693 * _2765.y);
+ _5387 = _2711;
+ float _2717 = _5446 + (_2693 * _2765.z);
+ _5388 = _2717;
+ _5389 = _5447 + (_2693 * _5652.x);
+ _5390 = _5448 + (_2693 * _5652.y);
+ _5391 = _5449 + (_2693 * _5652.z);
+ float _2740 = (_2705 * sin(_2711)) * cos(_2717);
+ _5383 = _2740;
+ float _2745 = (_2705 * sin(_2711)) * sin(_2717);
+ _5384 = _2745;
+ float _2748 = _2705 * cos(_2711);
+ _5385 = _2748;
+ vec3 _2449 = vec3(_2740, _2745, _2748);
+ bool _2453 = (_2439 * _2745) < 0.0;
+ if (_2453)
+ {
+ _2344 = true;
+ }
+ else
+ {
+ _2344 = abs(_2745) <= disk.u_thickness;
+ }
+ if (_2344)
+ {
+ if (_2453)
+ {
+ _2346 = mix(_2442, _2449, vec3(_2439 / (_2439 - _2745)));
+ }
+ else
+ {
+ _2346 = _2449;
+ }
+ float _2473 = length(vec2(_2346.xz));
+ if (_2473 >= max(disk.u_inner_radius, 38070001664.0))
+ {
+ _2345 = _2473 <= disk.u_outer_radius;
+ }
+ else
+ {
+ _2345 = false;
+ }
+ if (_2345)
+ {
+ do
+ {
+ float _2814 = length(vec2(_2346.xz));
+ float _2817 = max(disk.u_inner_radius, 38070001664.0);
+ if (_2814 < _2817)
+ {
+ _2806 = true;
+ }
+ else
+ {
+ _2806 = _2814 > disk.u_outer_radius;
+ }
+ if (_2806)
+ {
+ _2805 = vec3(0.0);
+ break;
+ }
+ float _2828 = _2814 / _2817;
+ float _2837 = pow(max((1.0 - sqrt(1.0 / _2828)) / ((_2828 * _2828) * _2828), 0.0) * 17.5746936798095703125, 0.25);
+ float _2859 = sqrt(max(1.0 - (19035000832.0 / _2814), 0.0)) / max(1.0 - dot(normalize(cross(vec3(0.0, 1.0, 0.0), normalize(vec3(_2346.x, 0.0, _2346.z)))) * sqrt(6344999936.0 / max(_2814 - 12689999872.0, 1.0)), -normalize(_2449 - _2442)), 0.001000000047497451305389404296875);
+ float _2914 = clamp(_2859 * (disk.u_temperature * _2837), 1000.0, 40000.0) * 0.00999999977648258209228515625;
+ bool _2916 = _2914 <= 66.0;
+ if (_2916)
+ {
+ _2910 = 1.0;
+ }
+ else
+ {
+ _2910 = clamp(1.29293620586395263671875 * pow(_2914 - 60.0, -0.133204758167266845703125), 0.0, 1.0);
+ }
+ vec3 _5658 = _2909;
+ _5658.x = _2910;
+ _2909 = _5658;
+ if (_2916)
+ {
+ _2910 = clamp((0.390081584453582763671875 * log(_2914)) - 0.6318414211273193359375, 0.0, 1.0);
+ }
+ else
+ {
+ _2910 = clamp(1.129890918731689453125 * pow(_2914 - 60.0, -0.075514845550060272216796875), 0.0, 1.0);
+ }
+ vec3 _5660 = _2909;
+ _5660.y = _2910;
+ _2909 = _5660;
+ if (_2914 >= 66.0)
+ {
+ _2910 = 1.0;
+ }
+ else
+ {
+ if (_2914 <= 19.0)
+ {
+ _2910 = 0.0;
+ }
+ else
+ {
+ _2910 = clamp((0.54320681095123291015625 * log(_2914 - 10.0)) - 1.19625413417816162109375, 0.0, 1.0);
+ }
+ }
+ vec3 _5662 = _2909;
+ _5662.z = _2910;
+ _2909 = _5662;
+ float _2871 = (pow(_2837, 2.0) * pow(_2859, 4.0)) * (smoothstep(_2817, _2817 * 1.12000000476837158203125, _2814) * (1.0 - smoothstep(disk.u_outer_radius * 0.87999999523162841796875, disk.u_outer_radius, _2814)));
+ if (disk.u_turbulence > 0.0)
+ {
+ float _2881 = (sim.u_time * 0.300000011920928955078125) / sqrt(_2828);
+ float _2882 = cos(_2881);
+ float _2884 = sin(_2881);
+ vec3 _2954 = (vec3((_2346.x * _2882) - (_2346.z * _2884), 0.0, (_2346.x * _2884) + (_2346.z * _2882)) * 1.0000000133514319600180897396058e-10) * 3.0;
+ int _2955 = 0;
+ float _2956 = 0.5;
+ float _2957 = 0.0;
+ for (;;)
+ {
+ if (!(_2955 < 3))
+ {
+ break;
+ }
+ vec3 _2988 = floor(_2954);
+ vec3 _2989 = fract(_2954);
+ vec3 _2994 = (_2989 * _2989) * (vec3(3.0) - (_2989 * 2.0));
+ vec3 _3023 = fract(_2988 * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3029 = _3023 + vec3(dot(_3023, _3023.yxz + vec3(33.3300018310546875)));
+ vec3 _3039 = fract((_2988 + vec3(1.0, 0.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3045 = _3039 + vec3(dot(_3039, _3039.yxz + vec3(33.3300018310546875)));
+ vec3 _3055 = fract((_2988 + vec3(0.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3061 = _3055 + vec3(dot(_3055, _3055.yxz + vec3(33.3300018310546875)));
+ vec3 _3071 = fract((_2988 + vec3(1.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3077 = _3071 + vec3(dot(_3071, _3071.yxz + vec3(33.3300018310546875)));
+ vec3 _3087 = fract((_2988 + vec3(0.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3093 = _3087 + vec3(dot(_3087, _3087.yxz + vec3(33.3300018310546875)));
+ vec3 _3103 = fract((_2988 + vec3(1.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3109 = _3103 + vec3(dot(_3103, _3103.yxz + vec3(33.3300018310546875)));
+ vec3 _3119 = fract((_2988 + vec3(0.0, 1.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3125 = _3119 + vec3(dot(_3119, _3119.yxz + vec3(33.3300018310546875)));
+ vec3 _3135 = fract((_2988 + vec3(1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3141 = _3135 + vec3(dot(_3135, _3135.yxz + vec3(33.3300018310546875)));
+ float _3010 = _2994.x;
+ float _3013 = _2994.y;
+ float _2970 = _2956;
+ float _2971 = _2970 * mix(mix(mix(fract((_3029.x + _3029.y) * _3029.z), fract((_3045.x + _3045.y) * _3045.z), _3010), mix(fract((_3061.x + _3061.y) * _3061.z), fract((_3077.x + _3077.y) * _3077.z), _3010), _3013), mix(mix(fract((_3093.x + _3093.y) * _3093.z), fract((_3109.x + _3109.y) * _3109.z), _3010), mix(fract((_3125.x + _3125.y) * _3125.z), fract((_3141.x + _3141.y) * _3141.z), _3010), _3013), _2994.z);
+ _2954 = (_2954 * 2.0) + vec3(100.0, 200.0, 300.0);
+ _2955++;
+ _2956 = _2970 * 0.5;
+ _2957 += _2971;
+ continue;
+ }
+ _2807 = _2871 * max(1.0 + (disk.u_turbulence * (_2957 - 0.5)), 0.0);
+ }
+ else
+ {
+ _2807 = _2871;
+ }
+ _2805 = (_5662 * _2807) * max(disk.u_brightness, 0.0);
+ break;
+ } while(false);
+ _2343 = true;
+ _2346 = _2805;
+ _2344 = false;
+ _2345 = false;
+ break;
+ }
+ }
+ if ((_2342 - 5 * (_2342 / 5)) == 0)
+ {
+ float _5466 = _5383;
+ float _5467 = _5384;
+ float _5468 = _5385;
+ _3148 = false;
+ do
+ {
+ vec3 _3160 = vec3(_5466, _5467, _5468);
+ int _3150 = 0;
+ for (;;)
+ {
+ bool _3163_ladder_break = false;
+ do
+ {
+ if (!(_3150 < obj.u_num_objects))
+ {
+ _3163_ladder_break = true;
+ break;
+ }
+ vec3 _3179 = _3160 - obj.u_obj_pos_radius.data[_3150].xyz;
+ float _3180 = dot(_3179, _3179);
+ float _3181 = obj.u_obj_pos_radius.data[_3150].w * obj.u_obj_pos_radius.data[_3150].w;
+ if (_3180 > (_3181 * 4.0))
+ {
+ break;
+ }
+ if (_3180 <= _3181)
+ {
+ _5453 = obj.u_obj_color.data[_3150];
+ _5454 = obj.u_obj_pos_radius.data[_3150].xyz;
+ _3148 = true;
+ _3149 = true;
+ _3163_ladder_break = true;
+ break;
+ }
+ break;
+ } while(false);
+ if (_3163_ladder_break)
+ {
+ break;
+ }
+ _3150++;
+ continue;
+ }
+ if (_3148)
+ {
+ break;
+ }
+ _3148 = true;
+ _3149 = false;
+ break;
+ } while(false);
+ _2345 = _3149;
+ }
+ else
+ {
+ _2345 = false;
+ }
+ if (_2345)
+ {
+ _2343 = false;
+ _2346 = vec3(0.0);
+ _2344 = false;
+ _2345 = true;
+ break;
+ }
+ if (_5389 > 0.0)
+ {
+ _2350 = _5386 > 634500022272.0;
+ }
+ else
+ {
+ _2350 = false;
+ }
+ if (_2350)
+ {
+ _2343 = false;
+ _2346 = vec3(0.0);
+ _2344 = false;
+ _2345 = false;
+ break;
+ }
+ _2342++;
+ continue;
+ }
+ vec3 _2528 = normalize(vec3(_5383, _5384, _5385) - cam.u_cam_pos);
+ vec3 _3209 = dFdx(_2528);
+ vec3 _3212 = dFdy(_2528);
+ vec3 _2351;
+ if (_2343)
+ {
+ _2351 = _2346;
+ }
+ else
+ {
+ if (_2344)
+ {
+ _2351 = vec3(0.0);
+ }
+ else
+ {
+ if (_2345)
+ {
+ vec3 _2552 = vec3(_5383, _5384, _5385);
+ _2351 = _5453.xyz * (0.100000001490116119384765625 + (0.89999997615814208984375 * max(dot(normalize(_2552 - _5454), normalize(cam.u_cam_pos - _2552)), 0.0)));
+ }
+ else
+ {
+ _2351 = textureLod(u_HDRIEnvironment, _2528, clamp(log2(max(max(length(_3209), length(_3212)) * 666.66668701171875, 1.0)), 0.0, 10.0)).xyz;
+ }
+ }
+ }
+ entryPointParam_fragmentMain = vec4(_2351, 1.0);
+ break;
+ }
+ if (cam.u_moving != 0)
+ {
+ vec3 _3253 = normalize(((cam.u_cam_right * ((((2.0 * _v0.x) - 1.0) * cam.u_aspect) * cam.u_tan_half_fov)) - (cam.u_cam_up * ((1.0 - (2.0 * _v0.y)) * cam.u_tan_half_fov))) + cam.u_cam_forward);
+ float _3458 = length(cam.u_cam_pos);
+ float _3461 = acos(cam.u_cam_pos.z / _3458);
+ float _3463 = atan(cam.u_cam_pos.y, cam.u_cam_pos.x);
+ float _3464 = _3253.x;
+ float _3465 = _3253.y;
+ float _3466 = _3253.z;
+ float _3479 = (((sin(_3461) * cos(_3463)) * _3464) + ((sin(_3461) * sin(_3463)) * _3465)) + (cos(_3461) * _3466);
+ float _3493 = ((((cos(_3461) * cos(_3463)) * _3464) + ((cos(_3461) * sin(_3463)) * _3465)) - (sin(_3461) * _3466)) / _3458;
+ float _3503 = (((-sin(_3463)) * _3464) + (cos(_3463) * _3465)) / (_3458 * sin(_3461));
+ float _3510 = 1.0 - (12689999872.0 / _3458);
+ float _5225 = cam.u_cam_pos.x;
+ float _5226 = cam.u_cam_pos.y;
+ float _5227 = cam.u_cam_pos.z;
+ float _5228 = _3458;
+ float _5229 = _3461;
+ float _5230 = _3463;
+ float _5231 = _3479;
+ float _5232 = _3493;
+ float _5233 = _3503;
+ float _5234 = _3510 * sqrt(((_3479 * _3479) / _3510) + ((_3458 * _3458) * ((_3493 * _3493) + (((sin(_3461) * sin(_3461)) * _3503) * _3503))));
+ vec4 _5295 = vec4(0.0);
+ vec3 _5296 = vec3(0.0);
+ int _3215;
+ if (cam.u_moving != 0)
+ {
+ _3215 = sim.u_max_steps_moving;
+ }
+ else
+ {
+ _3215 = sim.u_max_steps_static;
+ }
+ if (_3215 <= 0)
+ {
+ if (cam.u_moving != 0)
+ {
+ _3215 = 12000;
+ }
+ else
+ {
+ _3215 = 8000;
+ }
+ }
+ float _3216;
+ if (sim.u_early_exit_distance > 0.0)
+ {
+ _3216 = sim.u_early_exit_distance;
+ }
+ else
+ {
+ _3216 = 1999999991808.0;
+ }
+ int _3217 = 0;
+ bool _3218;
+ bool _3219;
+ bool _3220;
+ vec3 _3221;
+ bool _3225;
+ bool _3531;
+ float _3532;
+ vec3 _3570;
+ vec3 _3680;
+ bool _3681;
+ float _3682;
+ vec3 _3784;
+ float _3785;
+ bool _4024;
+ for (;;)
+ {
+ if (!(_3217 < _3215))
+ {
+ _3218 = false;
+ _3221 = vec3(0.0);
+ _3219 = false;
+ _3220 = false;
+ break;
+ }
+ if (_5228 <= 12689999872.0)
+ {
+ _3218 = false;
+ _3221 = vec3(0.0);
+ _3219 = true;
+ _3220 = false;
+ break;
+ }
+ if (_5228 > _3216)
+ {
+ _3218 = true;
+ }
+ else
+ {
+ _3218 = _5228 > 1000000015047466219876688855040.0;
+ }
+ if (_3218)
+ {
+ _3218 = false;
+ _3221 = vec3(0.0);
+ _3219 = false;
+ _3220 = false;
+ break;
+ }
+ float _3312 = _5225;
+ float _3314 = _5226;
+ float _3316 = _5227;
+ vec3 _3317 = vec3(_3312, _3314, _3316);
+ float _5301 = _3314;
+ float _3539 = 0.0199999995529651641845703125 * max(_5228 - 19035000832.0, 0.0);
+ if (length(vec2(_3312, _3316)) < (disk.u_outer_radius * 3.0))
+ {
+ _3531 = abs(_5301) < (disk.u_thickness * 8.0);
+ }
+ else
+ {
+ _3531 = false;
+ }
+ if (_3531)
+ {
+ _3532 = min(_3539, disk.u_thickness);
+ }
+ else
+ {
+ _3532 = _3539;
+ }
+ float _3568 = clamp(_3532, 1000000.0, 20000000000.0);
+ float _5291 = _5233;
+ float _5290 = _5232;
+ float _5289 = _5231;
+ float _5288 = _5230;
+ float _5287 = _5229;
+ float _5286 = _5228;
+ float _3636 = 1.0 - (12689999872.0 / _5286);
+ float _3639 = _5234 / _3636;
+ vec3 _3640 = vec3(_5289, _5290, _5291);
+ float _3643 = (2.0 * _5286) * _5286;
+ float _3655 = sin(_5287);
+ vec3 _5664 = _3570;
+ _5664.x = ((((((-12689999872.0) / _3643) * _3636) * _3639) * _3639) + (((12689999872.0 / (_3643 * _3636)) * _5289) * _5289)) + (_5286 * ((_5290 * _5290) + (((_3655 * _3655) * _5291) * _5291)));
+ float _3663 = (-2.0) * _5289;
+ float _3666 = cos(_5287);
+ _5664.y = ((_3663 * _5290) / _5286) + (((_3655 * _3666) * _5291) * _5291);
+ _5664.z = ((_3663 * _5291) / _5286) - ((((2.0 * _3666) / _3655) * _5290) * _5291);
+ _3570 = _5664;
+ float _3580 = _5286 + (_3568 * _3640.x);
+ _5228 = _3580;
+ float _3586 = _5287 + (_3568 * _3640.y);
+ _5229 = _3586;
+ float _3592 = _5288 + (_3568 * _3640.z);
+ _5230 = _3592;
+ _5231 = _5289 + (_3568 * _5664.x);
+ _5232 = _5290 + (_3568 * _5664.y);
+ _5233 = _5291 + (_3568 * _5664.z);
+ float _3615 = (_3580 * sin(_3586)) * cos(_3592);
+ _5225 = _3615;
+ float _3620 = (_3580 * sin(_3586)) * sin(_3592);
+ _5226 = _3620;
+ float _3623 = _3580 * cos(_3586);
+ _5227 = _3623;
+ vec3 _3324 = vec3(_3615, _3620, _3623);
+ bool _3328 = (_3314 * _3620) < 0.0;
+ if (_3328)
+ {
+ _3219 = true;
+ }
+ else
+ {
+ _3219 = abs(_3620) <= disk.u_thickness;
+ }
+ if (_3219)
+ {
+ if (_3328)
+ {
+ _3221 = mix(_3317, _3324, vec3(_3314 / (_3314 - _3620)));
+ }
+ else
+ {
+ _3221 = _3324;
+ }
+ float _3348 = length(vec2(_3221.xz));
+ if (_3348 >= max(disk.u_inner_radius, 38070001664.0))
+ {
+ _3220 = _3348 <= disk.u_outer_radius;
+ }
+ else
+ {
+ _3220 = false;
+ }
+ if (_3220)
+ {
+ do
+ {
+ float _3689 = length(vec2(_3221.xz));
+ float _3692 = max(disk.u_inner_radius, 38070001664.0);
+ if (_3689 < _3692)
+ {
+ _3681 = true;
+ }
+ else
+ {
+ _3681 = _3689 > disk.u_outer_radius;
+ }
+ if (_3681)
+ {
+ _3680 = vec3(0.0);
+ break;
+ }
+ float _3703 = _3689 / _3692;
+ float _3712 = pow(max((1.0 - sqrt(1.0 / _3703)) / ((_3703 * _3703) * _3703), 0.0) * 17.5746936798095703125, 0.25);
+ float _3734 = sqrt(max(1.0 - (19035000832.0 / _3689), 0.0)) / max(1.0 - dot(normalize(cross(vec3(0.0, 1.0, 0.0), normalize(vec3(_3221.x, 0.0, _3221.z)))) * sqrt(6344999936.0 / max(_3689 - 12689999872.0, 1.0)), -normalize(_3324 - _3317)), 0.001000000047497451305389404296875);
+ float _3789 = clamp(_3734 * (disk.u_temperature * _3712), 1000.0, 40000.0) * 0.00999999977648258209228515625;
+ bool _3791 = _3789 <= 66.0;
+ if (_3791)
+ {
+ _3785 = 1.0;
+ }
+ else
+ {
+ _3785 = clamp(1.29293620586395263671875 * pow(_3789 - 60.0, -0.133204758167266845703125), 0.0, 1.0);
+ }
+ vec3 _5670 = _3784;
+ _5670.x = _3785;
+ _3784 = _5670;
+ if (_3791)
+ {
+ _3785 = clamp((0.390081584453582763671875 * log(_3789)) - 0.6318414211273193359375, 0.0, 1.0);
+ }
+ else
+ {
+ _3785 = clamp(1.129890918731689453125 * pow(_3789 - 60.0, -0.075514845550060272216796875), 0.0, 1.0);
+ }
+ vec3 _5672 = _3784;
+ _5672.y = _3785;
+ _3784 = _5672;
+ if (_3789 >= 66.0)
+ {
+ _3785 = 1.0;
+ }
+ else
+ {
+ if (_3789 <= 19.0)
+ {
+ _3785 = 0.0;
+ }
+ else
+ {
+ _3785 = clamp((0.54320681095123291015625 * log(_3789 - 10.0)) - 1.19625413417816162109375, 0.0, 1.0);
+ }
+ }
+ vec3 _5674 = _3784;
+ _5674.z = _3785;
+ _3784 = _5674;
+ float _3746 = (pow(_3712, 2.0) * pow(_3734, 4.0)) * (smoothstep(_3692, _3692 * 1.12000000476837158203125, _3689) * (1.0 - smoothstep(disk.u_outer_radius * 0.87999999523162841796875, disk.u_outer_radius, _3689)));
+ if (disk.u_turbulence > 0.0)
+ {
+ float _3756 = (sim.u_time * 0.300000011920928955078125) / sqrt(_3703);
+ float _3757 = cos(_3756);
+ float _3759 = sin(_3756);
+ vec3 _3829 = (vec3((_3221.x * _3757) - (_3221.z * _3759), 0.0, (_3221.x * _3759) + (_3221.z * _3757)) * 1.0000000133514319600180897396058e-10) * 3.0;
+ int _3830 = 0;
+ float _3831 = 0.5;
+ float _3832 = 0.0;
+ for (;;)
+ {
+ if (!(_3830 < 3))
+ {
+ break;
+ }
+ vec3 _3863 = floor(_3829);
+ vec3 _3864 = fract(_3829);
+ vec3 _3869 = (_3864 * _3864) * (vec3(3.0) - (_3864 * 2.0));
+ vec3 _3898 = fract(_3863 * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3904 = _3898 + vec3(dot(_3898, _3898.yxz + vec3(33.3300018310546875)));
+ vec3 _3914 = fract((_3863 + vec3(1.0, 0.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3920 = _3914 + vec3(dot(_3914, _3914.yxz + vec3(33.3300018310546875)));
+ vec3 _3930 = fract((_3863 + vec3(0.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3936 = _3930 + vec3(dot(_3930, _3930.yxz + vec3(33.3300018310546875)));
+ vec3 _3946 = fract((_3863 + vec3(1.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3952 = _3946 + vec3(dot(_3946, _3946.yxz + vec3(33.3300018310546875)));
+ vec3 _3962 = fract((_3863 + vec3(0.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3968 = _3962 + vec3(dot(_3962, _3962.yxz + vec3(33.3300018310546875)));
+ vec3 _3978 = fract((_3863 + vec3(1.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _3984 = _3978 + vec3(dot(_3978, _3978.yxz + vec3(33.3300018310546875)));
+ vec3 _3994 = fract((_3863 + vec3(0.0, 1.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4000 = _3994 + vec3(dot(_3994, _3994.yxz + vec3(33.3300018310546875)));
+ vec3 _4010 = fract((_3863 + vec3(1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4016 = _4010 + vec3(dot(_4010, _4010.yxz + vec3(33.3300018310546875)));
+ float _3885 = _3869.x;
+ float _3888 = _3869.y;
+ float _3845 = _3831;
+ float _3846 = _3845 * mix(mix(mix(fract((_3904.x + _3904.y) * _3904.z), fract((_3920.x + _3920.y) * _3920.z), _3885), mix(fract((_3936.x + _3936.y) * _3936.z), fract((_3952.x + _3952.y) * _3952.z), _3885), _3888), mix(mix(fract((_3968.x + _3968.y) * _3968.z), fract((_3984.x + _3984.y) * _3984.z), _3885), mix(fract((_4000.x + _4000.y) * _4000.z), fract((_4016.x + _4016.y) * _4016.z), _3885), _3888), _3869.z);
+ _3829 = (_3829 * 2.0) + vec3(100.0, 200.0, 300.0);
+ _3830++;
+ _3831 = _3845 * 0.5;
+ _3832 += _3846;
+ continue;
+ }
+ _3682 = _3746 * max(1.0 + (disk.u_turbulence * (_3832 - 0.5)), 0.0);
+ }
+ else
+ {
+ _3682 = _3746;
+ }
+ _3680 = (_5674 * _3682) * max(disk.u_brightness, 0.0);
+ break;
+ } while(false);
+ _3218 = true;
+ _3221 = _3680;
+ _3219 = false;
+ _3220 = false;
+ break;
+ }
+ }
+ if ((_3217 - 5 * (_3217 / 5)) == 0)
+ {
+ float _5308 = _5225;
+ float _5309 = _5226;
+ float _5310 = _5227;
+ _4023 = false;
+ do
+ {
+ vec3 _4035 = vec3(_5308, _5309, _5310);
+ int _4025 = 0;
+ for (;;)
+ {
+ bool _4038_ladder_break = false;
+ do
+ {
+ if (!(_4025 < obj.u_num_objects))
+ {
+ _4038_ladder_break = true;
+ break;
+ }
+ vec3 _4054 = _4035 - obj.u_obj_pos_radius.data[_4025].xyz;
+ float _4055 = dot(_4054, _4054);
+ float _4056 = obj.u_obj_pos_radius.data[_4025].w * obj.u_obj_pos_radius.data[_4025].w;
+ if (_4055 > (_4056 * 4.0))
+ {
+ break;
+ }
+ if (_4055 <= _4056)
+ {
+ _5295 = obj.u_obj_color.data[_4025];
+ _5296 = obj.u_obj_pos_radius.data[_4025].xyz;
+ _4023 = true;
+ _4024 = true;
+ _4038_ladder_break = true;
+ break;
+ }
+ break;
+ } while(false);
+ if (_4038_ladder_break)
+ {
+ break;
+ }
+ _4025++;
+ continue;
+ }
+ if (_4023)
+ {
+ break;
+ }
+ _4023 = true;
+ _4024 = false;
+ break;
+ } while(false);
+ _3220 = _4024;
+ }
+ else
+ {
+ _3220 = false;
+ }
+ if (_3220)
+ {
+ _3218 = false;
+ _3221 = vec3(0.0);
+ _3219 = false;
+ _3220 = true;
+ break;
+ }
+ if (_5231 > 0.0)
+ {
+ _3225 = _5228 > 634500022272.0;
+ }
+ else
+ {
+ _3225 = false;
+ }
+ if (_3225)
+ {
+ _3218 = false;
+ _3221 = vec3(0.0);
+ _3219 = false;
+ _3220 = false;
+ break;
+ }
+ _3217++;
+ continue;
+ }
+ vec3 _3403 = normalize(vec3(_5225, _5226, _5227) - cam.u_cam_pos);
+ vec3 _4084 = dFdx(_3403);
+ vec3 _4087 = dFdy(_3403);
+ vec3 _3226;
+ if (_3218)
+ {
+ _3226 = _3221;
+ }
+ else
+ {
+ if (_3219)
+ {
+ _3226 = vec3(0.0);
+ }
+ else
+ {
+ if (_3220)
+ {
+ vec3 _3427 = vec3(_5225, _5226, _5227);
+ _3226 = _5295.xyz * (0.100000001490116119384765625 + (0.89999997615814208984375 * max(dot(normalize(_3427 - _5296), normalize(cam.u_cam_pos - _3427)), 0.0)));
+ }
+ else
+ {
+ _3226 = textureLod(u_HDRIEnvironment, _3403, clamp(log2(max(max(length(_4084), length(_4087)) * 666.66668701171875, 1.0)), 0.0, 10.0)).xyz;
+ }
+ }
+ }
+ entryPointParam_fragmentMain = vec4(clamp((_3226 * ((_3226 * 2.5099999904632568359375) + vec3(0.02999999932944774627685546875))) / ((_3226 * ((_3226 * 2.4300000667572021484375) + vec3(0.589999973773956298828125))) + vec3(0.14000000059604644775390625)), vec3(0.0), vec3(1.0)), 1.0);
+ break;
+ }
+ float _4104 = dFdx(_v0.x);
+ float _4107 = dFdy(_v0.y);
+ vec2 _1390 = vec2(_4104, _4107);
+ int i = 0;
+ vec3 sum = vec3(0.0);
+ int _4110;
+ float _4111;
+ bool _4113;
+ bool _4114;
+ bool _4115;
+ vec3 _4116;
+ bool _4120;
+ vec3 _4121;
+ bool _4426;
+ float _4427;
+ vec3 _4465;
+ vec3 _4575;
+ bool _4576;
+ float _4577;
+ vec3 _4679;
+ float _4680;
+ bool _4919;
+ for (;;)
+ {
+ if (!(i < 4))
+ {
+ break;
+ }
+ vec2 _1413 = _v0 + (_1399[i] * _1390);
+ vec3 _4148 = normalize(((cam.u_cam_right * ((((2.0 * _1413.x) - 1.0) * cam.u_aspect) * cam.u_tan_half_fov)) - (cam.u_cam_up * ((1.0 - (2.0 * _1413.y)) * cam.u_tan_half_fov))) + cam.u_cam_forward);
+ float _4353 = length(cam.u_cam_pos);
+ float _4356 = acos(cam.u_cam_pos.z / _4353);
+ float _4358 = atan(cam.u_cam_pos.y, cam.u_cam_pos.x);
+ float _4359 = _4148.x;
+ float _4360 = _4148.y;
+ float _4361 = _4148.z;
+ float _4374 = (((sin(_4356) * cos(_4358)) * _4359) + ((sin(_4356) * sin(_4358)) * _4360)) + (cos(_4356) * _4361);
+ float _4388 = ((((cos(_4356) * cos(_4358)) * _4359) + ((cos(_4356) * sin(_4358)) * _4360)) - (sin(_4356) * _4361)) / _4353;
+ float _4398 = (((-sin(_4358)) * _4359) + (cos(_4358) * _4360)) / (_4353 * sin(_4356));
+ float _4405 = 1.0 - (12689999872.0 / _4353);
+ float _5067 = cam.u_cam_pos.x;
+ float _5068 = cam.u_cam_pos.y;
+ float _5069 = cam.u_cam_pos.z;
+ float _5070 = _4353;
+ float _5071 = _4356;
+ float _5072 = _4358;
+ float _5073 = _4374;
+ float _5074 = _4388;
+ float _5075 = _4398;
+ float _5076 = _4405 * sqrt(((_4374 * _4374) / _4405) + ((_4353 * _4353) * ((_4388 * _4388) + (((sin(_4356) * sin(_4356)) * _4398) * _4398))));
+ vec4 _5137 = vec4(0.0);
+ vec3 _5138 = vec3(0.0);
+ if (cam.u_moving != 0)
+ {
+ _4110 = sim.u_max_steps_moving;
+ }
+ else
+ {
+ _4110 = sim.u_max_steps_static;
+ }
+ if (_4110 <= 0)
+ {
+ if (cam.u_moving != 0)
+ {
+ _4110 = 12000;
+ }
+ else
+ {
+ _4110 = 8000;
+ }
+ }
+ if (sim.u_early_exit_distance > 0.0)
+ {
+ _4111 = sim.u_early_exit_distance;
+ }
+ else
+ {
+ _4111 = 1999999991808.0;
+ }
+ int _4112 = 0;
+ for (;;)
+ {
+ if (!(_4112 < _4110))
+ {
+ _4113 = false;
+ _4116 = vec3(0.0);
+ _4114 = false;
+ _4115 = false;
+ break;
+ }
+ if (_5070 <= 12689999872.0)
+ {
+ _4113 = false;
+ _4116 = vec3(0.0);
+ _4114 = true;
+ _4115 = false;
+ break;
+ }
+ if (_5070 > _4111)
+ {
+ _4113 = true;
+ }
+ else
+ {
+ _4113 = _5070 > 1000000015047466219876688855040.0;
+ }
+ if (_4113)
+ {
+ _4113 = false;
+ _4116 = vec3(0.0);
+ _4114 = false;
+ _4115 = false;
+ break;
+ }
+ float _4207 = _5067;
+ float _4209 = _5068;
+ float _4211 = _5069;
+ vec3 _4212 = vec3(_4207, _4209, _4211);
+ float _5143 = _4209;
+ float _4434 = 0.0199999995529651641845703125 * max(_5070 - 19035000832.0, 0.0);
+ if (length(vec2(_4207, _4211)) < (disk.u_outer_radius * 3.0))
+ {
+ _4426 = abs(_5143) < (disk.u_thickness * 8.0);
+ }
+ else
+ {
+ _4426 = false;
+ }
+ if (_4426)
+ {
+ _4427 = min(_4434, disk.u_thickness);
+ }
+ else
+ {
+ _4427 = _4434;
+ }
+ float _4463 = clamp(_4427, 1000000.0, 20000000000.0);
+ float _5133 = _5075;
+ float _5132 = _5074;
+ float _5131 = _5073;
+ float _5130 = _5072;
+ float _5129 = _5071;
+ float _5128 = _5070;
+ float _4531 = 1.0 - (12689999872.0 / _5128);
+ float _4534 = _5076 / _4531;
+ vec3 _4535 = vec3(_5131, _5132, _5133);
+ float _4538 = (2.0 * _5128) * _5128;
+ float _4550 = sin(_5129);
+ vec3 _5676 = _4465;
+ _5676.x = ((((((-12689999872.0) / _4538) * _4531) * _4534) * _4534) + (((12689999872.0 / (_4538 * _4531)) * _5131) * _5131)) + (_5128 * ((_5132 * _5132) + (((_4550 * _4550) * _5133) * _5133)));
+ float _4558 = (-2.0) * _5131;
+ float _4561 = cos(_5129);
+ _5676.y = ((_4558 * _5132) / _5128) + (((_4550 * _4561) * _5133) * _5133);
+ _5676.z = ((_4558 * _5133) / _5128) - ((((2.0 * _4561) / _4550) * _5132) * _5133);
+ _4465 = _5676;
+ float _4475 = _5128 + (_4463 * _4535.x);
+ _5070 = _4475;
+ float _4481 = _5129 + (_4463 * _4535.y);
+ _5071 = _4481;
+ float _4487 = _5130 + (_4463 * _4535.z);
+ _5072 = _4487;
+ _5073 = _5131 + (_4463 * _5676.x);
+ _5074 = _5132 + (_4463 * _5676.y);
+ _5075 = _5133 + (_4463 * _5676.z);
+ float _4510 = (_4475 * sin(_4481)) * cos(_4487);
+ _5067 = _4510;
+ float _4515 = (_4475 * sin(_4481)) * sin(_4487);
+ _5068 = _4515;
+ float _4518 = _4475 * cos(_4481);
+ _5069 = _4518;
+ vec3 _4219 = vec3(_4510, _4515, _4518);
+ bool _4223 = (_4209 * _4515) < 0.0;
+ if (_4223)
+ {
+ _4114 = true;
+ }
+ else
+ {
+ _4114 = abs(_4515) <= disk.u_thickness;
+ }
+ if (_4114)
+ {
+ if (_4223)
+ {
+ _4116 = mix(_4212, _4219, vec3(_4209 / (_4209 - _4515)));
+ }
+ else
+ {
+ _4116 = _4219;
+ }
+ float _4243 = length(vec2(_4116.xz));
+ if (_4243 >= max(disk.u_inner_radius, 38070001664.0))
+ {
+ _4115 = _4243 <= disk.u_outer_radius;
+ }
+ else
+ {
+ _4115 = false;
+ }
+ if (_4115)
+ {
+ do
+ {
+ float _4584 = length(vec2(_4116.xz));
+ float _4587 = max(disk.u_inner_radius, 38070001664.0);
+ if (_4584 < _4587)
+ {
+ _4576 = true;
+ }
+ else
+ {
+ _4576 = _4584 > disk.u_outer_radius;
+ }
+ if (_4576)
+ {
+ _4575 = vec3(0.0);
+ break;
+ }
+ float _4598 = _4584 / _4587;
+ float _4607 = pow(max((1.0 - sqrt(1.0 / _4598)) / ((_4598 * _4598) * _4598), 0.0) * 17.5746936798095703125, 0.25);
+ float _4629 = sqrt(max(1.0 - (19035000832.0 / _4584), 0.0)) / max(1.0 - dot(normalize(cross(vec3(0.0, 1.0, 0.0), normalize(vec3(_4116.x, 0.0, _4116.z)))) * sqrt(6344999936.0 / max(_4584 - 12689999872.0, 1.0)), -normalize(_4219 - _4212)), 0.001000000047497451305389404296875);
+ float _4684 = clamp(_4629 * (disk.u_temperature * _4607), 1000.0, 40000.0) * 0.00999999977648258209228515625;
+ bool _4686 = _4684 <= 66.0;
+ if (_4686)
+ {
+ _4680 = 1.0;
+ }
+ else
+ {
+ _4680 = clamp(1.29293620586395263671875 * pow(_4684 - 60.0, -0.133204758167266845703125), 0.0, 1.0);
+ }
+ vec3 _5682 = _4679;
+ _5682.x = _4680;
+ _4679 = _5682;
+ if (_4686)
+ {
+ _4680 = clamp((0.390081584453582763671875 * log(_4684)) - 0.6318414211273193359375, 0.0, 1.0);
+ }
+ else
+ {
+ _4680 = clamp(1.129890918731689453125 * pow(_4684 - 60.0, -0.075514845550060272216796875), 0.0, 1.0);
+ }
+ vec3 _5684 = _4679;
+ _5684.y = _4680;
+ _4679 = _5684;
+ if (_4684 >= 66.0)
+ {
+ _4680 = 1.0;
+ }
+ else
+ {
+ if (_4684 <= 19.0)
+ {
+ _4680 = 0.0;
+ }
+ else
+ {
+ _4680 = clamp((0.54320681095123291015625 * log(_4684 - 10.0)) - 1.19625413417816162109375, 0.0, 1.0);
+ }
+ }
+ vec3 _5686 = _4679;
+ _5686.z = _4680;
+ _4679 = _5686;
+ float _4641 = (pow(_4607, 2.0) * pow(_4629, 4.0)) * (smoothstep(_4587, _4587 * 1.12000000476837158203125, _4584) * (1.0 - smoothstep(disk.u_outer_radius * 0.87999999523162841796875, disk.u_outer_radius, _4584)));
+ if (disk.u_turbulence > 0.0)
+ {
+ float _4651 = (sim.u_time * 0.300000011920928955078125) / sqrt(_4598);
+ float _4652 = cos(_4651);
+ float _4654 = sin(_4651);
+ vec3 _4724 = (vec3((_4116.x * _4652) - (_4116.z * _4654), 0.0, (_4116.x * _4654) + (_4116.z * _4652)) * 1.0000000133514319600180897396058e-10) * 3.0;
+ int _4725 = 0;
+ float _4726 = 0.5;
+ float _4727 = 0.0;
+ for (;;)
+ {
+ if (!(_4725 < 3))
+ {
+ break;
+ }
+ vec3 _4758 = floor(_4724);
+ vec3 _4759 = fract(_4724);
+ vec3 _4764 = (_4759 * _4759) * (vec3(3.0) - (_4759 * 2.0));
+ vec3 _4793 = fract(_4758 * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4799 = _4793 + vec3(dot(_4793, _4793.yxz + vec3(33.3300018310546875)));
+ vec3 _4809 = fract((_4758 + vec3(1.0, 0.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4815 = _4809 + vec3(dot(_4809, _4809.yxz + vec3(33.3300018310546875)));
+ vec3 _4825 = fract((_4758 + vec3(0.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4831 = _4825 + vec3(dot(_4825, _4825.yxz + vec3(33.3300018310546875)));
+ vec3 _4841 = fract((_4758 + vec3(1.0, 1.0, 0.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4847 = _4841 + vec3(dot(_4841, _4841.yxz + vec3(33.3300018310546875)));
+ vec3 _4857 = fract((_4758 + vec3(0.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4863 = _4857 + vec3(dot(_4857, _4857.yxz + vec3(33.3300018310546875)));
+ vec3 _4873 = fract((_4758 + vec3(1.0, 0.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4879 = _4873 + vec3(dot(_4873, _4873.yxz + vec3(33.3300018310546875)));
+ vec3 _4889 = fract((_4758 + vec3(0.0, 1.0, 1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4895 = _4889 + vec3(dot(_4889, _4889.yxz + vec3(33.3300018310546875)));
+ vec3 _4905 = fract((_4758 + vec3(1.0)) * vec3(0.103100001811981201171875, 0.10300000011920928955078125, 0.097300000488758087158203125));
+ vec3 _4911 = _4905 + vec3(dot(_4905, _4905.yxz + vec3(33.3300018310546875)));
+ float _4780 = _4764.x;
+ float _4783 = _4764.y;
+ float _4740 = _4726;
+ float _4741 = _4740 * mix(mix(mix(fract((_4799.x + _4799.y) * _4799.z), fract((_4815.x + _4815.y) * _4815.z), _4780), mix(fract((_4831.x + _4831.y) * _4831.z), fract((_4847.x + _4847.y) * _4847.z), _4780), _4783), mix(mix(fract((_4863.x + _4863.y) * _4863.z), fract((_4879.x + _4879.y) * _4879.z), _4780), mix(fract((_4895.x + _4895.y) * _4895.z), fract((_4911.x + _4911.y) * _4911.z), _4780), _4783), _4764.z);
+ _4724 = (_4724 * 2.0) + vec3(100.0, 200.0, 300.0);
+ _4725++;
+ _4726 = _4740 * 0.5;
+ _4727 += _4741;
+ continue;
+ }
+ _4577 = _4641 * max(1.0 + (disk.u_turbulence * (_4727 - 0.5)), 0.0);
+ }
+ else
+ {
+ _4577 = _4641;
+ }
+ _4575 = (_5686 * _4577) * max(disk.u_brightness, 0.0);
+ break;
+ } while(false);
+ _4113 = true;
+ _4116 = _4575;
+ _4114 = false;
+ _4115 = false;
+ break;
+ }
+ }
+ if ((_4112 - 5 * (_4112 / 5)) == 0)
+ {
+ float _5150 = _5067;
+ float _5151 = _5068;
+ float _5152 = _5069;
+ _4918 = false;
+ do
+ {
+ vec3 _4930 = vec3(_5150, _5151, _5152);
+ int _4920 = 0;
+ for (;;)
+ {
+ bool _4933_ladder_break = false;
+ do
+ {
+ if (!(_4920 < obj.u_num_objects))
+ {
+ _4933_ladder_break = true;
+ break;
+ }
+ vec3 _4949 = _4930 - obj.u_obj_pos_radius.data[_4920].xyz;
+ float _4950 = dot(_4949, _4949);
+ float _4951 = obj.u_obj_pos_radius.data[_4920].w * obj.u_obj_pos_radius.data[_4920].w;
+ if (_4950 > (_4951 * 4.0))
+ {
+ break;
+ }
+ if (_4950 <= _4951)
+ {
+ _5137 = obj.u_obj_color.data[_4920];
+ _5138 = obj.u_obj_pos_radius.data[_4920].xyz;
+ _4918 = true;
+ _4919 = true;
+ _4933_ladder_break = true;
+ break;
+ }
+ break;
+ } while(false);
+ if (_4933_ladder_break)
+ {
+ break;
+ }
+ _4920++;
+ continue;
+ }
+ if (_4918)
+ {
+ break;
+ }
+ _4918 = true;
+ _4919 = false;
+ break;
+ } while(false);
+ _4115 = _4919;
+ }
+ else
+ {
+ _4115 = false;
+ }
+ if (_4115)
+ {
+ _4113 = false;
+ _4116 = vec3(0.0);
+ _4114 = false;
+ _4115 = true;
+ break;
+ }
+ if (_5073 > 0.0)
+ {
+ _4120 = _5070 > 634500022272.0;
+ }
+ else
+ {
+ _4120 = false;
+ }
+ if (_4120)
+ {
+ _4113 = false;
+ _4116 = vec3(0.0);
+ _4114 = false;
+ _4115 = false;
+ break;
+ }
+ _4112++;
+ continue;
+ }
+ vec3 _4298 = normalize(vec3(_5067, _5068, _5069) - cam.u_cam_pos);
+ vec3 _4979 = dFdx(_4298);
+ vec3 _4982 = dFdy(_4298);
+ if (_4113)
+ {
+ _4121 = _4116;
+ }
+ else
+ {
+ if (_4114)
+ {
+ _4121 = vec3(0.0);
+ }
+ else
+ {
+ if (_4115)
+ {
+ vec3 _4322 = vec3(_5067, _5068, _5069);
+ _4121 = _5137.xyz * (0.100000001490116119384765625 + (0.89999997615814208984375 * max(dot(normalize(_4322 - _5138), normalize(cam.u_cam_pos - _4322)), 0.0)));
+ }
+ else
+ {
+ _4121 = textureLod(u_HDRIEnvironment, _4298, clamp(log2(max(max(length(_4979), length(_4982)) * 666.66668701171875, 1.0)), 0.0, 10.0)).xyz;
+ }
+ }
+ }
+ i++;
+ sum += _4121;
+ continue;
+ }
+ vec3 _1426 = sum * 0.25;
+ entryPointParam_fragmentMain = vec4(clamp((_1426 * ((_1426 * 2.5099999904632568359375) + vec3(0.02999999932944774627685546875))) / ((_1426 * ((_1426 * 2.4300000667572021484375) + vec3(0.589999973773956298828125))) + vec3(0.14000000059604644775390625)), vec3(0.0), vec3(1.0)), 1.0);
+ break;
+ } while(false);
+}
+
+