WIP: Real time two_spheres

Works but the ray tracer is flipped left to right

Author: llGaetanll

TODO.md

@@ -81,4 +81,8 @@ Once CPU-side camera is working:
 
 ## Technical Debt
 
-1. [ ] `Array<T, N>` currently requires `T: Copy + Default` because we use `[Default::default(); N]` for initialization. This is overly restrictive. Ideally, `T` would only need to be "zeroable" (all zero bytes is a valid default). This would allow types like `Sphere` that aren't `Copy` but can be safely zero-initialized. The goal is something like `core::array::from_fn(|_| Default::default())` but in a form rust-gpu accepts.
+1. [ ] **Ray tracer flips image left-to-right**: The interactive camera controls have inverted signs on movement and mouse look to compensate. The ray tracer appears to be rendering the image mirrored horizontally. The workaround is in `host/src/main.rs` (`update_camera`). The root cause should be investigated - likely in `Camera::new()` or `Camera::get_ray()` in `rtx-util/src/cam.rs`, possibly related to how pixel coordinates map to ray directions.
+
+2. [ ] **Crash when camera enters an object**: The program sometimes crashes, likely when the camera position moves inside geometry. This may cause issues with ray-object intersection tests (e.g., negative t values, NaN from inside-surface calculations). Needs investigation.
+
+2. [ ] `Array<T, N>` currently requires `T: Copy + Default` because we use `[Default::default(); N]` for initialization. This is overly restrictive. Ideally, `T` would only need to be "zeroable" (all zero bytes is a valid default). This would allow types like `Sphere` that aren't `Copy` but can be safely zero-initialized. The goal is something like `core::array::from_fn(|_| Default::default())` but in a form rust-gpu accepts.

crates/host/src/gpu.rs

