Release v0.9.10: Aspect ratio scaling fixes

Author: Soddentrough

Cargo.toml

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

src/engine.rs

@@ -95,7 +95,8 @@ pub struct AudioUniforms {
     pub frame_count: u32,
     pub step_fraction: f32,
     pub steps_to_fill: u32,
-    pub padding: [u32; 3],
+    pub aspect_ratio: f32,
+    pub padding: [u32; 2],
 }
 
 
@@ -2189,7 +2190,8 @@ impl VulkanEngine {
             frame_count: self.frame_count,
             step_fraction,
             steps_to_fill: steps,
-            padding: [0; 3],
+            aspect_ratio: self.size.width as f32 / self.size.height as f32,
+            padding: [0; 2],
         };
 
         uniforms.spectrum.copy_from_slice(&state.spectrum_data);
@@ -4313,8 +4315,13 @@ impl VulkanEngine {
 
             // --- 3D Engine Camera Math ---
             let aspect = vp_w / vp_h.max(1.0);
+            
+            // Update aspect_ratio uniform dynamically based on the current viewport
+            self.queue.write_buffer(&self.uniform_buffer, 8676, bytemuck::cast_slice(&[aspect as f32]));
 
-            let proj = glam::Mat4::perspective_rh_gl(std::f32::consts::PI / 3.0, aspect, 0.1, 1000.0);
+            let fov_x = std::f32::consts::PI / 2.0;
+            let fov_y = 2.0 * ((fov_x / 2.0).tan() / aspect).atan();
+            let proj = glam::Mat4::perspective_rh_gl(fov_y, aspect, 0.1, 1000.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),

src/main.rs

@@ -382,12 +382,14 @@ async fn run_gui(app_state: Arc<Mutex<AppState>>, mut active_stream: Option<audi
                                                 state.show_hud = !state.show_hud;
                                             },
                                             WinitKeyCode::KeyF => {
-                                                is_fullscreen = !is_fullscreen;
+                                                let currently_fullscreen = window.fullscreen().is_some();
+                                                is_fullscreen = !currently_fullscreen;
                                                 if is_fullscreen {
                                                     window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
                                                     keep_awake = keepawake::Builder::default().display(true).idle(true).create().ok();
                                                 } else {
                                                     window.set_fullscreen(None);
+                                                    let _ = window.request_inner_size(winit::dpi::LogicalSize::new(1024.0, 768.0));
                                                     keep_awake = None;
                                                 }
                                             },
@@ -1236,12 +1238,14 @@ async fn run_gui(app_state: Arc<Mutex<AppState>>, mut active_stream: Option<audi
                                     continue;
                                 }
                                 gilrs::Button::Start => {
-                                    is_fullscreen = !is_fullscreen;
+                                    let currently_fullscreen = window.fullscreen().is_some();
+                                    is_fullscreen = !currently_fullscreen;
                                     if is_fullscreen {
                                         window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
                                         keep_awake = keepawake::Builder::default().display(true).idle(true).create().ok();
                                     } else {
                                         window.set_fullscreen(None);
+                                        let _ = window.request_inner_size(winit::dpi::LogicalSize::new(1024.0, 768.0));
                                         keep_awake = None;
                                     }
                                     continue;

src/shaders/_common.wgsl

@@ -42,7 +42,64 @@ struct AudioUniforms {
     frame_count: u32,
     step_fraction: f32,
     steps_to_fill: u32,
-    pad1: u32,
+    aspect_ratio: f32,
     pad2: u32,
     pad3: u32,
 };
+
+fn hash21_crt(p: vec2<f32>) -> f32 {
+    var p3 = fract(vec3<f32>(p.xyx) * 0.1031);
+    p3 = p3 + dot(p3, p3.yzx + 33.33);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+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);
+    return (crt_uv * (1.0 + r2 * distortion)) * 0.5 + 0.5;
+}
+
+struct CRTSettings {
+    scanline_intensity: f32,
+    vignette_scale: f32,
+    vignette_softness: f32,
+    noise_intensity: f32,
+    flicker_intensity: f32,
+    phosphor_tint: vec3<f32>,
+}
+
+fn get_default_crt() -> CRTSettings {
+    var settings: CRTSettings;
+    settings.scanline_intensity = 0.15;
+    settings.vignette_scale = 1.4;
+    settings.vignette_softness = 0.85;
+    settings.noise_intensity = 0.025;
+    settings.flicker_intensity = 0.03;
+    settings.phosphor_tint = vec3<f32>(1.0, 1.0, 1.0);
+    return settings;
+}
+
+fn apply_crt_effects(color: vec3<f32>, uv: vec2<f32>, clip_pos: vec2<f32>, time: f32, settings: CRTSettings) -> vec3<f32> {
+    var final_color = color;
+    
+    // CRT scanlines
+    let scanline = 1.0 - settings.scanline_intensity + settings.scanline_intensity * cos(clip_pos.y * 3.14159);
+    final_color *= scanline;
+    
+    // Vignette
+    let crt_uv = uv * 2.0 - 1.0;
+    let r = length(crt_uv);
+    let bezel = smoothstep(settings.vignette_scale, settings.vignette_softness, r);
+    final_color *= bezel;
+    
+    // Flicker
+    let flicker = 1.0 - settings.flicker_intensity + settings.flicker_intensity * sin(time * 377.0);
+    final_color *= flicker;
+    
+    // Analog noise
+    let noise_val = hash21_crt(clip_pos + fract(time) * 137.0);
+    let static_noise = noise_val * settings.noise_intensity * bezel;
+    final_color = final_color + static_noise;
+    
+    return final_color * settings.phosphor_tint;
+}

src/shaders/spectrum.wgsl

@@ -173,17 +173,14 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     } 
     else {
         // --- MODE 2: AMBER CRT ---
-        // Apply radial distortion
-        let crt_uv = in.uv * 2.0 - 1.0;
-        let r2 = dot(crt_uv, crt_uv);
-        let distorted_uv = crt_uv * (1.0 + r2 * 0.15); // Curve
-        let final_uv = distorted_uv * 0.5 + 0.5;
+        // Apply radial distortion (Disabled to preserve grid alignment with UI)
+        let final_uv = in.uv;
 
         if final_uv.x < 0.0 || final_uv.x > 1.0 || final_uv.y < 0.0 || final_uv.y > 1.0 {
             return vec4<f32>(0.0, 0.0, 0.0, 1.0);
         }
 
-        let aspect = dpdx(in.uv.x) / dpdy(in.uv.y);
+        let aspect = audio.aspect_ratio;
         var final_color = vec3<f32>(0.0);
         let amber = vec3<f32>(1.0, 0.65, 0.1);
 
@@ -230,11 +227,14 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
         let mask_intensity = 0.7 + 0.3 * sin(mask_x * 3.14159) * sin(mask_y * 3.14159);
         final_color = final_color * mask_intensity;
 
-        let vignette = smoothstep(1.5, 0.2, length(distorted_uv));
-        let scanlines = sin(final_uv.y * 400.0 * aspect) * 0.15 + 0.85;
-        let flicker = sin(audio.time * 60.0) * 0.03 + 0.97;
+        var crt_settings = get_default_crt();
+        crt_settings.scanline_intensity = 0.15;
+        crt_settings.vignette_scale = 1.5;
+        crt_settings.vignette_softness = 0.2;
+        crt_settings.flicker_intensity = 0.03;
+        crt_settings.noise_intensity = 0.0;
 
-        final_color = final_color * vignette * scanlines * flicker;
+        final_color = apply_crt_effects(final_color, in.uv, in.clip_position.xy, audio.time, crt_settings);
 
         return vec4<f32>(final_color, 1.0);
     }

