refactored into modules

benches/default_benchmark.rs

@@ -5,8 +5,8 @@ use rand_distr::Uniform;
 use raytracer::bvh::aabb::Aabb;
 
 use raytracer::interval::Interval;
-use raytracer::render::ray::Ray;
 use raytracer::linalg::vec3::Vec3;
+use raytracer::render::ray::Ray;
 
 pub fn criterion_benchmark(c: &mut Criterion) {
     let bbox: Aabb = Aabb::new_from_points(Vec3::new(1.0, 1.0, 1.0), Vec3::new(2.0, 2.0, 2.0));

src/bvh/aabb.rs

@@ -1,7 +1,7 @@
 use crate::elements::Hittable;
 use crate::interval::Interval;
-use crate::render::Ray;
 use crate::linalg::Vec3;
+use crate::render::Ray;
 
 use std::fmt;
 use std::ops::Index;
@@ -172,8 +172,8 @@ impl Index<usize> for Aabb {
 mod tests {
     use crate::bvh::aabb::Aabb;
     use crate::interval::Interval;
-    use crate::render::Ray;
     use crate::linalg::Vec3;
+    use crate::render::Ray;
     use assert_approx_eq::assert_approx_eq;
 
     // Test creating a new aabb, taking intervals as an argument

src/bvh/bvh_node.rs

@@ -4,8 +4,8 @@ use super::aabb::Aabb;
 
 use crate::elements::*;
 use crate::interval::Interval;
-use crate::render::Ray;
 use crate::linalg::Vec3;
+use crate::render::Ray;
 
 use rand::rngs::SmallRng;
 use rand::{Rng, SeedableRng};

src/bvh/mod.rs

@@ -2,4 +2,4 @@ mod aabb;
 pub use aabb::Aabb;
 
 mod bvh_node;
-pub use bvh_node::BVHNode;
+pub use bvh_node::BVHNode;

src/config.rs

@@ -1,8 +1,8 @@
-use crate::render::camera::Camera;
 use crate::elements::*;
 use crate::interval::Interval;
+use crate::render::camera::Camera;
 use crate::render::Ray;
-use crate::{render::camera::JSONCamera, color::Color};
+use crate::{color::Color, render::camera::JSONCamera};
 
 use serde::{Deserialize, Serialize};
 

src/elements.rs

@@ -11,10 +11,13 @@ use serde::{Deserialize, Serialize};
 extern crate wavefront_obj;
 use wavefront_obj::obj;
 
-use crate::linalg::{Vec3, Onb, mat4::{Mat4, Vec4}};
-use crate::{bvh::Aabb, materials::*};
-use crate::render::Ray;
 use crate::interval::Interval;
+use crate::linalg::{
+    mat4::{Mat4, Vec4},
+    Onb, Vec3,
+};
+use crate::render::Ray;
+use crate::{bvh::Aabb, materials::*};
 
 // hitrecord gets returned on a hit, containting the point on the ray, the point in the global coordinate system, the normal and the material for the hit
 #[derive(Debug)]
@@ -822,8 +825,8 @@ impl JSONObj {
 mod tests {
     use crate::color::Color;
     use crate::elements::*;
-    use crate::render::Ray;
     use crate::linalg::Vec3;
+    use crate::render::Ray;
     use assert_approx_eq::assert_approx_eq;
 
     #[test_log::test]

src/lib.rs

@@ -1,8 +1,8 @@
-pub mod render;
 pub mod bvh;
 pub mod color;
 pub mod config;
 pub mod elements;
 pub mod interval;
 pub mod linalg;
-pub mod materials;
+pub mod materials;
+pub mod render;

src/linalg/mat4.rs

@@ -458,7 +458,10 @@ impl Div<f64> for Mat4 {
 
 #[cfg(test)]
 mod tests {
-    use crate::linalg::{vec3::Vec3, mat4::{Mat4, Vec4}};
+    use crate::linalg::{
+        mat4::{Mat4, Vec4},
+        vec3::Vec3,
+    };
     use assert_approx_eq::assert_approx_eq;
 
     // Test creating a new vector with three rows, taking floats as an argument

src/linalg/mod.rs

@@ -4,4 +4,4 @@ pub use vec3::Vec3;
 pub mod mat4;
 
 mod onb;
-pub use onb::Onb;
+pub use onb::Onb;

src/materials/dielectric.rs

@@ -1,9 +1,9 @@
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
-use crate::{color::Color, render::Ray, elements::HitRecord, linalg::Vec3};
+use crate::{color::Color, elements::HitRecord, linalg::Vec3, render::Ray};
 
-use super::{Refracts, RefractRecord};
+use super::{RefractRecord, Refracts};
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct Dielectric {
@@ -42,7 +42,9 @@ impl Refracts for Dielectric {
 
         let cannot_refract: bool = refraction_ratio * sin_theta > 1.0;
 
-        if cannot_refract || super::metal::reflectance(cos_theta, refraction_ratio) > rng.gen::<f64>() {
+        if cannot_refract
+            || super::metal::reflectance(cos_theta, refraction_ratio) > rng.gen::<f64>()
+        {
             let direction: Vec3 = super::metal::reflect_vector(&unit_direction, &hit_record.normal);
             let reflected_ray: Ray = Ray::new(hit_record.point, direction);
             let refract_record: RefractRecord = RefractRecord {
@@ -61,4 +63,4 @@ impl Refracts for Dielectric {
             return Some(refract_record);
         }
     }
-}
+}

src/materials/diffuse_light.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use crate::{elements::HitRecord, color::Color, render::Ray};
+use crate::{color::Color, elements::HitRecord, render::Ray};
 
 use super::Emmits;
 
@@ -26,4 +26,4 @@ impl Emmits for DiffuseLight {
             None
         }
     }
-}
+}

src/materials/lambertian.rs

@@ -1,9 +1,13 @@
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
-use crate::{color::Color, render::{Ray, Pdf, CosinePDF}, elements::HitRecord};
+use crate::{
+    color::Color,
+    elements::HitRecord,
+    render::{CosinePDF, Pdf, Ray},
+};
 
-use super::{Scatterable, ScatterRecord};
+use super::{ScatterRecord, Scatterable};
 
 // Lambertian (diffuse) material, that scatters rays in a semi-random direction (lambertian distribution = more concentrated around the normal)
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
@@ -36,4 +40,4 @@ impl Scatterable for Lambertian {
 
         Some(scatter)
     }
-}
+}

src/materials/metal.rs

@@ -1,9 +1,9 @@
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
-use crate::{color::Color, render::Ray, elements::HitRecord, linalg::Vec3};
+use crate::{color::Color, elements::HitRecord, linalg::Vec3, render::Ray};
 
-use super::{Reflects, ReflectRecord};
+use super::{ReflectRecord, Reflects};
 
 // Metal material, with a fuzz factor. Metal reflects all rays in a predictable way (normal reflection)
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
@@ -73,4 +73,4 @@ pub fn reflectance(cosine: f64, ref_idx: f64) -> f64 {
     let mut r0 = (1.0 - ref_idx) / (1.0 + ref_idx);
     r0 = r0 * r0;
     r0 + (1.0 - r0) * (1.0 - cosine).powi(5)
-}
+}

src/materials/mod.rs

@@ -11,9 +11,13 @@ mod dielectric;
 pub use dielectric::Dielectric;
 
 use rand::Rng;
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
-use crate::{elements::HitRecord, render::{Ray, Pdf}, color::Color};
+use crate::{
+    color::Color,
+    elements::HitRecord,
+    render::{Pdf, Ray},
+};
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub enum Material {
@@ -128,4 +132,4 @@ impl Emmits for Material {
             _ => None,
         }
     }
-}
+}

src/render/camera.rs

@@ -1,7 +1,7 @@
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
-use crate::{config::Config, render::ray::Ray, linalg::Vec3};
+use crate::{config::Config, linalg::Vec3, render::ray::Ray};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct JSONCamera {

src/render/integrator.rs

@@ -6,12 +6,12 @@ use rayon::prelude::*;
 
 use crate::{
     bvh::BVHNode,
-    render::camera::Camera,
     color::Color,
     config::{Config, JSONScene},
     elements::{Element, Hittable, JSONElement},
     interval::Interval,
     materials::{Emmits, Reflects, Refracts, Scatterable},
+    render::camera::Camera,
     render::pdf::{HittablePDF, MixedPDF, PDFTrait, Pdf},
     render::ray::Ray,
 };
@@ -274,4 +274,4 @@ mod tests {
         //render(scene, config)?;
         Ok(())
     }
-}
+}

src/render/mod.rs

@@ -1,8 +1,8 @@
-pub mod integrator;
 pub mod camera;
+pub mod integrator;
 
 mod pdf;
-pub use pdf::{Pdf, PDFTrait, CosinePDF, MixedPDF, HittablePDF};
+pub use pdf::{CosinePDF, HittablePDF, MixedPDF, PDFTrait, Pdf};
 
 mod ray;
-pub use ray::Ray;
+pub use ray::Ray;

src/render/ray.rs

@@ -56,8 +56,8 @@ impl fmt::Display for Ray {
 
 #[cfg(test)]
 mod tests {
-    use crate::render::ray::Ray;
     use crate::linalg::Vec3;
+    use crate::render::ray::Ray;
     use assert_approx_eq::assert_approx_eq;
 
     #[test_log::test]