perf: optimize 3D CRT Oscilloscope and Neon Cuboids shaders, add benchmarking

Author: Soddentrough

src/main.rs

@@ -46,6 +46,9 @@ struct Args {
 
     #[arg(long, default_value_t = false)]
     gpu_fft: bool,
+
+    #[arg(long)]
+    bench: Option<u32>,
 }
 
 struct Tui {
@@ -159,14 +162,14 @@ fn main() -> Result<(), Box<dyn Error>> {
             eprintln!("App error: {:?}", err);
         }
     } else {
-        pollster::block_on(run_gui(app_state, initial_stream, args.fullscreen, args.gpu_fft));
+        pollster::block_on(run_gui(app_state, initial_stream, args.fullscreen, args.gpu_fft, args.bench));
     }
 
     Ok(())
 }
 
 #[allow(unused_variables, unused_assignments)]
-async fn run_gui(app_state: Arc<Mutex<AppState>>, mut active_stream: Option<audio::PlaybackHandle>, is_fullscreen: bool, use_gpu_fft: bool) {
+async fn run_gui(app_state: Arc<Mutex<AppState>>, mut active_stream: Option<audio::PlaybackHandle>, is_fullscreen: bool, use_gpu_fft: bool, bench: Option<u32>) {
     if use_gpu_fft {
         let mut state = app_state.lock().unwrap();
         state.gpu_fft = true;
@@ -258,6 +261,7 @@ async fn run_gui(app_state: Arc<Mutex<AppState>>, mut active_stream: Option<audi
     let mut rfd_pending = false;
 
     let mut modifiers = winit::keyboard::ModifiersState::empty();
+    let mut frame_count = 0u32;
 
     #[allow(deprecated)]
     let _ = event_loop.run(move |event, elwt| {
@@ -803,6 +807,19 @@ async fn run_gui(app_state: Arc<Mutex<AppState>>, mut active_stream: Option<audi
                                 state.stats.gpu_fft_us = state.stats.gpu_fft_us * 0.9 + ft * 0.1;
                             }
                         }
+
+                        if let Some(bench_frames) = bench {
+                            frame_count += 1;
+                            if frame_count >= bench_frames {
+                                let vis_def = &crate::state::VISUALIZERS[state.current_visualizer_idx];
+                                println!("BENCHMARK_RESULT_VISUALIZER: {}", vis_def.name);
+                                println!("BENCHMARK_RESULT_FPS: {:.2}", state.current_fps);
+                                println!("BENCHMARK_RESULT_SHADER_US: {:.2}", state.stats.shader_us);
+                                println!("BENCHMARK_RESULT_RENDER_US: {:.2}", state.stats.render_us);
+                                elwt.exit();
+                                return;
+                            }
+                        }
 
                         // Process engine actions
                         match action {

src/shaders/vis_3doscilloscope.wgsl

@@ -33,8 +33,9 @@ fn project_3d(p3: vec3<f32>, ro: vec3<f32>, u: vec3<f32>, v_cam: vec3<f32>, w: v
     let dir = p3 - ro;
     let dist_w = dot(dir, w);
     if dist_w <= 0.001 { return vec3<f32>(999.0, 999.0, dist_w); }
-    let proj_x = dot(dir, u) / dist_w;
-    let proj_y = dot(dir, v_cam) / dist_w;
+    let inv_dist_w = 1.0 / dist_w;
+    let proj_x = dot(dir, u) * inv_dist_w;
+    let proj_y = dot(dir, v_cam) * inv_dist_w;
     // Negate proj_y so +Z (up) maps to -Y (top of screen in our coords)
     return vec3<f32>(proj_x, -proj_y, dist_w);
 }
@@ -74,20 +75,25 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
 
     let num_lines = min(max(1u, audio.waveform_history_size), 144u);
     let res = f32(max(audio.waveform_resolution, 128u));
+    let inv_res_minus_1 = 19.2 / (res - 1.0);
 
-    for (var i = 0u; i < num_lines; i = i + 1u) {
-        // Z layout: back to front. i=0 is back (oldest), i=num_lines-1 is front (newest).
-        let y_line = mix(9.48, -1.8, f32(i) / f32(num_lines - 1u));
-        let hist_idx = i;
-        
-        let t = (y_line - ro.y) / rd.y;
-        if t <= 0.0 {
-            // Lines are iterated back-to-front (decreasing Y). When rd.y > 0,
-            // once t goes negative all remaining lines are also behind the camera.
-            if rd.y > 0.0 { break; }
-            continue;
-        }
-        {
+    if rd.y > 0.0 {
+        let t_min = max(0.0, (ro.z - 1.5) / max(0.2 - rd.z, 0.00001));
+        let t_max = (ro.z + 1.5) / max(-0.2 - rd.z, 0.00001);
+
+        for (var i = 0u; i < num_lines; i = i + 1u) {
+            // Z layout: back to front. i=0 is back (oldest), i=num_lines-1 is front (newest).
+            let y_line = mix(9.48, -1.8, f32(i) / f32(num_lines - 1u));
+            let hist_idx = i;
+            
+            let t = (y_line - ro.y) / rd.y;
+            if t < t_min {
+                break;
+            }
+            if t > t_max {
+                continue;
+            }
+            
             let hit_x = ro.x + rd.x * t;
 
             let edge_fade = smoothstep(9.6, 6.6, abs(hit_x));
@@ -103,23 +109,25 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
             // Scale down slightly since we have 3x more lines now
             let search_radius = clamp(i32(t * 0.4), 1, 6);
             let start_idx = max(0, idx - search_radius);
-            let end_idx = min(i32(res) - 1i, idx + search_radius);
+            let end_idx = min(i32(res) - 2, idx + search_radius);
 
             var min_dist = 1000.0;
 
+            let hist_offset = clamp(hist_idx, 0u, max(1u, audio.waveform_history_size) - 1u) * 2048u;
+            
             var j_u = u32(start_idx);
-            var x_prev = -9.6 + f32(j_u) / (res - 1.0) * 19.2;
+            var x_prev = -9.6 + f32(j_u) * inv_res_minus_1;
             var mask_prev = smoothstep(9.6, 6.6, abs(x_prev));
-            var v_prev = get_waveform(hist_idx, j_u);
+            var v_prev = waveform_history[hist_offset + j_u];
             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);
 
             for (var j = start_idx; j <= end_idx; j = j + 1) {
                 j_u = u32(j + 1);
-                let x_curr = -9.6 + f32(j_u) / (res - 1.0) * 19.2;
+                let x_curr = -9.6 + f32(j_u) * inv_res_minus_1;
                 let mask_curr = smoothstep(9.6, 6.6, abs(x_curr));
-                let v_curr = get_waveform(hist_idx, j_u);
+                let v_curr = waveform_history[hist_offset + j_u];
                 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);
@@ -150,7 +158,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
 
             // Sample waveform height at hit point for color grading
             let hit_wave_idx = u32(clamp((hit_x + 9.6) / 19.2 * (res - 1.0), 0.0, res - 1.0));
-            let wave_height = clamp(abs(get_waveform(hist_idx, hit_wave_idx)) * 2.0, 0.0, 1.0);
+            let wave_height = clamp(abs(waveform_history[hist_offset + hit_wave_idx]) * 2.0, 0.0, 1.0);
             let line_amber = mix(amber_lo, amber_hi, wave_height);
 
             accumulated_color += line_amber * (core + bloom) * depth_fade * edge_fade * age_fade;

src/shaders/vis_cuboids.wgsl

@@ -21,9 +21,8 @@ fn sdWireframeBox(p: vec3<f32>, b: vec3<f32>, e: f32) -> f32 {
 }
 
 fn get_history_amplitude(bin: u32, steps_ago: u32) -> f32 {
-    let row = (audio.heatmap_row + 1024u - (steps_ago % 1024u)) % 1024u;
-    let clamped_bin = clamp(bin, 0u, 255u);
-    return textureLoad(history_tex, vec2<i32>(i32(clamped_bin), i32(row)), 0).x;
+    let row = (audio.heatmap_row + 1024u - (steps_ago & 1023u)) & 1023u;
+    return textureLoad(history_tex, vec2<i32>(i32(bin), i32(row)), 0).x;
 }
 
 struct SceneResult {
@@ -32,6 +31,44 @@ struct SceneResult {
     amp: f32,
 };
 
+fn evaluate_cell(p: vec3<f32>, ix: i32, iz: i32, res_in: SceneResult) -> SceneResult {
+    var res = res_in;
+    let x_spacing = 1.35;
+    let z_spacing = 1.35;
+    let cx = f32(ix) * x_spacing;
+    let cz = f32(iz) * z_spacing;
+    
+    let dist_from_center = sqrt(f32(ix * ix + iz * iz));
+    let bin = clamp(u32(dist_from_center * 10.0) + 4u, 0u, 255u);
+    let steps_ago = u32(dist_from_center * 3.0);
+    let amp = get_history_amplitude(bin, steps_ago);
+    let shift = clamp(amp / 100.0, 0.0, 1.0) * 1.5;
+    
+    let thick = 0.009 + clamp(amp / 100.0, 0.0, 1.0) * 0.007;
+    let b = vec3<f32>(0.22, 0.85, 0.22);
+    
+    // Mathematically proven: Only the box on the same side of y=0.0 as p.y can possibly be the closest.
+    if (p.y < 0.0) {
+        let y_center_b = -2.9 + shift;
+        let d_b = sdWireframeBox(p - vec3<f32>(cx, y_center_b, cz), b, thick);
+        if (d_b < res.d) {
+            res.d = d_b;
+            res.hit_type = 1;
+            res.amp = amp;
+        }
+    } else {
+        let y_center_t = 2.9 - shift;
+        let d_t = sdWireframeBox(p - vec3<f32>(cx, y_center_t, cz), b, thick);
+        if (d_t < res.d) {
+            res.d = d_t;
+            res.hit_type = 2;
+            res.amp = amp;
+        }
+    }
+    
+    return res;
+}
+
 fn map_scene(p: vec3<f32>) -> SceneResult {
     let x_spacing = 1.35;
     let z_spacing = 1.35;
@@ -44,8 +81,54 @@ fn map_scene(p: vec3<f32>) -> SceneResult {
     res.hit_type = 0;
     res.amp = 0.0;
 
-    for (var dx = -1; dx <= 1; dx = dx + 1) {
-        for (var dz = -1; dz <= 1; dz = dz + 1) {
+    // Early return if completely out of bounds of the grid
+    if (ix_center < -16 || ix_center > 16 || iz_center < -21 || iz_center > 7) {
+        return res;
+    }
+    
+    let cx_center = f32(ix_center) * x_spacing;
+    let cz_center = f32(iz_center) * z_spacing;
+    
+    // 1. Evaluate center cell first to establish a tight bound
+    if (ix_center >= -15 && ix_center <= 15 && iz_center >= -20 && iz_center <= 6) {
+        res = evaluate_cell(p, ix_center, iz_center, res);
+    }
+    
+    // 2. Early return if the current best distance is closer than any neighbor cell could possibly be.
+    // The closest horizontal distance to any box in a neighbor is at least 1.13 - distance_to_center_cell.
+    let dx_center_dist = abs(p.x - cx_center);
+    let dz_center_dist = abs(p.z - cz_center);
+    let d_neighbor_min = min(1.13 - dx_center_dist, 1.13 - dz_center_dist);
+    if (res.d < d_neighbor_min) {
+        return res;
+    }
+    
+    // 3. Evaluate neighbor cells only if they are within the dynamic bounds and closer.
+    // If res.d <= 1.13, we can skip neighbors on the opposite side of the center cell.
+    var dx_start = -1;
+    var dx_end = 1;
+    if (res.d <= 1.13) {
+        if (p.x >= cx_center) {
+            dx_start = 0;
+        } else {
+            dx_end = 0;
+        }
+    }
+    
+    var dz_start = -1;
+    var dz_end = 1;
+    if (res.d <= 1.13) {
+        if (p.z >= cz_center) {
+            dz_start = 0;
+        } else {
+            dz_end = 0;
+        }
+    }
+    
+    for (var dx = dx_start; dx <= dx_end; dx = dx + 1) {
+        for (var dz = dz_start; dz <= dz_end; dz = dz + 1) {
+            if (dx == 0 && dz == 0) { continue; }
+            
             let ix = ix_center + dx;
             let iz = iz_center + dz;
 
@@ -54,32 +137,11 @@ fn map_scene(p: vec3<f32>) -> SceneResult {
             let cx = f32(ix) * x_spacing;
             let cz = f32(iz) * z_spacing;
 
-            let dist_from_center = length(vec2<f32>(f32(ix), f32(iz)));
-            let bin = clamp(u32(dist_from_center * 10.0) + 4u, 0u, 255u);
-            let steps_ago = u32(dist_from_center * 3.0);
-            let amp = get_history_amplitude(bin, steps_ago);
-            let shift = clamp(amp / 100.0, 0.0, 1.0) * 1.5;
-            
-            let thick = 0.009 + clamp(amp / 100.0, 0.0, 1.0) * 0.007;
-            let b = vec3<f32>(0.22, 0.85, 0.22);
-            
-            // Bottom Box
-            let y_center_b = -2.9 + shift;
-            let d_b = sdWireframeBox(p - vec3<f32>(cx, y_center_b, cz), b, thick);
-            if (d_b < res.d) {
-                res.d = d_b;
-                res.hit_type = 1;
-                res.amp = amp;
-            }
+            // Strict mathematical lower bound check: distance to cell boundary
+            let d_horizontal = max(abs(p.x - cx) - 0.22, abs(p.z - cz) - 0.22);
+            if (d_horizontal >= res.d) { continue; }
 
-            // Top Box
-            let y_center_t = 2.9 - shift;
-            let d_t = sdWireframeBox(p - vec3<f32>(cx, y_center_t, cz), b, thick);
-            if (d_t < res.d) {
-                res.d = d_t;
-                res.hit_type = 2;
-                res.amp = amp;
-            }
+            res = evaluate_cell(p, ix, iz, res);
         }
     }
 

test_sine.wav

@@ -0,0 +1,61 @@
+use std::process::Command;
+use std::str;
+
+#[test]
+fn test_visualizer_benchmark() {
+    let visualizers = vec!["3doscilloscope", "3doscilloscope_freq"];
+    
+    println!("\n==================================================");
+    println!("RUNNING VISUALIZER BENCHMARKS (500 FRAMES)...");
+    println!("==================================================");
+
+    for vis in visualizers {
+        let output = Command::new("cargo")
+            .args(&[
+                "run",
+                "--release",
+                "--",
+                "test_sine.wav",
+                "--vis",
+                vis,
+                "--bench",
+                "500",
+            ])
+            .output()
+            .expect("Failed to execute cargo run");
+
+        let stdout = str::from_utf8(&output.stdout).unwrap();
+        let stderr = str::from_utf8(&output.stderr).unwrap();
+
+        if !output.status.success() {
+            eprintln!("Benchmark failed for visualizer: {}", vis);
+            eprintln!("STDOUT:\n{}", stdout);
+            eprintln!("STDERR:\n{}", stderr);
+            panic!("Visualizer benchmark command exited with error status");
+        }
+
+        // Parse benchmark results from stdout
+        let mut parsed_name = String::new();
+        let mut parsed_fps = String::new();
+        let mut parsed_shader_us = String::new();
+        let mut parsed_render_us = String::new();
+
+        for line in stdout.lines() {
+            if let Some(val) = line.strip_prefix("BENCHMARK_RESULT_VISUALIZER: ") {
+                parsed_name = val.to_string();
+            } else if let Some(val) = line.strip_prefix("BENCHMARK_RESULT_FPS: ") {
+                parsed_fps = val.to_string();
+            } else if let Some(val) = line.strip_prefix("BENCHMARK_RESULT_SHADER_US: ") {
+                parsed_shader_us = val.to_string();
+            } else if let Some(val) = line.strip_prefix("BENCHMARK_RESULT_RENDER_US: ") {
+                parsed_render_us = val.to_string();
+            }
+        }
+
+        println!("Visualizer:   {}", parsed_name);
+        println!("FPS:          {}", parsed_fps);
+        println!("Shader Time:  {} us", parsed_shader_us);
+        println!("Render Time:  {} us", parsed_render_us);
+        println!("--------------------------------------------------");
+    }
+}