v0.9.12: Visualization system overhaul — correctness, timing, realism

Critical fixes:
- ferrofluidsim: WGSL Particle was 48B vs 32B host buffer; 1/3 of particles
  were phantom static splats. Repacked to two vec4s.
- video: real viewport dims in VideoParams (was hardcoded 1080p); repack
  planes when decoder stride violates 256B row alignment (panic risk)
- racer: light pools now match lamppost spacing (76u); car march exit budget
  covers the full bounding box diagonal

Framerate independence:
- play_time accumulates smoothed real dt (x2.88 preserves 144fps tuning)
- frame_dt + history_cam_z added to AudioUniforms; all compute sims
  (fire, firesim, biolum, ferrofluid) use real dt with pow-corrected damping
- synthwave cam_z uses history-locked uniform (scroll sync at any fps)

Dead code removal:
- GPU FFT pipeline/buffers deleted (FFT is CPU-side; shader was a naive DFT)
- vis_3dtest.wgsl removed; gpu_spectrum upload gated to consumers;
  waveform history upload skipped when unchanged

Robustness:
- smoothstep_r() helper; ~80 spec-indeterminate reversed-edge smoothsteps
  migrated across all shaders
- Fixed: oscilloscope double-amber tint, 3d-osc div-by-zero, HUD full-scale
  peak invisibility, solar flare-dist ordering + ejecta sawtooth, spectrum
  startup line + phosphor decay calibration, spatial glyph index, matrix
  mod-by-zero, firesim LFE guard, resynth EQ soft-knee

Performance:
- vumeters AABB pre-test, ferrofluid sky early-out + adaptive Lipschitz
  step, neon smoke bypass when silent + 100->80 steps, firesim black-pixel
  early-out, loop-invariant hoisting in 3d oscilloscope

Realism pass:
- Fire Simulation: upward anisotropic erosion w/ body texture, tongue
  seeding, flame bending, blue combustion fringe, renderer-side rising
  ember sparks, merged fuel line, smoke scatter direction fixed, taller
  tongues (buoyancy/cooling), no more blown white cores or purple fringing
- Retro VU Meters: DENON removed (generic AUDIO marker); finite rounded
  chassis with rolled bevel edge, rack screws, pivot cap, dial grain,
  signal-reactive lamp, red-zone threshold fix, real aspect uniform
- Matrix Rain: authentic half-width katakana + digits glyph set (55 glyphs)
- Synthwave Racer: tapered fuselage, rounded SDF primitives, smin-blended
  panels, smooth wheel wells, side skirts + front valance

Includes VIS_REVIEW.md with the full audit and remaining backlog.

Author: Soddentrough

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rusttracker"
-version = "0.9.11"
+version = "0.9.12"
 edition = "2024"
 default-run = "rusttracker"
 description = "High-Performance Vulkan Tracker Module Visualizer"

Cargo.toml

@@ -44,8 +44,10 @@ struct AudioUniforms {
     step_fraction: f32,
     steps_to_fill: u32,
     aspect_ratio: f32,
-    pad2: u32,
-    pad3: u32,
+    // Real frame delta in seconds (clamped) — for framerate-independent sims
+    frame_dt: f32,
+    // (push_count + step_fraction) * 0.5 — world Z locked to history rows
+    history_cam_z: f32,
 };
 
 // Narkowicz ACES fitted tonemapping curve.
@@ -62,6 +64,12 @@ fn hash21_crt(p: vec2<f32>) -> f32 {
     return fract((p3.x + p3.y) * p3.z);
 }
 
