triangle

# Conflicts:
#	src/camera.rs
#	src/math_utils.rs

.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"
-version = "0.2.16"
+name = "crossbeam-deque"
+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"
-version = "0.8.5"
+name = "r-efi"
+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,53 +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, linear_to_gamma};
+use crate::math_utils::{clamp, degrees_to_radians, random_in_unit_disk};
 use crate::ppm_writer::PPMWriter;
-use crate::types_defined::{Camera, Color, Point, Ray, Vec3};
+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,
-        camera_center: Point,
-        focal_length: Vec3,
+        center: Point,
+        look_at: Point,
+        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,
-            viewport_width,
-            viewport_height,
-            camera_center,
-            focal_length,
-            viewport_u,
-            viewport_v,
+            // aspect_ratio,
+            // viewport_width,
+            // viewport_height,
+            center,
+            // look_at,
+            // v_up,
+            // 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,
@@ -59,45 +93,72 @@ 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 {
+            // 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 rng = &mut thread_rng();
-                for _ in 0..self.sample_times {
+                
+                let sample_color: Vec3 = (0..self.sample_times)
+                    .into_par_iter()
+                    .map(|_| {
+                        let r = self.get_ray(i, j);
+                        return self.ray_color_sync(&r, self.reflect_depth, RwLock::new(world));
+                    }).sum();
+                let color: Vec3 = sample_color * (1.0 / self.sample_times as f32);
+
+
+                // // color
+                // let mut color = Color::new(0.0, 0.0, 0.0);
+                // for _ in 0..self.sample_times {
+                //     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(
+                    clamp(color.x, 0.0, 1.0),
+                    clamp(color.y, 0.0, 1.0),
+                    clamp(color.z, 0.0, 1.0),
+                );
+
+                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 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 * each sample color
-                color = color * (1.0 / self.sample_times as f32);
-
-                // clamp color rgb
-                let color_clamped = Color::new(
-                    clamp(linear_to_gamma(color.x), 0.0, 1.0),
-                    clamp(linear_to_gamma(color.y), 0.0, 1.0),
-                    clamp(linear_to_gamma(color.z), 0.0, 1.0),
-                );
-
-                let _ = self.ppm_file_writer.write(color_clamped.to_color());
-
-                
-                // content
-                // img_content.push_str(&color_clamped.to_color_str().as_str());
-                // img_content.push('\n');
-            }
-        }
-
-        // img_content
+        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 {
@@ -108,14 +169,100 @@ impl<'a> Camera<'a> {
         }
 
         // 限制出射光线的角度（0.001经验值）
-        let hr = world.hit(&ray, 0.001, f32::MAX);
-        if hr.t >= 0.0 {
-            // diffuse normal vec
-            let diffuse_vec = Vec3::random_unit();
-            let lambertian_vec = diffuse_vec + hr.normal;
-            // 每次反射按0.5计算颜色（反射率 ）
-            return 0.5 * self.ray_color(&Ray::new(ray.point, lambertian_vec), depth - 1, world);
+        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.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(ray, hc, l, depth, world),
+                        MaterialKind::Metal(m) => self.scatter_color(ray, hc, m, depth, world),
+                        MaterialKind::Dielectric(d) => self.scatter_color(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(&Ray::new(ray.point, lambertian_vec), depth - 1, world)
+                    } else {
+                        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;
+        }
+
         // v / |v|
         let unit_direction = ray.direction / ray.direction.length();
         let a = 0.5 * (unit_direction.y + 1.0);
@@ -125,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,15 +1,15 @@
+use crate::material::MaterialKind;
+use crate::math_utils::{front_face_normal, is_front_face};
 use crate::types_defined::{HitRecord, Ray, Vec3};
 
-pub trait Hittable {
-    fn hit(&self, r: &Ray, t_min: f32, t_max: f32) -> HitRecord;
+pub trait Hittable: Send + Sync {
+    fn hit(&self, r: &Ray, t_min: f32, t_max: f32, hit_record: &mut HitRecord) -> bool;
 }
 
-
 pub struct HittableList {
-    pub objects: Vec<Box<dyn Hittable>>
+    pub objects: Vec<Box<dyn Hittable>>,
 }
 
-
 impl HittableList {
     pub fn new() -> Self {
         HittableList { objects: vec![] }
@@ -19,22 +19,39 @@ impl HittableList {
         let _ = &self.objects.push(object);
     }
 
-    pub fn hit(&self, r: &Ray, t_min: f32, t_max: f32) -> HitRecord {
-        for object in &self.objects {
-            let temp = object.hit(r, t_min, t_max);
-            if temp.t >= 0.0 {
-                return temp
-            }
-        }
-        HitRecord {
-            t: -1.0,
-            normal: Vec3 {
-                x: 0.0,
-                y: 0.0,
-                z: 0.0,
-            },
+    pub fn hit(&self, r: &Ray, t_min: f32, t_max: f32, hit_record: &mut HitRecord) -> bool {
+        let mut hits = false;
+        let mut closest_so_far = t_max;
+
+        let temp_hit_record = &mut HitRecord {
+            t: 0.0,
+            normal: Vec3::new(0.0, 0.0, 0.0),
+            p: Vec3::new(0.0, 0.0, 0.0),
             front_face: false,
+            material: None,
+        };
+
+        for object in &self.objects {
+            let hit = object.hit(r, t_min, closest_so_far, temp_hit_record);
+            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 = is_front_face(r, 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
+                };
+            }
+        }
+
+        hits
     }
 }
-

src/main.rs

@@ -1,9 +1,13 @@
 use std::fs::File;
 use std::io::BufWriter;
 
+use rand::{rng, Rng};
+
 use crate::hittable::HittableList;
+use crate::material::{Dielectric, Lambertian, MaterialKind, Metal};
 use crate::ppm_writer::PPMWriter;
-use crate::types_defined::{Camera, Point, Sphere, Vec3};
+use crate::triangle::Triangle;
+use crate::types_defined::{Camera, Color, Point, Sphere, Vec3};
 mod camera;
 mod color;
 mod hittable;
@@ -11,9 +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();
@@ -21,8 +26,14 @@ fn main() {
 
 fn camera_render() {
 
-    let width: i32 = 400;
-    let height: i32 = 200;
+    let fov: f32 = 90.;
+    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);
@@ -34,27 +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),
-        Vec3::new(0.0, 0.0, -1.0),
-        50,
-        50,
+        1.0,
         pw
     );
     // world
     // world objects(spheres)
     let mut world = HittableList::new();
-    world.put(Box::new(Sphere::new(Point::new(0.0, 0.0, -1.0), 0.5)));
-    world.put(Box::new(Sphere::new(Point::new(0.3, 0.1, -1.0), 0.1)));
-    world.put(Box::new(Sphere::new(Point::new(-0.5, 0.0, -1.0), 0.3)));
-    world.put(Box::new(Sphere::new(Point::new(0.0, -1000.0, -1.0), 1000.0)));
-    world.put(Box::new(Sphere::new(Point::new(-0.5, 0.2, -0.5), 0.4)));
+
+    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.784,0.784,0.784)}));
+    // 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.799, 0.599, 0.799), fuzz: 0.0005}));
+    // 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,    0.0, -1.0), 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.2, left_dia_small_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

