diff options
Diffstat (limited to 'assets/shaders/generated/geodesic.glsl')
| -rw-r--r-- | assets/shaders/generated/geodesic.glsl | 1854 |
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); +} + + |