triangle

.gitignore

@@ -1 +1,3 @@
 /target
+.idea/
+.vscode/

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "bitflags"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.1"
@@ -9,13 +15,45 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
 [[package]]
-name = "getrandom"
+name = "crossbeam-deque"
-version = "0.2.16"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "getrandom"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
 dependencies = [
  "cfg-if",
  "libc",
+ "r-efi",
  "wasi",
 ]
 
@@ -53,21 +91,26 @@ dependencies = [
 ]
 
 [[package]]
-name = "rand"
+name = "r-efi"
-version = "0.8.5"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "libc",
  "rand_chacha",
  "rand_core",
 ]
 
 [[package]]
 name = "rand_chacha"
-version = "0.3.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
  "rand_core",
@@ -75,9 +118,9 @@ dependencies = [
 
 [[package]]
 name = "rand_core"
-version = "0.6.4"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
  "getrandom",
 ]
@@ -87,6 +130,27 @@ name = "ray-trace-w1"
 version = "0.1.0"
 dependencies = [
  "rand",
+ "rayon",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
@@ -108,9 +172,21 @@ checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "wasi"
-version = "0.11.1+wasi-snapshot-preview1"
+version = "0.14.2+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
+]
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
 
 [[package]]
 name = "zerocopy"

Cargo.toml

@@ -4,4 +4,5 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-rand = "0.8.5"  # 使用最新稳定版
+rand = "0.9.2"  # 使用最新稳定版
+rayon = "1.11.0"

src/camera.rs

@@ -1,54 +1,87 @@
 use std::fs::File;
 use std::io::{BufWriter};
+use std::sync::{RwLock};
+use std::time::Instant;
 
 use crate::hittable::HittableList;
-use crate::math_utils::clamp;
+use crate::math_utils::{clamp, degrees_to_radians, random_in_unit_disk};
 use crate::ppm_writer::PPMWriter;
 use crate::types_defined::{Camera, Color, HitRecord, Point, Ray, Vec3};
 use rand::rngs::ThreadRng;