src/shaders/vis_3doscilloscope.wgsl

@@ -52,7 +52,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     let dy = dpdy(in.uv.y);
     let aspect = dy / max(dx, 0.00001);
 
-    // Scale screen coords
+    // Scale screen coords to maintain horizontal FOV
     let p = vec2<f32>(distorted_uv.x * aspect, distorted_uv.y) * 0.9;
 
     // Subtly rotate camera around center
@@ -75,7 +75,10 @@ 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);
+    let safe_aspect = max(aspect, 0.001);
+    let bound = 9.6 * safe_aspect;
+    let inner_bound = max(bound - 3.0, 0.0);
+    let inv_res_minus_1 = (bound * 2.0) / (res - 1.0);
 
     if rd.y > 0.0 {
         let t_min = max(0.0, (ro.z - 1.5) / max(0.2 - rd.z, 0.00001));
@@ -96,13 +99,13 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
 
             let hit_x = ro.x + rd.x * t;
 
-            let edge_fade = smoothstep(9.6, 6.6, abs(hit_x));
+            let edge_fade = smoothstep(bound, inner_bound, abs(hit_x));
             if edge_fade <= 0.00001 {
                 continue;
             }
 
             // Map X from -9.6 to 9.6 to dynamic resolution
-            let float_idx = (hit_x + 9.6) / 19.2 * (res - 1.0);
+            let float_idx = (hit_x + bound) / (bound * 2.0) * (res - 1.0);
             let idx = i32(round(float_idx));
 
             // Search radius proportional to distance to avoid aliasing/dropout on distant lines
@@ -116,17 +119,17 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
             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) * inv_res_minus_1;