+// Reversed-edge smoothstep: equivalent to smoothstep(hi, lo, x) with hi > lo,
+// which is indeterminate per the WGSL spec. Use this instead.
+fn smoothstep_r(hi: f32, lo: f32, x: f32) -> f32 {
+    return 1.0 - smoothstep(lo, hi, x);
+}
+
 fn crt_distort_uv(uv: vec2<f32>, distortion: f32) -> vec2<f32> {
     let crt_uv = uv * 2.0 - 1.0;
     let r2 = dot(crt_uv, crt_uv);
@@ -98,7 +106,7 @@ fn apply_crt_effects(color: vec3<f32>, uv: vec2<f32>, clip_pos: vec2<f32>, time:
     // Vignette
     let crt_uv = uv * 2.0 - 1.0;
     let r = length(crt_uv);
-    let bezel = smoothstep(settings.vignette_scale, settings.vignette_softness, r);
+    let bezel = smoothstep_r(settings.vignette_scale, settings.vignette_softness, r);
     final_color *= bezel;
 
     // Flicker

VIS_REVIEW.md

@@ -132,7 +132,8 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     if (idx >= 65536u) { return; }
 
     var p = particles[idx];
-    let dt = 0.016;
+    // Framerate-independent timestep (real frame dt, clamped)
+    let dt = clamp(audio.frame_dt, 0.001, 0.033);
     let time = audio.smooth_time;
     let idx_f = f32(idx);
 
@@ -166,7 +167,8 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
         let target_vel = wave_vel + drift_vel;
 
         // High drag keeps particles flowing smoothly with currents rather than zipping around
-        vel = mix(vel, target_vel, 0.15);
+        // (0.15 per 16ms step, converted to the real dt)
+        vel = mix(vel, target_vel, 1.0 - pow(0.85, dt / 0.016));
 
         // Audio reactivity - Bass agitation triggers glow directly
         let bass = max(audio.spectrum[0].x, audio.spectrum[1].x) * 0.02;
@@ -184,8 +186,9 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
         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;
+        // (reuse disp from above — the field is smooth and the horizontal
+        // integration step is tiny, so a second evaluation is wasted work)
+        pos.y = wave_h;
         vel.y = 0.0;
 
         // Wave breaks and foam structure simulation (active at crests)

src/engine.rs

@@ -3,11 +3,11 @@
 @group(0) @binding(0)
 var<uniform> audio: AudioUniforms;
 
+// Packed to exactly 32 bytes to match the host allocation (100_000 * 32B).
+// pos.w = mass, vel.w = EMA-smoothed spectrum value (filters transients for standing waves)
 struct Particle {
-    pos: vec3<f32>,
-    vel: vec3<f32>,
-    mass: f32,
-    smooth_spec: f32,  // EMA-smoothed spectrum value — filters transients for standing waves
+    pos: vec4<f32>,
+    vel: vec4<f32>,
 }
 
 @group(0) @binding(1)
@@ -30,42 +30,42 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     if (idx >= 100000u) { return; }
 
     var p = particles[idx];
-    
+
     // Initialize if pos is exactly 0
-    if (length(p.pos) < 0.001 && length(p.vel) < 0.001) {
+    if (length(p.pos.xyz) < 0.001 && length(p.vel.xyz) < 0.001) {
         let rng1 = fract(sin(f32(idx) * 12.9898) * 43758.5453);
         let rng2 = fract(sin(f32(idx) * 78.233) * 43758.5453);
         let angle = rng1 * 6.28318;
         let r = sqrt(rng2) * 5.0;
-        p.pos = vec3<f32>(cos(angle) * r, 0.1, sin(angle) * r);
-        p.vel = vec3<f32>(0.0);
-        p.mass = 1.0;
-        p.smooth_spec = 0.0;
+        p.pos = vec4<f32>(cos(angle) * r, 0.1, sin(angle) * r, 1.0);
+        p.vel = vec4<f32>(0.0);
     }
 
-    // Physics
-    let dt = 0.016;
+    // Physics — framerate-independent timestep (real frame dt, clamped)
+    let dt = clamp(audio.frame_dt, 0.001, 0.033);
     var force = vec3<f32>(0.0, -9.8, 0.0); // Gravity
 
     // Frequency-driven magnetic field
     let angle = atan2(p.pos.z, p.pos.x);
     let abs_angle = abs(angle);
     let spec_idx = min(u32((abs_angle / 3.14159) * 127.0), 127u);
     let raw_spec = clamp(audio.spectrum[spec_idx / 4u][spec_idx % 4u], 0.0, 1.0);
-    
+
     // Temporal EMA smoothing — standing wave filter
     // Slow attack (0.03): transient hits are ignored, only sustained frequencies build peaks
     // Moderate decay (0.08): fluid relaxes gracefully when a frequency stops
-    let rate = select(0.08, 0.03, raw_spec > p.smooth_spec);
-    p.smooth_spec = mix(p.smooth_spec, raw_spec, rate);
-    let spec_val = p.smooth_spec;
+    // Rates are per-16ms-step; converted to the real dt so behavior is fps-independent
+    let dt_scale = dt / 0.016;
+    let rate = 1.0 - pow(1.0 - select(0.08, 0.03, raw_spec > p.vel.w), dt_scale);
+    p.vel.w = mix(p.vel.w, raw_spec, rate);
+    let spec_val = p.vel.w;
 
     // Dynamic magnet position based on smoothed frequency
     let mag_r = 0.5 + spec_val * 4.0;
     let mag_h = -0.5 + spec_val * 3.0;
     let mag_pos = vec3<f32>(cos(angle) * mag_r, mag_h, sin(angle) * mag_r);
 
-    let dir = mag_pos - p.pos;
+    let dir = mag_pos - p.pos.xyz;
     let dist_sq = dot(dir, dir);
     let mag_force = (spec_val * 200.0 + 20.0) / (dist_sq + 0.5);
     force += normalize(dir) * mag_force;
@@ -80,7 +80,7 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     force += turbulence * (3.0 + spec_val * 8.0);
 
     // Central electromagnet to keep the fluid pooled together
-    let center_dir = vec3<f32>(0.0, -1.0, 0.0) - p.pos;
+    let center_dir = vec3<f32>(0.0, -1.0, 0.0) - p.pos.xyz;
     force += normalize(center_dir) * (60.0 / (dot(center_dir, center_dir) + 1.0));
 
     // Floor collision
@@ -91,12 +91,12 @@ fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
     }
 
     // Spring back to origin slightly to keep them in bounds
-    force -= p.pos * 5.0;
+    force -= p.pos.xyz * 5.0;
 
-    // Integration with viscous damping (0.91 = thick fluid, resists rapid motion)
-    p.vel += force * dt;
-    p.vel *= 0.91;
-    p.pos += p.vel * dt;
+    // Integration with viscous damping (0.91 per 16ms step = thick fluid),
+    // converted to the real dt so damping strength is fps-independent
+    p.vel = vec4<f32>((p.vel.xyz + force * dt) * pow(0.91, dt_scale), p.vel.w);
+    p.pos = vec4<f32>(p.pos.xyz + p.vel.xyz * dt, p.pos.w);
 
     particles[idx] = p;
 

src/shaders/_common.wgsl

@@ -10,7 +10,7 @@ struct FireParams {
     num_channels: u32,
     lfe_idx: u32,
     fft_channels: u32,
-    _pad1: u32,
+    dt: f32,
     display_order: array<vec4<u32>, 4>,
     channels: array<vec4<f32>, 8>,
 };
@@ -55,8 +55,9 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let bottom = params.height - 1u;
     let idx = y * w + x;
 
-    // Seed RNG from position + time
-    let seed = pcg_hash(x + y * 1337u + bitcast<u32>(params.time * 100.0));
+    // Rates below were tuned per-frame at 144fps; scale by real dt so the
+    // simulation evolves identically at any refresh rate.
+    let dt_scale = params.dt * 144.0;
 
     // === Bottom row: update coal bed with thermal inertia ===
     if (y == bottom) {
@@ -67,7 +68,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         if lfe_idx < n_ch {
             n_spatial_ch = n_ch - 1u;
         }
-        let channel_width = 1024.0 / f32(max(n_spatial_ch, 1u));
+        let channel_width = f32(params.width) / f32(max(n_spatial_ch, 1u));
         var sigma_scale = 0.18;
         if n_spatial_ch <= 2u {
             sigma_scale = 0.4;
@@ -93,7 +94,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
             spatial_idx += 1u;
         }
         if lfe_idx < n_ch {
-            let lfe_dist = f32(x) - 512.0;
+            let lfe_dist = f32(x) - f32(params.width) * 0.5;
             let lfe_influence = exp(-(lfe_dist * lfe_dist) / (2.0 * 90.0 * 90.0));
             var lfe_disp_idx = 999u;
             for (var i = 0u; i < n_ch; i = i + 1u) {
@@ -119,9 +120,9 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         let coal_target = 1.0 - exp(-(params.bass * 0.5 + activity * 3.0));
         let current = coal_bed[x];
         if (coal_target > current) {
-            coal_bed[x] = current + (coal_target - current) * 0.18;
+            coal_bed[x] = current + (coal_target - current) * min(0.18 * dt_scale, 1.0);
         } else {
-            coal_bed[x] = current + (coal_target - current) * 0.008;
+            coal_bed[x] = current + (coal_target - current) * min(0.008 * dt_scale, 1.0);
         }
 
         // Use lower frequency noise to create wide, organic hotspots rather than single-pixel static
@@ -173,10 +174,11 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let cool_noise = perlin_noise(p_cool + vec2<f32>(0.0, params.time * 6.0));
 
     // Higher variance in cooling forces the flame to tear into distinct licks
-    let base_cooling = 0.0015 + (cool_noise + 1.0) * 0.0015;
-    
+    let base_cooling = (0.0015 + (cool_noise + 1.0) * 0.0015) * dt_scale;
+
     // Occasional sparks (holes in the flame) for realism, clumped by noise
-    let spark = select(0.0, 0.06, cool_noise > 0.8 && y > 100u);
+    // (threshold 0.55: this perlin gradient noise peaks around +/-0.7, so 0.8 was unreachable)
+    let spark = select(0.0, 0.06 * dt_scale, cool_noise > 0.55 && y > 100u);
 
     // Normalize the cooling factor so heavily compressed tracks don't turn off cooling entirely
     let dynamic_cooling = mix(0.6, 1.0, params.cooling_factor);

src/shaders/biolum_compute.wgsl

@@ -10,7 +10,7 @@ struct FireParams {
     num_channels: u32,
     lfe_idx: u32,
     fft_channels: u32,
-    _pad1: u32,
+    dt: f32,
     display_order: array<vec4<u32>, 4>,
     channels: array<vec4<f32>, 8>,
 };
@@ -85,8 +85,9 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let bottom = params.height - 1u;
     let idx = y * w + x;
 
-    // Seed RNG from position + time
-    let seed = pcg_hash(x + y * 1337u + bitcast<u32>(params.time * 100.0));
+    // Rates below were tuned per-frame at 144fps; scale by real dt so the
+    // simulation evolves identically at any refresh rate.
+    let dt_scale = params.dt * 144.0;
 
     // === Bottom row: update coal bed with thermal inertia ===
     if (y == bottom) {
@@ -97,10 +98,11 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         if lfe_idx < n_ch {
             n_spatial_ch = n_ch - 1u;
         }
-        let channel_width = 1024.0 / f32(max(n_spatial_ch, 1u));
-        // Sharp fuel sources for distinct columns
-        var sigma_scale = 0.08;
-        if n_spatial_ch <= 2u { sigma_scale = 0.2; }
+        let channel_width = f32(params.width) / f32(max(n_spatial_ch, 1u));
+        // Fuel gaussians: wide enough that adjacent channel fires merge into a
+        // continuous fire line (narrow ones read as separated pillars with gaps)
+        var sigma_scale = 0.14;
+        if n_spatial_ch <= 2u { sigma_scale = 0.25; }
 
         var spatial_idx = 0u;
         for (var i = 0u; i < n_ch; i = i + 1u) {
@@ -137,7 +139,12 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         }
         if lfe_idx < n_ch {
             var lfe_bass = 0.0;
-            let offset = lfe_idx * 1024u;
+            // Guard the FFT channel index the same way spatial channels are guarded above
+            var lfe_ch = lfe_idx;
+            if (params.fft_channels < params.num_channels) {
+                lfe_ch = lfe_ch % max(params.fft_channels, 1u);
+            }
+            let offset = lfe_ch * 1024u;
             for (var b = 0u; b < 200u; b = b + 5u) {
                 let c = multi_spectrum[offset + b];
                 lfe_bass += clamp(length(c) * 100.0, 0.0, 100.0);
@@ -152,9 +159,9 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         let coal_target = min(params.bass * 0.05 + activity * 1.2, 1.0);
         let current = coal_bed[x];
         if (coal_target > current) {
-            coal_bed[x] = current + (coal_target - current) * 0.18;
+            coal_bed[x] = current + (coal_target - current) * min(0.18 * dt_scale, 1.0);
         } else {
-            coal_bed[x] = current + (coal_target - current) * 0.008;
+            coal_bed[x] = current + (coal_target - current) * min(0.008 * dt_scale, 1.0);
         }
 
         output_grid[idx] = min(coal_bed[x], 1.0);
@@ -167,14 +174,17 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
         var out_val = coal_heat;
 
-        // Embers are directly spawned by extreme high-frequency transients (snares, hi-hats)
+        // Embers are spawned by high-frequency transients (snares, hi-hats) and
+        // mid-band bursts (kicks, toms) so they rise through the flame regularly
         let spark_bin = 800u + (x % 200u);
         var spark_noise = 0.0;
+        var mid_noise = 0.0;
         for (var i = 0u; i < params.num_channels; i = i + 1u) {
             spark_noise += length(multi_spectrum[i * 1024u + spark_bin]);
+            mid_noise += length(multi_spectrum[i * 1024u + 300u + (x % 150u)]);
         }
-        
-        if (coal_heat > 0.4 && spark_noise * 150.0 > 1.0) {
+
+        if (coal_heat > 0.3 && (spark_noise * 150.0 > 0.6 || mid_noise * 90.0 > 1.6)) {
             out_val = 6.0; // Crisp ember packet
         }
 
@@ -193,7 +203,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let smoke = max(-current_val, 0.0);
 
     // 1. Thermal Buoyancy: Hot air and warm smoke rise.
-    var buoyancy = 0.5; // Stronger base updraft
+    var buoyancy = 0.7; // Stronger base updraft
     buoyancy += heat * 6.5; // Roaring vertical speed
     buoyancy += smoke * 1.5;
     let buoyancy_vel = vec2<f32>(0.0, -1.0) * buoyancy;
@@ -223,29 +233,33 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let jitter_seed = u32(x + y * params.width) + bitcast<u32>(params.time * 100.0);
     let jitter = (f32(pcg_hash(jitter_seed) % 100u) / 100.0) - 0.5; // -0.5 to 0.5
 
-    let dt = 1.0;
+    let dt = dt_scale;
     let src_p = p1 - vel * dt + vec2<f32>(0.0, jitter * 2.0);
-    
+
     var new_val = sample_grid(src_p.x, src_p.y);
-    
+
     if (new_val > 0.0) {
-        // Fire cooling (Constant to prevent spatial standing-wave interference)
-        let base_cooling = 0.02; 
-        
+        // Fire cooling (Constant to prevent spatial standing-wave interference).
+        // 0.016 (down from 0.02) lets tongues stretch taller before dying.
+        let base_cooling = 0.016;
+
         var cooling_rate = base_cooling * params.cooling_factor;
         // Embers (val > 1.0) cool logarithmically so they survive the journey upwards
-        if (new_val > 1.0) { cooling_rate = new_val * 0.02; } 
-        
+        // (slower than fire cooling: real embers stay lit while they rise)
+        if (new_val > 1.0) { cooling_rate = new_val * 0.012; }
+        cooling_rate *= dt_scale;
+
         new_val -= cooling_rate;
 
         // COMBUSTION: When fire runs out of heat (crosses 0), it becomes smoke.
         if (new_val <= 0.0) {
-            // A gentle puff of smoke when the flame dies (prevents screen-wide smoke explosion)
-            new_val = -0.15; 
+            // A puff of smoke when the flame dies (enough to read as sooty
+            // smoke above the flame tops, not a screen-wide haze)
+            new_val = -0.28;
         }
     } else if (new_val < 0.0) {
         // Smoke dissipating slowly as it mixes with cold air
-        new_val += 0.005; 
+        new_val += 0.005 * dt_scale;
         if (new_val > 0.0) { new_val = 0.0; }
     }