web(audio): sync AudioListener position/orientation with camera (including orbit); visuals: subtle halo glow in WGSL

Author: rgilks

crates/app-core/shaders/scene.wgsl

@@ -35,7 +35,12 @@ fn fs_main(inf: VsOut) -> @location(0) vec4<f32> {
 
   // Emissive pulse boosts brightness subtly
     let emissive = 0.7 * clamp(inf.pulse, 0.0, 1.5);
-    let rgb = inf.color.rgb * (1.0 + emissive);
+    var rgb = inf.color.rgb * (1.0 + emissive);
+
+    // Subtle outer glow/halo based on radius
+    let halo = smoothstep(0.75, 0.55, r) * 0.12; // outer ring brightness
+    rgb += halo * inf.color.rgb;
+
     return vec4<f32>(rgb, shape_alpha * inf.color.a);
 }
 

crates/app-native/src/main.rs

@@ -480,13 +480,11 @@ fn main() {
                 if new_hover != hover {
                     // update colors to highlight hovered voice
                     let mut vis = state.shared.lock().unwrap();
-                    if let Some(prev) = hover {
-                        // restore base color
-                        let base = DEFAULT_VOICE_COLORS[prev];
-                        vis.colors[prev] = Vec4::new(base[0], base[1], base[2], 1.0);
+                    // restore all to base first then apply hover brighten for determinism
+                    for (i, base) in DEFAULT_VOICE_COLORS.iter().enumerate() {
+                        vis.colors[i] = Vec4::new(base[0], base[1], base[2], 1.0);
                     }
                     if let Some(i) = new_hover {
-                        // brighten
                         vis.colors[i].x = (vis.colors[i].x * 1.4).min(1.0);
                         vis.colors[i].y = (vis.colors[i].y * 1.4).min(1.0);
                         vis.colors[i].z = (vis.colors[i].z * 1.4).min(1.0);
@@ -543,7 +541,18 @@ struct AudioState {
     oscillators: Vec<ActiveOscillator>,
 }
 
-fn start_audio_engine(shared_vis: Arc<Mutex<VisState>>, shared_engine: Arc<Mutex<MusicEngine>>) -> Option<cpal::Stream> {
+fn compute_equal_power_gains(pos_x_engine: f32) -> (f32, f32) {
+    // Map engine-space X (roughly -1..1 typical) into pan -1..1
+    let pan = (pos_x_engine / 1.5).clamp(-1.0, 1.0);
+    // Equal-power panning
+    let angle = (pan + 1.0) * std::f32::consts::FRAC_PI_4; // 0..pi/2
+    (angle.cos(), angle.sin())
+}
+
+fn start_audio_engine(
+    shared_vis: Arc<Mutex<VisState>>,
+    shared_engine: Arc<Mutex<MusicEngine>>,
+) -> Option<cpal::Stream> {
     let host = cpal::default_host();
     let device = host.default_output_device()?;
     let config = device.default_output_config().ok()?;
@@ -579,12 +588,13 @@ fn start_audio_engine(shared_vis: Arc<Mutex<VisState>>, shared_engine: Arc<Mutex
                     last = now;
                     let now_sec = start_instant.elapsed().as_secs_f64();
                     events.clear();
-                    engine.tick(dt, now_sec, &mut events);
-                    // Apply any changes back to shared engine voices (positions/mute/solo)
+                    // Pull latest voice state from shared engine to reflect input changes
                     {
-                        let mut guard = shared.lock().unwrap();
-                        guard.voices = engine.voices.clone();
+                        if let Ok(guard) = shared.lock() {
+                            engine.voices = guard.voices.clone();
+                        }
                     }
+                    engine.tick(dt, now_sec, &mut events);
 
                     if !events.is_empty() {
                         let mut guard = state_clone.lock().unwrap();
@@ -602,10 +612,7 @@ fn start_audio_engine(shared_vis: Arc<Mutex<VisState>>, shared_engine: Arc<Mutex
                             };
                             // Stereo pan from voice X position (engine-space)
                             let pos_x = engine.voices[ev.voice_index].position.x;
-                            let pan = (pos_x / 1.5).clamp(-1.0, 1.0); // -1 left .. 1 right
-                            let angle = (pan + 1.0) * std::f32::consts::FRAC_PI_4; // 0..pi/2
-                            let left_gain = angle.cos();
-                            let right_gain = angle.sin();
+                            let (left_gain, right_gain) = compute_equal_power_gains(pos_x);
                             guard.oscillators.push(ActiveOscillator {
                                 amplitude: ev.velocity.min(1.0),
                                 phase: 0.0,

crates/app-web/src/lib.rs

@@ -154,6 +154,7 @@ async fn init() -> anyhow::Result<()> {
                     };
                     let listener = audio_ctx.listener();
                     listener.set_position(0.0, 0.0, 1.5);
+                    let listener_for_tick = listener.clone();
 
                     // Music engine
                     let voice_configs = vec![
@@ -808,16 +809,29 @@ async fn init() -> anyhow::Result<()> {
                                 BASE_SCALE + ps[2] * SCALE_PULSE_MULTIPLIER,
                             ];
 
+                            // Compute camera eye for orbit or fixed
+                            let mut cam_eye = Vec3::new(0.0, 0.0, CAMERA_Z);
+                            if *orbit_tick.borrow() {
+                                orbit_t += dt_sec * 0.1; // rad/s
+                                let r = 6.0f32;
+                                cam_eye = Vec3::new(r * orbit_t.cos(), 0.0, r * orbit_t.sin());
+                            }
+                            let cam_target = Vec3::ZERO;
+                            // Sync AudioListener position + orientation to camera
+                            let fwd = (cam_target - cam_eye).normalize();
+                            listener_for_tick
+                                .set_position(cam_eye.x as f64, cam_eye.y as f64, cam_eye.z as f64);
+                            let _ = listener_for_tick.set_orientation(
+                                fwd.x as f64,
+                                fwd.y as f64,
+                                fwd.z as f64,
+                                0.0,
+                                1.0,
+                                0.0,
+                            );
+
                             if let Some(g) = &mut gpu {
-                                // Optional slow orbit
-                                if *orbit_tick.borrow() {
-                                    orbit_t += dt_sec * 0.1; // rad/s
-                                    let r = 6.0f32;
-                                    let eye = Vec3::new(r * orbit_t.cos(), 0.0, r * orbit_t.sin());
-                                    g.set_camera(eye, Vec3::ZERO);
-                                } else {
-                                    g.set_camera(Vec3::new(0.0, 0.0, CAMERA_Z), Vec3::ZERO);
-                                }
+                                g.set_camera(cam_eye, cam_target);
                                 // Keep WebGPU surface sized to canvas backing size
                                 let w = canvas_for_tick.width();
                                 let h = canvas_for_tick.height();