2§2. Motion Blur

Author: esdmr

src/camera.rs

@@ -2,7 +2,7 @@ use indicatif::{ParallelProgressIterator, ProgressIterator};
 use rayon::prelude::*;
 
 use crate::{
-    float::{Fl, lerp, random},
+    float::{lerp, random, Fl},
     hittable::{Hittable, HittableObject},
     interval::Interval,
     material::Material,
@@ -130,7 +130,9 @@ impl Camera {
             self.sample_defocus_disk()
         };
 
-        Ray::new(origin, pixel_sample - origin, x, y)
+        Ray::new(origin, pixel_sample - origin)
+            .at_time(random())
+            .for_pixel((x, y))
     }
 
     fn sample_square() -> Vec3 {

src/dielectric.rs

@@ -43,7 +43,9 @@ impl Material for DielectricMaterial {
 
         Some(ScatterRecord {
             attenuation: Color::new(1., 1., 1.),
-            scattered: Ray::new(rec.p, direction, r_in.pixel_x(), r_in.pixel_y()),
+            scattered: Ray::new(rec.p, direction)
+                .at_time_of(r_in)
+                .for_pixel_of(r_in),
         })
     }
 }

src/lambertian.rs

@@ -26,7 +26,9 @@ impl Material for LambertianMaterial {
 
         Some(ScatterRecord {
             attenuation: self.albedo,
-            scattered: Ray::new(rec.p, scatter_direction, r_in.pixel_x(), r_in.pixel_y()),
+            scattered: Ray::new(rec.p, scatter_direction)
+                .at_time_of(r_in)
+                .for_pixel_of(r_in),
         })
     }
 }

src/main.rs

