Fix visualizer rendering artifacts

Author: Soddentrough

Cargo.lock

@@ -1780,12 +1780,14 @@ where
             for i in 0..frames_read {
                 let l_val = chunk.samples[i * hardware_channels];
                 left_peak = left_peak.max(l_val.abs());
-                if l_val.abs() >= 1.0 { clips += 1; }
+                // Use a small epsilon above 1.0 to prevent 0dBFS peaks in losslessly 
+                // mastered tracks from falsely triggering clipping events
+                if l_val.abs() > 1.0001 { clips += 1; }
 
                 if hardware_channels > 1 {
                     let r_val = chunk.samples[i * hardware_channels + 1];
                     right_peak = right_peak.max(r_val.abs());
-                    if r_val.abs() >= 1.0 { clips += 1; }
+                    if r_val.abs() > 1.0001 { clips += 1; }
                 } else {
                     right_peak = left_peak;
                 }

src/audio.rs

@@ -114,23 +114,26 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
             }
         }
 
-        let coal_target = min(params.bass * 0.25 + activity * 2.5, 1.0);
+        // Use exponential soft-clipping for AGC (Automatic Gain Control)
+        // This ensures quiet tracks still generate nice flames, while brickwalled tracks smoothly approach 1.0 without hard clipping.
+        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;
         } else {
             coal_bed[x] = current + (coal_target - current) * 0.008;
         }
 
