multi threading

Cargo.lock

@@ -14,6 +14,37 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+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"
@@ -99,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]]

Cargo.toml

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

src/camera.rs

@@ -1,5 +1,7 @@
 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, degrees_to_radians, random_in_unit_disk};
@@ -7,6 +9,7 @@ use crate::ppm_writer::PPMWriter;
 use crate::types_defined::{Camera, Color, HitRecord, Point, Ray, Vec3};
 use rand::rngs::ThreadRng;
 use rand::{Rng, rng};
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use crate::material::{Material, MaterialKind};
 
 impl<'a> Camera<'a> {
@@ -90,22 +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)
-                for _ in 0..self.sample_times {
+                    .into_par_iter()
-                    let r = self.get_ray(i, j);
+                    .map(|_| {
-                    let sample_color = self.ray_color(&r, self.reflect_depth, world);
+                        let r = self.get_ray(i, j);
-                    color = color + sample_color;
+                        return self.ray_color_sync(&r, self.reflect_depth, RwLock::new(world));
-                }
+                    }).sum();
-                // color * each sample color
+                let color: Vec3 = sample_color * (1.0 / self.sample_times as f32);
-                color = 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(
@@ -119,7 +136,8 @@ impl<'a> Camera<'a> {
         }
 
         let  _ = self.ppm_file_writer.finish();
-
+        let end = Instant::now();
+        println!("================[{}mils]=====================", end.duration_since(start).as_millis())
         // img_content
     }
 
@@ -197,6 +215,61 @@ impl<'a> Camera<'a> {
         (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);
+        // return background color.
+        (1.0 - a) * Color::new(1.0, 1.0, 1.0) + a * Color::new(0.5, 0.7, 1.0)
+    }
+
     // -> [x, y, 0]
     fn random_square(&self, rng: &mut ThreadRng) -> Vec3 {
         Vec3::new(rng.random_range(-0.5..0.1), rng.random_range(-0.5..0.1), 0.0)
@@ -229,6 +302,33 @@ impl<'a> Camera<'a> {
             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

@@ -2,7 +2,7 @@ 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;
 }
 
@@ -54,4 +54,4 @@ impl HittableList {
 
         hits
     }
-}
+}

src/main.rs

@@ -25,7 +25,7 @@ fn main() {
 fn camera_render() {
 
     let fov: f32 = 90.;
-    let scale = 1;
+    let scale = 4;
     let width: i32 = 1920/scale;
     let height: i32 = 1080/scale;
     let sample_times = 50;

src/vec3.rs

@@ -1,5 +1,5 @@
 
-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::{rng, Rng};
 use crate::types_defined::Vec3;
@@ -158,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 }
+    }
 }