Cleanup (#36)

* Fix lint errors and code warnings

- Fix redundant field names in struct initializations
- Remove redundant serde_json import in scenefile.rs
- Fix collapsible else-if blocks in bbox.rs
- Remove needless return statements in box_terrain.rs
- Fix syntax error in ocean.rs amplitude function

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix lint errors in material and geometry modules

- Fix needless return statements in various material modules
- Fix redundant field names in struct initializations
- Fix indentation issues and syntax errors in rendercontext.rs
- Update legacy numeric constants with newer syntax
- Fix conditional return structure to avoid compiler errors

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix more lint errors throughout the codebase

- Fix needless returns in procedural modules
- Fix manual_clamp warnings by using .clamp() in color.rs and noise.rs
- Fix wrong_self_convention warnings in Color methods
- Fix op_ref warnings by removing unnecessary references
- Fix indentation and syntax errors in participatingmedia.rs
- Fix let_and_return in noise.rs
- Fix needless borrow issues in rendercontext.rs
- Convert write! with newline to writeln! in paint.rs
- Fix redundant closure with map/Arc::new in fireworks.rs
- Fix unnecessary casts in rendercontext.rs

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix syntax error in participatingmedia.rs

- Fix missing enclosing brace for HomogenousFog::intersects function
- Fix variable resolution issue in Color class for as_vec and as_u8 methods
- Fix semicolon in FireworkMaterial::scatter that was causing return type mismatch
- Update method invocations to use the renamed methods

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Clippy fix

* Fix BBox lint warnings

- Remove needless return statements
- Remove unnecessary references
- Replace if-return chains with if-else expressions
- Fix control flow in entry_face and exit_face methods

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix clippy lints for borrowed_box in texture.rs, needless_late_init in functions.rs, and remove legacy numeric constants in several files

* Fix remaining clippy lints:
- Replace &Vec with &[T] in octree.rs and ocean.rs
- Replace std::f64 legacy constants with f64::constants in infinite.rs and repeating_mesh.rs
- Fix documentation comments in ocean.rs
- Add type definition for complex return type in ocean.rs

* Fix compilation errors in:
- octree.rs: Use _max and _min in recursive call
- ocean.rs: Fix transpose function to use to_vec()
- fireworks.rs and csg.rs: Add explicit Vec type for collected Arc values

* Fix remaining clippy warnings:
- Replace if-else chains with logical expressions in BBox methods
- Replace while loop with while-let in csg.rs
- Fix documentation comment in model.rs
- Suppress too_many_arguments warning in create_particles

* Add Clippy to CI workflow to ensure code quality

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: peterbraden

.github/workflows/rust.yml

@@ -1,4 +1,4 @@
-name: Build, Tests and Examples
+name: Build, Tests, Lint and Examples
 
 on: [push]
 
@@ -9,6 +9,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v1
+    - name: Install Clippy
+      run: rustup component add clippy
+    - name: Run Clippy
+      run: cargo clippy -- -D errors
     - name: Build
       run: cargo build --verbose
     - name: Run tests

demo/demo.png

@@ -37,11 +37,11 @@ impl SimpleCamera {
         //let viewPlaneHalfHeight = aspectRatio*viewPlaneHalfWidth
 
         SimpleCamera {
-            location: location,
+            location,
 
-            camz: camz,
+            camz,
             camx: camx * aspect_ratio,
-            camy: camy,
+            camy,
 
             tax: angle.tan(),
             tay: angle.tan()
@@ -197,17 +197,17 @@ impl FlatLensCamera {
         //let viewPlaneHalfHeight = aspectRatio*viewPlaneHalfWidth
 
         FlatLensCamera {
-            location: location,
+            location,
 
-            camz: camz,
+            camz,
             camx: camx * aspect_ratio,
-            camy: camy,
+            camy,
 
             tax: angle.tan(),
             tay: angle.tan(),
 
-            aperture: aperture,
-            focus: focus,
+            aperture,
+            focus,
         }
     }
 }
@@ -224,7 +224,7 @@ impl Camera for FlatLensCamera {
         let ro = self.location + Vector3::new(point_lens[0], point_lens[1], 0.0);
 
         Ray {
-            ro: ro,
+            ro,
             rd: (focal_point - ro).normalize()
         }
 

src/camera.rs

@@ -10,7 +10,7 @@ pub struct Color {
 
 impl Color {
     pub fn new(r:f64, g:f64, b:f64) -> Color {
-        return Color {
+        Color {
             rgb: Vector3::new(r,g,b)
         }
     }
@@ -20,40 +20,40 @@ impl Color {
     }
 
     pub fn white() -> Color {
-        return Color::new(1f64,1f64,1f64);
+        Color::new(1f64,1f64,1f64)
     }
     pub fn red() -> Color {
-        return Color::new(1f64,0f64,0f64);
+        Color::new(1f64,0f64,0f64)
     }
     pub fn blue() -> Color {
-        return Color::new(0f64,0f64,01f64);
+        Color::new(0f64,0f64,01f64)
     }
     pub fn green() -> Color {
-        return Color::new(0f64,1f64,0f64);
+        Color::new(0f64,1f64,0f64)
     }
 
-    pub fn to_u8(&self) -> (u8, u8, u8) {
-        return ((self.rgb[0] * 255f64).min(255f64) as u8, (self.rgb[1] * 255f64).min(255f64) as u8, (self.rgb[2] * 255f64).min(255f64) as u8);
+    pub fn as_u8(&self) -> (u8, u8, u8) {
+        ((self.rgb[0] * 255f64).min(255f64) as u8, (self.rgb[1] * 255f64).min(255f64) as u8, (self.rgb[2] * 255f64).min(255f64) as u8)
     }
 
-    pub fn to_vec(&self) -> Vector3<f64> {
-        return self.rgb.clone();
+    pub fn as_vec(&self) -> Vector3<f64> {
+        self.rgb
     }
 
 	pub fn clamp(&self, val: f64) -> Color {
-        return Color::new(self.rgb.x.min(val), self.rgb.y.min(val), self.rgb.z.min(val));
+        Color::new(self.rgb.x.min(val), self.rgb.y.min(val), self.rgb.z.min(val))
 	}
 
     pub fn min() -> Color {
-        return Color::new(1./255.,1./255.,1./255.);
+        Color::new(1./255.,1./255.,1./255.)
     }
 
     pub fn ignore_nan(&self) -> Color {
-        return Color::new(
+        Color::new(
             if self.rgb.x.is_nan() { 0. } else { self.rgb.x },
             if self.rgb.y.is_nan() { 0. } else { self.rgb.y },
             if self.rgb.z.is_nan() { 0. } else { self.rgb.z },
-        );
+        )
     }
 
     /// Blend this color with another color using the given factor
@@ -65,7 +65,7 @@ impl Color {
     /// # Returns
     /// A new color that is a blend of this color and the other color
     pub fn blend(&self, other: &Color, factor: f64) -> Color {
-        let clamped_factor = factor.max(0.0).min(1.0);
+        let clamped_factor = factor.clamp(0.0, 1.0);
         let self_factor = 1.0 - clamped_factor;
 
         Color::new(
@@ -97,7 +97,7 @@ impl Mul<Color> for Color {
     type Output = Color;
 
     fn mul(self, _rhs: Color) -> Color {
-        Color {rgb: (_rhs * self.to_vec()).to_vec() }
+        Color {rgb: (_rhs * self.as_vec()).as_vec() }
     }
 }
 
@@ -122,7 +122,7 @@ impl Add<Vector3<f64>> for Color {
 
     fn add(self, _rhs: Vector3<f64>) -> Color {
         Color {
-            rgb: _rhs + &self.rgb
+            rgb: _rhs + self.rgb
         }
     }
 }

src/color.rs

@@ -4,13 +4,13 @@ use crate::geometry::_rand::Rng;
 use std::f64;
 
 pub fn rand() -> f64 {
-    return _rand::thread_rng().gen_range(0.,1.);
+    _rand::thread_rng().gen_range(0.,1.)
 }
 
 pub fn random_point_on_unit_sphere() -> Vector3<f64>{
     let u = rand();
     let v = rand();
-    return point_on_unit_sphere(u, v);
+    point_on_unit_sphere(u, v)
 }
 
 pub fn point_on_unit_sphere(u: f64, v: f64) -> Vector3<f64>{
@@ -24,21 +24,21 @@ pub fn point_on_unit_sphere(u: f64, v: f64) -> Vector3<f64>{
     let x = r * sin_phi * cos_theta;
     let y = r * sin_phi * sin_theta;
     let z = r * cos_phi;
-    return Vector3::new(x, y, z);
+    Vector3::new(x, y, z)
 }
 
 pub fn random_point_on_disc(radius: f64) -> Vector2<f64>{
     let r = radius * rand().sqrt();
     let theta = rand() * 2.0 * f64::consts::PI;
-    return Vector2::new(r * theta.cos(), r * theta.sin());
+    Vector2::new(r * theta.cos(), r * theta.sin())
 }
 
 pub fn uniform_sample_hemisphere(r1: f64, r2: f64) -> Vector3<f64>{
     let sin_theta = (1. - r1 * r1).sqrt(); 
     let  phi = 2. * f64::consts::PI * r2; 
     let x = sin_theta * phi.cos(); 
     let z = sin_theta * phi.sin(); 
-    return Vector3::new(x, r1, z); 
+    Vector3::new(x, r1, z)
 }
 
 // Transform into the world of vec

src/geometry.rs

@@ -33,7 +33,7 @@ pub struct MediumIntersection {
 
 impl cmp::PartialEq for Intersection {
     fn eq(&self, other: &Intersection) -> bool {
-        &self.point == &other.point
+        self.point == other.point
     }
 }
 

src/intersection.rs

@@ -10,7 +10,7 @@ pub struct Ambient {
 
 impl MaterialModel for Ambient {
     fn scatter(&self, _r: &Ray, _intersection: &Intersection, _s: &Scene) -> ScatteredRay{
-        return ScatteredRay{ attenuate:self.albedo, ray: None };
+        ScatteredRay{ attenuate:self.albedo, ray: None }
     }
 
 

src/material/ambient.rs

@@ -13,6 +13,6 @@ pub struct Dielectric {
 
 impl MaterialModel for Dielectric {
     fn scatter(&self, r: &Ray, intersection: &Intersection, _s: &Scene) -> ScatteredRay{
-        return scatter_dielectric(self.refractive_index, self.attenuate, r, intersection);
+        scatter_dielectric(self.refractive_index, self.attenuate, r, intersection)
     }
 }

src/material/dielectric.rs

@@ -11,8 +11,8 @@ pub struct DiffuseLight {
 
 impl MaterialModel for DiffuseLight {
     fn scatter(&self, _r: &Ray, _intersection: &Intersection, _s: &Scene) -> ScatteredRay{
-        return ScatteredRay{ 
+        ScatteredRay{ 
             attenuate:self.color * self.intensity,
-            ray: None };
+            ray: None }
     }
 }

src/material/diffuse_light.rs

@@ -36,7 +36,7 @@ pub fn scatter_lambertian(albedo: Color, intersection: &Intersection) -> Scatter
         ro: intersection.point,
         rd: intersection.normal + random_point_on_unit_sphere(),
     };
-    return ScatteredRay{ attenuate:albedo, ray: Some(refl) };
+    ScatteredRay{ attenuate:albedo, ray: Some(refl) }
 }
 
 pub fn scatter_dielectric(
@@ -46,21 +46,27 @@ pub fn scatter_dielectric(
     intersection: &Intersection
 ) -> ScatteredRay {
 
-    let mut ni_over_nt = refractive_index; // Assumes it comes from air - TODO
-    let cosine;
     let drn = r.rd.dot(&intersection.normal);
-    let outward_normal;
-    if drn > 0.0 {
+    
+    let outward_normal = if drn > 0.0 {
         // when ray shoot through object back into vacuum,
         // ni_over_nt = ref_idx, surface normal has to be inverted.
-        cosine = drn / r.rd.norm(); 
-        outward_normal = -intersection.normal
+        -intersection.normal
     } else {
         // when ray shoots into object,
-        // ni_over_nt = 1 / ref_idx.
-        cosine = - drn / r.rd.norm(); 
-        ni_over_nt = 1.0 / refractive_index; 
-        outward_normal = intersection.normal
+        intersection.normal
+    };
+    
+    let cosine = if drn > 0.0 {
+        drn / r.rd.norm()
+    } else {
+        -drn / r.rd.norm()
+    };
+    
+    let ni_over_nt = if drn > 0.0 {
+        refractive_index // Assumes it comes from air - TODO
+    } else {
+        1.0 / refractive_index
     };
 
     match refract(r.rd, outward_normal, ni_over_nt) {
@@ -85,26 +91,27 @@ pub fn scatter_dielectric(
     }
 
     let reflected = reflect(r.rd, intersection.normal);
-    return ScatteredRay {
+    ScatteredRay {
         attenuate: Color::white(),
         ray: Some(Ray {
             ro: intersection.point,
             rd: reflected
         }) 
-    };
+    }
 }
 
 
 pub fn diffuse (pigment: Color, i: &Intersection, light_vec: &Vector3<f64>, light: &Light) -> Color {
     let diffuse_scale = light_vec.normalize().dot(&i.normal) * light.intensity;
     if diffuse_scale.is_sign_positive() {
-        return light.color * pigment * diffuse_scale;
+        light.color * pigment * diffuse_scale
+    } else {
+        Color::black()
     }
-    return Color::black()
 }
 
 pub fn phong (phong: f64, r: &Ray, intersection: &Intersection, light_vec: &Vector3<f64>) -> Color {
-    if phong < std::f64::MIN_POSITIVE {
+    if phong < f64::MIN_POSITIVE {
         return Color::black();
     }
     let ln = light_vec.normalize();
@@ -116,5 +123,5 @@ pub fn phong (phong: f64, r: &Ray, intersection: &Intersection, light_vec: &Vect
         return Color::white() * spec_scale;
     }
 
-    return Color::black();
+    Color::black()
 }