-            var mask_prev = smoothstep(9.6, 6.6, abs(x_prev));
+            var x_prev = -bound + f32(j_u) * inv_res_minus_1;
+            var mask_prev = smoothstep(bound, inner_bound, abs(x_prev));
             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) * inv_res_minus_1;
-                let mask_curr = smoothstep(9.6, 6.6, abs(x_curr));
+                let x_curr = -bound + f32(j_u) * inv_res_minus_1;
+                let mask_curr = smoothstep(bound, inner_bound, abs(x_curr));
                 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);
@@ -157,7 +160,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
             let age_fade = mix(0.05, 1.0, f32(i) / f32(num_lines - 1u));
 
             // 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 hit_wave_idx = u32(clamp((hit_x + bound) / (bound * 2.0) * (res - 1.0), 0.0, res - 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);
 

src/shaders/vis_3doscilloscope_freq.wgsl

@@ -53,7 +53,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     let dy = dpdy(in.uv.y);
     let aspect = dy / max(dx, 0.00001);
 
-    // Scale screen coords
+    // Scale screen coords to maintain horizontal FOV
     let p = vec2<f32>(distorted_uv.x * aspect, distorted_uv.y) * 0.9;
 
     // Subtly rotate camera around center

src/shaders/vis_3drain.wgsl

@@ -153,7 +153,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     let dy = dpdy(in.uv.y);
     let aspect = dy / max(dx, 0.00001);
     let safe_aspect = select(1.0, aspect, abs(aspect) > 0.0001);
-    let p = vec2<f32>(uv.x * safe_aspect, -uv.y); // p.y is +1 at top, -1 at bottom
+    let p = vec2<f32>(uv.x, -uv.y / safe_aspect); // p.y is +1 at top, -1 at bottom
 
     let bass = max(audio.spectrum[0].x, audio.spectrum[1].x);
     let mid = (audio.spectrum[20].x + audio.spectrum[30].x) * 0.5;

src/shaders/vis_flame.wgsl

@@ -31,11 +31,7 @@ fn demoscene_palette(h: f32) -> vec3<f32> {
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     // --- CRT barrel distortion ---
-    let crt_uv = in.uv * 2.0 - 1.0;
-    let r2 = dot(crt_uv, crt_uv);
-    // Reduced from 0.08 to 0.03 for a more subtle bend
-    let distorted = crt_uv * (1.0 + r2 * 0.03);
-    let uv = distorted * 0.5 + 0.5;
+    let uv = crt_distort_uv(in.uv, 0.03);
 
     // Outside the CRT tube → pure black
     if uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0 {
@@ -81,22 +77,19 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     }
     color *= phosphor;
 
-    // --- Vignette (darken edges of CRT) ---
-    let vignette = smoothstep(1.5, 0.85, length(crt_uv));
-    color *= vignette;
-
-    // --- Analog noise / static ---
-    let noise = hash12(in.clip_position.xy + fract(audio.smooth_time) * 137.0);
-    color += vec3<f32>(noise * 0.025 * vignette);
-
-    // --- CRT flicker (subtle 60Hz-ish wobble) ---
-    let flicker = 0.97 + 0.03 * sin(audio.smooth_time * 377.0);
-    color *= flicker;
-
     // --- Bezel edge glow (faint amber reflection near corners) ---
+    let crt_uv = uv * 2.0 - 1.0;
     let bezel_dist = max(abs(crt_uv.x) - 0.85, 0.0) + max(abs(crt_uv.y) - 0.85, 0.0);
     let bezel_glow = exp(-bezel_dist * 30.0) * 0.03;
     color += vec3<f32>(1.0, 0.6, 0.2) * bezel_glow * clamp(heat * 3.0, 0.0, 1.0);
 
+    var crt_settings = get_default_crt();
+    crt_settings.scanline_intensity = 0.0; // Use vis_flame's custom scanlines instead
+    crt_settings.vignette_scale = 1.5;
+    crt_settings.vignette_softness = 0.85;
+    crt_settings.noise_intensity = 0.025;
+    crt_settings.flicker_intensity = 0.03;
+    color = apply_crt_effects(color, in.uv, in.clip_position.xy, audio.smooth_time, crt_settings);
+
     return vec4<f32>(color, 1.0);
 }

