refactor: optimize lightning renderer, update shader SDF logic, and expose lamp mesh generator

Soddentrough · Soddentrough · commit fcfc1af2bbc3 · 2026-05-20T21:19:22.000+09:00
diff --git a/src/engine.rs b/src/engine.rs
@@ -278,7 +278,7 @@ pub struct VulkanEngine<'a> {
     smooth_dt: f64,
 }
 
-fn generate_lamp_mesh() -> (Vec<Vertex>, Vec<u32>) {
+pub(crate) fn generate_lamp_mesh() -> (Vec<Vertex>, Vec<u32>) {
     let mut vertices = Vec::new();
     let mut indices = Vec::new();
     
diff --git a/src/shaders/vis_3drain.wgsl b/src/shaders/vis_3drain.wgsl
@@ -37,46 +37,55 @@ fn project_3d(p3: vec3<f32>, ro: vec3<f32>, u: vec3<f32>, v_cam: vec3<f32>, w: v
     return vec3<f32>(proj_x, proj_y, dist_w);
 }
 
-fn draw_3d_segment(p: vec2<f32>, ro: vec3<f32>, u: vec3<f32>, v_cam: vec3<f32>, w: vec3<f32>, start_pos: vec3<f32>, end_pos: vec3<f32>, thickness_base: f32, intensity: f32, is_branch: bool) -> f32 {
-    var pA = project_3d(start_pos, ro, u, v_cam, w);
-    var pB = project_3d(end_pos, ro, u, v_cam, w);
+fn draw_projected_segment(p: vec2<f32>, pA: vec3<f32>, pB: vec3<f32>, thickness_base: f32, intensity: f32, is_branch: bool) -> f32 {
+    if (pA.z <= 0.1 || pB.z <= 0.1) {
+        return 0.0;
+    }
     
-    if (pA.z <= 0.0 && pB.z <= 0.0) { return 0.0; }
+    let margin = select(0.08, 0.04, is_branch);
+    let min_x = min(pA.x, pB.x) - margin;
+    let max_x = max(pA.x, pB.x) + margin;
+    let min_y = min(pA.y, pB.y) - margin;
+    let max_y = max(pA.y, pB.y) + margin;
     
-    if (pA.z <= 0.0 && pB.z > 0.0) {
-        let t = clamp(-pA.z / (pB.z - pA.z), 0.0, 1.0);
-        let front_pos = start_pos + (end_pos - start_pos) * t;
-        pA = project_3d(front_pos, ro, u, v_cam, w);
-    } else if (pB.z <= 0.0 && pA.z > 0.0) {
-        let t = clamp(-pA.z / (pB.z - pA.z), 0.0, 1.0);
-        let front_pos = start_pos + (end_pos - start_pos) * t;
-        pB = project_3d(front_pos, ro, u, v_cam, w);
+    if (p.x < min_x || p.x > max_x || p.y < min_y || p.y > max_y) {
+        return 0.0;
     }
     
-    if (pA.z > 0.0 || pB.z > 0.0) {
-        let d = sd_segment(p, pA.xy, pB.xy);
-        let depth = max(0.4, max(pA.z, pB.z));
-        let thickness = thickness_base / depth;
-        let core = smoothstep(thickness * 0.5, 0.0, d);
-        let glow_radius = select(60.0, 120.0, is_branch); // Branches have a tighter, less intense glow
-        let glow_mult = select(0.7, 0.3, is_branch);
-        let glow = exp(-d * glow_radius) * glow_mult;
-        return (core + glow) * intensity;
-    }
-    return 0.0;
+    let d = sd_segment(p, pA.xy, pB.xy);
+    let depth = max(0.4, max(pA.z, pB.z));
+    let thickness = thickness_base / depth;
+    let core = smoothstep(thickness * 0.5, 0.0, d);
+    let glow_radius = select(60.0, 120.0, is_branch); // Branches have a tighter, less intense glow
+    let glow_mult = select(0.7, 0.3, is_branch);
+    let glow = exp(-d * glow_radius) * glow_mult;
+    return (core + glow) * intensity;
 }
 
 fn draw_3d_lightning_bolt(ro: vec3<f32>, u: vec3<f32>, v_cam: vec3<f32>, w: vec3<f32>, p: vec2<f32>, seed: f32, intensity: f32, origin: vec3<f32>, plane_z: f32) -> f32 {
     if (intensity < 0.01) { return 0.0; }
 
-    var bolt = 0.0;
-    var current_pos = origin;
     let segments = 15;
     let frustum_height = plane_z - ro.z;
     let bolt_height = frustum_height * 2.4; // Ensure it reaches ground
     let seg_h = bolt_height / f32(segments);
     let j_scale = plane_z * 0.15; // Scale jitter with distance
 
+    // Bounding box check in screen space (Fast Pruning)
+    let max_dev_3d = 6.5 * j_scale;
+    let p_top = project_3d(origin, ro, u, v_cam, w);
+    let p_bot = project_3d(origin - vec3<f32>(0.0, bolt_height, 0.0), ro, u, v_cam, w);
+    
+    let depth_min = max(0.1, plane_z - max_dev_3d - ro.z);
+    let margin = max_dev_3d / depth_min + 0.15;
+    
+    let d_line = sd_segment(p, p_top.xy, p_bot.xy);
+    if (d_line > margin) { return 0.0; }
+
+    var bolt = 0.0;
+    var current_pos = origin;
+    var p_curr_proj = p_top;
+
     // Simulate dart leaders and return stroke pulsing via high-frequency flicker
     let flicker = 0.6 + 0.4 * sin(audio.smooth_time * 60.0 + seed);
     let main_intensity = intensity * flicker;
@@ -87,43 +96,51 @@ fn draw_3d_lightning_bolt(ro: vec3<f32>, u: vec3<f32>, v_cam: vec3<f32>, w: vec3
         let x_jitter = (hash11(seed + f_i * 7.13) - 0.5) * j_scale * 2.5;
         let z_jitter = (hash11(seed + f_i * 13.7) - 0.5) * j_scale * 2.5;
         let next_pos = current_pos + vec3<f32>(x_jitter, -seg_h, z_jitter);
+        let p_next_proj = project_3d(next_pos, ro, u, v_cam, w);
 
         // 1. Main Return Stroke Channel
         let thickness = 0.012 + main_intensity * 0.015;
-        bolt += draw_3d_segment(p, ro, u, v_cam, w, current_pos, next_pos, thickness, main_intensity, false);
+        bolt += draw_projected_segment(p, p_curr_proj, p_next_proj, thickness, main_intensity, false);
 
         // 2. Stepped Leaders (Primary Branches)
-        // Spawn branches from most nodes to simulate the searching fractal nature
         if (hash11(seed + f_i * 3.1) > 0.25) {
             let bx = (hash11(seed + f_i * 8.2) - 0.5) * j_scale * 4.0;
             let bz = (hash11(seed + f_i * 9.3) - 0.5) * j_scale * 4.0;
             let branch_pos = current_pos + vec3<f32>(bx, -seg_h * 1.5, bz);
+            let p_branch_proj = project_3d(branch_pos, ro, u, v_cam, w);
             
-            bolt += draw_3d_segment(p, ro, u, v_cam, w, current_pos, branch_pos, 0.005, branch_intensity, true);
+            bolt += draw_projected_segment(p, p_curr_proj, p_branch_proj, 0.005, branch_intensity, true);
             
             // 3. Sub-branches (Secondary splits from the stepped leaders)
             if (hash11(seed + f_i * 2.4) > 0.35) {
                 let bx2 = (hash11(seed + f_i * 1.2) - 0.5) * j_scale * 3.0;
                 let bz2 = (hash11(seed + f_i * 4.3) - 0.5) * j_scale * 3.0;
                 let branch_pos2 = branch_pos + vec3<f32>(bx2, -seg_h * 1.2, bz2);
-                bolt += draw_3d_segment(p, ro, u, v_cam, w, branch_pos, branch_pos2, 0.003, branch_intensity * 0.6, true);
+                let p_branch2_proj = project_3d(branch_pos2, ro, u, v_cam, w);
+                
+                bolt += draw_projected_segment(p, p_branch_proj, p_branch2_proj, 0.003, branch_intensity * 0.6, true);
             }
         }
         
         // 4. Major splits (connecting leaders that travel alongside the main channel)
         if (i == 3 || i == 8) {
             var split_pos = current_pos;
+            var p_split_proj = p_curr_proj;
             for (var j = 0; j < 4; j = j + 1) {
                 let f_j = f32(j);
                 let sx = (hash11(seed + f_i * 5.0 + f_j) - 0.5) * j_scale * 3.0;
                 let sz = (hash11(seed + f_i * 6.0 + f_j) - 0.5) * j_scale * 3.0;
                 let next_split = split_pos + vec3<f32>(sx, -seg_h * 1.1, sz);
-                bolt += draw_3d_segment(p, ro, u, v_cam, w, split_pos, next_split, 0.007, branch_intensity * 1.5, true);
+                let p_next_split_proj = project_3d(next_split, ro, u, v_cam, w);
+                
+                bolt += draw_projected_segment(p, p_split_proj, p_next_split_proj, 0.007, branch_intensity * 1.5, true);
                 split_pos = next_split;
+                p_split_proj = p_next_split_proj;
             }
         }
 
         current_pos = next_pos;
+        p_curr_proj = p_next_proj;
     }
 
     return bolt;
diff --git a/src/shaders/vis_ferrofluid.wgsl b/src/shaders/vis_ferrofluid.wgsl
@@ -62,6 +62,21 @@ fn smax(a: f32, b: f32, k: f32) -> f32 {
 }
 
 // --- Speaker Layout (up to 7.1.4) ---
+const SPEAKER_DIR_2D = array<vec2<f32>, 12>(
+    vec2<f32>(-0.5, -0.866),
+    vec2<f32>(0.5, -0.866),
+    vec2<f32>(0.0, -1.0),
+    vec2<f32>(0.0, 0.0), // LFE (unused directionally)
+    vec2<f32>(-0.94, 0.34),
+    vec2<f32>(0.94, 0.34),
+    vec2<f32>(-0.5, 0.866),
+    vec2<f32>(0.5, 0.866),
+    vec2<f32>(-0.70710678, -0.70710678),
+    vec2<f32>(0.70710678, -0.70710678),
+    vec2<f32>(-0.70710678, 0.70710678),
+    vec2<f32>(0.70710678, 0.70710678)
+);
+
 // Note: This shader maps channels[] (instrument/track data) to speaker positions.
 // For surround content where spatial_channels[] carries the speaker mix,
 // swap get_vu(i) for a spatial accessor if needed.
@@ -106,7 +121,7 @@ fn map_dist(p: vec3<f32>) -> f32 {
             alignment = 1.0;
             spike_pos_r = 0.0;
         } else {
-            let dir2d = normalize(get_speaker_dir(i).xz);
+            let dir2d = SPEAKER_DIR_2D[i];
             alignment = max(0.0, dot(p_xz_norm, dir2d));
             spike_pos_r = 1.5;
         }
@@ -152,29 +167,45 @@ struct MapData {
 }
 
 fn map(p: vec3<f32>) -> MapData {
-    // Delegate to the canonical SDF — single source of truth for the distance field.
-    let d = map_dist(p);
-
-    // Glow computation (cosmetic only — uses channel alignment but does NOT
-    // affect the SDF value, so the distance can never diverge from map_dist).
     let dist_xz = length(p.xz);
-    let p_xz_norm = p.xz / max(dist_xz, 0.0001);
+
+    // Base infinite plane thickness
+    var fluid_h = 0.0;
+
     let num_ch = min(audio.num_channels, 12u);
+    var total_displacement = 0.0;
+
+    // Normalized xz for angle alignment
+    let p_xz_norm = p.xz / max(dist_xz, 0.0001);
     var glow = vec3<f32>(0.0);
 
     for (var i = 0u; i < num_ch; i++) {
         let vu = clamp(get_vu(i), 0.0, 1.0);
+
         var alignment = 1.0;
         var spike_pos_r = 1.5;
-        if i == 3u { alignment = 1.0; spike_pos_r = 0.0; }
-        else {
-            let dir2d = normalize(get_speaker_dir(i).xz);
+
+        if i == 3u { // LFE channel — center blob
+            alignment = 1.0;
+            spike_pos_r = 0.0;
+        } else {
+            let dir2d = SPEAKER_DIR_2D[i];
             alignment = max(0.0, dot(p_xz_norm, dir2d));
+            spike_pos_r = 1.5;
         }
+        
         let dist_to_spike = abs(dist_xz - spike_pos_r);
         let spatial_falloff = exp(-dist_to_spike * 3.0);
+
+        // Soften spike shape (pow 8) to keep SDF slopes within Lipschitz bound
         var lobe = pow(alignment, 8.0) * vu * 1.5 * spatial_falloff;
-        if i != 3u { lobe *= smoothstep(0.1, 0.5, dist_xz); }
+        
+        // Attenuate directional lobes at the center to prevent radial crease artifacts
+        if i != 3u {
+            lobe *= smoothstep(0.1, 0.5, dist_xz);
+        }
+        
+        total_displacement = smax(total_displacement, lobe, 0.3);
 
         if lobe > 0.1 {
             var ch_color = vec3<f32>(0.2, 0.6, 1.0);
@@ -184,6 +215,18 @@ fn map(p: vec3<f32>) -> MapData {
         }
     }
 
+    // Subtle ripples from spectrum bass
+    let bass = clamp(audio.spectrum[0].x + audio.spectrum[1].x, 0.0, 2.0);
+    let ripple = sin(dist_xz * 12.0 - audio.time * 8.0) * 0.015 * bass * smoothstep(PUDDLE_RADIUS, 0.0, dist_xz);
+
+    // Organic surface perturbation (smooth magnetic domain noise)
+    let noise_p = p * 4.0 + vec3<f32>(audio.time * 0.5, 0.0, audio.time * 0.3);
+    let surface_noise = (hash3_smooth(noise_p) - 0.5) * 0.05;
+
+    fluid_h += total_displacement + ripple + surface_noise;
+
+    let d = (p.y + 0.5 - fluid_h) * STEP_SCALE;
+
     return MapData(d, 1, glow);
 }
 
diff --git a/src/shaders/vis_ferrofluidsim.wgsl b/src/shaders/vis_ferrofluidsim.wgsl
@@ -51,23 +51,32 @@ fn get_density(p: vec2<f32>) -> f32 {
     let fx = fract(px);
     let fz = fract(pz);
     
+    var w_x: array<f32, 5>;
+    for (var i = 0; i < 5; i++) {
+        let dx = f32(i - 2) - fx;
+        w_x[i] = exp(-dx * dx * 0.12);
+    }
+    
+    var w_z: array<f32, 5>;
+    for (var j = 0; j < 5; j++) {
+        let dz = f32(j - 2) - fz;
+        w_z[j] = exp(-dz * dz * 0.12);
+    }
+    
     var sum = 0.0;
     var w_sum = 0.0;
     
     // 5×5 Gaussian kernel at stride 1 — no aliasing artifacts
     // Wide sigma blends the 5×5 compute splat into smooth, continuous mounds
     for (var i = -2; i <= 2; i++) {
+        let cx = ix + i;
+        let wx = w_x[i + 2];
         for (var j = -2; j <= 2; j++) {
-            let cx = ix + i;
+            let cx_coord = cx;
             let cz = iz + j;
-            let val = get_density_raw(cx, cz);
+            let val = get_density_raw(cx_coord, cz);
             
-            let dx = f32(i) - fx;
-            let dy = f32(j) - fz;
-            let dist_sq = dx*dx + dy*dy;
-            
-            // Wide Gaussian for smooth blending
-            let w = exp(-dist_sq * 0.12);
+            let w = wx * w_z[j + 2];
             sum += val * w;
             w_sum += w;
         }
@@ -81,11 +90,15 @@ fn get_density(p: vec2<f32>) -> f32 {
 }
 
 fn map(p: vec3<f32>) -> f32 {
+    let dist_from_center = length(p.xz);
+    if (dist_from_center > PUDDLE_RADIUS + 0.5) {
+        return (p.y + 0.5) * LIPSCHITZ;
+    }
+
     let particle_h = get_density(p.xz);
     
     // Base puddle: thin continuous fluid layer that prevents holes
     // Simulates surface tension — ferrofluid never has gaps in its surface
-    let dist_from_center = length(p.xz);
     let base_h = BASE_HEIGHT * smoothstep(PUDDLE_RADIUS, PUDDLE_RADIUS * 0.5, dist_from_center);
     
     let h = max(particle_h, base_h);
diff --git a/src/shaders/vis_neon.wgsl b/src/shaders/vis_neon.wgsl
@@ -116,12 +116,18 @@ fn map_scene(p: vec3<f32>) -> vec2<f32> {
 }
 
 fn calc_normal(p: vec3<f32>) -> vec3<f32> {
-    let e = vec2<f32>(0.01, 0.0);
-    return normalize(vec3<f32>(
-        map_scene(p + e.xyy).x - map_scene(p - e.xyy).x,
-        map_scene(p + e.yxy).x - map_scene(p - e.yxy).x,
-        map_scene(p + e.yyx).x - map_scene(p - e.yyx).x
-    ));
+    let d_floor = p.y + 1.0;
+    let d_wall = 10.0 - p.z;
+    let d_ceil = 5.0 - p.y;
+    let d_left = p.x + 8.0;
+    let d_right = 8.0 - p.x;
+    
+    let min_d = min(d_floor, min(d_wall, min(d_ceil, min(d_left, d_right))));
+    if (min_d == d_floor) { return vec3<f32>(0.0, 1.0, 0.0); }
+    if (min_d == d_ceil)  { return vec3<f32>(0.0, -1.0, 0.0); }
+    if (min_d == d_left)  { return vec3<f32>(1.0, 0.0, 0.0); }
+    if (min_d == d_right) { return vec3<f32>(-1.0, 0.0, 0.0); }
+    return vec3<f32>(0.0, 0.0, -1.0);
 }
 
 fn get_smoke_density(p: vec3<f32>, time: f32, audio_activity: f32) -> f32 {

Original file line number	Diff line number	Diff line change
`@@ -278,7 +278,7 @@ pub struct VulkanEngine<'a> {`
`278`	`278`	`smooth_dt: f64,`
`279`	`279`	`}`
`280`	`280`
`281`		`-fn generate_lamp_mesh() -> (Vec<Vertex>, Vec<u32>) {`
	`281`	`+pub(crate) fn generate_lamp_mesh() -> (Vec<Vertex>, Vec<u32>) {`
`282`	`282`	`let mut vertices = Vec::new();`
`283`	`283`	`let mut indices = Vec::new();`
`284`	`284`