Bioluma vis update

Author: Soddentrough

src/engine.rs

@@ -2840,6 +2840,9 @@ impl<'a> VulkanEngine<'a> {
                                 shortcut(ui, "f", Some("Start"), "Toggle Fullscreen");
                                 shortcut(ui, "g", Some("R1"), "Toggle GPU FFT");
                                 shortcut(ui, "[ / ]", None, "Scale Panels");
+                                if state.visualizer_mode == 19 {
+                                    shortcut(ui, "c", None, "Toggle Camera Mode");
+                                }
                             });
                     });
             }
@@ -4159,7 +4162,6 @@ impl<'a> VulkanEngine<'a> {
         }
 
         if vis_def.id == 19 {
-            println!("DEBUG: Bioluminescence Waves Sim Compute Dispatching!");
             let mut compute_pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
                 label: Some("Bioluminescence Waves Sim Compute"),
                 timestamp_writes: None,
@@ -4210,11 +4212,19 @@ impl<'a> VulkanEngine<'a> {
             let aspect = vp_w / vp_h.max(1.0);
 
             let proj = glam::Mat4::perspective_rh_gl(std::f32::consts::PI / 3.0, aspect, 0.1, 1000.0);
-            let view = glam::Mat4::look_at_rh(
-                glam::Vec3::new(0.0, 1.5, -2.0),
-                glam::Vec3::new(0.0, 1.5, 0.0),
-                glam::Vec3::new(0.0, 1.0, 0.0),
-            );
+            let view = if state.visualizer_mode == 19 && state.biolum_top_down {
+                glam::Mat4::look_at_rh(
+                    glam::Vec3::new(0.0, 14.0, 0.0),
+                    glam::Vec3::new(0.0, 0.0, 0.0),
+                    glam::Vec3::new(0.0, 0.0, 1.0),
+                )
+            } else {
+                glam::Mat4::look_at_rh(
+                    glam::Vec3::new(0.0, 1.5, -2.0),
+                    glam::Vec3::new(0.0, 1.5, 0.0),
+                    glam::Vec3::new(0.0, 1.0, 0.0),
+                )
+            };
             let camera_uniforms = CameraUniforms {
                 view_matrix: view.to_cols_array_2d(),
                 proj_matrix: proj.to_cols_array_2d(),

src/main.rs

@@ -393,6 +393,14 @@ async fn run_gui(app_state: Arc<Mutex<AppState>>, mut active_stream: Option<audi
                                                 let mut state = app_state.lock().unwrap();
                                                 state.gpu_fft = !state.gpu_fft;
                                             },
+                                            WinitKeyCode::KeyC => {
+                                                let mut state = app_state.lock().unwrap();
+                                                if state.visualizer_mode == 19 {
+                                                    state.biolum_top_down = !state.biolum_top_down;
+                                                    state.osd_text = Some(format!("Camera: {}", if state.biolum_top_down { "Top-down" } else { "Perspective" }));
+                                                    state.osd_timer = 2.0;
+                                                }
+                                            },
                                             WinitKeyCode::KeyS => {
                                                 let mut state = app_state.lock().unwrap();
                                                 state.show_stats = !state.show_stats;

src/shaders/biolum_compute.wgsl

@@ -31,6 +31,32 @@ fn hash31(p: f32) -> vec3<f32> {
     return fract((p3.xxy + p3.yzz) * p3.zyx);
 }
 
+fn noise2d(p: vec2<f32>) -> f32 {
+    let ip = floor(p);
+    let fp = fract(p);
+    
+    let u = fp * fp * (3.0 - 2.0 * fp);
+    
+    let a = hash11(ip.x + ip.y * 57.0);
+    let b = hash11(ip.x + 1.0 + ip.y * 57.0);
+    let c = hash11(ip.x + (ip.y + 1.0) * 57.0);
+    let d = hash11(ip.x + 1.0 + (ip.y + 1.0) * 57.0);
+    
+    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+fn fbm2d(p: vec2<f32>) -> f32 {
+    var value = 0.0;
+    var amplitude = 0.5;
+    var pos = p;
+    for (var i = 0; i < 3; i = i + 1) {
+        value += amplitude * noise2d(pos);
+        pos = pos * 2.0;
+        amplitude = amplitude * 0.5;
+    }
+    return value;
+}
+
 fn get_gerstner_wave(wave: GerstnerWave, xz: vec2<f32>, time: f32) -> vec3<f32> {
     let k = 2.0 * 3.14159265 / wave.wavelength;
     let c = wave.speed;
@@ -53,18 +79,53 @@ fn get_gerstner_wave(wave: GerstnerWave, xz: vec2<f32>, time: f32) -> vec3<f32>
 fn get_wave_displacement(xz: vec2<f32>, time: f32) -> vec3<f32> {
     var displacement = vec3<f32>(0.0);
 
-    var waves: array<GerstnerWave, 3>;
-    waves[0] = GerstnerWave(vec2<f32>(0.0, 1.0), 0.6, 14.0, 2.5, 0.5);
-    waves[1] = GerstnerWave(vec2<f32>(0.7, 0.7), 0.35, 7.0, 1.8, 0.4);
-    waves[2] = GerstnerWave(vec2<f32>(-0.7, 0.7), 0.15, 3.5, 1.2, 0.3);
+    var waves: array<GerstnerWave, 5>;
+    waves[0] = GerstnerWave(vec2<f32>(0.1, 0.99), 0.55, 16.0, 2.2, 0.7);
+    waves[1] = GerstnerWave(vec2<f32>(0.6, 0.8), 0.35, 8.5, 1.6, 0.55);
+    waves[2] = GerstnerWave(vec2<f32>(-0.65, 0.75), 0.25, 5.0, 1.3, 0.45);
+    waves[3] = GerstnerWave(vec2<f32>(0.9, 0.4), 0.1, 2.8, 1.0, 0.35);
+    waves[4] = GerstnerWave(vec2<f32>(-0.8, 0.5), 0.06, 1.5, 0.8, 0.25);
 
-    for (var i = 0; i < 3; i = i + 1) {
+    for (var i = 0; i < 5; i = i + 1) {
         displacement += get_gerstner_wave(waves[i], xz, time);
     }
 
     return displacement;
 }
 
+fn get_wave_velocity(xz: vec2<f32>, time: f32) -> vec3<f32> {
+    var velocity = vec3<f32>(0.0);
+    
+    var waves: array<GerstnerWave, 5>;
+    waves[0] = GerstnerWave(vec2<f32>(0.1, 0.99), 0.55, 16.0, 2.2, 0.7);
+    waves[1] = GerstnerWave(vec2<f32>(0.6, 0.8), 0.35, 8.5, 1.6, 0.55);
+    waves[2] = GerstnerWave(vec2<f32>(-0.65, 0.75), 0.25, 5.0, 1.3, 0.45);
+    waves[3] = GerstnerWave(vec2<f32>(0.9, 0.4), 0.1, 2.8, 1.0, 0.35);
+    waves[4] = GerstnerWave(vec2<f32>(-0.8, 0.5), 0.06, 1.5, 0.8, 0.25);
+    
+    for (var i = 0; i < 5; i = i + 1) {
+        let wave = waves[i];
+        let k = 2.0 * 3.14159265 / wave.wavelength;
+        let c = wave.speed;
+        let w = c * k;
+        let dir = normalize(wave.direction);
+        let theta = k * dot(dir, xz) - w * time;
+        
+        let sin_t = sin(theta);
+        let cos_t = cos(theta);
+        
+        let q = wave.steepness / (wave.amplitude * k + 0.0001);
+        
+        let vx = q * wave.amplitude * dir.x * w * sin_t;
+        let vz = q * wave.amplitude * dir.y * w * sin_t;
+        let vy = -w * wave.amplitude * cos_t;
+        
+        velocity += vec3<f32>(vx, vy, vz);
+    }
+    
+    return velocity;
+}
+
 @compute @workgroup_size(256)
 fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     let idx = global_id.x;
@@ -85,70 +146,70 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
         let pos_z = (rnd.y - 0.5) * 50.0;
         let disp = get_wave_displacement(vec2<f32>(pos_x, pos_z), time);
 
-        p.pos = vec4<f32>(pos_x + disp.x, disp.y + rnd.z * 0.4, pos_z + disp.z, rnd.z * 4.0 + 1.0); // life: 1.0 to 5.0s
-        p.vel = vec4<f32>((rnd.x - 0.5) * 0.4, 0.0, (rnd.y - 0.5) * 0.4, rnd.x * 0.2); // energy
+        p.pos = vec4<f32>(pos_x + disp.x, disp.y, pos_z + disp.z, rnd.z * 4.0 + 1.0); // life: 1.0 to 5.0s
+        p.vel = vec4<f32>((rnd.x - 0.5) * 0.4, 0.0, (rnd.y - 0.5) * 0.4, 0.12); // energy starts at ground state
     } else {
         var pos = p.pos.xyz;
         var vel = p.vel.xyz;
         var energy = p.vel.w;
 
+        // Decay energy glow slowly (takes ~2-3 seconds to fade to ground state of 0.12)
+        energy = max(energy - dt * 0.5, 0.12);
+        
+        // Local wave physics at particle coordinate
         let disp = get_wave_displacement(pos.xz, time);
         let wave_h = disp.y;
 
-        var force = vec3<f32>(0.0);
+        // Smoothly interpolate towards the true orbital wave velocity + drift current
+        let wave_vel = get_wave_velocity(pos.xz, time);
+        let drift_vel = vec3<f32>(0.15, 0.0, 0.0); // slow global current drift
+        let target_vel = wave_vel + drift_vel;
 
-        // Fluid vs Air Physics
-        if (pos.y <= wave_h + 0.1) {
-            // Under/on the water surface
-            let depth = wave_h - pos.y;
-            // Buoyancy force
-            force.y += max(depth, 0.0) * 35.0;
-            // Align back to wave displacement slightly
-            force.x += (disp.x - (pos.x - (pos.x - disp.x))) * 0.5;
-            force.z += (disp.z - (pos.z - (pos.z - disp.z))) * 0.5;
-            
-            // Drag
-            vel *= 0.93;
+        // High drag keeps particles flowing smoothly with currents rather than zipping around
+        vel = mix(vel, target_vel, 0.15);
+        
+        // Audio reactivity - Bass agitation triggers glow directly
+        let bass = max(audio.spectrum[0].x, audio.spectrum[1].x) * 0.02;
+        if (bass > 0.15) {
+            energy = max(energy, clamp(bass * 1.5, 0.0, 2.0));
 
-            // Flow field (currents + curl noise simulation)
-            let wave_current = vec3<f32>(disp.x, 0.0, disp.z) * 1.5;
-            force += wave_current;
+            // Add a tiny localized horizontal puff (agitation), not a high-velocity launch
+            let rnd_impulse = hash31(idx_f + time);
+            pos.x += (rnd_impulse.x - 0.5) * bass * 0.08;
+            pos.z += (rnd_impulse.y - 0.5) * bass * 0.08;
+        }
+        
+        // Integrate horizontal position
+        pos.x += vel.x * dt;
+        pos.z += vel.z * dt;
+        
+        // Snap vertical position to the surface wave height
+        let new_disp = get_wave_displacement(pos.xz, time);
+        pos.y = new_disp.y;
+        vel.y = 0.0;
+        
+        // Wave breaks and foam structure simulation (active at crests)
+        let crest_factor = smoothstep(0.35, 1.2, wave_h);
+        if (crest_factor > 0.0) {
+            // High frequency fBm noise creates organic foam lines and breaks
+            let noise_coord = pos.xz * 2.5 + vec2<f32>(time * 1.5, time * 1.0);
+            let foam_noise = fbm2d(noise_coord);
 
-            let swell = vec3<f32>(
-                sin(pos.z * 0.4 + time) * 1.2,
-                cos(pos.x * 0.4 - time) * 0.3,
-                cos(pos.y * 0.4 + time) * 1.2
-            );
-            force += swell;
+            // horizontal micro-agitation/diffusion clusters particles into foam filaments
+            let foam_disp = vec3<f32>(
+                hash11(idx_f + time) - 0.5,
+                0.0,
+                hash11(idx_f + time * 1.3) - 0.5
+            ) * 0.22 * crest_factor * foam_noise;
+            pos += foam_disp;
 
-            // Audio reactivity - Bass disruption
-            // In WGPU, AudioUniforms.spectrum holds values from 0.0 to ~100.0
-            let bass = max(audio.spectrum[0].x, audio.spectrum[1].x) * 0.02;
-            if (bass > 0.15) {
-                let rnd_impulse = hash31(idx_f + time);
-                vel.y += bass * 4.0 * rnd_impulse.z;
-                vel.x += (rnd_impulse.x - 0.5) * bass * 2.0;
-                vel.z += (rnd_impulse.y - 0.5) * bass * 2.0;
-                energy = clamp(max(energy, bass * 2.0), 0.0, 1.5);
+            // Excite glow in the breaking foam zones
+            let shear_agitation = foam_noise * 1.3 * crest_factor;
+            if (shear_agitation > 0.3) {
+                energy = max(energy, 1.6);
             }
-            
-            // Glow when near wave crests due to high shear stress
-            let crest = smoothstep(0.1, 0.8, wave_h);
-            energy = max(energy, crest * 0.95);
-        } else {
-            // In the air (sea spray)
-            force.y -= 9.8; // Gravity
-            force.x += 1.5; // Wind blowing right
-            vel *= 0.98;    // Air resistance
         }
 
-        // Decay energy glow
-        energy = max(energy - dt * 0.25, 0.0);
-        
-        // Integrate
-        vel += force * dt;
-        pos += vel * dt;
-        
         p.pos = vec4<f32>(pos, p.pos.w);
         p.vel = vec4<f32>(vel, energy);
     }

src/shaders/vis_bioluminescence.wgsl

@@ -122,7 +122,7 @@ fn fs_main(in: VertexOutput3D) -> @location(0) vec4<f32> {
 
     // Brightness profile
     let intensity = (0.2 + in.energy * 2.5) * (1.0 - smoothstep(0.0, 0.5, dist));
-    
+
     // Add distance fog to match the deep ocean depth feel
     let fog_factor = smoothstep(5.0, 35.0, in.depth);
     var final_color = mix(color * intensity, vec3<f32>(0.001, 0.003, 0.008), fog_factor);

src/state.rs

@@ -195,6 +195,7 @@ pub struct AppState {
     pub osd_timer: f32,
     pub cumulative_scrub: f64,
     pub audio_device_lost: bool,
+    pub biolum_top_down: bool,
 }
 
 pub fn get_history_file_path() -> std::path::PathBuf {
@@ -325,6 +326,7 @@ impl AppState {
             osd_timer: 0.0,
             cumulative_scrub: 0.0,
             audio_device_lost: false,
+            biolum_top_down: false,
         }
     }
 
@@ -414,6 +416,7 @@ impl AppState {
             osd_timer: self.osd_timer,
             cumulative_scrub: self.cumulative_scrub,
             audio_device_lost: self.audio_device_lost,
+            biolum_top_down: self.biolum_top_down,
         }
     }
 }