src/shaders/vis_oscilloscope.wgsl

@@ -80,14 +80,12 @@ fn get_wave_dist(hist_idx: u32, uv: vec2<f32>, aspect: f32) -> f32 {
 @fragment
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     // CRT barrel distortion
-    let crt_uv = in.uv * 2.0 - 1.0;
-    let r2 = dot(crt_uv, crt_uv);
-    let distorted_uv = crt_uv * (1.0 + r2 * 0.05);
-    let final_uv = distorted_uv * 0.5 + 0.5;
+    let final_uv = crt_distort_uv(in.uv, 0.05);
 
-    let aspect = dpdx(in.uv.x) / dpdy(in.uv.y);
+    let aspect = audio.aspect_ratio;
     var final_color = vec3<f32>(0.0);
 
+    let crt_uv = in.uv * 2.0 - 1.0;
     let r = length(crt_uv);
     let edge_blur = smoothstep(0.2, 1.5, r);
 
@@ -96,11 +94,20 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
 
     var wave_intensity = 0.0;
 
+    let dy = dpdy(in.uv.y);
+    let base_thickness = max(dy * 0.6, 0.0005);
+    let blur_thickness = max(dy * 2.0, 0.0015);
+
     // Performance: skip every other history frame when count exceeds 72,
     // compensating with doubled contribution to maintain total brightness.
     let hist_count = min(audio.waveform_history_size, 144u);
     let step = select(1u, 2u, hist_count > 72u);
     let step_scale = f32(step);
+    
+    // Lock thickness to physical screen pixels so it doesn't vanish on short windows
+    let thickness = base_thickness + edge_blur * blur_thickness;
+    // Tighter bloom (reduced spread and intensity)
+    let bloom_spread = max(dy * 0.2, 0.0002);
 
     for (var i = 0u; i < hist_count; i = i + step) {
         let true_dist = get_wave_dist(i, final_uv, aspect);
@@ -111,12 +118,8 @@ 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);
 
-        // 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.00005 / (true_dist * true_dist + 0.0002) * 0.02;
+        let bloom = 0.00005 / (true_dist * true_dist + bloom_spread) * 0.02;
 
         // Tighter halation (faster falloff)
         let halation = exp(-true_dist * 120.0) * 0.01;
@@ -130,24 +133,18 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     let mapped = wave_intensity * amber;
     var tonemapped = (mapped * (2.51 * mapped + 0.03)) / (mapped * (2.43 * mapped + 0.59) + 0.14);
 
-    final_color = tonemapped;
-
-    // CRT scanlines
-    let scanline = 0.85 + 0.15 * cos(in.clip_position.y * 3.14159);
-    final_color *= scanline;
-
+    var crt_settings = get_default_crt();
+    crt_settings.phosphor_tint = amber; // Not used as tint for everything, just to configure if needed. Actually we'll keep final_color.
+    
     // Smooth CRT bezel fade (radial, no rectangular edges)
     let bezel = smoothstep(1.4, 0.9, r);
-
-    // Analog noise / static (like vis_flame)
-    let noise_val = hash21(in.clip_position.xy + fract(audio.smooth_time) * 137.0);
-    let static_noise = noise_val * 0.035 * bezel;
 
-    // Add extra faint glow from the waveform onto the noise
+    // Analog noise glow
+    let noise_val = hash21_crt(in.clip_position.xy + fract(audio.smooth_time) * 137.0);
     let noise_glow = amber * noise_val * 0.015 * bezel * clamp(wave_intensity * 0.8, 0.0, 1.0);
 
-    final_color = final_color * bezel;
-    final_color = final_color + static_noise + noise_glow;
+    final_color = apply_crt_effects(tonemapped, in.uv, in.clip_position.xy, audio.smooth_time, crt_settings);
+    final_color = final_color + noise_glow;
 
     // Output Linear RGB. WGPU Srgb surface will apply the sRGB gamma curve automatically.
     return vec4<f32>(final_color, 1.0);