k/raytracer-rs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: k:main
Branches Tags
k:main
k:threading
k:action
..
compare: k:action
Branches Tags
k:main
k:threading
k:action

No commits in common. "main" and "action" have entirely different histories.
main ... action

7 changed files with 115 additions and 94 deletions
Download patch file Download diff file Expand all files Collapse all files

52
Cargo.lock generated
View file

@ -40,6 +40,37 @@ dependencies = [
"libc",
]
[[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 = "equivalent"
version = "1.0.2"
@ -186,11 +217,32 @@ version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
[[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]]
name = "rust-ray"
version = "0.1.0"
dependencies = [
"rand",
"rayon",
]
[[package]]

1
Cargo.toml
View file

@ -5,3 +5,4 @@ edition = "2024"
[dependencies]
rand = "0.10.0"
rayon = "1.11.0"

20
src/main.rs
View file

@ -11,25 +11,33 @@ use vec3::{Point3,Vec3};
use material::{Metal,Lambertian,Material};
fn main() {
let aspect_ratio = 16.0 / 9.0;
let image_width = 1920;
let image_width = 800;
let focal_length = 1.0;
let viewport_height = 2.0;
let camera_center = Point3::new(0.0, 0.0, 0.0);
let m = Lambertian::new(Vec3::new(0.5,0.5,0.5));
let world_m: Box <dyn Material> = Box::new(m);
let b: Box <dyn Material> = Box::new(m);
let world_m = std::rc::Rc::new(b);
let m = Lambertian::new(Vec3::new(0.1, 0.2, 0.5));
let center_m: Box <dyn Material> = Box::new(m);
let b: Box <dyn Material> = Box::new(m);
let center_m = std::rc::Rc::new(b);
let m = Metal::new(Vec3::new(0.8, 0.8, 0.8), 0.3);
let left_m: Box <dyn Material> = Box::new(m);
let b: Box <dyn Material> = Box::new(m);
let left_m = std::rc::Rc::new(b);
let m = Metal::new(Vec3::new(0.8, 0.6, 0.2), 0.5);
let right_m: Box <dyn Material> = Box::new(m);
let b: Box <dyn Material> = Box::new(m);
let right_m = std::rc::Rc::new(b);
let mut camera = Camera::new(aspect_ratio,image_width,focal_length,Point3::new(-1.0,1.0,1.0),Point3::new(0.0,0.0,-1.0),90.0);
let mut camera = Camera::new(aspect_ratio,image_width,focal_length,viewport_height,camera_center);
let mut world = World::new();
world.add(Sphere::new(0.5, Point3::new(0.0, 0.0, -1.0),center_m));
world.add(Sphere::new(0.5, Point3::new(-1.0, 0.0, -1.0),left_m));

2
src/material.rs
View file

@ -9,7 +9,7 @@ pub struct Scatter {
pub ray: Ray,
}
pub trait Material: Send + Sync {
pub trait Material {
fn scatter(&self, r_in: &Ray, rec: &HitRecord, rng: &mut ThreadRng) -> Option<Scatter>;
}

18
src/object.rs
View file

@ -4,19 +4,19 @@ use crate::material::{Material,Scatter};
use rand::prelude::*;
pub trait Hittable: Send + Sync{
fn hit(&self, ray: Ray, interval:Interval) -> Option<HitRecord<'_>>;
pub trait Hittable {
fn hit(&self, ray: Ray, interval:Interval) -> Option<HitRecord>;
}
pub struct HitRecord<'a> {
pub struct HitRecord {
point: Point3,
normal: Vec3,
root: f64,
front_face: bool,
material: &'a dyn Material,
material: std::rc::Rc<Box<dyn Material>>,
}
impl HitRecord <'_> {
impl HitRecord {
pub fn normal(&self) -> Vec3 {
self.normal
}
@ -43,17 +43,17 @@ impl HitRecord <'_> {
pub struct Sphere {
radius: f64,
center: Point3,
material: Box<dyn Material>
material: std::rc::Rc<Box<dyn Material>>
}
impl Sphere {
pub fn new(radius: f64, center: Point3, material: Box<dyn Material>) -> Self {
pub fn new(radius: f64, center: Point3, material:std::rc::Rc<Box<dyn Material>>) -> Self {
Sphere { radius, center , material}
}
}
impl Hittable for Sphere {
fn hit(&self, ray: Ray, interval:Interval) -> Option<HitRecord<'_>> {
fn hit(&self, ray: Ray, interval:Interval) -> Option<HitRecord> {
let oc = self.center - ray.origin();
let a = ray.direction().length_squared();
let h = Vec3::dot(ray.direction(), oc.to_vec());
@ -79,7 +79,7 @@ impl Hittable for Sphere {
point,
normal,
front_face: false,
material: self.material.as_ref(),
material: self.material.clone()
};
tmp.set_face_normal(ray, normal);
Some(tmp)

88
src/render.rs
View file

@ -1,13 +1,11 @@
use crate::object::{HitRecord, Hittable};
use crate::vec3::{Interval, Ray, Vec3, Point3};
use crate::image::Image;
use std::sync::Arc;
use std::thread;
use rand::prelude::*;
pub struct World {
pub objects: Vec<Arc<dyn Hittable>>,
pub objects: Vec<Box<dyn Hittable>>,
}
impl World {
@ -18,10 +16,10 @@ impl World {
}
pub fn add(&mut self, object: impl Hittable + 'static) {
self.objects.push(Arc::new(object));
self.objects.push(Box::new(object));
}
pub fn hit(&self, ray: Ray, interval:Interval) -> Option<HitRecord<'_>> {
pub fn hit(&self, ray: Ray, interval:Interval) -> Option<HitRecord> {
let mut hit_anything = None;
let mut closest_so_far = interval.max();
@ -46,88 +44,54 @@ pub struct Camera {
}
impl Camera {
pub fn new(aspect_ratio:f64,image_width: i32, focal_length:f64, look_from: Point3, look_at: Point3,fov:f64) -> Self{
pub fn new(aspect_ratio:f64,image_width: i32, focal_length:f64, viewport_height:f64, camera_center: Point3) -> Self{
let image_height = (image_width as f64 / aspect_ratio) as i32;
let theta = (fov as f64).to_radians();
let h = (theta/2.0).tan();
let viewport_height = 2.0 * h * focal_length;
let viewport_width = viewport_height * (image_width as f64 / image_height as f64);
let w = (look_from - look_at).to_vec().unit();
let u = Vec3::new(0.0,1.0,0.0).cross(w).unit();
let v = w.cross(u);
let viewport_u = u * viewport_width;
let viewport_v = (v*-1.0)*viewport_height;
let viewport_u = Vec3::new(viewport_width as f64, 0.0, 0.0);
let viewport_v = Vec3::new(0.0, -viewport_height as f64, 0.0);
let pixel_delta_u = viewport_u / image_width as f64;
let pixel_delta_v = viewport_v / image_height as f64;
let viewport_upper_left = look_from.to_vec() - (w * focal_length) - viewport_u/2.0 - viewport_v/2.0;
let viewport_upper_left = (camera_center.to_vec()
- Vec3::new(0.0, 0.0, focal_length)
- viewport_u / 2.0
- viewport_v / 2.0).to_point();
let pixel00_loc = (viewport_upper_left + ((pixel_delta_u + pixel_delta_v) * 0.5)).to_point();
let pixel00_loc = viewport_upper_left + ((pixel_delta_u + pixel_delta_v) * 0.5).to_point();
let img = Image::new(image_width, image_height);
Self{img,pixel00_loc,camera_center:look_from,pixel_delta_u,pixel_delta_v}
Self{img,pixel00_loc,camera_center,pixel_delta_u,pixel_delta_v}
}
pub fn render(&mut self, world: &World){
let thread_count = thread::available_parallelism().unwrap().get() as i32;
let height = self.img.height;
let width = self.img.width;
let total_pixels = height*width;
let num_samples = 25;
//cast to const ref
let const_self = &*self;
let threads:Vec<Vec<((i32,i32),(f64,f64,f64))>> = thread::scope(|s|{
(0..thread_count).map(|i|{
s.spawn(move ||{
let mut rng:ThreadRng = rand::rng();
let start = (i*total_pixels)/thread_count;
let end = ((i+1)*total_pixels)/thread_count;
(start..end).map(|i|{
let x = i%width;
let y = i/width;
for y in 0..self.img.height {
for x in 0..self.img.width {
let (mut r,mut g,mut b) = (0.0,0.0,0.0);
for _ in 0..num_samples{
let ray = const_self.get_ray(x,y,&mut rng);
let (tr,tg,tb) = trace(ray, &world,10,&mut rng);
r+=tr;
g+=tg;
b+=tb;
let num_samples=10.0;
let depth=10;
for _ in 0..num_samples as i32{
let ray = self.get_ray(x,y,&mut rng);
let (tr,tg,tb)= trace(ray, &world,depth,&mut rng);
r+= tr;
g+= tg;
b+= tb;
}
r/=num_samples as f64;
g/=num_samples as f64;
b/=num_samples as f64;
r /= num_samples;
g /= num_samples;
b /= num_samples;
r = r.clamp(0.0,1.0).sqrt();
g = g.clamp(0.0,1.0).sqrt();
b = b.clamp(0.0,1.0).sqrt();
((x,y),(r,g,b))
}).collect::<Vec<_>>()
})
}).collect::<Vec<_>>().into_iter().map(|t|{t.join().unwrap()}).collect()
});
for t in threads {
for c in t {
let ((x,y),rgb) = c;
if let Some(px) = self.img.get_pixel(x,y){
let (r,g,b)= rgb;
px.set_color(r,g,b);
} else {
eprintln!("Invalid pixel: ({} {})",x,y);
}
} else{/*ignore*/}
}
}
self.img.save("./foo.ppm").unwrap();

12
src/vec3.rs
View file

@ -1,6 +1,5 @@
use std::ops::{Add, Div, Mul, Sub};
#[repr(align(32))]
#[derive(Clone, Copy)]
pub struct Vec3 {
x: f64,
@ -8,7 +7,6 @@ pub struct Vec3 {
z: f64,
}
#[repr(align(32))]
#[derive(Clone, Copy)]
pub struct Point3 {
x: f64,
@ -134,7 +132,6 @@ impl Vec3 {
z: self.z,
}
}
pub fn dot(self, other: Vec3) -> f64 {
self.x * other.x + self.y * other.y + self.z * other.z
}
@ -152,11 +149,10 @@ impl Vec3 {
}
pub fn cross(self, other: Vec3) -> Vec3 {
Vec3{
x: self.y * other.z - self.z * other.y,
y: self.z * other.x - self.x * other.z,
z: self.x * other.y - self.y * other.x,
}
let x = self.y * other.z - self.z * other.y;
let y = self.z * other.x - self.x * other.z;
let z = self.x * other.y - self.y * other.x;
Vec3 { x, y, z }
}
pub fn length_squared(self) -> f64 {