@@ -183,6 +183,8 @@ impl GpuContext {
             time: 0.0,
             cursor_x: 0.0,
             cursor_y: 0.0,
+            cam_pos: [278.0, 278.0, -800.0],
+            cam_dir: [0.0, 0.0, 1.0], // Looking down +Z
         };
 
         {

crates/host/src/main.rs

@@ -75,8 +75,9 @@ struct RustShaderSandboxApp {
     cursor_y: f32,
     // Camera state
     cam_pos: [f32; 3],
-    cam_yaw: f32,   // radians, 0 = looking down -Z
-    cam_pitch: f32, // radians, 0 = horizontal
+    cam_dir: [f32; 3], // normalized forward direction
+    cam_yaw: f32,      // radians, 0 = looking down -Z
+    cam_pitch: f32,    // radians, 0 = horizontal
     keys_held: KeysHeld,
     last_cursor_x: f32,
     last_cursor_y: f32,
@@ -85,12 +86,18 @@ struct RustShaderSandboxApp {
 
 impl RustShaderSandboxApp {
     fn new(scene: String) -> Self {
-        // Default camera: Cornell box position, looking into the box
-        // Cornell box camera: lookfrom (278, 278, -800), lookat (278, 278, 0)
-        // This means looking down +Z from a negative Z position
-        let cam_pos = [278.0, 278.0, -800.0];
-        let cam_yaw = PI; // Looking down +Z (opposite of default -Z)
-        let cam_pitch = 0.0;
+        // Default camera: two_spheres position
+        // two_spheres camera: lookfrom (0, 1, 5), lookat (0, 0, 0)
+        // Direction to origin: (0, -1, -5), normalized ≈ (0, -0.196, -0.98)
+        let cam_pos = [0.0, 1.0, 5.0];
+        let cam_yaw: f32 = 0.0; // Looking down -Z
+        let cam_pitch: f32 = -0.197; // Slightly down to look at origin
+        // Initial direction from yaw/pitch
+        let cam_dir = [
+            cam_yaw.sin() * cam_pitch.cos(),
+            cam_pitch.sin(),
+            cam_yaw.cos() * cam_pitch.cos(),
+        ];
 
         Self {
             scene,
@@ -103,6 +110,7 @@ impl RustShaderSandboxApp {
             cursor_x: 0.0,
             cursor_y: 0.0,
             cam_pos,
+            cam_dir,
             cam_yaw,
             cam_pitch,
             keys_held: KeysHeld::default(),
@@ -120,12 +128,23 @@ impl RustShaderSandboxApp {
         self.last_frame = now;
 
         // Mouse look: compute delta from last cursor position
-        let mouse_dx = self.cursor_x - self.last_cursor_x;
-        let mouse_dy = self.cursor_y - self.last_cursor_y;
+        // Skip if last_cursor is uninitialized (first frame)
+        let first_frame = self.last_cursor_x == 0.0 && self.last_cursor_y == 0.0;
+        let mouse_dx = if first_frame {
+            0.0
+        } else {
+            self.cursor_x - self.last_cursor_x
+        };
+        let mouse_dy = if first_frame {
+            0.0
+        } else {
+            self.cursor_y - self.last_cursor_y
+        };
         self.last_cursor_x = self.cursor_x;
         self.last_cursor_y = self.cursor_y;
 
         // Update yaw/pitch from mouse (sensitivity factor)
+        // Signs inverted to compensate for ray tracer's left-right flip
         let sensitivity = 0.003;
         self.cam_yaw -= mouse_dx * sensitivity;
         self.cam_pitch -= mouse_dy * sensitivity;
@@ -141,9 +160,10 @@ impl RustShaderSandboxApp {
         let right_z = (self.cam_yaw - PI / 2.0).cos();
 
         // Movement speed (units per second)
-        let speed = 200.0 * dt;
+        let speed = 5.0 * dt;
 
         // Apply movement based on held keys
+        // Signs inverted to compensate for ray tracer's left-right flip
         if self.keys_held.w {
             self.cam_pos[0] += forward_x * speed;
             self.cam_pos[2] += forward_z * speed;
@@ -167,28 +187,22 @@ impl RustShaderSandboxApp {
             self.cam_pos[1] -= speed;
         }
 
-        // Compute lookat point (1 unit in front of camera)
-        let look_forward_x = self.cam_yaw.sin() * self.cam_pitch.cos();
-        let look_forward_y = self.cam_pitch.sin();
-        let look_forward_z = self.cam_yaw.cos() * self.cam_pitch.cos();
-
-        let lookat = [
-            self.cam_pos[0] + look_forward_x,
-            self.cam_pos[1] + look_forward_y,
-            self.cam_pos[2] + look_forward_z,
+        // Compute forward direction (normalized)
+        self.cam_dir = [
+            self.cam_yaw.sin() * self.cam_pitch.cos(),
+            self.cam_pitch.sin(),
+            self.cam_yaw.cos() * self.cam_pitch.cos(),
         ];
 
         // Log camera params
         log::debug!(
-            "Camera: pos=({:.1}, {:.1}, {:.1}) lookat=({:.1}, {:.1}, {:.1}) yaw={:.2} pitch={:.2}",
+            "Camera: pos=({:.1}, {:.1}, {:.1}) dir=({:.2}, {:.2}, {:.2})",
             self.cam_pos[0],
             self.cam_pos[1],
             self.cam_pos[2],
-            lookat[0],
-            lookat[1],
-            lookat[2],
-            self.cam_yaw,
-            self.cam_pitch
+            self.cam_dir[0],
+            self.cam_dir[1],
+            self.cam_dir[2],
         );
     }
 
@@ -278,6 +292,8 @@ impl RustShaderSandboxApp {
             time: self.start.elapsed().as_secs_f32(),
             cursor_x: self.cursor_x,
             cursor_y: self.cursor_y,
+            cam_pos: self.cam_pos,
+            cam_dir: self.cam_dir,
         };
 
         {

crates/shader/src/lib.rs

@@ -109,8 +109,26 @@ pub fn two_spheres_fs(
     #[spirv(push_constant)] constants: &ShaderConstants,
     output: &mut Vec4,
 ) {
-    let (cam, mat_table, tex_table, world) =
-        scene::two_spheres(constants.width as usize, constants.height as usize);
+    use spirv_std::glam::Vec3;
+
+    let lookfrom = Vec3::new(
+        constants.cam_pos[0],
+        constants.cam_pos[1],
+        constants.cam_pos[2],
+    );
+    let cam_dir = Vec3::new(
+        constants.cam_dir[0],
+        constants.cam_dir[1],
+        constants.cam_dir[2],
+    );
+    let lookat = lookfrom + cam_dir;
+
+    let (cam, mat_table, tex_table, world) = scene::two_spheres(
+        constants.width as usize,
+        constants.height as usize,
+        lookfrom,
+        lookat,
+    );
 
     let i = frag_coord.y as usize;
     let j = frag_coord.x as usize;

crates/shader/src/scene.rs

@@ -558,6 +558,8 @@ pub fn dielectric_test(
 pub fn two_spheres(
     img_width: usize,
     img_height: usize,
+    lookfrom: Point3,
+    lookat: Point3,
 ) -> (Camera, MaterialTable, TextureTable, Scene) {
     let mut tex_table = TextureTable::new();
     tex_table
@@ -594,8 +596,8 @@ pub fn two_spheres(
     };
 
     let cam = Camera::new(CameraParams {
-        lookfrom: Point3::new(0., 1., 5.),
-        lookat: Point3::new(0., 0., 0.),
+        lookfrom,
+        lookat,
         vup: Vec3::new(0., 1., 0.),
         fov_v: 40.0,
         defocus_angle: 0.0,

crates/shared/src/lib.rs

@@ -11,4 +11,6 @@ pub struct ShaderConstants {
     pub time: f32,
     pub cursor_x: f32,
     pub cursor_y: f32,
+    pub cam_pos: [f32; 3],
+    pub cam_dir: [f32; 3],
 }