Resolve all warnings.

ray-tracing-egui/src/render.rs

@@ -23,6 +23,7 @@ use vulkano::{
 
 type DynRenderer =
     dyn ClassicalRenderer<SmallRng, Box<dyn Scene<SmallRng> + Sync>, BasicCamera> + Sync;
+#[allow(clippy::type_complexity)]
 pub const RENDERER: [(&str, fn(u32, u32) -> Box<DynRenderer>); 5] = [
     ("Depth", |w, h| {
         Box::new(DepthRenderer::new(w, h)) as Box<DynRenderer>

ray-tracing-material/src/iridescent.rs

@@ -98,70 +98,65 @@ impl Iridescent {
 
         if local_c_squred.is_infinite() {
             1.0
+        } else if local_cos_k_delta.abs() < 1.0 {
+            let k_delta = f32::acos(local_cos_k_delta);
+
+            let u = f32::sin(k_delta) / f32::sin(self.n * k_delta);
+
+            // if k_delta.is_nan() || u.is_nan() || r.is_nan() {
+            //     dbg!((
+            //         l,
+            //         theta1,
+            //         theta2,
+            //         local_cos_k_delta,
+            //         local_c_squred,
+            //         s_polaized,
+            //         k_delta,
+            //         u,
+            //         r
+            //     ));
+            // }
+
+            local_c_squred / (local_c_squred + u * u)
+        } else if local_cos_k_delta.abs() > 1.0 {
+            let imk_delta = -f32::ln(f32::abs(
+                local_cos_k_delta - f32::sqrt(local_cos_k_delta * local_cos_k_delta - 1.0),
+            ));
+
+            let u = f32::sinh(imk_delta) / f32::sinh(self.n * imk_delta);
+
+            // if imk_delta.is_nan() || u.is_nan() || r.is_nan() {
+            //     dbg!((
+            //         l,
+            //         theta1,
+            //         theta2,
+            //         local_cos_k_delta,
+            //         local_c_squred,
+            //         s_polaized,
+            //         imk_delta,
+            //         u,
+            //         r
+            //     ));
+            // }
+
+            local_c_squred / (local_c_squred + u * u)
         } else {
-            if local_cos_k_delta.abs() < 1.0 {
+            let u = 1.0 / self.n;
-                let k_delta = f32::acos(local_cos_k_delta);
 
-                let u = f32::sin(k_delta) / f32::sin(self.n * k_delta);
+            // if u.is_nan() || r.is_nan() {
+            //     dbg!((
+            //         l,
+            //         theta1,
+            //         theta2,
+            //         local_cos_k_delta,
+            //         local_c_squred,
+            //         s_polaized,
+            //         u,
+            //         r
+            //     ));
+            // }
 
-                let r = local_c_squred / (local_c_squred + u * u);
+            local_c_squred / (local_c_squred + u * u)
-                // if k_delta.is_nan() || u.is_nan() || r.is_nan() {
-                //     dbg!((
-                //         l,
-                //         theta1,
-                //         theta2,
-                //         local_cos_k_delta,
-                //         local_c_squred,
-                //         s_polaized,
-                //         k_delta,
-                //         u,
-                //         r
-                //     ));
-                // }
-
-                r
-            } else if local_cos_k_delta.abs() > 1.0 {
-                let imk_delta = -f32::ln(f32::abs(
-                    local_cos_k_delta - f32::sqrt(local_cos_k_delta * local_cos_k_delta - 1.0),
-                ));
-
-                let u = f32::sinh(imk_delta) / f32::sinh(self.n * imk_delta);
-
-                let r = local_c_squred / (local_c_squred + u * u);
-                // if imk_delta.is_nan() || u.is_nan() || r.is_nan() {
-                //     dbg!((
-                //         l,
-                //         theta1,
-                //         theta2,
-                //         local_cos_k_delta,
-                //         local_c_squred,
-                //         s_polaized,
-                //         imk_delta,
-                //         u,
-                //         r
-                //     ));
-                // }
-
-                r
-            } else {
-                let u = 1.0 / self.n;
-
-                let r = local_c_squred / (local_c_squred + u * u);
-                // if u.is_nan() || r.is_nan() {
-                //     dbg!((
-                //         l,
-                //         theta1,
-                //         theta2,
-                //         local_cos_k_delta,
-                //         local_c_squred,
-                //         s_polaized,
-                //         u,
-                //         r
-                //     ));
-                // }
-
-                r
-            }
         }
     }
 

ray-tracing-scene/src/acceleration_structure/mod.rs

@@ -83,7 +83,7 @@ impl<A: AccelerationStructure<u32>, R: Rng> Scene<R> for AccelerationStructureSc
 
         let material = &self.materials[i as usize];
 
-        let light_pdf = if let Some(l) = &material.light {
+        let light_pdf = if let Some(_l) = &material.light {
             0.0
         } else {
             0.0

ray-tracing-scene/src/examples/basic_cornell.rs

@@ -19,6 +19,12 @@ impl<R: Rng> BasicCornell<R> {
     }
 }
 
+impl<R: Rng> Default for BasicCornell<R> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<R: Rng + 'static> ExampleScene<R> for BasicCornell<R> {
     fn get_scene(&self) -> Box<dyn Scene<R> + Sync> {
         let s = self.scene.get_or_init(|| {

ray-tracing-scene/src/examples/cornell2.rs

@@ -22,6 +22,12 @@ impl<R: Rng> Cornell2<R> {
     }
 }
 
+impl<R: Rng> Default for Cornell2<R> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<R: Rng + 'static> ExampleScene<R> for Cornell2<R> {
     fn get_scene(&self) -> Box<dyn Scene<R> + Sync> {
         let s = self.scene.get_or_init(|| {

ray-tracing-scene/src/examples/mis_test.rs

@@ -1,15 +1,11 @@
-use std::cell::OnceCell;
-
-use crate::triangle_bvh::{BVHMaterial, Triangle, TriangleBVH};
-
 use super::ExampleScene;
-
+use crate::triangle_bvh::{BVHMaterial, Triangle, TriangleBVH};
 use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene};
 use ray_tracing_material::{
-    diffuse::DiffuseMaterial,
     microfacet::{BeckmannDistribution, Microfacet},
     mirror::Mirror,
 };
+use std::cell::OnceCell;
 
 pub struct MISTest<R: Rng> {
     scene: OnceCell<TriangleBVH<R>>,
@@ -67,6 +63,12 @@ impl<R: Rng> MISTest<R> {
     }
 }
 
+impl<R: Rng> Default for MISTest<R> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<R: Rng + 'static> ExampleScene<R> for MISTest<R> {
     fn get_scene(&self) -> Box<dyn Scene<R> + Sync> {
         let s = self.scene.get_or_init(move || {

ray-tracing-scene/src/examples/mod.rs

@@ -49,7 +49,7 @@ pub fn example_scenes<R: Rng + Debug + 'static>() -> HashMap<&'static str, Box<d
     );
     map.insert("mis_test", Box::new(mis_test::MISTest::new()));
 
-    let material = Iridescent::new(250.0, 250.0, 1.0, 1.3, 20);
+    // let material = Iridescent::new(250.0, 250.0, 1.0, 1.3, 20);
     let material = Iridescent::new(0.9 * 988.0, 0.1 * 988.0, 1.0, 1.5, 20);
     map.insert("sphere", Box::new(sphere::SphereScene::new(material)));
     map

ray-tracing-scene/src/examples/sphere.rs

@@ -1,13 +1,7 @@
-use std::{
-    cell::{Cell, OnceCell},
-    marker::PhantomData,
-};
-
-use ray_tracing_core::prelude::*;
-
-use crate::basic_scene::BasicScene;
-
 use super::ExampleScene;
+use crate::basic_scene::BasicScene;
+use ray_tracing_core::prelude::*;
+use std::cell::{Cell, OnceCell};
 
 pub struct SphereScene<M> {
     scene: OnceCell<BasicScene<M>>,

ray-tracing-scene/src/examples/stanford_dragon.rs

@@ -1,15 +1,11 @@
-use rand::Rng;
-use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene};
-use ray_tracing_material::{
-    microfacet::{BeckmannDistribution, Microfacet},
-    oren_nayar::OrenNayar,
-};
-use std::cell::{Cell, OnceCell};
-
 use crate::{
     parse_obj::ObjData,
     triangle_bvh::{BVHMaterial, Triangle, TriangleBVH},
 };
+use rand::Rng;
+use ray_tracing_core::{light::AreaLight, prelude::*, scene::Scene};
+use ray_tracing_material::oren_nayar::OrenNayar;
+use std::cell::{Cell, OnceCell};
 
 use super::ExampleScene;
 

ray-tracing-scene/src/examples/stanford_dragon_as.rs

@@ -28,6 +28,12 @@ impl<R: Rng> StanfordDragon<R> {
     }
 }
 
+impl<R: Rng> Default for StanfordDragon<R> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<R: Rng + 'static> ExampleScene<R> for StanfordDragon<R> {
     fn get_scene(&self) -> Box<dyn Scene<R> + Sync> {
         let s = self.scene.get_or_init(|| {