-use rand::{Rng, thread_rng};
+use rand::{Rng, rng};
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use crate::material::{Material, MaterialKind};
 
 impl<'a> Camera<'a> {
     pub fn new(
+        fov: f32,
         image_width: i32,
         aspect_ratio: f32,
-        viewport_height: f32,
+        center: Point,
-        camera_center: Point,
+        look_at: Point,
-        focal_length: Vec3,
+        v_up: Vec3,
         sample_times: i8,
         reflect_depth: i8,
+        defocus_angle : f32,
+        focal_distance: f32,
         ppm_file_writer: &'a mut PPMWriter<BufWriter<File>>
     ) -> Self {
+
+    //    let focal_length = (look_at - center).length();
+
+       let theta = degrees_to_radians(fov);
+       let h = f32::tan(theta / 2.);
+       let viewport_height = 2. * h * focal_distance;
+    //    let viewport_height = 2. * h * focal_length;
+
         let image_height = ((image_width as f32 / aspect_ratio) as i32).max(1);
         let viewport_width = viewport_height * (image_width as f32 / image_height as f32);
 
-        let viewport_u = Vec3::new(viewport_width, 0.0, 0.0);
+
+        let  w = (center - look_at).normalize();
+        let  u = v_up.cross(w).normalize();
+        let  v = w.cross(u);
+
+
+        let viewport_u = viewport_width * u;
         // image x--> right
         //       |
         //       y
         // space: y up , x right , z back, -z front
-        let viewport_v = Vec3::new(0.0, -viewport_height, 0.0);
+        let viewport_v = viewport_height * (-1. * v);
         // width per pix
         let viewport_u_delta = viewport_u / (image_width as f32);
         // height per pix
         let viewport_v_delta = viewport_v / (image_height as f32);
         let viewport_top_left_pixel =
-            camera_center + focal_length - viewport_u / 2.0 - viewport_v / 2.0;
+            center - focal_distance * w - viewport_u / 2.0 - viewport_v / 2.0;
+            // center - focal_length * w - viewport_u / 2.0 - viewport_v / 2.0;
         // padding 0.5* delta u/v
         let viewport_top_left_pixel_center =
             viewport_top_left_pixel - viewport_u_delta / 2.0 - viewport_v_delta / 2.0;
 
+
+        // Calculate the camera defocus disk basis vectors.
+        let defocus_radius = focal_distance * degrees_to_radians(defocus_angle / 2.0).tan();
+        let defocus_disk_u = u * defocus_radius;
+        let defocus_disk_v = v * defocus_radius;
+
         Camera {
             image_width,
             image_height,
-            aspect_ratio,
+            // aspect_ratio,
-            viewport_width,
+            // viewport_width,
-            viewport_height,
+            // viewport_height,
-            camera_center,
+            center,
-            focal_length,
+            // look_at,
-            viewport_u,
+            // v_up,
-            viewport_v,
+            // focal_length,
+            // viewport_u,
+            // viewport_v,
+            defocus_angle,
+            defocus_disk_u,
+            defocus_disk_v,
+
             viewport_u_delta,
             viewport_v_delta,
             viewport_top_left_pixel_center,
@@ -60,27 +93,36 @@ impl<'a> Camera<'a> {
 
     pub fn render(&mut self, world: &HittableList) {
         // let mut img_content = format!("P3\n{} {}\n255\n", self.image_width, self.image_height);
-
+        let start = Instant::now();
+        
+        
+        
+        
         for j in 0..self.image_height {
             // if j % 10 == 0 {
                 println!("scan line {}/{} ", j + 1, self.image_height);
             // }
 
             for i in 0..self.image_width {
-                // color
+                
-                let mut color = Color::new(0.0, 0.0, 0.0);
+                let sample_color: Vec3 = (0..self.sample_times)
-                let rng = &mut thread_rng();
+                    .into_par_iter()
-                for _ in 0..self.sample_times {
+                    .map(|_| {
-                    let bias = self.random_square(rng);
+                        let r = self.get_ray(i, j);
-                    let pix_sample = self.viewport_top_left_pixel_center
+                        return self.ray_color_sync(&r, self.reflect_depth, RwLock::new(world));
-                        + (i as f32 + bias.x) * self.viewport_u_delta
+                    }).sum();
-                        + (j as f32 + bias.y) * self.viewport_v_delta;
+                let color: Vec3 = sample_color * (1.0 / self.sample_times as f32);
-                    let r = Ray::new(self.camera_center, pix_sample - self.camera_center);
+
-                    let sample_color = self.ray_color(&r, self.reflect_depth, world);
+
-                    color = color + sample_color;
+                // // color
-                }
+                // let mut color = Color::new(0.0, 0.0, 0.0);
-                // color * each sample color
+                // for _ in 0..self.sample_times {
-                color = color * (1.0 / self.sample_times as f32);
+                //     let r = self.get_ray(i, j);
+                //     let sample_color = self.ray_color(&r, self.reflect_depth, world);
+                //     color = color + sample_color;
+                // }
+                // // color * each sample color
+                // color = color * (1.0 / self.sample_times as f32);
 
                 // clamp color rgb
                 let color_clamped = Color::new(
@@ -89,13 +131,36 @@ impl<'a> Camera<'a> {
                     clamp(color.z, 0.0, 1.0),
                 );
 
-                self.ppm_file_writer.write(color.to_color());
+                let _ = self.ppm_file_writer.write(color_clamped.to_color());
             }
         }
 
+        let  _ = self.ppm_file_writer.finish();
+        let end = Instant::now();
+        println!("================[{}mils]=====================", end.duration_since(start).as_millis())
         // img_content
     }
 
+    fn defocus_disk_sample(&self) -> Point {
+        // Returns a random point in the camera defocus disk.
+        let p = random_in_unit_disk();
+        return self.center + (p.x * self.defocus_disk_u) + (p.y * self.defocus_disk_v);
+    }
+
+    fn get_ray(&self, i: i32, j: i32) -> Ray {
+        let rng = &mut rng();
+        let bias = self.random_square(rng);
+        let pix_sample = self.viewport_top_left_pixel_center
+            + (i as f32 + bias.x) * self.viewport_u_delta
+            + (j as f32 + bias.y) * self.viewport_v_delta;
+        let center = if self.defocus_angle < 0. {
+            self.center
+        } else {
+            self.defocus_disk_sample()
+        };
+        Ray::new(center, pix_sample - self.center)
+    }
+
     fn ray_color(&self, ray: &Ray, depth: i8, world: &HittableList) -> Vec3 {
 
         // 反射次数
@@ -113,8 +178,6 @@ impl<'a> Camera<'a> {
         };
         let hit = world.hit(&ray, 0.001, f32::MAX, hit_record);
         if hit {
-            let scatted = &mut Ray::new(Point::new(0.0, 0.0, 0.0), Vec3::random());
-            let attenuation = &mut Color::new(1.0, 1.0, 1.0);
             let hit_m = &hit_record.material;
             let hc = &mut HitRecord{
                 t: hit_record.t,
@@ -125,43 +188,78 @@ impl<'a> Camera<'a> {
             };
             let hit_c = match hit_m {
                 Some(mk) => {
-                    let mc = match mk {
+                    match mk {
-                        MaterialKind::Lambertian(l) => {
+                        // MaterialKind::Lambertian(l) => l.albedo,
-                            if l.scatter(ray, hc, attenuation, scatted) {
+                        MaterialKind::Lambertian(l) => self.scatter_color(ray, hc, l, depth, world),
-                                let r_c = self.ray_color(scatted, depth - 1, world);
+                        MaterialKind::Metal(m) => self.scatter_color(ray, hc, m, depth, world),
-                                let sc_color = Vec3::new(attenuation.x * r_c.x, attenuation.y * r_c.y, attenuation.z * r_c.z);
+                        MaterialKind::Dielectric(d) => self.scatter_color(ray, hc, d, depth, world)
-                                    // *attenuation * ;
+                    }
-                                Color::new(sc_color.x, sc_color.y, sc_color.z)
-                            } else {
-                                Color::new(0.0, 0.0, 0.0)
-                            }
-                        },
-                        MaterialKind::Metal(m) => {
-                            if m.scatter(ray, hc, attenuation, scatted) {
-                                let r_c = self.ray_color(scatted, depth - 1, world);
-                                let sc_color = Vec3::new(attenuation.x * r_c.x, attenuation.y * r_c.y, attenuation.z * r_c.z);
-                                // *attenuation * ;
-
-                                Color::new(sc_color.x, sc_color.y, sc_color.z)
-                            } else {
-                                Color::new(0.0, 0.0, 0.0)
-                            }
-                        }
-                    };
-                    return mc
                 },
                 None => {
-                    // if hit_record.t >= 0.0 {
+                    if hit_record.t >= 0.0 {
-                    //     // diffuse normal vec
+                        let diffuse_vec = Vec3::random_unit();
-                    //     let diffuse_vec = Vec3::random_unit();
+                        let lambertian_vec = diffuse_vec + hit_record.normal;
-                    //     let lambertian_vec = diffuse_vec + hit_record.normal;
+                        0.5 * self.ray_color(&Ray::new(ray.point, lambertian_vec), depth - 1, world)
-                    //     // 每次反射按0.5计算颜色（反射率 ）
+                    } else {
-                    //     return 0.5 * self.ray_color(&Ray::new(ray.point, lambertian_vec), depth - 1, world);
+                        Color::new(0.0, 0.0, 0.0)
-                    // }
+                    }
-                    Color::new(0.0, 0.0, 0.0)
                 }
             };
+            return hit_c;
+        }
 
+        // v / |v|
+        let unit_direction = ray.direction / ray.direction.length();
+        let a = 0.5 * (unit_direction.y + 1.0);
+        // return background color.
+        (1.0 - a) * Color::new(1.0, 1.0, 1.0) + a * Color::new(0.5, 0.7, 1.0)
+    }
+
+
+    fn ray_color_sync(&self, ray: &Ray, depth: i8, world: RwLock<&HittableList>) -> Vec3 {
+
+        // 反射次数
+        if depth <= 0 {
+            return Vec3::new(0.0, 0.0, 0.0);
+        }
+
+        // 限制出射光线的角度（0.001经验值）
+        let hit_record = &mut HitRecord{
+            t: 0.0,
+            p: Vec3::new(0.0, 0.0, 0.0),
+            normal: Vec3::new(0.0, 0.0, 0.0),
+            front_face: false,
+            material: None,
+        };
+        let hit = world.read().unwrap().hit(&ray, 0.001, f32::MAX, hit_record);
+        if hit {
+            let hit_m = &hit_record.material;
+            let hc = &mut HitRecord{
+                t: hit_record.t,
+                p: hit_record.p,
+                normal: hit_record.normal,
+                front_face: hit_record.front_face,
+                material: None,
+            };
+            let hit_c = match hit_m {
+                Some(mk) => {
+                    match mk {
+                        // MaterialKind::Lambertian(l) => l.albedo,
+                        MaterialKind::Lambertian(l) => self.scatter_color_sync(ray, hc, l, depth, world),
+                        MaterialKind::Metal(m) => self.scatter_color_sync(ray, hc, m, depth, world),
+                        MaterialKind::Dielectric(d) => self.scatter_color_sync(ray, hc, d, depth, world)
+                    }
+                },
+                None => {
+                    if hit_record.t >= 0.0 {
+                        let diffuse_vec = Vec3::random_unit();
+                        let lambertian_vec = diffuse_vec + hit_record.normal;
+                        0.5 * self.ray_color_sync(&Ray::new(ray.point, lambertian_vec), depth - 1, world)
+                    } else {
+                        Color::new(0.0, 0.0, 0.0)
+                    }
+                }
+            };
             return hit_c;
         }
 
@@ -174,6 +272,65 @@ impl<'a> Camera<'a> {
 
     // -> [x, y, 0]
     fn random_square(&self, rng: &mut ThreadRng) -> Vec3 {
-        Vec3::new(rng.gen_range(-0.5..0.1), rng.gen_range(-0.5..0.1), 0.0)
+        Vec3::new(rng.random_range(-0.5..0.1), rng.random_range(-0.5..0.1), 0.0)
     }
+
+
+    fn scatter_color(
+        &self,
+        ray: &Ray,
+        hc: &mut HitRecord,
+        material: &impl Material,
+        depth: i8,
+        world: &HittableList,
+    ) -> Color {
+        let mut scatted = Ray::new(Point::new(0.0, 0.0, 0.0), Vec3::random());
+        let mut attenuation = Color::new(1.0, 1.0, 1.0);
+        if material.scatter(ray, hc, &mut attenuation, &mut scatted) {
+            let r_c = self.ray_color(&scatted, depth - 1, world);
+            let sc_color = Vec3::new(
+                attenuation.x * r_c.x,
+                attenuation.y * r_c.y,
+                attenuation.z * r_c.z,
+            );
+            let color = Color::new(sc_color.x, sc_color.y, sc_color.z);
+            // if near_zero(color) {
+            //     println!("near zero: {:?}", scatted.direction);
+            // }
+            color
+        } else {
+            Color::new(0.0, 0.0, 0.0)
+        }
+    }
+    
+    fn scatter_color_sync(
+        &self,
+        ray: &Ray,
+        hc: &mut HitRecord,
+        material: &impl Material,
+        depth: i8,
+        world: RwLock<&HittableList>,
+    ) -> Color {
+        let mut scatted = Ray::new(Point::new(0.0, 0.0, 0.0), Vec3::random());
+        let mut attenuation = Color::new(1.0, 1.0, 1.0);
+        if material.scatter(ray, hc, &mut attenuation, &mut scatted) {
+            let r_c = self.ray_color_sync(&scatted, depth - 1, world);
+            let sc_color = Vec3::new(
+                attenuation.x * r_c.x,
+                attenuation.y * r_c.y,
+                attenuation.z * r_c.z,
+            );
+            let color = Color::new(sc_color.x, sc_color.y, sc_color.z);
+            // if near_zero(color) {
+            //     println!("near zero: {:?}", scatted.direction);
+            // }
+            color
+        } else {
+            Color::new(0.0, 0.0, 0.0)
+        }
+    }
+
 }
+
+
+

src/hittable.rs

@@ -1,7 +1,8 @@
 use crate::material::MaterialKind;
+use crate::math_utils::{front_face_normal, is_front_face};
 use crate::types_defined::{HitRecord, Ray, Vec3};
 
-pub trait Hittable {
+pub trait Hittable: Send + Sync {
     fn hit(&self, r: &Ray, t_min: f32, t_max: f32, hit_record: &mut HitRecord) -> bool;
 }
 
@@ -32,27 +33,25 @@ impl HittableList {
 
         for object in &self.objects {
             let hit = object.hit(r, t_min, closest_so_far, temp_hit_record);
-            if hit {
+            if hit && temp_hit_record.t < closest_so_far {
                 hits = true;
                 closest_so_far = temp_hit_record.t;
                 hit_record.t = temp_hit_record.t;
                 hit_record.p = temp_hit_record.p;
-                hit_record.front_face = temp_hit_record.front_face;
+                hit_record.front_face = is_front_face(r, temp_hit_record.normal);
-                hit_record.normal = temp_hit_record.normal;
+                hit_record.normal = front_face_normal(r, temp_hit_record.normal);
                 hit_record.material = if let Some(ref m) = temp_hit_record.material {
                     match m {
                         MaterialKind::Lambertian(l) => Some(MaterialKind::Lambertian(l.clone())),
                         MaterialKind::Metal(m) => Some(MaterialKind::Metal(m.clone())),
+                        MaterialKind::Dielectric(d) => Some(MaterialKind::Dielectric(d.clone()))
                     }
                 } else {
                     None
                 };
-                if temp_hit_record.t >= 0.0 {
-                    return true;
-                }
             }
         }
 
         hits
     }
-}
+}

src/main.rs

@@ -1,9 +1,12 @@
 use std::fs::File;
 use std::io::BufWriter;
 
+use rand::{rng, Rng};
+
 use crate::hittable::HittableList;
-use crate::material::{Lambertian, MaterialKind, Metal};
+use crate::material::{Dielectric, Lambertian, MaterialKind, Metal};
 use crate::ppm_writer::PPMWriter;
+use crate::triangle::Triangle;
 use crate::types_defined::{Camera, Color, Point, Sphere, Vec3};
 mod camera;
 mod color;
@@ -12,10 +15,10 @@ mod ray;
 mod sphere;
 mod types_defined;
 mod vec3;
-mod write_file_util;
 mod math_utils;
 mod ppm_writer;
 mod material;
+mod triangle;
 
 fn main() {
     camera_render();
@@ -23,8 +26,14 @@ fn main() {
 
 fn camera_render() {
 
-    let width: i32 = 400;
+    let fov: f32 = 90.;
-    let height: i32 = 200;
+    let scale = 1;
+    let width: i32 = 1920/scale;
+    let height: i32 = 1080/scale;
+    let sample_times = 20;
+    let reflect_depth = 20;
+
+
     let pw_r = PPMWriter::new(
         BufWriter::new(File::create("./target/ray_sphere_normal_scene_render.ppm").unwrap()), 
         width, height);
@@ -36,33 +45,89 @@ fn camera_render() {
     
 
     let mut camera: Camera = Camera::new(
+        fov,
         width,
-        16.0 / 9.0,
+        width as f32 / height as f32,
+        Point::new(-0.0, 5.0, 5.0),
+        Point::new(0.0, 0.0, -1.0),
+        Vec3::new(0., 1., 0.),
+        sample_times,
+        reflect_depth,
         2.0,
-        Point::new(0.0, 0.0, 0.0),
+        1.0,
-        Vec3::new(0.0, 0.0, -1.0),
-        100,
-        50,
         pw
     );
     // world
     // world objects(spheres)
     let mut world = HittableList::new();
 
-    let plane_m = Some(MaterialKind::Lambertian(Lambertian{albedo: Color::new(0.3, 0.2, 0.5)}));
+    let plane_m = Some(MaterialKind::Lambertian(Lambertian{albedo: Color::new(0.508, 0.508, 0.508)}));
-    let plane2_m = Some(MaterialKind::Metal(Metal{albedo: Color::new(0.3, 0.2, 0.5)}));
+    // // let plane2_m = Some(MaterialKind::Metal(Metal{albedo: Color::new(0.784,0.784,0.784)}));
-    let center_m = Some(MaterialKind::Lambertian(Lambertian{albedo: Color::new(0.1, 0.2, 0.5)}));
+    // let center_m = Some(MaterialKind::Lambertian(Lambertian{albedo: Color::new(0.2, 0.5, 0.5)}));
-    let left_m = Some(MaterialKind::Metal(Metal{albedo: Color::new(0.8, 0.8, 0.8)}));
+    // let left_m = Some(MaterialKind::Metal(Metal{albedo: Color::new(0.799, 0.599, 0.799), fuzz: 0.0005}));
-    let right_m = Some(MaterialKind::Metal(Metal{albedo: Color::new(0.8, 0.6, 0.2)}));
+    // let left_behind_m = Some(MaterialKind::Lambertian(Lambertian{albedo: Color::new(0.799, 0.599, 0.599)}));
+    // let right_m = Some(MaterialKind::Metal(Metal{albedo: Color::new(0.8, 0.6, 0.2), fuzz: 0.003}));
+    // // 折射率 1.33
+    // let left_dia_m = Some(MaterialKind::Dielectric(Dielectric{albedo: Color::new(0.8, 0.6, 0.2), refraction_index: 1.00 / 1.33}));
+    // let left_dia_small_m = Some(MaterialKind::Dielectric(Dielectric{albedo: Color::new(0.8, 0.6, 0.2), refraction_index: 1.00 / 2.5}));
 
-    world.put(Box::new(Sphere::new(Point::new(0.0, -100.5, -1.2), 100.0, plane2_m)));
+    // world.put(Box::new(Sphere::new(Point::new(0.0,    0.0, -1.0), 0.5, center_m)));
-    world.put(Box::new(Sphere::new(Point::new(0.0,    0.0, -1.2), 0.5, center_m)));
+    // world.put(Box::new(Sphere::new(Point::new(-1.0,    0.0, -1.0), 0.5, left_dia_m)));
-    world.put(Box::new(Sphere::new(Point::new(-1.0,    0.0, -1.0), 0.5, left_m)));
+    // world.put(Box::new(Sphere::new(Point::new(-1.0,    0.0, -1.0), 0.2, left_dia_small_m)));
-    world.put(Box::new(Sphere::new(Point::new(1.0,    0.0, -1.0), 0.5, right_m)));
+    // // world.put(Box::new(Sphere::new(Point::new(-1.0,    0.0, -1.0), 0.5, left_m)));
+    // world.put(Box::new(Sphere::new(Point::new(-3.5,    1.5, -5.5), 1.5, left_behind_m)));
+    // world.put(Box::new(Sphere::new(Point::new(1.0,    0.0, -1.0), 0.5, right_m)));
+    world.put(Box::new(Sphere::new(Point::new(0.0, -500.5, -1.0), 500.0, plane_m)));
+
+    // world.put(Box::new(Triangle::new(
+    //     Point::new(0.0, 0.5, 0.0),
+    //     Point::new(5.5, 0.5, 0.0),
+    //     Point::new(5.5, 5.5, 0.0),
+    //     Some(MaterialKind::Metal(Metal { albedo: Color::new(0.8, 0.6, 0.2), fuzz: 0.00001 }))
+    // )));
+    world.put(Box::new(Triangle::new(
+        Point::new(0.0, 0.5, 5.0),
+        Point::new(0.0, 5.5, -5.0),
+        Point::new(5.5, 0.5, 0.0),
+        Some(MaterialKind::Dielectric(Dielectric { albedo: Color::new(1.0, 1.0, 1.0), refraction_index: 1./1.5 }))
+    )));
+
+    gen_spheres(&mut world);
 
     camera.render(&world);
-    // write_image(
-    //     ppm_content,
-    //     "".to_string(),
-    // )
 }
+
+
+fn gen_spheres(world: &mut HittableList) {
+    let rng = &mut rng();
+
+    for _ in 0..500 {
+        let x = rng.random_range(-20..20);
+        let z = rng.random_range(-20..20);
+
+        let radius = rng.random_range(0.01..0.8);
+
+        // R = random(0.7, 0.95)  # 红通道
+        // G = random(R - 0.2, R + 0.2)  # 绿通道（与 R 相近）
+        // B = random(min(R, G) - 0.15, max(R, G) + 0.15)  # 蓝通道（与 R/G 相近）
+        // 基础值在 0.7~0.95 之间
+        let base:f32 = rng.random_range(0.7..0.95);
+        // 每个通道在 base 附近小幅波动（±0.15）
+        let r: f32 = rng.random_range((base - 0.15).max(0.6)..(base + 0.15).min(1.0));
+        let g: f32 = rng.random_range((base - 0.15).max(0.6)..(base + 0.15).min(1.0));
+        let b: f32 = rng.random_range((base - 0.15).max(0.6)..(base + 0.15).min(1.0));
+
+        let materail_color = Color::new(r,g, b);
+
+        let materail_kind =  rng.random_range(0.0..1.0);
+        let material = if materail_kind <= 0.33333 {
+            MaterialKind::Lambertian(Lambertian { albedo: materail_color })
+        } else if materail_kind > 0.3 && materail_kind <= 0.66666 {
+            MaterialKind::Metal(Metal { albedo: materail_color, fuzz: 0.00001 })
+        } else {
+            MaterialKind::Dielectric(Dielectric { albedo: materail_color, refraction_index: 1./1.5 })
+        };
+
+        world.put(Box::new(Sphere::new(Point::new(x as f32, 0., z as f32), radius, Some(material))));
+    }
+}

src/material.rs

@@ -1,4 +1,4 @@
-use crate::math_utils::{near_zero, reflect};
+use crate::math_utils::{near_zero, reflect, refract};
 use crate::types_defined::{Color, HitRecord, Ray, Vec3};
 
 
@@ -6,6 +6,7 @@ use crate::types_defined::{Color, HitRecord, Ray, Vec3};
 pub enum MaterialKind {
     Lambertian(Lambertian),
     Metal(Metal),
+    Dielectric (Dielectric),
 }
 
 pub trait Material {
@@ -28,12 +29,12 @@ impl Clone for Lambertian {
 impl Material for Lambertian {
     fn scatter(&self, r_in: &Ray, hit_record: &mut HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool {
 
-        let scatter_direction = hit_record.normal + Vec3::random_unit();
+        let mut scatter_direction = r_in.direction + Vec3::random_unit_on_hemisphere(hit_record.normal);
-        // let scatter_direction = reflect(r_in.direction, hit_record.normal);
 
         if near_zero(scatter_direction) {
-            scattered.direction = hit_record.normal;
+            scatter_direction = hit_record.normal;
         }
+            
 
         *scattered = Ray::new(hit_record.p, scatter_direction);
         *attenuation = self.albedo.clone();
@@ -45,27 +46,64 @@ impl Material for Lambertian {
 #[derive(Debug)]
 pub struct Metal {
     pub albedo: Color,
+    pub fuzz: f32
 }
 
 impl Clone for Metal {
     fn clone(&self) -> Self {
         Metal {
             albedo: self.albedo,
+            fuzz: self.fuzz
         }
     }
 }
 
 impl Material for Metal {
     fn scatter(&self, r_in: &Ray, hit_record: &mut HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool {
-        /*
-            vec3 reflected = reflect(r_in.direction(), rec.normal);
-            scattered = ray(rec.p, reflected);
-            attenuation = albedo;
-            return true;
-        */
         let reflected = reflect(r_in.direction, hit_record.normal);
-        *scattered = Ray::new(hit_record.p, reflected);
+        let fuzz_relected = (reflected / reflected.length_squared()) + (Vec3::random_unit() * self.fuzz);
+        *scattered = Ray::new(hit_record.p, fuzz_relected);
         *attenuation = self.albedo.clone();
+        true
+    }
+}
+
+impl Clone for Dielectric {
+    fn clone(&self) -> Self {
+        Dielectric {
+            albedo: self.albedo,
+            refraction_index: self.refraction_index
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Dielectric {
+    pub albedo: Color,
+    pub refraction_index: f32
+}
+
+impl Material for Dielectric {
+    fn scatter(&self, r_in: &Ray, hit_record: &mut HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool {
+
+        *attenuation = Color::new(1.0, 1.0, 1.0);
+
+        let unit_direction = r_in.direction.normalize();
+
+
+        let cos = -unit_direction.dot(hit_record.normal).min(1.0);
+        let sin = (1.0 - cos.powi(2)).sqrt();
+
+        let direction = if self.refraction_index * sin > 1.0 {
+            reflect(unit_direction, hit_record.normal)
+        } else {
+            refract(unit_direction, hit_record.normal, self.refraction_index)
+        };
+
+
+        // let refracted  = refract(unit_direction, hit_record.normal, ri);
+        *scattered = Ray::new(hit_record.p, direction);
+
         true
     }
 }

src/math_utils.rs

@@ -1,4 +1,22 @@
-use crate::types_defined::Vec3;
+use std::f32::consts::PI;
+
+use rand::{rng, Rng};
+
+use crate::types_defined::{Ray, Vec3};
+
+pub fn random_in_unit_disk() -> Vec3 {
+    let rng = &mut rng();
+    loop {
+        let p = Vec3::new(rng.random_range(-1.0..1.0), rng.random_range(-1.0..1.0), 0.0);
+        if p.length_squared() < 1.0 {
+            return p;
+        }
+    } 
+}
+
+pub fn degrees_to_radians(deg: f32) -> f32 {
+    deg * PI / 180.
+}
 
 pub fn clamp(value: f32, low: f32, high: f32) -> f32 {
     if value < low {
@@ -11,11 +29,54 @@ pub fn clamp(value: f32, low: f32, high: f32) -> f32 {
 }
 
 pub fn near_zero(v: Vec3) -> bool {
-    const EPSILON: f32 = 1e-8;
+    const EPSILON: f32 = 1e-4;
 
     v.x.abs() < EPSILON && v.y.abs() < EPSILON && v.z.abs() < EPSILON
 }
 
 pub fn reflect(v: Vec3, n: Vec3) -> Vec3 {
     v - ((2.0 * v.dot(n)) * n)
+}
+
+// v, normal, 折射率
+pub fn refract(uv: Vec3, n: Vec3, etai_over_etat: f32) -> Vec3 {
+    // auto cos_theta = std::fmin(dot(-uv, n), 1.0);
+    // vec3 r_out_perp =  etai_over_etat * (uv + cos_theta*n);
+    // vec3 r_out_parallel = -std::sqrt(std::fabs(1.0 - r_out_perp.length_squared())) * n;
+    // return r_out_perp + r_out_parallel;
+    let cos_theta = (-uv.dot(n)).min(1.0);
+    let r_out_perp = etai_over_etat * (uv + cos_theta * n);
+    let r_out_parallel = -(f32::sqrt(f32::abs(1.0 - r_out_perp.length()))) * n;
+    r_out_perp + r_out_parallel
+
+    // let v_normalized = v;
+    // let n_normalized = n.normalize();
+
+    // let cos_theta = f32::min(-v_normalized.dot(n_normalized), 1.0);
+    // let sin_theta = (1.0 - cos_theta * cos_theta).sqrt();
+    // // 检查是否全内反射（无法折射）
+    // if etai_over_etat * sin_theta > 1.0 {
+    //     return reflect(v_normalized, n)
+    // }
+
+    // let r_out_perp = etai_over_etat * (v_normalized + cos_theta * n_normalized);
+    // let discriminant = 1.0 - r_out_perp.length_squared();
+    // // if discriminant < 0.0 {
+    // //     return -1.0 * v; // 全内反射，返回零向量（或改为反射）
+    // // }
+    // let r_out_parallel = -discriminant * n_normalized;
+    
+    // r_out_perp + r_out_parallel
+}
+
+pub fn is_front_face(r: &Ray, outward_normal: Vec3) -> bool {
+    r.direction.dot(outward_normal) < 0.0
+}
+
+pub fn front_face_normal(r: &Ray, outward_normal: Vec3) -> Vec3 {
+    if is_front_face(r, outward_normal) {
+        outward_normal
+    } else {
+        -1. * outward_normal
+    }
 }

src/ppm_writer.rs

@@ -30,7 +30,7 @@ impl<W: Write> PPMWriter<W> {
     }
 
     /// 完成写入并刷新缓冲区
-    pub fn finish(mut self) -> Result<()> {
+    pub fn finish(&mut self) -> Result<()> {
         self.writter.flush()
     }
 }

src/sphere.rs

@@ -1,6 +1,7 @@
 use crate::hittable;
-use crate::material::{Lambertian, Material, MaterialKind, Metal};
+use crate::material::{MaterialKind};
-use crate::types_defined::{Color, HitRecord, Point, Ray, Sphere};
+use crate::math_utils::{front_face_normal, is_front_face};
+use crate::types_defined::{HitRecord, Point, Ray, Sphere};
 
 impl Sphere {
     pub fn new(c: Point, r: f32, m: Option<MaterialKind>) -> Self {
@@ -34,7 +35,7 @@ impl hittable::Hittable for Sphere {
         if root <= t_min || root >= t_max {
             root = far;
             if root <= t_min || root >= t_max {
-                // hit_record.t = -1.0;
+                hit_record.t = -1.0;
                 return false
             }
         }
@@ -44,12 +45,13 @@ impl hittable::Hittable for Sphere {
 
         hit_record.t = root;
         hit_record.p = p;
-        hit_record.normal = normal;
+        hit_record.normal = front_face_normal(r, normal);
-        hit_record.front_face = r.direction.dot(normal) < 0.0;
+        hit_record.front_face = is_front_face(r, normal);
         hit_record.material = if let Some(ref m) = self.material {
             match m {
                 MaterialKind::Lambertian(l) => Some(MaterialKind::Lambertian(l.clone())),
                 MaterialKind::Metal(m) => Some(MaterialKind::Metal(m.clone())),
+                MaterialKind::Dielectric(d) => Some(MaterialKind::Dielectric(d.clone())),
             }
         } else {
             None

src/triangle.rs

@@ -0,0 +1,100 @@
+use crate::{hittable::Hittable, material::MaterialKind, math_utils::is_front_face, types_defined::{HitRecord, Point, Ray, Vec3}};
+
+pub struct Triangle {
+    pub points: Vec<Vec3>,
+    pub material: Option<MaterialKind>,
+}
+
+impl Triangle {
+    pub fn new(p1: Point, p2: Point, p3: Point, material: Option<MaterialKind>,) -> Self {
+        Triangle { 
+            points: vec![
+                p1, p2, p3
+            ],
+            material: material
+        }
+    }
+}
+
+impl Hittable for Triangle {
+
+    fn hit(&self, r: &Ray, t_min: f32, t_max: f32, hit_record: &mut HitRecord) -> bool {
+        let p0 = self.points[0];
+        let p1 = self.points[1];
+        let p2 = self.points[2];
+        let u = Vec3 {
+            x: p1.x - p0.x,
+            y: p1.y - p0.y,
+            z: p1.z - p0.z,
+        };
+        let v = Vec3 {
+            x: p2.x - p0.x,
+            y: p2.y - p0.y,
+            z: p2.z - p0.z,
+        };
+        let normal = Vec3 {
+            x: u.y * v.z - u.z * v.y,
+            y: u.z * v.x - u.x * v.z,
+            z: u.x * v.y - u.y * v.x,
+        };
+        let denominator = r.direction.x * normal.x + r.direction.y * normal.y + r.direction.z * normal.z;
+        if denominator.abs() < std::f32::EPSILON {
+            return false;
+        }
+        let w0 = Vec3 {
+            x: r.point.x - p0.x,
+            y: r.point.y - p0.y,
+            z: r.point.z - p0.z,
+        };
+        let t = -(w0.x * normal.x + w0.y * normal.y + w0.z * normal.z) / denominator;
+        if t < t_min || t > t_max {
+            return false;
+        }
+        let P = Vec3 {
+            x: r.point.x + t * r.direction.x,
+            y: r.point.y + t * r.direction.y,
+            z: r.point.z + t * r.direction.z,
+        };
+        let w = Vec3 {
+            x: P.x - p0.x,
+            y: P.y - p0.y,
+            z: P.z - p0.z,
+        };
+        let uv_cross = Vec3 {
+            x: u.y * v.z - u.z * v.y,
+            y: u.z * v.x - u.x * v.z,
+            z: u.x * v.y - u.y * v.x,
+        };
+        let wv_cross = Vec3 {
+            x: w.y * v.z - w.z * v.y,
+            y: w.z * v.x - w.x * v.z,
+            z: w.x * v.y - w.y * v.x,
+        };
+        let uw_cross = Vec3 {
+            x: u.y * w.z - u.z * w.y,
+            y: u.z * w.x - u.x * w.z,
+            z: u.x * w.y - u.y * w.x,
+        };
+        let alpha = (wv_cross.x * normal.x + wv_cross.y * normal.y + wv_cross.z * normal.z) / (uv_cross.x * normal.x + uv_cross.y * normal.y + uv_cross.z * normal.z);
+        let beta = (uw_cross.x * normal.x + uw_cross.y * normal.y + uw_cross.z * normal.z) / (uv_cross.x * normal.x + uv_cross.y * normal.y + uv_cross.z * normal.z);
+        if alpha >= 0.0 && beta >= 0.0 && alpha + beta <= 1.0 {
+        
+            hit_record.p = P;
+            hit_record.t = t;
+            hit_record.normal = normal;
+            hit_record.front_face = is_front_face(r, normal);
+            hit_record.material = if let Some(ref m) = self.material {
+                match m {
+                    MaterialKind::Lambertian(l) => Some(MaterialKind::Lambertian(l.clone())),
+                    MaterialKind::Metal(m) => Some(MaterialKind::Metal(m.clone())),
+                    MaterialKind::Dielectric(d) => Some(MaterialKind::Dielectric(d.clone())),
+                }
+            } else {
+                None
+            };
+
+            return true;
+        }
+        false
+    }
+}

src/types_defined.rs

@@ -1,6 +1,5 @@
-use std::{fs::File, io::{BufWriter, Write}};
+use std::{fs::File, io::{BufWriter}};
-use rand::distributions::Open01;
+use crate::{material::MaterialKind};
-use crate::material::{Material, MaterialKind};
 use crate::ppm_writer::PPMWriter;
 
 /*
@@ -35,13 +34,19 @@ pub struct HitRecord {
 pub struct Camera<'a> {
     pub image_width: i32,
     pub image_height: i32,
-    pub aspect_ratio: f32,
+    // pub aspect_ratio: f32,
-    pub viewport_width: f32,
+    // pub viewport_width: f32,
-    pub viewport_height: f32,
+    // pub viewport_height: f32,
-    pub camera_center: Point,
+    pub center: Point,
-    pub focal_length: Vec3,
+    // pub look_at: Point,
-    pub viewport_u: Vec3,
+    // pub v_up: Vec3,
-    pub viewport_v: Vec3,
+    // pub focal_length: Vec3,
+    // pub viewport_u: Vec3,
+    // pub viewport_v: Vec3,
+    pub defocus_angle: f32,
+    pub defocus_disk_u: Vec3,
+    pub defocus_disk_v: Vec3,
+
     pub viewport_u_delta: Vec3,
     pub viewport_v_delta: Vec3,
     pub viewport_top_left_pixel_center: Vec3,
@@ -54,6 +59,7 @@ pub struct Camera<'a> {
     pub ppm_file_writer: &'a mut PPMWriter<BufWriter<File>>
 }
 
+
 /*
 /////////////
 // for test
@@ -63,4 +69,4 @@ pub struct Sphere {
     pub center: Point,
     pub radius: f32,
     pub material: Option<MaterialKind>,
-}
+}

src/vec3.rs

@@ -1,7 +1,7 @@
 
-use std::{fmt::Display, ops::{Add, AddAssign, Div, Mul, MulAssign, Sub}};
+use std::{fmt::Display, iter::Sum, ops::{Add, AddAssign, Div, Mul, MulAssign, Sub}};
 use std::fmt;
-use rand::{thread_rng, Rng};
+use rand::{rng, Rng};
 use crate::types_defined::Vec3;
 
 impl Display for Vec3 {
@@ -37,20 +37,32 @@ impl Vec3 {
         return self.length_squared().sqrt();
     }
 
+    pub fn normalize(self) -> Vec3 {
+        let length = self.length_squared().sqrt();
+        if length != 0. {
+            let new_x = self.x / length;
+            let new_y = self.y / length;
+            let new_z = self.z / length;
+            Vec3 { x: new_x, y: new_y, z: new_z }
+        } else {
+            Vec3 { x: 0., y: 0., z: 0. }
+        }
+    }
+
     pub fn random_range(min: f32, max: f32) -> Self {
-        let rng = &mut thread_rng();
+        let rng = &mut rng();
-        Vec3::new(rng.gen_range(min..max), rng.gen_range(min..max), rng.gen_range(min..max))
+        Vec3::new(rng.random_range(min..max), rng.random_range(min..max), rng.random_range(min..max))
     }
 
     pub fn random() -> Self {
-        let rng = &mut thread_rng();
+        let rng = &mut rng();
-        Vec3::new(rng.r#gen(), rng.r#gen(), rng.r#gen())
+        Vec3::new(rng.random(), rng.random(), rng.random())
     }
 
     pub fn random_unit() -> Self {
         loop {
             let v = Vec3::random();
-            if f32::MIN < v.length_squared() && v.length_squared() <= 1.0 {
+            if 1e-160 < v.length_squared() && v.length_squared() <= 1.0 {
                 return v / v.length_squared();
             }
         }
@@ -146,4 +158,18 @@ impl MulAssign<f32> for Vec3 {
     fn mul_assign(&mut self, scalar: f32) {
         *self = *self * scalar;
     }
+}
+
+impl Sum for Vec3 {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        let mut sum_x = 0.0;
+        let mut sum_y = 0.0;
+        let mut sum_z = 0.0;
+        for vec in iter {
+            sum_x += vec.x;
+            sum_y += vec.y;
+            sum_z += vec.z;
+        }
+        Vec3 { x: sum_x, y: sum_y, z: sum_z }
+    }
 }

src/write_file_util.rs

@@ -1,12 +0,0 @@
-use std::{fs::File, io::{BufWriter, Write}};
-
-pub fn write_image(content: String, file_path: String) {
-    if let Ok(file) = File::create(file_path) {
-        let mut writer = BufWriter::new(file);
-        if let Err(e) = writer.write(content.as_bytes()) {
-            println!("写出失败：{:#}", e)
-        }
-    } else {
-        println!("PPM保存失败")
-    }
-}