[add]: volumetric cloud rendering

1 files changed, 194 insertions, 18 deletions

diff --git a/Assets/Shaders/Geodesic.glsl b/Assets/Shaders/Geodesic.glsl
index 9f871a7..ace58a5 100644
--- a/Assets/Shaders/Geodesic.glsl
+++ b/Assets/Shaders/Geodesic.glsl
@@ -20,6 +20,7 @@ layout(std140, binding = 2) uniform Disk
     float disk_r2;
     float disk_num;
     float thickness;
+    float disk_density;
 };
 
 layout(std140, binding = 3) uniform Objects 
@@ -35,7 +36,7 @@ layout(std140, binding = 4) uniform Simulation
     int   maxStepsMoving;
     int   maxStepsStatic;
     float earlyExitDistance;
-    int   _pad0;
+    float time;
 };
 
 const float  SagA_rs  = 1.269e10;
@@ -54,6 +55,112 @@ vec4 objectColor = vec4(0.0);
 vec3 hitCenter = vec3(0.0);
 float hitRadius = 0.0;
 
+float hash(float p) 
+{
+    p = fract(p * 0.1031);
+    p *= p + 33.33;
+    p *= p + p;
+    return fract(p);
+}
+
+float hash(vec2 p) 
+{
+    vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973));
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+float hash(vec3 p) 
+{
+    p = fract(p * vec3(0.1031, 0.1030, 0.0973));
+    p += dot(p, p.yxz + 33.33);
+    return fract((p.x + p.y) * p.z);
+}
+
+float noise(vec3 x) 
+{
+    vec3 i = floor(x);
+    vec3 frac = fract(x);
+    
+    vec3 u = frac * frac * (3.0 - 2.0 * frac);
+    
+    float a = hash(i);
+    float b = hash(i + vec3(1.0, 0.0, 0.0));
+    float c = hash(i + vec3(0.0, 1.0, 0.0));
+    float d = hash(i + vec3(1.0, 1.0, 0.0));
+    float e = hash(i + vec3(0.0, 0.0, 1.0));
+    float f = hash(i + vec3(1.0, 0.0, 1.0));
+    float g = hash(i + vec3(0.0, 1.0, 1.0));
+    float h = hash(i + vec3(1.0, 1.0, 1.0));
+    
+    return mix(mix(mix(a, b, u.x), mix(c, d, u.x), u.y),
+               mix(mix(e, f, u.x), mix(g, h, u.x), u.y), u.z);
+}
+
+float fbm(vec3 x, int octaves) 
+{
+    float v = 0.0;
+    float a = 0.5;
+    float f = 1.0;
+    vec3 shift = vec3(100, 200, 300);
+    
+    for (int i = 0; i < octaves; ++i) 
+    {
+        v += a * noise(x * f);
+        x = x * 2.0 + shift;
+        a *= 0.5;
+        f *= 2.0;
+    }
+    return v;
+}
+
+float GetCloudDensity(vec3 pos) 
+{
+    float r_cyl = length(vec2(pos.x, pos.z));
+    float r_norm = (r_cyl - disk_r1) / (disk_r2 - disk_r1);
+    
+    if (r_norm < 0.0 || r_norm > 1.0) 
+        return 0.0;
+    
+    float h_norm = abs(pos.y) / thickness;
+    float vertical_falloff = exp(-h_norm * h_norm * 3.0);
+    float radial_density = 1.0 - r_norm * 0.5;
+    
+    vec3 noise_pos = pos * 1e-10;
+    float keplerian_speed = 1.0 / sqrt(r_norm + 0.1);
+    
+    float rotation_angle = time * keplerian_speed * 0.5;
+    vec3 rotated_pos = vec3(
+        pos.x * cos(rotation_angle) - pos.z * sin(rotation_angle),
+        pos.y,
+        pos.x * sin(rotation_angle) + pos.z * cos(rotation_angle)
+    ) * 1e-10;
+    
+    float large_turbulence = fbm(rotated_pos * 1.2, 5);
+    
+    float medium_wisps = fbm(rotated_pos * 2.5, 4);
+    float small_detail = fbm(rotated_pos * 6.0, 3);
+    float fine_detail  = fbm(rotated_pos * 10.0, 2);
+    
+    float noise_mask = large_turbulence * 0.4 + 
+                       medium_wisps * 0.3 + 
+                       small_detail * 0.2 + 
+                       fine_detail * 0.1;
+    
+    noise_mask = smoothstep(0.25, 0.75, noise_mask);
+    
+    float angle = atan(pos.z, pos.x);
+    float rotated_angle = angle + time * 0.5;
+    
+    float spiral_arms = sin(rotated_angle * 3.0 + r_norm * 15.0) * 0.15 + 0.85;
+    
+    float orbital_angle = angle + time * keplerian_speed * 0.8;
+    float orbital_pattern = sin(orbital_angle * 2.0 + r_norm * 8.0) * 0.2 + 0.8;
+    
+    float density = vertical_falloff * radial_density * noise_mask * spiral_arms * orbital_pattern;
+    return density * disk_density;
+}
+
 struct Ray 
 {
     float x, y, z;
@@ -163,11 +270,62 @@ void RK4Step(inout Ray ray, float dL)
     ray.z = ray.r * cos(ray.theta);
 }
 
