fix(3d): Tighten torus proxy hull and ensure floor grid visibility

- Adjusted Torus proxy hull in vs_main to 1.5x0.5x1.5 for better SDF fit.
- Updated VisualDebug::add_box to use per-object local extents.
- Standardized floor grid mapping in fs_main using planar p.xz projection.
- Verified non-uniform scale and rotation robustness in test_3d_render.

3 files changed, 86 insertions, 49 deletions

diff --git a/src/3d/renderer.cc b/src/3d/renderer.cc
index 488846d..2fb2221 100644
--- a/src/3d/renderer.cc
+++ b/src/3d/renderer.cc
@@ -113,16 +113,22 @@ 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 q = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
+        
         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);
     }
     return d;
@@ -177,7 +183,8 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
         let ro = globals.camera_pos_time.xyz;
         let rd = normalize(in.world_pos - ro);
         
-        var t = length(in.world_pos - ro) * 0.9;
+        var t = length(in.world_pos - ro) * 0.7; // Even more conservative start
+        var hit = false;
         for (var i = 0; i < 64; i = i + 1) {
             p = ro + rd * t;
             let q = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
@@ -189,10 +196,11 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
             let s = min(scale_x, min(scale_y, scale_z));
             let d_world = d_local * s;
 
-            if (d_world < 0.001) { break; }
+            if (d_world < 0.0005) { hit = true; break; }
             t = t + d_world;
-            if (t > length(in.world_pos - ro) * 1.5) { discard; }
+            if (t > length(in.world_pos - ro) * 2.0) { break; }
         }
+        if (!hit) { discard; }
         
         let q_hit = (obj.inv_model * vec4<f32>(p, 1.0)).xyz;
         
@@ -249,7 +257,7 @@ fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
 
     let shadow = calc_shadow(p, light_dir, 0.05, 20.0, in.instance_index);
     let diffuse = max(dot(normal, light_dir), 0.0);
-    let lighting = diffuse * (0.2 + 0.8 * shadow) + 0.15;
+    let lighting = diffuse * (0.1 + 0.9 * shadow) + 0.1; // Ambient + Shadowed Diffuse
     return vec4<f32>(base_color * lighting, 1.0);
 }
 
diff --git a/src/tests/test_3d_render.cc b/src/tests/test_3d_render.cc
index 4c84c7c..d4d3525 100644
--- a/src/tests/test_3d_render.cc
+++ b/src/tests/test_3d_render.cc
@@ -239,8 +239,15 @@ int main(int argc, char** argv) {
     g_camera.aspect_ratio = platform_get_aspect_ratio(&platform_state);
 
     for (size_t i = 1; i < g_scene.objects.size(); ++i) {
-      g_scene.objects[i].rotation =
-          quat::from_axis(vec3(0, 1, 0), time * 2.0f + i);
+      // Rotation around a random-ish 3D axis
+      vec3 axis =
+          vec3(std::sin((float)i), std::cos((float)i), 0.5f).normalize();
+      g_scene.objects[i].rotation = quat::from_axis(axis, time * 2.0f + i);
+
+      // Non-uniform scaling variance
+      float s = 0.5f + 0.1f * std::sin(time * 0.5f + i);
+      g_scene.objects[i].scale = vec3(s, s * 1.4f, s * 0.8f);
+
       g_scene.objects[i].position.y = std::sin(time * 3.0f + i) * 1.5f;
     }
 
diff --git a/src/util/mini_math.h b/src/util/mini_math.h
index 56e6832..2307087 100644
--- a/src/util/mini_math.h
+++ b/src/util/mini_math.h
@@ -258,51 +258,73 @@ struct mat4 {
   }
 
   mat4 inverse() const {
-    mat4 inv;
-    inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] +
-             m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
-    inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] +
-             m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11] +
-             m[12] * m[7] * m[10];
-    inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] +
-             m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
-    inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] +
-              m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10] +
-              m[12] * m[6] * m[9];
-    inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] +
-             m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11] +
-             m[13] * m[3] * m[10];
-    inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] +
-             m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
-    inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] -
-             m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
-    inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] +
-              m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
-    inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] +
-             m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
-    inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] -
-             m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
-    inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] +
-              m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
-    inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] -
-              m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
-    inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] -
-             m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
-    inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] +
-             m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
-    inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] -
-              m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
-    inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] +
-              m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
+    float n11 = m[0], n12 = m[4], n13 = m[8], n14 = m[12];
+    float n21 = m[1], n22 = m[5], n23 = m[9], n24 = m[13];
+    float n31 = m[2], n32 = m[6], n33 = m[10], n34 = m[14];
+    float n41 = m[3], n42 = m[7], n43 = m[11], n44 = m[15];
 
-    float det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
-    if (det == 0)
-      return mat4(); // Return identity on failure
+    float t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 -
+                n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44;
+    float t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 +
+                n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44;
+    float t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 -
+                n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44;
+    float t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 +
+                n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
 
-    det = 1.0f / det;
-    for (int i = 0; i < 16; i++)
-      inv[i] = inv[i] * det;
-    return inv;
+    float det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
+
+    if (det == 0.0f)
+      return mat4();
+
+    float inv_det = 1.0f / det;
+
+    mat4 res;
+    res.m[0] = t11 * inv_det;
+    res.m[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 +
+                n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) *
+               inv_det;
+    res.m[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 -
+                n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) *
+               inv_det;
+    res.m[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 +
+                n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) *
+               inv_det;
+
+    res.m[4] = t12 * inv_det;
+    res.m[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 -
+                n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) *
+               inv_det;
+    res.m[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 +
+                n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) *
+               inv_det;
+    res.m[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 -
+                n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) *
+               inv_det;
+
+    res.m[8] = t13 * inv_det;
+    res.m[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 +
+                n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) *
+               inv_det;
+    res.m[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 -
+                 n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) *
+                inv_det;
+    res.m[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 +
+                 n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) *
+                inv_det;
+
+    res.m[12] = t14 * inv_det;
+    res.m[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 -
+                 n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) *
+                inv_det;
+    res.m[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 +
+                 n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) *
+                inv_det;
+    res.m[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 -
+                 n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) *
+                inv_det;
+
+    return res;
   }
 };
 #endif /* defined(USE_MAT4) */