From ae4b03ef6f5ef07dcc80affd6877d17fceee7d29 Mon Sep 17 00:00:00 2001
From: skal <pascal.massimino@gmail.com>
Date: Fri, 6 Feb 2026 01:38:51 +0100
Subject: feat(perf): Add toggle for GPU BVH and fix fallback

Completed Task #18-B.
- Implemented GPU-side BVH traversal for scene queries, improving performance.
- Added a --no-bvh command-line flag to disable the feature for debugging and performance comparison.
- Fixed a shader compilation issue where the non-BVH fallback path failed to render objects.
---
 assets/final/shaders/math/sdf_utils.wgsl     |  8 ++++
 assets/final/shaders/render/scene_query.wgsl | 60 ++++++++++++++++++++--------
 assets/final/shaders/renderer_3d.wgsl        | 15 +++++--
 3 files changed, 64 insertions(+), 19 deletions(-)

(limited to 'assets/final/shaders')

diff --git a/assets/final/shaders/math/sdf_utils.wgsl b/assets/final/shaders/math/sdf_utils.wgsl
index ce902bf..502ba5b 100644
--- a/assets/final/shaders/math/sdf_utils.wgsl
+++ b/assets/final/shaders/math/sdf_utils.wgsl
@@ -7,3 +7,11 @@ fn get_normal_basic(p: vec3<f32>, obj_type: f32) -> vec3<f32> {
         get_dist(p + e.yyx, obj_type) - get_dist(p - e.yyx, obj_type)
     ));
 }
+
+// Distance to an Axis-Aligned Bounding Box
+fn aabb_sdf(p: vec3<f32>, min_p: vec3<f32>, max_p: vec3<f32>) -> f32 {
+    let center = (min_p + max_p) * 0.5;
+    let extent = (max_p - min_p) * 0.5;
+    let q = abs(p - center) - extent;
+    return length(max(q, vec3<f32>(0.0))) + min(max(q.x, max(q.y, q.z)), 0.0);
+}
diff --git a/assets/final/shaders/render/scene_query.wgsl b/assets/final/shaders/render/scene_query.wgsl
index b58f28c..e44b79c 100644
--- a/assets/final/shaders/render/scene_query.wgsl
+++ b/assets/final/shaders/render/scene_query.wgsl
@@ -1,4 +1,5 @@
 #include "math/sdf_shapes"
+#include "math/sdf_utils" // For aabb_sdf helper
 
 fn get_dist(p: vec3<f32>, obj_type: f32) -> f32 {
     if (obj_type == 1.0) { return length(p) - 1.0; } // Unit Sphere
@@ -10,24 +11,51 @@ fn get_dist(p: vec3<f32>, obj_type: f32) -> f32 {
 
 fn map_scene(p: vec3<f32>, skip_idx: u32) -> f32 {
     var d = 1000.0;
-    let count = u32(globals.params.x);
-    
-    for (var i = 0u; i < count; i = i + 1u) {
-        if (i == skip_idx) { continue; }
-        let obj = object_data.objects[i];
-        let obj_type = obj.params.x;
-        // Skip rasterized objects (like the floor) in the SDF map
-        if (obj_type <= 0.0) { continue; } 
+    let use_bvh = (globals.params.y > 0.5);
 
-        let q = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
+    if (use_bvh) {
+        var stack: array<i32, 32>;
+        var stack_ptr = 0;
         
-        let scale_x = length(obj.model[0].xyz);
-        let scale_y = length(obj.model[1].xyz);
-        let scale_z = length(obj.model[2].xyz);
-        // Use conservative minimum scale to avoid overstepping the distance field
-        let s = min(scale_x, min(scale_y, scale_z));
-        
-        d = min(d, get_dist(q, obj_type) * s);
+        if (arrayLength(&bvh_nodes) > 0u) {
+            stack[stack_ptr] = 0;
+            stack_ptr++;
+        }
+
+        while (stack_ptr > 0) {
+            stack_ptr--;
+            let node_idx = stack[stack_ptr];
+            let node = bvh_nodes[node_idx];
+
+            if (aabb_sdf(p, node.min, node.max) < d) {
+                if (node.left_idx < 0) { // Leaf
+                    let obj_idx = u32(node.obj_idx_or_right);
+                    if (obj_idx == skip_idx) { continue; }
+                    let obj = object_data.objects[obj_idx];
+                    let q = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
+                    let s = min(length(obj.model[0].xyz), min(length(obj.model[1].xyz), length(obj.model[2].xyz)));
+                    d = min(d, get_dist(q, obj.params.x) * s);
+                } else { // Internal
+                    if (stack_ptr < 31) {
+                        stack[stack_ptr] = node.left_idx;
+                        stack_ptr++;
+                        stack[stack_ptr] = node.obj_idx_or_right;
+                        stack_ptr++;
+                    }
+                }
+            }
+        }
+    } else { // Fallback to linear scan
+        let count = u32(globals.params.x);
+        for (var i = 0u; i < count; i = i + 1u) {
+            if (i == skip_idx) { continue; }
+            let obj = object_data.objects[i];
+            if (obj.params.x <= 0.0) { continue; } // Skip raster objects
+            let q = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
+            let s = min(length(obj.model[0].xyz), min(length(obj.model[1].xyz), length(obj.model[2].xyz)));
+            d = min(d, get_dist(q, obj.params.x) * s);
+        }
     }
+
     return d;
 }
diff --git a/assets/final/shaders/renderer_3d.wgsl b/assets/final/shaders/renderer_3d.wgsl
index b39525d..723aeb0 100644
--- a/assets/final/shaders/renderer_3d.wgsl
+++ b/assets/final/shaders/renderer_3d.wgsl
@@ -2,9 +2,18 @@
 
 @group(0) @binding(0) var<uniform> globals: GlobalUniforms;
 @group(0) @binding(1) var<storage, read> object_data: ObjectsBuffer;
-@group(0) @binding(2) var noise_tex: texture_2d<f32>;
-@group(0) @binding(3) var noise_sampler: sampler;
-@group(0) @binding(4) var sky_tex: texture_2d<f32>;
+
+struct BVHNode {
+    min: vec3<f32>,
+    left_idx: i32,
+    max: vec3<f32>,
+    obj_idx_or_right: i32,
+};
+@group(0) @binding(2) var<storage, read> bvh_nodes: array<BVHNode>;
+
+@group(0) @binding(3) var noise_tex: texture_2d<f32>;
+@group(0) @binding(4) var noise_sampler: sampler;
+@group(0) @binding(5) var sky_tex: texture_2d<f32>;
 
 struct VertexOutput {
     @builtin(position) position: vec4<f32>,
-- 
cgit v1.2.3