-        let jitter = (perlin_noise(vec2<f32>(f32(x) * 0.5, params.time * 10.0)) + 1.0) * 0.5;
+        // Use lower frequency noise to create wide, organic hotspots rather than single-pixel static
+        let jitter = (perlin_noise(vec2<f32>(f32(x) * 0.05, params.time * 10.0)) + 1.0) * 0.5;
         output_grid[idx] = min(coal_bed[x] * (0.7 + 0.3 * jitter), 1.0);
         return;
     }
 
     // === Hearth rows: inject coal heat ===
     if (y >= bottom - 2u) {
         let coal_heat = min(coal_bed[x], 1.0);
-        let jitter = (perlin_noise(vec2<f32>(f32(x) * 0.5, params.time * 10.0)) + 1.0) * 0.5;
+        let jitter = (perlin_noise(vec2<f32>(f32(x) * 0.05, params.time * 10.0)) + 1.0) * 0.5;
 
         if (y == bottom - 1u) {
             output_grid[idx] = coal_heat * (0.85 + 0.15 * jitter);
@@ -152,16 +155,31 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     // Global wind swaying the fire
     let wind = i32(sin(params.time * 1.5 + f32(x) * 0.003) * params.highs * 2.0);
 
-    // Cellular Automaton: read from exactly one pixel in the row below
+    // Classic DOS fire averaging: blend adjacent pixels to allow heat to diffuse into organic shapes
     let src_x = clamp(i32(x) + spread + wind, 0i, i32(w) - 1);
-    let heat = input_grid[(y + 1u) * w + u32(src_x)];
+    let xl = max(src_x - 1, 0i);
+    let xr = min(src_x + 1, i32(w) - 1);
+    
+    let h1 = input_grid[(y + 1u) * w + u32(xl)];
+    let h2 = input_grid[(y + 1u) * w + u32(src_x)];
+    let h3 = input_grid[(y + 1u) * w + u32(xr)];
+    
+    // Weighted horizontal blur favors the center pixel
+    let heat = (h1 + h2 * 2.0 + h3) / 4.0;
 
     // Cooling varies spatially to create uneven tips and licks
-    let cool_noise = perlin_noise(p1 * 3.0 - vec2<f32>(params.time * 2.0, 0.0));
-    let base_cooling = 0.001 + (cool_noise + 1.0) * 0.0008;
+    // Stretch the noise vertically and move it upwards to simulate rising flame tongues
+    let p_cool = vec2<f32>(f32(x) * 0.015, f32(y) * 0.03);
+    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;
 
     // Occasional sparks (holes in the flame) for realism, clumped by noise
     let spark = select(0.0, 0.06, cool_noise > 0.8 && y > 100u);
 
-    output_grid[idx] = max(heat - base_cooling * params.cooling_factor - spark, 0.0);
+    // 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);
+
+    output_grid[idx] = max(heat - base_cooling * dynamic_cooling - spark, 0.0);
 }

src/shaders/fire_compute.wgsl

@@ -111,7 +111,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
             var x_prev = -9.6 + f32(j_u) / (res - 1.0) * 19.2;
             var mask_prev = smoothstep(9.6, 6.6, abs(x_prev));
             var v_prev = get_waveform(hist_idx, j_u);
-            var p_prev = abs(v_prev) * mask_prev * 6.0;
+            var p_prev = v_prev * mask_prev * 1.2;
             var p3_prev = vec3<f32>(x_prev, y_line, p_prev);
             var proj_prev = project_3d(p3_prev, ro, u, v_cam, w);
 
@@ -120,7 +120,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
                 let x_curr = -9.6 + f32(j_u) / (res - 1.0) * 19.2;
                 let mask_curr = smoothstep(9.6, 6.6, abs(x_curr));
                 let v_curr = get_waveform(hist_idx, j_u);
-                let p_curr = abs(v_curr) * mask_curr * 6.0;
+                let p_curr = v_curr * mask_curr * 1.2;
                 let p3_curr = vec3<f32>(x_curr, y_line, p_curr);
                 let proj_curr = project_3d(p3_curr, ro, u, v_cam, w);
 

src/shaders/vis_3doscilloscope.wgsl

@@ -114,8 +114,8 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
                 let v1 = get_resynthesized_wave(i, x_norm1);
 
                 // Allow true negative waveforms, just apply mask
-                let p0 = v0 * mask0 * 4.0;
-                let p1 = v1 * mask1 * 4.0;
+                let p0 = v0 * mask0 * 1.2;
+                let p1 = v1 * mask1 * 1.2;
 
                 let p3_0 = vec3<f32>(x0, y_line, p0);
                 let p3_1 = vec3<f32>(x1, y_line, p1);

src/shaders/vis_3doscilloscope_freq.wgsl

@@ -47,8 +47,10 @@ fn get_wave_dist(hist_idx: u32, uv: vec2<f32>, aspect: f32) -> f32 {
     var min_dist = 1000.0;
 
     // Check local neighborhood for proper line segment coverage
-    let start_idx = max(0i, i32(idx) - 1);
-    let end_idx = min(i32(res) - 2i, i32(idx) + 1);
+    // Since lines are thin, a small search radius is sufficient to prevent horizontal clipping
+    let search_radius = clamp(i32(res * 0.003), 2, 8);
+    let start_idx = max(0i, i32(idx) - search_radius);
+    let end_idx = min(i32(res) - 2i, i32(idx) + search_radius);
 
     let p = vec2<f32>(uv.x * aspect, uv.y);
 
@@ -109,15 +111,15 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
         // 0.05 gives a long 1-second smooth trail.
         let age = exp(-frames_old * 0.06);
 
-        // Beam thickness scales down with dynamic resolution to prevent huge blobs
-        let thickness = 0.002 + edge_blur * 0.006;
-        let core = smoothstep(thickness, 0.0, true_dist) * 0.4;
+        // Much thinner beam for crisp, high-resolution lines instead of thick noodles
+        let thickness = 0.0005 + edge_blur * 0.0015;
+        let core = smoothstep(thickness, 0.0, true_dist) * 0.6;
 
         // Tighter bloom (reduced spread and intensity)
-        let bloom = 0.0002 / (true_dist * true_dist + 0.001) * 0.03;
+        let bloom = 0.00005 / (true_dist * true_dist + 0.0002) * 0.02;
 
         // Tighter halation (faster falloff)
-        let halation = exp(-true_dist * 80.0) * 0.015;
+        let halation = exp(-true_dist * 120.0) * 0.01;
 
         let frame_intensity = (core + bloom + halation) * age * step_scale;