fmt and tidy

1 files changed, 44 insertions, 12 deletions

diff --git a/src/hittable/instance/rotate_x.rs b/src/hittable/instance/rotate_x.rs
index 4ebc04d..0e09223 100644
--- a/src/hittable/instance/rotate_x.rs
+++ b/src/hittable/instance/rotate_x.rs
@@ -1,6 +1,11 @@
 use std::sync::Arc;
 
-use crate::{hittable::{HitRecord, Hittable, AABB}, ray::Ray, util::degrees_to_radians, vec3::{Point3, Vec3}};
+use crate::{
+    hittable::{HitRecord, Hittable, AABB},
+    ray::Ray,
+    util::degrees_to_radians,
+    vec3::{Point3, Vec3},
+};
 
 pub struct RotateX {
     hittable: Arc<dyn Hittable>,
@@ -14,11 +19,25 @@ impl RotateX {
         let radians = degrees_to_radians(angle);
         let sin_theta = radians.sin();
         let cos_theta = radians.cos();
-        match hittable.bounding_box(0.0, 1.0) { // TODO: passing in 0.0 and 1.0 for time seems suspicious.
-            None => Self { hittable, sin_theta, cos_theta, aabb: None },
+        match hittable.bounding_box(0.0, 1.0) {
+            // TODO: passing in 0.0 and 1.0 for time seems suspicious.
+            None => Self {
+                hittable,
+                sin_theta,
+                cos_theta,
+                aabb: None,
+            },
             Some(aabb) => {
-                let mut min = Point3 { x: f64::INFINITY, y: f64::INFINITY, z: f64::INFINITY };
-                let mut max = Point3 { x: -f64::INFINITY, y: -f64::INFINITY, z: -f64::INFINITY };
+                let mut min = Point3 {
+                    x: f64::INFINITY,
+                    y: f64::INFINITY,
+                    z: f64::INFINITY,
+                };
+                let mut max = Point3 {
+                    x: -f64::INFINITY,
+                    y: -f64::INFINITY,
+                    z: -f64::INFINITY,
+                };
                 for i in 0..2 {
                     for j in 0..2 {
                         for k in 0..2 {
@@ -28,15 +47,24 @@ impl RotateX {
                             let new_y = cos_theta * y + sin_theta * y;
                             let new_z = -sin_theta * y + cos_theta * z;
 
-                            let tester = Vec3 { y: new_y, x, z: new_z };
+                            let tester = Vec3 {
+                                y: new_y,
+                                x,
+                                z: new_z,
+                            };
                             for c in 0..3 {
-                                *min.get_mut(c).unwrap() = min.get(c).unwrap().min(*tester.get(c).unwrap());
-                                *max.get_mut(c).unwrap() = max.get(c).unwrap().max(*tester.get(c).unwrap());
+                                *min.get_mut(c).unwrap() =
+                                    min.get(c).unwrap().min(*tester.get(c).unwrap());
+                                *max.get_mut(c).unwrap() =
+                                    max.get(c).unwrap().max(*tester.get(c).unwrap());
                             }
                         }
                     }
                 }
-                let aabb = AABB { minimum: min, maximum: max };
+                let aabb = AABB {
+                    minimum: min,
+                    maximum: max,
+                };
 
                 Self {
                     hittable,
@@ -56,17 +84,21 @@ impl Hittable for RotateX {
 
         origin.y = self.cos_theta * ray.origin.y - self.sin_theta * ray.origin.z;
         origin.z = self.sin_theta * ray.origin.y + self.cos_theta * ray.origin.z;
-        
+
         direction.y = self.cos_theta * ray.direction.y - self.sin_theta * ray.direction.z;
         direction.z = self.sin_theta * ray.direction.y + self.cos_theta * ray.direction.z;
 
-        let rotated_ray = Ray { origin, direction, time: ray.time };
+        let rotated_ray = Ray {
+            origin,
+            direction,
+            time: ray.time,
+        };
         let mut hit_record = self.hittable.hit(&rotated_ray, t_min, t_max)?;
 
         let mut p = hit_record.p.clone();
         let mut normal = hit_record.normal.clone();
 
-        p.y = self.cos_theta * hit_record.p.y+ self.sin_theta * hit_record.p.z;
+        p.y = self.cos_theta * hit_record.p.y + self.sin_theta * hit_record.p.z;
         p.z = -self.sin_theta * hit_record.p.y + self.cos_theta * hit_record.p.z;
 
         normal.y = self.cos_theta * hit_record.normal.y + self.sin_theta * hit_record.normal.z;