@@ -0,0 +1,109 @@
+use crate::math_utils::{near_zero, reflect, refract};
+use crate::types_defined::{Color, HitRecord, Ray, Vec3};
+
+
+#[derive(Debug)]
+pub enum MaterialKind {
+    Lambertian(Lambertian),
+    Metal(Metal),
+    Dielectric (Dielectric),
+}
+
+pub trait Material {
+    fn scatter(&self, r_in: &Ray, hit_record: &mut HitRecord, attenuation: &mut Color, ray: &mut Ray) -> bool;
+}
+
+#[derive(Debug)]
+pub struct Lambertian {
+    pub albedo: Color,
+}
+
+impl Clone for Lambertian {
+    fn clone(&self) -> Self {
+        Lambertian {
+            albedo: self.albedo,
+        }
+    }
+}
+
+impl Material for Lambertian {
+    fn scatter(&self, r_in: &Ray, hit_record: &mut HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool {
+
+        let mut scatter_direction = r_in.direction + Vec3::random_unit_on_hemisphere(hit_record.normal);
+
+        if near_zero(scatter_direction) {
+            scatter_direction = hit_record.normal;
+        }
+            
+
+        *scattered = Ray::new(hit_record.p, scatter_direction);
+        *attenuation = self.albedo.clone();
+
+        true
+    }
+}
+
+#[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 {
+        let reflected = reflect(r_in.direction, hit_record.normal);
+        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,3 +1,22 @@
+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 {
@@ -9,10 +28,55 @@ pub fn clamp(value: f32, low: f32, high: f32) -> f32 {
     return value;
 }
 
-pub fn linear_to_gamma(value: f32) -> f32 {
-    if value > 0.0 {
-        value.sqrt()
+pub fn near_zero(v: Vec3) -> bool {
+    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 {
-        0.0
+        -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,17 +1,20 @@
 use crate::hittable;
+use crate::material::{MaterialKind};
+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) -> Self {
+    pub fn new(c: Point, r: f32, m: Option<MaterialKind>) -> Self {
         Self {
             center: c,
             radius: r,
+            material: m,
         }
     }
 }
 
 impl hittable::Hittable for Sphere {
-    fn hit(&self, r: &Ray, t_min: f32, t_max: f32) -> HitRecord {
+    fn hit(&self, r: &Ray, t_min: f32, t_max: f32, hit_record: &mut HitRecord) -> bool {
         let a: f32 = r.direction.length_squared();
         let h = r.direction.dot(self.center - r.point);
         // let b = -2.0 * r.direction.dot(sphere_center - r.point);
@@ -19,6 +22,10 @@ impl hittable::Hittable for Sphere {
 
         let discriminant = h * h - a * c;
 
+        if discriminant < 0.0 {
+            return false;
+        }
+
         // // 两个交点
         let disc_sqrt = discriminant.sqrt();
         let near = (h - disc_sqrt) / a;
@@ -28,19 +35,29 @@ impl hittable::Hittable for Sphere {
         if root <= t_min || root >= t_max {
             root = far;
             if root <= t_min || root >= t_max {
-                root = -1.0;
+                hit_record.t = -1.0;
+                return false
             }
         }
 
         let p = r.at(root);
         let normal = (p - self.center) / self.radius;
-        HitRecord {
-            t: root,
-            // p,
-            normal,
-            // check if r.p inside(>=0) the sphere.
-            front_face: r.direction.dot(normal) < 0.0,
+
+        hit_record.t = root;
+        hit_record.p = p;
+        hit_record.normal = front_face_normal(r, 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
+        };
+
+        true
     }
 }
     

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,5 +1,5 @@
-use std::{fs::File, io::{BufWriter, Write}};
-
+use std::{fs::File, io::{BufWriter}};
+use crate::{material::MaterialKind};
 use crate::ppm_writer::PPMWriter;
 
 /*
@@ -25,21 +25,28 @@ pub struct Ray {
 
 pub struct HitRecord {
     pub t: f32,
-    // pub p: Vec3,
+    pub p: Vec3,
     pub normal: Vec3,
     pub front_face: bool,
+    pub material: Option<MaterialKind>,
 }
 
 pub struct Camera<'a> {
     pub image_width: i32,
     pub image_height: i32,
-    pub aspect_ratio: f32,
-    pub viewport_width: f32,
-    pub viewport_height: f32,
-    pub camera_center: Point,
-    pub focal_length: Vec3,
-    pub viewport_u: Vec3,
-    pub viewport_v: Vec3,
+    // pub aspect_ratio: f32,
+    // pub viewport_width: f32,
+    // pub viewport_height: f32,
+    pub center: Point,
+    // pub look_at: Point,
+    // pub v_up: 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,
@@ -52,6 +59,7 @@ pub struct Camera<'a> {
     pub ppm_file_writer: &'a mut PPMWriter<BufWriter<File>>
 }
 
+
 /*
 /////////////
 // for test
@@ -60,4 +68,5 @@ pub struct Camera<'a> {
 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();
-        Vec3::new(rng.gen_range(min..max), rng.gen_range(min..max), rng.gen_range(min..max))
+        let rng = &mut rng();
+        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();
-        Vec3::new(rng.r#gen(), rng.r#gen(), rng.r#gen())
+        let rng = &mut rng();
+        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();
             }
         }
@@ -125,6 +137,15 @@ impl Div<f32> for Vec3 {
     }
 }
 
+// Vec * Vec
+impl Mul<Vec3> for Vec3 {
+    type Output = Self;
+
+    fn mul(self, rhs: Vec3) -> Self::Output {
+        Vec3::new(self.x * rhs.x, self.y * rhs.y, self.z * rhs.z)
+    }
+}
+
 // 加法赋值: Vec3 += Vec3
 impl AddAssign for Vec3 {
     fn add_assign(&mut self, other: Self) {
@@ -138,3 +159,17 @@ impl MulAssign<f32> for Vec3 {
         *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保存失败")
-    }
-}