@@ -31,16 +31,17 @@ pub fn main() {
     for a in -11..11 {
         for b in -11..11 {
             let choose_mat = random();
-            let center = Pos3::new(
-                (a as Fl) + 0.9 * random(),
-                0.2,
-                (b as Fl) + 0.9 * random(),
-            );
+            let center = Pos3::new((a as Fl) + 0.9 * random(), 0.2, (b as Fl) + 0.9 * random());
 
             if choose_mat < 0.8 {
                 world.add(
-                    Sphere::new(center, 0.2, LambertianMaterial::new(Color::random()).into())
-                        .into(),
+                    Sphere::new_moving(
+                        center,
+                        center + Vec3::new(0., random() * 0.5, 0.),
+                        0.2,
+                        LambertianMaterial::new(Color::random()).into(),
+                    )
+                    .into(),
                 );
             } else if choose_mat < 0.95 {
                 world.add(
@@ -90,8 +91,8 @@ pub fn main() {
 
     let camera = Camera::new(CameraOptions {
         aspect_ratio: 16. / 9.,
-        image_width: 1200,
-        samples_per_pixel: 50,
+        image_width: 400,
+        samples_per_pixel: 100,
         max_depth: 50,
         v_fov: 20.,
         look_from: Pos3::new(13., 2., 3.),

src/metal.rs

@@ -1,5 +1,9 @@
 use crate::{
-    float::Fl, hittable::HitRecord, material::{Material, ScatterRecord}, ray::Ray, vec3::{Color, Vec3}
+    float::Fl,
+    hittable::HitRecord,
+    material::{Material, ScatterRecord},
+    ray::Ray,
+    vec3::{Color, Vec3},
 };
 
 #[derive(Debug, Default, PartialEq, Clone, Copy)]
@@ -18,7 +22,9 @@ impl Material for MetalMaterial {
     fn scatter(&self, r_in: &Ray, rec: &HitRecord) -> Option<ScatterRecord> {
         let reflected =
             r_in.direction().reflect(&rec.normal) + Vec3::random_normalized() * self.fuzz;
-        let scattered = Ray::new(rec.p, reflected, r_in.pixel_x(), r_in.pixel_y());
+        let scattered = Ray::new(rec.p, reflected)
+            .at_time_of(r_in)
+            .for_pixel_of(r_in);
 
         (scattered.direction().dot(&rec.normal) > 0.).then_some(ScatterRecord {
             attenuation: self.albedo,

src/ray.rs

@@ -4,17 +4,17 @@ use crate::{float::Fl, vec3::{Pos3, Vec3}};
 pub struct Ray {
     origin: Pos3,
     direction: Vec3,
-    pixel_x: usize,
-    pixel_y: usize,
+    time: Fl,
+    pixel: Option<(usize, usize)>,
 }
 
 impl Ray {
-    pub const fn new(origin: Pos3, direction: Vec3, pixel_x: usize, pixel_y: usize) -> Self {
+    pub const fn new(origin: Pos3, direction: Vec3) -> Self {
         Self {
             origin,
             direction,
-            pixel_x,
-            pixel_y,
+            time: 0.,
+            pixel: None,
         }
     }
 
@@ -26,16 +26,50 @@ impl Ray {
         &self.direction
     }
 
-    pub const fn pixel_x(&self) -> usize {
-        self.pixel_x
+    pub const fn at_time(&self, time: Fl) -> Self {
+        Self {
+            direction: self.direction,
+            origin: self.origin,
+            time,
+            pixel: self.pixel,
+        }
+    }
+
+    pub const fn at_time_of(&self, other: &Self) -> Self {
+        self.at_time(other.time)
+    }
+
+    pub fn at_time_mut(&mut self, time: Fl) {
+        self.time = time;
+    }
+
+    pub const fn time(&self) -> Fl {
+        self.time
+    }
+
+    pub const fn for_pixel(&self, pixel: (usize, usize)) -> Self {
+        Self {
+            direction: self.direction,
+            origin: self.origin,
+            time: self.time,
+            pixel: Some(pixel),
+        }
+    }
+
+    pub const fn for_pixel_of(&self, other: &Self) -> Self {
+        if let Some(p) = other.pixel {
+            self.for_pixel(p)
+        } else {
+            *self
+        }
     }
 
-    pub const fn pixel_y(&self) -> usize {
-        self.pixel_y
+    pub fn for_pixel_mut(&mut self, pixel: (usize, usize)) {
+        self.pixel = Some(pixel);
     }
 
-    pub const fn is_pixel_at(&self, x: usize, y: usize) -> bool {
-        self.pixel_x == x && self.pixel_y == y
+    pub const fn pixel(&self) -> Option<(usize, usize)> {
+        self.pixel
     }
 
     pub fn at(&self, t: Fl) -> Pos3 {

src/sphere.rs

@@ -4,24 +4,33 @@ use crate::{
 
 #[derive(Debug, Clone)]
 pub struct Sphere {
-    center: Pos3,
+    center: Ray,
     radius: Fl,
     mat: MaterialObject,
 }
 
 impl Sphere {
     pub fn new(center: Pos3, radius: Fl, mat: MaterialObject) -> Self {
         Self {
-            center,
-            radius,
+            center: Ray::new(center, Pos3::default()),
+            radius: radius.max(0.),
+            mat,
+        }
+    }
+
+    pub fn new_moving(center1: Pos3, center2: Pos3, radius: Fl, mat: MaterialObject) -> Self {
+        Self {
+            center: Ray::new(center1, center2 - center1),
+            radius: radius.max(0.),
             mat,
         }
     }
 }
 
 impl Hittable for Sphere {
     fn hit(&self, r: &Ray, ray_t: Interval) -> Option<HitRecord> {
-        let oc = &self.center - r.origin();
+        let current_center = self.center.at(r.time());
+        let oc = &current_center - r.origin();
         let a = r.direction().squared_abs();
         let h = r.direction().dot(&oc);
         let c = oc.squared_abs() - self.radius * self.radius;
@@ -44,7 +53,7 @@ impl Hittable for Sphere {
 
         let t = root;
         let p = r.at(t);
-        let outward_normal = (p - self.center) / self.radius;
+        let outward_normal = (p - current_center) / self.radius;
 
         Some(HitRecord::new(t, p, self.mat.clone(), r, outward_normal))
     }