-bool CrossesEquatorialPlane(vec3 oldPos, vec3 newPos) 
+bool IsInDiskVolume(vec3 pos) 
+{
+    float r_cyl = length(vec2(pos.x, pos.z));
+    return (r_cyl >= disk_r1 && r_cyl <= disk_r2 && abs(pos.y) <= thickness);
+}
+
+vec4 SampleDiskColor(vec3 pos)
 {
-    bool crossed = (oldPos.y * newPos.y < 0.0);
-    float r = length(vec2(newPos.x, newPos.z));
-    return crossed && (r >= disk_r1 && r <= disk_r2);
+    float r_cyl = length(vec2(pos.x, pos.z));
+    float r_norm = (r_cyl - disk_r1) / (disk_r2 - disk_r1);
+    
+    vec3 innerColor = vec3(1.0, 0.9, 0.5);
+    vec3 midColor = vec3(1.0, 0.6, 0.2);
+    vec3 outerColor = vec3(0.9, 0.3, 0.1);
+    
+    vec3 baseColor;
+    if (r_norm < 0.5)
+        baseColor = mix(innerColor, midColor, r_norm * 2.0);
+    else
+        baseColor = mix(midColor, outerColor, (r_norm - 0.5) * 2.0);
+    
+    float r_norm_rot = (r_cyl - disk_r1) / (disk_r2 - disk_r1);
+    float keplerian_speed = 1.0 / sqrt(r_norm_rot + 0.1);
+    
+    vec3 noise_pos = pos * 1e-10;
+    
+    float color_rotation_angle = time * keplerian_speed * 0.3;
+    vec3 rotated_color_pos = vec3(
+        pos.x * cos(color_rotation_angle) - pos.z * sin(color_rotation_angle),
+        pos.y,
+        pos.x * sin(color_rotation_angle) + pos.z * cos(color_rotation_angle)
+    ) * 1e-10;
+    
+    float large_color = fbm(rotated_color_pos * 1.8, 4);
+    float medium_color = fbm(rotated_color_pos * 4.0, 3);
+    float small_color = fbm(rotated_color_pos * 8.0, 2);
+    float colorVariation = (large_color * 0.5 + medium_color * 0.3 + small_color * 0.2) * 0.6;
+    baseColor = baseColor * (1.0 + colorVariation);
+    
+    float density = GetCloudDensity(pos);
+    vec3 brightness_noise_pos = pos * 1e-10;
+    
+    float brightness_rotation_angle = time * keplerian_speed * 0.7;
+    vec3 rotated_brightness_pos = vec3(
+        pos.x * cos(brightness_rotation_angle) - pos.z * sin(brightness_rotation_angle),
+        pos.y,
+        pos.x * sin(brightness_rotation_angle) + pos.z * cos(brightness_rotation_angle)
+    ) * 1e-10;
+    
+    float brightness_large = fbm(rotated_brightness_pos * 3.0, 3);
+    float brightness_medium = fbm(rotated_brightness_pos * 5.0, 2);
+    float brightness_small = fbm(rotated_brightness_pos * 7.0, 2);
+    float brightness_noise = (brightness_large * 0.6 + brightness_medium * 0.3 + brightness_small * 0.1);
+    float brightness = 1.0 + density * 1.0 + brightness_noise * 0.4;
+    
+    return vec4(baseColor * brightness, density);
 }
 
 float CalculateAdaptiveStepSize(Ray ray, float baseStepSize) 
@@ -203,8 +361,10 @@ void main()
     float lambda  = 0.0;
 
     bool hitBlackHole = false;
-    bool hitDisk      = false;
     bool hitObject    = false;
+    
+    vec4 accumulatedColor = vec4(0.0);
+    float transmittance = 1.0;
 
     int maxSteps = cam.moving ? maxStepsMoving : maxStepsStatic;
     
@@ -246,10 +406,29 @@ void main()
 
         vec3 newPos = vec3(ray.x, ray.y, ray.z);
         
-        if (CrossesEquatorialPlane(prevPos, newPos)) 
-        { 
-            hitDisk = true; 
-            break; 
+        if (IsInDiskVolume(newPos)) 
+        {
+            vec4 diskSample = SampleDiskColor(newPos);
+            float density = diskSample.a;
+            vec3 diskColor = diskSample.rgb;
+            
+            float stepLength = currentStepSize * 1e-8;
+            float absorption = density * stepLength * 1.2;
+            float scattering = density * stepLength * 0.8;
+            float extinction = absorption + scattering;
+            
+            float stepTransmittance = exp(-extinction);
+            
+            vec3 emission = diskColor * density * stepLength * 2.5 * sqrt(disk_density);
+            accumulatedColor.rgb += emission * transmittance;
+            
+            transmittance *= stepTransmittance;
+            
+            if (transmittance < 0.01)
+            {
+                accumulatedColor.a = 1.0 - transmittance;
+                break;
+            }
         }
         
         if (i % objectCheckInterval == 0 && InterceptObject(ray)) 
@@ -264,13 +443,9 @@ void main()
             break;
     }
 
-    if (hitDisk) 
-    {
-        double r = length(vec3(ray.x, ray.y, ray.z)) / disk_r2;
-        vec3 diskColor = vec3(1.0, r, 0.2);
-        color = vec4(diskColor, r);
-
-    } else if (hitBlackHole)
+    accumulatedColor.a = 1.0 - transmittance;
+    
+    if (hitBlackHole)
         color = vec4(0.0, 0.0, 0.0, 1.0);
     else if (hitObject) 
     {
@@ -284,8 +459,9 @@ void main()
         vec3  shaded    = objectColor.rgb * intensity;
 
         color = vec4(shaded, objectColor.a);
+        color = mix(accumulatedColor, color, color.a);
     } else
-        color = vec4(0.0);
+        color = accumulatedColor;
 
     imageStore(outImage, pix, color);
 }
\ No newline at end of file