From 45fafbcd4b41a5388ece377c4e051b5846407288 Mon Sep 17 00:00:00 2001 From: lamp Date: Sun, 21 Jan 2024 17:03:07 +0000 Subject: fmt and tidy --- src/camera.rs | 23 +- src/display/image.rs | 6 +- src/display/pixelflut.rs | 29 +- src/hittable/bvh_node.rs | 89 +++- src/hittable/constant_medium.rs | 20 +- src/hittable/hittable_box.rs | 75 ++- src/hittable/instance/moving.rs | 29 +- src/hittable/instance/rotate_x.rs | 56 ++- src/hittable/instance/rotate_y.rs | 54 +- src/hittable/instance/rotate_z.rs | 54 +- src/hittable/instance/translate.rs | 12 +- src/hittable/mod.rs | 4 +- src/hittable/model.rs | 118 ++--- src/hittable/sphere.rs | 22 +- src/hittable/triangle.rs | 15 +- src/hittable/xy_rect.rs | 31 +- src/hittable/xz_rect.rs | 31 +- src/hittable/yz_rect.rs | 31 +- src/main.rs | 106 +++- src/material/dielectric.rs | 33 +- src/material/diffuse_light.rs | 6 +- src/material/isotropic.rs | 33 +- src/material/lambertian.rs | 24 +- src/material/metal.rs | 18 +- src/material/mod.rs | 18 +- src/ray.rs | 14 +- src/scenes.rs | 986 ++++++++++++++++++++++++++++++++----- src/texture/checker_texture.rs | 2 +- src/texture/image_texture.rs | 8 +- src/texture/noise_texture.rs | 9 +- src/texture/perlin.rs | 19 +- src/texture/solid_color.rs | 4 +- src/vec3.rs | 8 +- 33 files changed, 1604 insertions(+), 383 deletions(-) diff --git a/src/camera.rs b/src/camera.rs index 55bf387..52c2011 100644 --- a/src/camera.rs +++ b/src/camera.rs @@ -1,6 +1,6 @@ use crate::ray::Ray; -use crate::vec3::{Point3, Vec3}; use crate::util::degrees_to_radians; +use crate::vec3::{Point3, Vec3}; pub struct Camera { origin: Point3, @@ -16,7 +16,17 @@ pub struct Camera { } impl Camera { - pub fn new(lookfrom: Point3, lookat: Point3, vup: Vec3, vfov: f64, aspect_ratio: f64, aperture: f64, focus_dist: f64, time_start: f64, time_end: f64) -> Camera { + pub fn new( + lookfrom: Point3, + lookat: Point3, + vup: Vec3, + vfov: f64, + aspect_ratio: f64, + aperture: f64, + focus_dist: f64, + time_start: f64, + time_end: f64, + ) -> Camera { let theta = degrees_to_radians(vfov); let h = (theta / 2.0).tan(); let viewport_height = 2.0 * h; @@ -30,10 +40,7 @@ impl Camera { let horizontal = focus_dist * viewport_width * &u; let vertical = focus_dist * viewport_height * &v; Camera { - lower_left_corner: &origin - - &horizontal / 2.0 - - &vertical / 2.0 - - focus_dist * &w, + lower_left_corner: &origin - &horizontal / 2.0 - &vertical / 2.0 - focus_dist * &w, origin, horizontal, vertical, @@ -51,7 +58,9 @@ impl Camera { let offset = &self.u * rd.x + &self.v * rd.y; Ray { origin: &self.origin + &offset, - direction: &self.lower_left_corner + s * &self.horizontal + t * &self.vertical - &self.origin - &offset, + direction: &self.lower_left_corner + s * &self.horizontal + t * &self.vertical + - &self.origin + - &offset, time: self.time_start + (self.time_end - self.time_start) * rand::random::(), } } diff --git a/src/display/image.rs b/src/display/image.rs index 77d8c83..4b25cb2 100644 --- a/src/display/image.rs +++ b/src/display/image.rs @@ -1,7 +1,7 @@ use std::io::Write; -use crate::vec3::Color; use crate::display::{Display, Pixel}; +use crate::vec3::Color; pub struct Image { width: usize, @@ -39,7 +39,9 @@ impl Display for Image { } fn maybe_write(&self, output: &mut impl Write) { - output.write_fmt(format_args!("P3\n{} {}\n255\n", self.width, self.height)).unwrap(); + output + .write_fmt(format_args!("P3\n{} {}\n255\n", self.width, self.height)) + .unwrap(); for y in (0..self.height).rev() { for x in 0..self.width { let pixel = self.data.get((y * self.width) + x).unwrap(); diff --git a/src/display/pixelflut.rs b/src/display/pixelflut.rs index 3a62f8d..9b71c8e 100644 --- a/src/display/pixelflut.rs +++ b/src/display/pixelflut.rs @@ -1,8 +1,8 @@ use std::io::Write; -use std::net::{TcpStream}; +use std::net::TcpStream; +use crate::display::{Display, Pixel}; use crate::vec3::Color; -use crate::display::{Display, Pixel}; pub struct Pixelflut { socket: TcpStream, @@ -54,15 +54,22 @@ impl Display for Pixelflut { for x in 0..self.width { let pixel = self.data.get((y * self.width) + x).unwrap(); let scale = 1.0 / pixel.sample_count as f64; - let mut r = (pixel.color.x * scale).sqrt(); - let mut g = (pixel.color.y * scale).sqrt(); - let mut b = (pixel.color.z * scale).sqrt(); - self.socket.write(format!("PX {} {} {:02x}{:02x}{:02x}\n", - self.x + x, - self.y + self.height - y, - (256.0 * r.clamp(0.0, 0.999)) as u32, - (256.0 * g.clamp(0.0, 0.999)) as u32, - (256.0 * b.clamp(0.0, 0.999)) as u32).as_bytes()); + let r = (pixel.color.x * scale).sqrt(); + let g = (pixel.color.y * scale).sqrt(); + let b = (pixel.color.z * scale).sqrt(); + self.socket + .write( + format!( + "PX {} {} {:02x}{:02x}{:02x}\n", + self.x + x, + self.y + self.height - y, + (256.0 * r.clamp(0.0, 0.999)) as u32, + (256.0 * g.clamp(0.0, 0.999)) as u32, + (256.0 * b.clamp(0.0, 0.999)) as u32 + ) + .as_bytes(), + ) + .unwrap(); } } } diff --git a/src/hittable/bvh_node.rs b/src/hittable/bvh_node.rs index d215bc3..405ab5b 100644 --- a/src/hittable/bvh_node.rs +++ b/src/hittable/bvh_node.rs @@ -2,7 +2,7 @@ use std::{cmp, sync::Arc}; use rand::seq::SliceRandom; -use crate::hittable::{HitRecord, Hittable, AABB, hittable_list::HittableList}; +use crate::hittable::{hittable_list::HittableList, HitRecord, Hittable, AABB}; use crate::ray::Ray; pub struct BVHNode { @@ -20,34 +20,72 @@ enum Axis { impl BVHNode { pub fn new(hittable_list: &HittableList, time_start: f64, time_end: f64) -> BVHNode { - Self::from_objects(&hittable_list.objects, 0, hittable_list.objects.len(), time_start, time_end) + Self::from_objects( + &hittable_list.objects, + 0, + hittable_list.objects.len(), + time_start, + time_end, + ) } - fn from_objects(src_objects: &Vec>, start: usize, end: usize, time_start: f64, time_end: f64) -> BVHNode { + fn from_objects( + src_objects: &Vec>, + start: usize, + end: usize, + time_start: f64, + time_end: f64, + ) -> BVHNode { let mut objects = src_objects.clone(); let comparator = [ - |a: &Arc, b: &Arc| Self::box_compare(a.clone(), b.clone(), Axis::X), - |a: &Arc, b: &Arc| Self::box_compare(a.clone(), b.clone(), Axis::Y), - |a: &Arc, b: &Arc| Self::box_compare(a.clone(), b.clone(), Axis::Z), - ].choose(&mut rand::thread_rng()).unwrap(); + |a: &Arc, b: &Arc| { + Self::box_compare(a.clone(), b.clone(), Axis::X) + }, + |a: &Arc, b: &Arc| { + Self::box_compare(a.clone(), b.clone(), Axis::Y) + }, + |a: &Arc, b: &Arc| { + Self::box_compare(a.clone(), b.clone(), Axis::Z) + }, + ] + .choose(&mut rand::thread_rng()) + .unwrap(); let object_span = end - start; let (left, right) = match object_span { - 1 => (objects.get(start).unwrap().clone(), objects.get(start).unwrap().clone()), + 1 => ( + objects.get(start).unwrap().clone(), + objects.get(start).unwrap().clone(), + ), 2 => match comparator(objects.get(start).unwrap(), objects.get(start + 1).unwrap()) { - cmp::Ordering::Less => (objects.get(start).unwrap().clone(), objects.get(start + 1).unwrap().clone()), - _ => (objects.get(start + 1).unwrap().clone(), objects.get(start).unwrap().clone()), - } + cmp::Ordering::Less => ( + objects.get(start).unwrap().clone(), + objects.get(start + 1).unwrap().clone(), + ), + _ => ( + objects.get(start + 1).unwrap().clone(), + objects.get(start).unwrap().clone(), + ), + }, _ => { objects[start..end].sort_by(comparator); let mid = start + object_span / 2; - (Arc::new(BVHNode::from_objects(&objects, start, mid, time_start, time_end)) as Arc, - Arc::new(BVHNode::from_objects(&objects, mid, end, time_start, time_end)) as Arc) - + ( + Arc::new(BVHNode::from_objects( + &objects, start, mid, time_start, time_end, + )) as Arc, + Arc::new(BVHNode::from_objects( + &objects, mid, end, time_start, time_end, + )) as Arc, + ) } }; - let box_left = left.bounding_box(time_start, time_end).expect("No bounding box in bvh_node constructor!"); - let box_right = right.bounding_box(time_start, time_end).expect("No bounding box in bvh_node constructor!"); + let box_left = left + .bounding_box(time_start, time_end) + .expect("No bounding box in bvh_node constructor!"); + let box_right = right + .bounding_box(time_start, time_end) + .expect("No bounding box in bvh_node constructor!"); BVHNode { left, @@ -56,19 +94,28 @@ impl BVHNode { } } - fn box_compare (a: Arc, b: Arc, axis: Axis) -> cmp::Ordering { - let box_a = a.bounding_box(0.0, 0.0).expect("No bounding box in bvh_node constructor!"); - let box_b = b.bounding_box(0.0, 0.0).expect("No bounding box in bvh_node constructor!"); + fn box_compare(a: Arc, b: Arc, axis: Axis) -> cmp::Ordering { + let box_a = a + .bounding_box(0.0, 0.0) + .expect("No bounding box in bvh_node constructor!"); + let box_b = b + .bounding_box(0.0, 0.0) + .expect("No bounding box in bvh_node constructor!"); // TODO: total_cmp is unstable :( - box_a.minimum.get(axis as usize).unwrap().partial_cmp(box_b.minimum.get(axis as usize).unwrap()).unwrap() + box_a + .minimum + .get(axis as usize) + .unwrap() + .partial_cmp(box_b.minimum.get(axis as usize).unwrap()) + .unwrap() } } impl Hittable for BVHNode { fn hit(&self, ray: &Ray, t_min: f64, t_max: f64) -> Option { if !self.aabb.hit(ray, t_min, t_max) { - return None + return None; } let hit_left = self.left.hit(ray, t_min, t_max); let hit_right_threshold = if let Some(hit_record_left) = &hit_left { diff --git a/src/hittable/constant_medium.rs b/src/hittable/constant_medium.rs index 36ac2ff..50bddc6 100644 --- a/src/hittable/constant_medium.rs +++ b/src/hittable/constant_medium.rs @@ -1,6 +1,12 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, material::{Isotropic, Material}, ray::Ray, texture::Texture, vec3::{Vec3, Point3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + material::{Isotropic, Material}, + ray::Ray, + texture::Texture, + vec3::Vec3, +}; pub struct ConstantMedium { boundary: Arc, @@ -13,7 +19,7 @@ impl ConstantMedium { Self { boundary, phase_function: Arc::new(Isotropic::from_texture(texture)), - neg_inv_density: -1.0/density, + neg_inv_density: -1.0 / density, } } } @@ -52,10 +58,14 @@ impl Hittable for ConstantMedium { p: ray.at(t), t, material: Some(self.phase_function.clone()), - normal: Vec3 { x: 1.0, y: 0.0, z: 0.0 }, // arbitrary + normal: Vec3 { + x: 1.0, + y: 0.0, + z: 0.0, + }, // arbitrary front_face: true, // arbitrary - u: 0.0, // arbitrary - v: 0.0, // arbitrary + u: 0.0, // arbitrary + v: 0.0, // arbitrary }) } diff --git a/src/hittable/hittable_box.rs b/src/hittable/hittable_box.rs index 7b95cc7..9631635 100644 --- a/src/hittable/hittable_box.rs +++ b/src/hittable/hittable_box.rs @@ -1,6 +1,14 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB, hittable_list::HittableList, xy_rect::XYRect, xz_rect::XZRect, yz_rect::YZRect}, material::Material, ray::Ray, vec3::Point3}; +use crate::{ + hittable::{ + hittable_list::HittableList, xy_rect::XYRect, xz_rect::XZRect, yz_rect::YZRect, HitRecord, + Hittable, AABB, + }, + material::Material, + ray::Ray, + vec3::Point3, +}; pub struct HittableBox { min: Point3, @@ -12,20 +20,58 @@ impl HittableBox { pub fn new(min: Point3, max: Point3, material: Arc) -> Self { let mut sides = HittableList::new(); - sides.add(Arc::new(XYRect { material: material.clone(), x0: min.x, x1: max.x, y0: min.y, y1: max.y, k: max.z })); - sides.add(Arc::new(XYRect { material: material.clone(), x0: min.x, x1: max.x, y0: min.y, y1: max.y, k: min.z })); + sides.add(Arc::new(XYRect { + material: material.clone(), + x0: min.x, + x1: max.x, + y0: min.y, + y1: max.y, + k: max.z, + })); + sides.add(Arc::new(XYRect { + material: material.clone(), + x0: min.x, + x1: max.x, + y0: min.y, + y1: max.y, + k: min.z, + })); - sides.add(Arc::new(XZRect { material: material.clone(), x0: min.x, x1: max.x, z0: min.z, z1: max.z, k: max.y })); - sides.add(Arc::new(XZRect { material: material.clone(), x0: min.x, x1: max.x, z0: min.z, z1: max.z, k: min.y })); + sides.add(Arc::new(XZRect { + material: material.clone(), + x0: min.x, + x1: max.x, + z0: min.z, + z1: max.z, + k: max.y, + })); + sides.add(Arc::new(XZRect { + material: material.clone(), + x0: min.x, + x1: max.x, + z0: min.z, + z1: max.z, + k: min.y, + })); - sides.add(Arc::new(YZRect { material: material.clone(), y0: min.y, y1: max.y, z0: min.z, z1: max.z, k: max.x })); - sides.add(Arc::new(YZRect { material: material.clone(), y0: min.y, y1: max.y, z0: min.z, z1: max.z, k: min.x })); + sides.add(Arc::new(YZRect { + material: material.clone(), + y0: min.y, + y1: max.y, + z0: min.z, + z1: max.z, + k: max.x, + })); + sides.add(Arc::new(YZRect { + material: material.clone(), + y0: min.y, + y1: max.y, + z0: min.z, + z1: max.z, + k: min.x, + })); - Self { - min, - max, - sides, - } + Self { min, max, sides } } } @@ -35,6 +81,9 @@ impl Hittable for HittableBox { } fn bounding_box(&self, _: f64, _: f64) -> Option { - Some(AABB { minimum: self.min.clone(), maximum: self.max.clone() }) + Some(AABB { + minimum: self.min.clone(), + maximum: self.max.clone(), + }) } } diff --git a/src/hittable/instance/moving.rs b/src/hittable/instance/moving.rs index 418fdbb..062af86 100644 --- a/src/hittable/instance/moving.rs +++ b/src/hittable/instance/moving.rs @@ -1,7 +1,7 @@ use std::sync::Arc; -use crate::{ray::Ray, vec3::Vec3}; use crate::hittable::{HitRecord, Hittable, AABB}; +use crate::{ray::Ray, vec3::Vec3}; pub struct Moving { pub hittable: Arc, @@ -13,13 +13,19 @@ pub struct Moving { impl Moving { fn offset_at(&self, time: f64) -> Vec3 { - &self.offset_start + ((time - self.time_start) / (self.time_end - self.time_start)) * (&self.offset_end - &self.offset_start) + &self.offset_start + + ((time - self.time_start) / (self.time_end - self.time_start)) + * (&self.offset_end - &self.offset_start) } } impl Hittable for Moving { fn hit(&self, ray: &Ray, t_min: f64, t_max: f64) -> Option { - let moved_ray = Ray { origin: &ray.origin - &self.offset_at(ray.time), direction: ray.direction.clone(), time: ray.time }; + let moved_ray = Ray { + origin: &ray.origin - &self.offset_at(ray.time), + direction: ray.direction.clone(), + time: ray.time, + }; let mut hit_record = self.hittable.hit(&moved_ray, t_min, t_max)?; hit_record.p += self.offset_at(ray.time).clone(); let normal = hit_record.normal.clone(); @@ -29,12 +35,15 @@ impl Hittable for Moving { fn bounding_box(&self, time_start: f64, time_end: f64) -> Option { let output_box = self.hittable.bounding_box(time_start, time_end)?; - Some(AABB { - minimum: &output_box.minimum + &self.offset_at(time_start), - maximum: &output_box.maximum + &self.offset_at(time_start), - }.surrounding_box(&AABB { - minimum: &output_box.minimum + &self.offset_at(time_end), - maximum: &output_box.maximum + &self.offset_at(time_end), - })) + Some( + AABB { + minimum: &output_box.minimum + &self.offset_at(time_start), + maximum: &output_box.maximum + &self.offset_at(time_start), + } + .surrounding_box(&AABB { + minimum: &output_box.minimum + &self.offset_at(time_end), + maximum: &output_box.maximum + &self.offset_at(time_end), + }), + ) } } diff --git a/src/hittable/instance/rotate_x.rs b/src/hittable/instance/rotate_x.rs index 4ebc04d..0e09223 100644 --- a/src/hittable/instance/rotate_x.rs +++ b/src/hittable/instance/rotate_x.rs @@ -1,6 +1,11 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, ray::Ray, util::degrees_to_radians, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + ray::Ray, + util::degrees_to_radians, + vec3::{Point3, Vec3}, +}; pub struct RotateX { hittable: Arc, @@ -14,11 +19,25 @@ impl RotateX { let radians = degrees_to_radians(angle); let sin_theta = radians.sin(); let cos_theta = radians.cos(); - match hittable.bounding_box(0.0, 1.0) { // TODO: passing in 0.0 and 1.0 for time seems suspicious. - None => Self { hittable, sin_theta, cos_theta, aabb: None }, + match hittable.bounding_box(0.0, 1.0) { + // TODO: passing in 0.0 and 1.0 for time seems suspicious. + None => Self { + hittable, + sin_theta, + cos_theta, + aabb: None, + }, Some(aabb) => { - let mut min = Point3 { x: f64::INFINITY, y: f64::INFINITY, z: f64::INFINITY }; - let mut max = Point3 { x: -f64::INFINITY, y: -f64::INFINITY, z: -f64::INFINITY }; + let mut min = Point3 { + x: f64::INFINITY, + y: f64::INFINITY, + z: f64::INFINITY, + }; + let mut max = Point3 { + x: -f64::INFINITY, + y: -f64::INFINITY, + z: -f64::INFINITY, + }; for i in 0..2 { for j in 0..2 { for k in 0..2 { @@ -28,15 +47,24 @@ impl RotateX { let new_y = cos_theta * y + sin_theta * y; let new_z = -sin_theta * y + cos_theta * z; - let tester = Vec3 { y: new_y, x, z: new_z }; + let tester = Vec3 { + y: new_y, + x, + z: new_z, + }; for c in 0..3 { - *min.get_mut(c).unwrap() = min.get(c).unwrap().min(*tester.get(c).unwrap()); - *max.get_mut(c).unwrap() = max.get(c).unwrap().max(*tester.get(c).unwrap()); + *min.get_mut(c).unwrap() = + min.get(c).unwrap().min(*tester.get(c).unwrap()); + *max.get_mut(c).unwrap() = + max.get(c).unwrap().max(*tester.get(c).unwrap()); } } } } - let aabb = AABB { minimum: min, maximum: max }; + let aabb = AABB { + minimum: min, + maximum: max, + }; Self { hittable, @@ -56,17 +84,21 @@ impl Hittable for RotateX { origin.y = self.cos_theta * ray.origin.y - self.sin_theta * ray.origin.z; origin.z = self.sin_theta * ray.origin.y + self.cos_theta * ray.origin.z; - + direction.y = self.cos_theta * ray.direction.y - self.sin_theta * ray.direction.z; direction.z = self.sin_theta * ray.direction.y + self.cos_theta * ray.direction.z; - let rotated_ray = Ray { origin, direction, time: ray.time }; + let rotated_ray = Ray { + origin, + direction, + time: ray.time, + }; let mut hit_record = self.hittable.hit(&rotated_ray, t_min, t_max)?; let mut p = hit_record.p.clone(); let mut normal = hit_record.normal.clone(); - p.y = self.cos_theta * hit_record.p.y+ self.sin_theta * hit_record.p.z; + p.y = self.cos_theta * hit_record.p.y + self.sin_theta * hit_record.p.z; p.z = -self.sin_theta * hit_record.p.y + self.cos_theta * hit_record.p.z; normal.y = self.cos_theta * hit_record.normal.y + self.sin_theta * hit_record.normal.z; diff --git a/src/hittable/instance/rotate_y.rs b/src/hittable/instance/rotate_y.rs index 8611616..8f34c09 100644 --- a/src/hittable/instance/rotate_y.rs +++ b/src/hittable/instance/rotate_y.rs @@ -1,6 +1,11 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, ray::Ray, util::degrees_to_radians, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + ray::Ray, + util::degrees_to_radians, + vec3::{Point3, Vec3}, +}; pub struct RotateY { hittable: Arc, @@ -14,11 +19,25 @@ impl RotateY { let radians = degrees_to_radians(angle); let sin_theta = radians.sin(); let cos_theta = radians.cos(); - match hittable.bounding_box(0.0, 1.0) { // TODO: passing in 0.0 and 1.0 for time seems suspicious. - None => Self { hittable, sin_theta, cos_theta, aabb: None }, + match hittable.bounding_box(0.0, 1.0) { + // TODO: passing in 0.0 and 1.0 for time seems suspicious. + None => Self { + hittable, + sin_theta, + cos_theta, + aabb: None, + }, Some(aabb) => { - let mut min = Point3 { x: f64::INFINITY, y: f64::INFINITY, z: f64::INFINITY }; - let mut max = Point3 { x: -f64::INFINITY, y: -f64::INFINITY, z: -f64::INFINITY }; + let mut min = Point3 { + x: f64::INFINITY, + y: f64::INFINITY, + z: f64::INFINITY, + }; + let mut max = Point3 { + x: -f64::INFINITY, + y: -f64::INFINITY, + z: -f64::INFINITY, + }; for i in 0..2 { for j in 0..2 { for k in 0..2 { @@ -28,15 +47,24 @@ impl RotateY { let new_x = cos_theta * x + sin_theta * z; let new_z = -sin_theta * x + cos_theta * z; - let tester = Vec3 { x: new_x, y, z: new_z }; + let tester = Vec3 { + x: new_x, + y, + z: new_z, + }; for c in 0..3 { - *min.get_mut(c).unwrap() = min.get(c).unwrap().min(*tester.get(c).unwrap()); - *max.get_mut(c).unwrap() = max.get(c).unwrap().max(*tester.get(c).unwrap()); + *min.get_mut(c).unwrap() = + min.get(c).unwrap().min(*tester.get(c).unwrap()); + *max.get_mut(c).unwrap() = + max.get(c).unwrap().max(*tester.get(c).unwrap()); } } } } - let aabb = AABB { minimum: min, maximum: max }; + let aabb = AABB { + minimum: min, + maximum: max, + }; Self { hittable, @@ -56,11 +84,15 @@ impl Hittable for RotateY { origin.x = self.cos_theta * ray.origin.x - self.sin_theta * ray.origin.z; origin.z = self.sin_theta * ray.origin.x + self.cos_theta * ray.origin.z; - + direction.x = self.cos_theta * ray.direction.x - self.sin_theta * ray.direction.z; direction.z = self.sin_theta * ray.direction.x + self.cos_theta * ray.direction.z; - let rotated_ray = Ray { origin, direction, time: ray.time }; + let rotated_ray = Ray { + origin, + direction, + time: ray.time, + }; let mut hit_record = self.hittable.hit(&rotated_ray, t_min, t_max)?; let mut p = hit_record.p.clone(); diff --git a/src/hittable/instance/rotate_z.rs b/src/hittable/instance/rotate_z.rs index 119baca..38601ce 100644 --- a/src/hittable/instance/rotate_z.rs +++ b/src/hittable/instance/rotate_z.rs @@ -1,6 +1,11 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, ray::Ray, util::degrees_to_radians, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + ray::Ray, + util::degrees_to_radians, + vec3::{Point3, Vec3}, +}; pub struct RotateZ { hittable: Arc, @@ -14,11 +19,25 @@ impl RotateZ { let radians = degrees_to_radians(angle); let sin_theta = radians.sin(); let cos_theta = radians.cos(); - match hittable.bounding_box(0.0, 1.0) { // TODO: passing in 0.0 and 1.0 for time seems suspicious. - None => Self { hittable, sin_theta, cos_theta, aabb: None }, + match hittable.bounding_box(0.0, 1.0) { + // TODO: passing in 0.0 and 1.0 for time seems suspicious. + None => Self { + hittable, + sin_theta, + cos_theta, + aabb: None, + }, Some(aabb) => { - let mut min = Point3 { x: f64::INFINITY, y: f64::INFINITY, z: f64::INFINITY }; - let mut max = Point3 { x: -f64::INFINITY, y: -f64::INFINITY, z: -f64::INFINITY }; + let mut min = Point3 { + x: f64::INFINITY, + y: f64::INFINITY, + z: f64::INFINITY, + }; + let mut max = Point3 { + x: -f64::INFINITY, + y: -f64::INFINITY, + z: -f64::INFINITY, + }; for i in 0..2 { for j in 0..2 { for k in 0..2 { @@ -28,15 +47,24 @@ impl RotateZ { let new_x = cos_theta * x + sin_theta * y; let new_y = -sin_theta * x + cos_theta * y; - let tester = Vec3 { x: new_x, z, y: new_y }; + let tester = Vec3 { + x: new_x, + z, + y: new_y, + }; for c in 0..3 { - *min.get_mut(c).unwrap() = min.get(c).unwrap().min(*tester.get(c).unwrap()); - *max.get_mut(c).unwrap() = max.get(c).unwrap().max(*tester.get(c).unwrap()); + *min.get_mut(c).unwrap() = + min.get(c).unwrap().min(*tester.get(c).unwrap()); + *max.get_mut(c).unwrap() = + max.get(c).unwrap().max(*tester.get(c).unwrap()); } } } } - let aabb = AABB { minimum: min, maximum: max }; + let aabb = AABB { + minimum: min, + maximum: max, + }; Self { hittable, @@ -56,11 +84,15 @@ impl Hittable for RotateZ { origin.x = self.cos_theta * ray.origin.x - self.sin_theta * ray.origin.y; origin.y = self.sin_theta * ray.origin.x + self.cos_theta * ray.origin.y; - + direction.x = self.cos_theta * ray.direction.x - self.sin_theta * ray.direction.y; direction.y = self.sin_theta * ray.direction.x + self.cos_theta * ray.direction.y; - let rotated_ray = Ray { origin, direction, time: ray.time }; + let rotated_ray = Ray { + origin, + direction, + time: ray.time, + }; let mut hit_record = self.hittable.hit(&rotated_ray, t_min, t_max)?; let mut p = hit_record.p.clone(); diff --git a/src/hittable/instance/translate.rs b/src/hittable/instance/translate.rs index a9c8162..8478bd4 100644 --- a/src/hittable/instance/translate.rs +++ b/src/hittable/instance/translate.rs @@ -1,6 +1,10 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, ray::Ray, vec3::Vec3}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + ray::Ray, + vec3::Vec3, +}; pub struct Translate { pub hittable: Arc, @@ -9,7 +13,11 @@ pub struct Translate { impl Hittable for Translate { fn hit(&self, ray: &Ray, t_min: f64, t_max: f64) -> Option { - let moved_ray = Ray { origin: &ray.origin - &self.offset, direction: ray.direction.clone(), time: ray.time }; + let moved_ray = Ray { + origin: &ray.origin - &self.offset, + direction: ray.direction.clone(), + time: ray.time, + }; let mut hit_record = self.hittable.hit(&moved_ray, t_min, t_max)?; hit_record.p += self.offset.clone(); let normal = hit_record.normal.clone(); diff --git a/src/hittable/mod.rs b/src/hittable/mod.rs index e888c71..b2b06f0 100644 --- a/src/hittable/mod.rs +++ b/src/hittable/mod.rs @@ -1,5 +1,5 @@ -pub mod instance; mod bvh_node; +pub mod instance; pub use bvh_node::BVHNode; mod constant_medium; pub use constant_medium::ConstantMedium; @@ -23,9 +23,9 @@ mod aabb; use std::sync::Arc; +use crate::material::Material; use crate::ray::Ray; use crate::vec3::{Point3, Vec3}; -use crate::material::Material; use aabb::AABB; #[derive(Clone)] diff --git a/src/hittable/model.rs b/src/hittable/model.rs index 1a652be..6357ab1 100644 --- a/src/hittable/model.rs +++ b/src/hittable/model.rs @@ -1,7 +1,12 @@ use std::sync::Arc; use std::vec::Vec; -use crate::{hittable::{HitRecord, Hittable, AABB, HittableList, Triangle}, material::Material, ray::Ray, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, HittableList, Triangle, AABB}, + material::Material, + ray::Ray, + vec3::Vec3, +}; pub struct Model { faces: HittableList, @@ -10,7 +15,15 @@ pub struct Model { impl Model { fn parse_face_triplet(triplet: &str) -> Option<(isize, Option, Option)> { let mut triplet_iter = triplet.split("/"); - Some((triplet_iter.next()?.parse::().ok()?, triplet_iter.next().and_then(|val| val.parse::().ok()) , triplet_iter.next().and_then(|val| val.parse::().ok()))) + Some(( + triplet_iter.next()?.parse::().ok()?, + triplet_iter + .next() + .and_then(|val| val.parse::().ok()), + triplet_iter + .next() + .and_then(|val| val.parse::().ok()), + )) } pub fn from_obj(obj_data: &str, material: Arc) -> Self { let mut geometric_vertices: Vec = Vec::new(); @@ -34,95 +47,85 @@ impl Model { None => { eprintln!("Malformed {} entry in OBJ: Missing x!", operator); continue; - }, - Some(val) => { - match val.parse::() { - Err(_) => { - eprintln!("Malformed {} entry in OBJ: Malformed f64 x!", operator); - continue; - }, - Ok(val) => val, - } } + Some(val) => match val.parse::() { + Err(_) => { + eprintln!("Malformed {} entry in OBJ: Malformed f64 x!", operator); + continue; + } + Ok(val) => val, + }, }; let y = match entry_iter.next() { None => { eprintln!("Malformed {} entry in OBJ: Missing y!", operator); continue; - }, - Some(val) => { - match val.parse::() { - Err(_) => { - eprintln!("Malformed {} entry in OBJ: Malformed f64 y!", operator); - continue; - }, - Ok(val) => val, - } } + Some(val) => match val.parse::() { + Err(_) => { + eprintln!("Malformed {} entry in OBJ: Malformed f64 y!", operator); + continue; + } + Ok(val) => val, + }, }; let z = match entry_iter.next() { None => { eprintln!("Malformed {} entry in OBJ: Missing z!", operator); continue; - }, - Some(val) => { - match val.parse::() { - Err(_) => { - eprintln!("Malformed {} entry in OBJ: Malformed f64 z!", operator); - continue; - }, - Ok(val) => val, - } } + Some(val) => match val.parse::() { + Err(_) => { + eprintln!("Malformed {} entry in OBJ: Malformed f64 z!", operator); + continue; + } + Ok(val) => val, + }, }; // who cares about w match operator { - "v" => geometric_vertices.push(Vec3 {x, y, z}), - "vn" => vertex_normals.push(Vec3 {x, y, z}), + "v" => geometric_vertices.push(Vec3 { x, y, z }), + "vn" => vertex_normals.push(Vec3 { x, y, z }), _ => panic!(), } - }, + } "vt" => { let u = match entry_iter.next() { None => { eprintln!("Malformed vt entry in OBJ: Missing u!"); continue; - }, - Some(val) => { - match val.parse::() { - Err(_) => { - eprintln!("Malformed vt entry in OBJ: Malformed f64 u!"); - continue; - }, - Ok(val) => val, - } } + Some(val) => match val.parse::() { + Err(_) => { + eprintln!("Malformed vt entry in OBJ: Malformed f64 u!"); + continue; + } + Ok(val) => val, + }, }; let v = match entry_iter.next() { None => { eprintln!("Malformed vt entry in OBJ: Missing v!"); continue; - }, - Some(val) => { - match val.parse::() { - Err(_) => { - eprintln!("Malformed v entry in OBJ: Malformed f64 v!"); - continue; - }, - Ok(val) => val, - } } + Some(val) => match val.parse::() { + Err(_) => { + eprintln!("Malformed v entry in OBJ: Malformed f64 v!"); + continue; + } + Ok(val) => val, + }, }; // who cares about w texture_vertices.push((u, v)); - }, + } "f" => { - let mut triplets : Vec<(isize, Option, Option)> = Vec::new(); + let mut triplets: Vec<(isize, Option, Option)> = Vec::new(); for triplet in entry_iter { match Self::parse_face_triplet(triplet) { None => { eprintln!("Encountered malformed triplet in f operator!"); - }, + } Some(val) => { triplets.push(val); } @@ -163,7 +166,7 @@ impl Model { if let Some(vn2) = triplets.get(2).unwrap().2 { if vn0 != vn1 || vn1 != vn2 { eprintln!("Unsupported geometry in OBJ file: Multiple normals for face!"); - continue + continue; } let mut vn0 = vn0; if vn0 < 0 { @@ -171,16 +174,17 @@ impl Model { } else { vn0 = vn0 - 1; } - triangle.custom_normal = Some(vertex_normals.get(vn0 as usize).unwrap().unit_vector()); + triangle.custom_normal = + Some(vertex_normals.get(vn0 as usize).unwrap().unit_vector()); } } } faces.push(Arc::new(triangle)); - }, + } _ => { eprintln!("Ignoring unknown operator {} in OBJ!", operator); continue; - }, + } } } Self { diff --git a/src/hittable/sphere.rs b/src/hittable/sphere.rs index 783b788..f276366 100644 --- a/src/hittable/sphere.rs +++ b/src/hittable/sphere.rs @@ -1,9 +1,13 @@ -use std::sync::Arc; use std::f64::consts; +use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, material::Material, vec3::Vec3}; use crate::ray::Ray; use crate::vec3::Point3; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + material::Material, + vec3::Vec3, +}; pub struct Sphere { pub center: Point3, @@ -54,8 +58,18 @@ impl Hittable for Sphere { fn bounding_box(&self, _: f64, _: f64) -> Option { Some(AABB { - minimum: &self.center - Vec3 { x: self.radius, y: self.radius, z: self.radius }, - maximum: &self.center + Vec3 { x: self.radius, y: self.radius, z: self.radius }, + minimum: &self.center + - Vec3 { + x: self.radius, + y: self.radius, + z: self.radius, + }, + maximum: &self.center + + Vec3 { + x: self.radius, + y: self.radius, + z: self.radius, + }, }) } } diff --git a/src/hittable/triangle.rs b/src/hittable/triangle.rs index 0fe5fc4..82b9e18 100644 --- a/src/hittable/triangle.rs +++ b/src/hittable/triangle.rs @@ -1,6 +1,11 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, material::Material, ray::Ray, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + material::Material, + ray::Ray, + vec3::{Point3, Vec3}, +}; pub struct Triangle { pub v0: Point3, @@ -12,7 +17,9 @@ pub struct Triangle { impl Triangle { fn has_vertex_at_infinity(&self) -> bool { - self.v0.has_infinite_member() || self.v1.has_infinite_member() || self.v2.has_infinite_member() + self.v0.has_infinite_member() + || self.v1.has_infinite_member() + || self.v2.has_infinite_member() } } @@ -71,9 +78,9 @@ impl Hittable for Triangle { maximum: Point3 { x: self.v0.x.max(self.v1.x).max(self.v2.x) + 0.0001, y: self.v0.y.max(self.v1.y).max(self.v2.y) + 0.0001, - z: self.v0.z.max(self.v1.z).max(self.v2.z) + 0.0001, + z: self.v0.z.max(self.v1.z).max(self.v2.z) + 0.0001, }, - }) + }), } } } diff --git a/src/hittable/xy_rect.rs b/src/hittable/xy_rect.rs index 8421bae..2d7dbeb 100644 --- a/src/hittable/xy_rect.rs +++ b/src/hittable/xy_rect.rs @@ -1,6 +1,11 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, material::Material, ray::Ray, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + material::Material, + ray::Ray, + vec3::{Point3, Vec3}, +}; pub struct XYRect { pub material: Arc, @@ -13,7 +18,10 @@ pub struct XYRect { impl XYRect { fn has_infinite_bounds(&self) -> bool { - self.x0.is_infinite() || self.x1.is_infinite() || self.y0.is_infinite() || self.y1.is_infinite() + self.x0.is_infinite() + || self.x1.is_infinite() + || self.y0.is_infinite() + || self.y1.is_infinite() } } @@ -32,7 +40,11 @@ impl Hittable for XYRect { hit_record.u = (x - self.x0) / (self.x1 - self.x0); hit_record.v = (y - self.y0) / (self.y1 - self.y0); hit_record.t = t; - let outward_normal = Vec3 { x: 0.0, y: 0.0, z: 1.0 }; + let outward_normal = Vec3 { + x: 0.0, + y: 0.0, + z: 1.0, + }; hit_record.set_face_normal(ray, &outward_normal); hit_record.material = Some(self.material.clone()); hit_record.p = ray.at(t); @@ -42,7 +54,18 @@ impl Hittable for XYRect { fn bounding_box(&self, _: f64, _: f64) -> Option { match self.has_infinite_bounds() { true => None, - false => Some(AABB { minimum: Point3 { x: self.x0, y: self.y0, z: self.k - 0.0001 }, maximum: Point3 { x: self.x1, y: self.y1, z: self.k + 0.0001 } }), + false => Some(AABB { + minimum: Point3 { + x: self.x0, + y: self.y0, + z: self.k - 0.0001, + }, + maximum: Point3 { + x: self.x1, + y: self.y1, + z: self.k + 0.0001, + }, + }), } } } diff --git a/src/hittable/xz_rect.rs b/src/hittable/xz_rect.rs index 4761f36..c990de5 100644 --- a/src/hittable/xz_rect.rs +++ b/src/hittable/xz_rect.rs @@ -1,6 +1,11 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, material::Material, ray::Ray, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + material::Material, + ray::Ray, + vec3::{Point3, Vec3}, +}; pub struct XZRect { pub material: Arc, @@ -13,7 +18,10 @@ pub struct XZRect { impl XZRect { fn has_infinite_bounds(&self) -> bool { - self.x0.is_infinite() || self.x1.is_infinite() || self.z0.is_infinite() || self.z1.is_infinite() + self.x0.is_infinite() + || self.x1.is_infinite() + || self.z0.is_infinite() + || self.z1.is_infinite() } } @@ -32,7 +40,11 @@ impl Hittable for XZRect { hit_record.u = (x - self.x0) / (self.x1 - self.x0); hit_record.v = (z - self.z0) / (self.z1 - self.z0); hit_record.t = t; - let outward_normal = Vec3 { x: 0.0, y: 1.0, z: 0.0 }; + let outward_normal = Vec3 { + x: 0.0, + y: 1.0, + z: 0.0, + }; hit_record.set_face_normal(ray, &outward_normal); hit_record.material = Some(self.material.clone()); hit_record.p = ray.at(t); @@ -42,7 +54,18 @@ impl Hittable for XZRect { fn bounding_box(&self, _: f64, _: f64) -> Option { match self.has_infinite_bounds() { true => None, - false => Some(AABB { minimum: Point3 { x: self.x0, y: self.k - 0.0001, z: self.z0 }, maximum: Point3 { x: self.x1, y: self.k + 0.0001, z: self.z1 } }), + false => Some(AABB { + minimum: Point3 { + x: self.x0, + y: self.k - 0.0001, + z: self.z0, + }, + maximum: Point3 { + x: self.x1, + y: self.k + 0.0001, + z: self.z1, + }, + }), } } } diff --git a/src/hittable/yz_rect.rs b/src/hittable/yz_rect.rs index dd90bdb..db068dd 100644 --- a/src/hittable/yz_rect.rs +++ b/src/hittable/yz_rect.rs @@ -1,6 +1,11 @@ use std::sync::Arc; -use crate::{hittable::{HitRecord, Hittable, AABB}, material::Material, ray::Ray, vec3::{Point3, Vec3}}; +use crate::{ + hittable::{HitRecord, Hittable, AABB}, + material::Material, + ray::Ray, + vec3::{Point3, Vec3}, +}; pub struct YZRect { pub material: Arc, @@ -13,7 +18,10 @@ pub struct YZRect { impl YZRect { fn has_infinite_bounds(&self) -> bool { - self.y0.is_infinite() || self.y1.is_infinite() || self.z0.is_infinite() || self.z1.is_infinite() + self.y0.is_infinite() + || self.y1.is_infinite() + || self.z0.is_infinite() + || self.z1.is_infinite() } } @@ -32,7 +40,11 @@ impl Hittable for YZRect { hit_record.u = (y - self.y0) / (self.y1 - self.y0); hit_record.v = (z - self.z0) / (self.z1 - self.z0); hit_record.t = t; - let outward_normal = Vec3 { x: 1.0, y: 0.0, z: 0.0 }; + let outward_normal = Vec3 { + x: 1.0, + y: 0.0, + z: 0.0, + }; hit_record.set_face_normal(ray, &outward_normal); hit_record.material = Some(self.material.clone()); hit_record.p = ray.at(t); @@ -42,7 +54,18 @@ impl Hittable for YZRect { fn bounding_box(&self, _: f64, _: f64) -> Option { match self.has_infinite_bounds() { true => None, - false => Some(AABB { minimum: Point3 { x: self.k - 0.0001, y: self.y0, z: self.z0 }, maximum: Point3 { x: self.k + 0.0001, y: self.y1, z: self.z1 } }), + false => Some(AABB { + minimum: Point3 { + x: self.k - 0.0001, + y: self.y0, + z: self.z0, + }, + maximum: Point3 { + x: self.k + 0.0001, + y: self.y1, + z: self.z1, + }, + }), } } } diff --git a/src/main.rs b/src/main.rs index 0fe2df9..1e889e6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,21 +1,24 @@ mod camera; +mod display; mod hittable; mod material; mod ray; +mod scenes; +mod texture; mod util; mod vec3; -mod display; -mod texture; -mod scenes; -use std::{sync::{Arc, mpsc}, thread}; +use std::{ + sync::{mpsc, Arc}, + thread, +}; use camera::Camera; -use hittable::Hittable; use display::{Display, Image, Pixelflut}; +use hittable::Hittable; use ray::Ray; -use vec3::{Vec3, Color, Point3}; use scenes::get_scene; +use vec3::{Color, Vec3}; struct PixelUpdate { color: Color, @@ -33,7 +36,7 @@ fn ray_color(ray: &Ray, background: &Color, world: &dyn Hittable, depth: u32) -> } match world.hit(ray, 0.001, f64::INFINITY) { None => background.clone(), - Some(mut rec) => { + Some(rec) => { let mut scattered = Ray::new(); let mut attenuation = Color::new(); if let Some(material) = &rec.material { @@ -44,13 +47,26 @@ fn ray_color(ray: &Ray, background: &Color, world: &dyn Hittable, depth: u32) -> emitted + attenuation * ray_color(&scattered, background, world, depth - 1) } } else { - Color { x: 0.0, y: 0.0, z: 0.0 } + Color { + x: 0.0, + y: 0.0, + z: 0.0, + } } - }, + } } } -fn render(image_width: u32, image_height: u32, samples_per_pixel: u32, max_depth: u32, world: Arc, background: Color, camera: Arc, tx: mpsc::Sender) { +fn render( + image_width: u32, + image_height: u32, + samples_per_pixel: u32, + max_depth: u32, + world: Arc, + background: Color, + camera: Arc, + tx: mpsc::Sender, +) { for j in (0..image_height).rev() { for i in 0..image_width { for _ in 0..samples_per_pixel { @@ -58,7 +74,12 @@ fn render(image_width: u32, image_height: u32, samples_per_pixel: u32, max_depth let v = ((j as f64) + rand::random::()) / ((image_height - 1) as f64); let ray = camera.get_ray(u, v); - tx.send(PixelUpdate { color: ray_color(&ray, &background, world.as_ref(), max_depth), x: i as usize, y: j as usize}).unwrap(); + tx.send(PixelUpdate { + color: ray_color(&ray, &background, world.as_ref(), max_depth), + x: i as usize, + y: j as usize, + }) + .unwrap(); } } } @@ -76,27 +97,67 @@ fn main() { const TIME_START: f64 = 0.0; const TIME_END: f64 = 1.0; // World - let (world, lookfrom, lookat, vfov, aperture, background) = get_scene(std::env::args().nth(1).unwrap_or("0".to_string()).trim().parse().unwrap_or(0)); + let (world, lookfrom, lookat, vfov, aperture, background) = get_scene( + std::env::args() + .nth(1) + .unwrap_or("0".to_string()) + .trim() + .parse() + .unwrap_or(0), + ); // Camera - let vup = Vec3 { x: 0.0, y: 1.0, z: 0.0 }; + let vup = Vec3 { + x: 0.0, + y: 1.0, + z: 0.0, + }; let dist_to_focus = 10.0; - let cam = Arc::new(Camera::new(lookfrom, lookat, vup, vfov, ASPECT_RATIO, aperture, dist_to_focus, TIME_START, TIME_END)); + let cam = Arc::new(Camera::new( + lookfrom, + lookat, + vup, + vfov, + ASPECT_RATIO, + aperture, + dist_to_focus, + TIME_START, + TIME_END, + )); // Render // let mut final_image = Image::new(IMAGE_WIDTH as usize, IMAGE_HEIGHT as usize); - let mut final_image = Pixelflut::new("192.168.0.38:1337", 0, 0, IMAGE_WIDTH as usize, IMAGE_HEIGHT as usize); + let mut final_image = Pixelflut::new( + "192.168.0.38:1337", + 0, + 0, + IMAGE_WIDTH as usize, + IMAGE_HEIGHT as usize, + ); let (tx, rx) = mpsc::channel::(); for _ in 0..THREAD_COUNT { let sender = tx.clone(); let world_ref = world.clone(); let camera_ref = cam.clone(); let background_clone = background.clone(); - thread::spawn( || { - render(IMAGE_WIDTH, IMAGE_HEIGHT, SAMPLES_PER_PIXEL / THREAD_COUNT, MAX_DEPTH, world_ref, background_clone, camera_ref, sender); + thread::spawn(|| { + render( + IMAGE_WIDTH, + IMAGE_HEIGHT, + SAMPLES_PER_PIXEL / THREAD_COUNT, + MAX_DEPTH, + world_ref, + background_clone, + camera_ref, + sender, + ); }); } - let expected_updates: u64 = (SAMPLES_PER_PIXEL / THREAD_COUNT) as u64 * THREAD_COUNT as u64 * IMAGE_HEIGHT as u64 * IMAGE_WIDTH as u64; - let print_frequency: u64 = (SAMPLES_PER_PIXEL / THREAD_COUNT) as u64 * THREAD_COUNT as u64 * IMAGE_WIDTH as u64; + let expected_updates: u64 = (SAMPLES_PER_PIXEL / THREAD_COUNT) as u64 + * THREAD_COUNT as u64 + * IMAGE_HEIGHT as u64 + * IMAGE_WIDTH as u64; + let print_frequency: u64 = + (SAMPLES_PER_PIXEL / THREAD_COUNT) as u64 * THREAD_COUNT as u64 * IMAGE_WIDTH as u64; let print_frequency = print_frequency * 3; let mut update_count: u64 = 0; loop { @@ -105,11 +166,14 @@ fn main() { final_image.add_sample(update.x, update.y, update.color); if update_count % print_frequency == 0 { final_image.maybe_update(); - eprint!("\rCurrent completion: {:.2}%", (update_count as f64 / expected_updates as f64) * 100.0) + eprint!( + "\rCurrent completion: {:.2}%", + (update_count as f64 / expected_updates as f64) * 100.0 + ) } } else { if Arc::strong_count(&world) == 1 { - break + break; } } } diff --git a/src/material/dielectric.rs b/src/material/dielectric.rs index 1a49f73..af6f9b0 100644 --- a/src/material/dielectric.rs +++ b/src/material/dielectric.rs @@ -1,9 +1,9 @@ use std::ops::Neg; use super::Material; -use crate::{hittable::HitRecord, vec3::Vec3}; -use crate::vec3::Color; use crate::ray::Ray; +use crate::vec3::Color; +use crate::{hittable::HitRecord, vec3::Vec3}; pub struct DielectricAttenuation { pub albedo: Color, @@ -25,7 +25,13 @@ impl Dielectric { } impl Material for Dielectric { - fn scatter(&self, ray_in: &Ray, hit_record: &HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool { + fn scatter( + &self, + ray_in: &Ray, + hit_record: &HitRecord, + attenuation: &mut Color, + scattered: &mut Ray, + ) -> bool { if let Some(props) = &self.attenuation { let outward_normal = if hit_record.front_face { hit_record.normal.clone() @@ -40,9 +46,17 @@ impl Material for Dielectric { *attenuation = props.albedo.clone(); } } else { - *attenuation = Color { x: 1.0, y: 1.0, z: 1.0 }; + *attenuation = Color { + x: 1.0, + y: 1.0, + z: 1.0, + }; } - let refraction_ratio = if hit_record.front_face { 1.0 / self.index_of_refraction } else { self.index_of_refraction }; + let refraction_ratio = if hit_record.front_face { + 1.0 / self.index_of_refraction + } else { + self.index_of_refraction + }; let unit_direction = ray_in.direction.unit_vector(); let cos_theta = hit_record.normal.dot(&-&unit_direction).min(1.0); let sin_theta = (1.0 - cos_theta * cos_theta).sqrt(); @@ -50,13 +64,18 @@ impl Material for Dielectric { let cannot_refract = refraction_ratio * sin_theta > 1.0; let direction: Vec3; - if cannot_refract || Self::reflectance(cos_theta, refraction_ratio) > rand::random::() { + if cannot_refract || Self::reflectance(cos_theta, refraction_ratio) > rand::random::() + { direction = unit_direction.reflect(&hit_record.normal) } else { direction = unit_direction.refract(&hit_record.normal, refraction_ratio) } - *scattered = Ray { origin: hit_record.p.clone(), direction, time: ray_in.time }; + *scattered = Ray { + origin: hit_record.p.clone(), + direction, + time: ray_in.time, + }; true } } diff --git a/src/material/diffuse_light.rs b/src/material/diffuse_light.rs index fecbcff..4feca3b 100644 --- a/src/material/diffuse_light.rs +++ b/src/material/diffuse_light.rs @@ -1,10 +1,10 @@ use std::sync::Arc; use super::Material; -use crate::{hittable::HitRecord, texture::Texture, vec3::Point3}; -use crate::vec3::Color; -use crate::texture::SolidColor; use crate::ray::Ray; +use crate::texture::SolidColor; +use crate::vec3::Color; +use crate::{hittable::HitRecord, texture::Texture, vec3::Point3}; pub struct DiffuseLight { emit: Arc, diff --git a/src/material/isotropic.rs b/src/material/isotropic.rs index f59fa7d..9949abd 100644 --- a/src/material/isotropic.rs +++ b/src/material/isotropic.rs @@ -1,32 +1,39 @@ use std::sync::Arc; use super::Material; -use crate::{hittable::HitRecord, texture::Texture, vec3::Vec3}; -use crate::vec3::Color; -use crate::texture::SolidColor; use crate::ray::Ray; +use crate::vec3::Color; +use crate::{hittable::HitRecord, texture::Texture, vec3::Vec3}; pub struct Isotropic { albedo: Arc, } impl Isotropic { - pub fn from_color(color: Color) -> Self { - Self { - albedo: Arc::new(SolidColor::from_color(color)), - } - } + // pub fn from_color(color: Color) -> Self { + // Self { + // albedo: Arc::new(SolidColor::from_color(color)), + // } + // } pub fn from_texture(texture: Arc) -> Self { - Self { - albedo: texture, - } + Self { albedo: texture } } } impl Material for Isotropic { - fn scatter(&self, ray_in: &Ray, hit_record: &HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool { - *scattered = Ray { origin: hit_record.p.clone(), direction: Vec3::random_in_unit_sphere(), time: ray_in.time }; + fn scatter( + &self, + ray_in: &Ray, + hit_record: &HitRecord, + attenuation: &mut Color, + scattered: &mut Ray, + ) -> bool { + *scattered = Ray { + origin: hit_record.p.clone(), + direction: Vec3::random_in_unit_sphere(), + time: ray_in.time, + }; *attenuation = self.albedo.value(hit_record.u, hit_record.v, &hit_record.p); true } diff --git a/src/material/lambertian.rs b/src/material/lambertian.rs index 95f698e..fed26f9 100644 --- a/src/material/lambertian.rs +++ b/src/material/lambertian.rs @@ -1,10 +1,10 @@ use std::sync::Arc; use super::Material; -use crate::{hittable::HitRecord, texture::Texture, vec3::Vec3}; -use crate::vec3::Color; -use crate::texture::SolidColor; use crate::ray::Ray; +use crate::texture::SolidColor; +use crate::vec3::Color; +use crate::{hittable::HitRecord, texture::Texture, vec3::Vec3}; pub struct Lambertian { pub albedo: Arc, @@ -13,13 +13,21 @@ pub struct Lambertian { impl Lambertian { pub fn from_color(color: Color) -> Self { Self { - albedo: Arc::new(SolidColor { color_value: color.clone() }), + albedo: Arc::new(SolidColor { + color_value: color.clone(), + }), } } } impl Material for Lambertian { - fn scatter(&self, ray_in : &Ray, hit_record: &HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool { + fn scatter( + &self, + ray_in: &Ray, + hit_record: &HitRecord, + attenuation: &mut Color, + scattered: &mut Ray, + ) -> bool { let mut scatter_direction = &hit_record.normal + Vec3::random_unit_vector(); // Catch zero-vector scatter directions that will generate issues later @@ -27,7 +35,11 @@ impl Material for Lambertian { scatter_direction = hit_record.normal.clone(); } - *scattered = Ray { origin: hit_record.p.clone(), direction: scatter_direction, time: ray_in.time }; + *scattered = Ray { + origin: hit_record.p.clone(), + direction: scatter_direction, + time: ray_in.time, + }; *attenuation = self.albedo.value(hit_record.u, hit_record.v, &hit_record.p); true } diff --git a/src/material/metal.rs b/src/material/metal.rs index 2865a2f..638e5e4 100644 --- a/src/material/metal.rs +++ b/src/material/metal.rs @@ -1,7 +1,7 @@ use super::Material; -use crate::{hittable::HitRecord, vec3::Vec3}; -use crate::vec3::Color; use crate::ray::Ray; +use crate::vec3::Color; +use crate::{hittable::HitRecord, vec3::Vec3}; pub struct Metal { pub albedo: Color, @@ -9,9 +9,19 @@ pub struct Metal { } impl Material for Metal { - fn scatter(&self, ray_in: &Ray, hit_record: &HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool { + fn scatter( + &self, + ray_in: &Ray, + hit_record: &HitRecord, + attenuation: &mut Color, + scattered: &mut Ray, + ) -> bool { let reflected = ray_in.direction.unit_vector().reflect(&hit_record.normal); - *scattered = Ray { origin: hit_record.p.clone(), direction: reflected + self.fuzz * Vec3::random_in_unit_sphere(), time: ray_in.time }; + *scattered = Ray { + origin: hit_record.p.clone(), + direction: reflected + self.fuzz * Vec3::random_in_unit_sphere(), + time: ray_in.time, + }; *attenuation = self.albedo.clone(); scattered.direction.dot(&hit_record.normal) > 0.0 } diff --git a/src/material/mod.rs b/src/material/mod.rs index c292ea1..cded09b 100644 --- a/src/material/mod.rs +++ b/src/material/mod.rs @@ -10,13 +10,23 @@ pub use diffuse_light::DiffuseLight; mod isotropic; pub use isotropic::Isotropic; -use crate::{hittable::HitRecord, vec3::Point3}; -use crate::vec3::Color; use crate::ray::Ray; +use crate::vec3::Color; +use crate::{hittable::HitRecord, vec3::Point3}; pub trait Material: Send + Sync { fn emitted(&self, _: f64, _: f64, _: &Point3) -> Color { - Color { x: 0.0, y: 0.0, z: 0.0 } + Color { + x: 0.0, + y: 0.0, + z: 0.0, + } } - fn scatter(&self, ray_in: &Ray, hit_record: &HitRecord, attenuation: &mut Color, scattered: &mut Ray) -> bool; + fn scatter( + &self, + ray_in: &Ray, + hit_record: &HitRecord, + attenuation: &mut Color, + scattered: &mut Ray, + ) -> bool; } diff --git a/src/ray.rs b/src/ray.rs index 0a4fc3c..a3636e6 100644 --- a/src/ray.rs +++ b/src/ray.rs @@ -9,9 +9,17 @@ pub struct Ray { impl Ray { pub fn new() -> Ray { Ray { - origin: Point3 { x: 0.0, y: 0.0, z: 0.0 }, - direction: Vec3 { x: 0.0, y:0.0, z: 0.0}, - time: 0.0 + origin: Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + direction: Vec3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + time: 0.0, } } diff --git a/src/scenes.rs b/src/scenes.rs index 54f6eb3..096055e 100644 --- a/src/scenes.rs +++ b/src/scenes.rs @@ -1,23 +1,25 @@ use std::sync::Arc; -use crate::hittable::{ConstantMedium, Hittable}; -use crate::hittable::HittableBox; -use crate::hittable::HittableList; -use crate::material::{Dielectric, DielectricAttenuation, DiffuseLight, Lambertian, Material, Metal}; -use crate::hittable::instance::RotateY; +use crate::hittable::instance::Moving; use crate::hittable::instance::RotateX; +use crate::hittable::instance::RotateY; use crate::hittable::instance::RotateZ; -use crate::hittable::Sphere; use crate::hittable::instance::Translate; -use crate::vec3::{Point3, Vec3, Color}; use crate::hittable::BVHNode; -use crate::texture::{CheckerTexture, ImageTexture, NoiseTexture, SolidColor}; +use crate::hittable::HittableBox; +use crate::hittable::HittableList; +use crate::hittable::Model; +use crate::hittable::Sphere; +use crate::hittable::Triangle; use crate::hittable::XYRect; use crate::hittable::XZRect; use crate::hittable::YZRect; -use crate::hittable::Triangle; -use crate::hittable::Model; -use crate::hittable::instance::Moving; +use crate::hittable::{ConstantMedium, Hittable}; +use crate::material::{ + Dielectric, DielectricAttenuation, DiffuseLight, Lambertian, Material, Metal, +}; +use crate::texture::{CheckerTexture, ImageTexture, NoiseTexture, SolidColor}; +use crate::vec3::{Color, Point3, Vec3}; pub fn get_scene(id: u32) -> (Arc, Point3, Point3, f64, f64, Color) { match id { @@ -37,141 +39,647 @@ pub fn get_scene(id: u32) -> (Arc, Point3, Point3, f64, f64, Color fn random_scene() -> (Arc, Point3, Point3, f64, f64, Color) { let mut world = HittableList::new(); - let checker = Arc::new(CheckerTexture::from_colors(Color { x: 0.2, y: 0.3, z: 0.1 } , Color { x: 0.9, y: 0.9, z: 0.9 })); + let checker = Arc::new(CheckerTexture::from_colors( + Color { + x: 0.2, + y: 0.3, + z: 0.1, + }, + Color { + x: 0.9, + y: 0.9, + z: 0.9, + }, + )); let ground_material = Arc::new(Lambertian { albedo: checker }); - world.add(Arc::new(Sphere{ center: Point3 { x: 0.0, y: -1000.0, z: 0.0 }, radius: 1000.0, material: ground_material })); + world.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: -1000.0, + z: 0.0, + }, + radius: 1000.0, + material: ground_material, + })); for a in -11..11 { for b in -11..11 { let choose_mat = rand::random::(); - let center = Point3 { x: (a as f64) + 0.9 * rand::random::(), y: 0.2, z: (b as f64) + 0.9 * rand::random::() }; - - if (¢er - Point3 { x: 4.0, y: 0.3, z: 0.0 }).length() > 0.9 { + let center = Point3 { + x: (a as f64) + 0.9 * rand::random::(), + y: 0.2, + z: (b as f64) + 0.9 * rand::random::(), + }; + + if (¢er + - Point3 { + x: 4.0, + y: 0.3, + z: 0.0, + }) + .length() + > 0.9 + { let sphere_material: Arc; if choose_mat < 0.8 { - let albedo = Arc::new(SolidColor::from_color(Color::random() * Color::random())); + let albedo = + Arc::new(SolidColor::from_color(Color::random() * Color::random())); sphere_material = Arc::new(Lambertian { albedo }); - world.add(Arc::new(Sphere { center, radius: 0.2, material: sphere_material })); + world.add(Arc::new(Sphere { + center, + radius: 0.2, + material: sphere_material, + })); } else if choose_mat < 0.95 { let albedo = Color::random_in_range(0.5, 1.0); let fuzz = rand::random::() / 2.0; sphere_material = Arc::new(Metal { albedo, fuzz }); - world.add(Arc::new(Sphere { center, radius: 0.2, material: sphere_material })); + world.add(Arc::new(Sphere { + center, + radius: 0.2, + material: sphere_material, + })); } else { - sphere_material = Arc::new(Dielectric { index_of_refraction: 1.5, attenuation: Some(DielectricAttenuation { albedo: Color { x: 0.5, y: 0.5, z: 0.8 }, constant: 0.8 } ) }); - world.add(Arc::new(Sphere { center, radius: 0.2, material: sphere_material })); + sphere_material = Arc::new(Dielectric { + index_of_refraction: 1.5, + attenuation: Some(DielectricAttenuation { + albedo: Color { + x: 0.5, + y: 0.5, + z: 0.8, + }, + constant: 0.8, + }), + }); + world.add(Arc::new(Sphere { + center, + radius: 0.2, + material: sphere_material, + })); } } } } - let material1 = Arc::new(Dielectric { index_of_refraction: 1.5, attenuation: Some(DielectricAttenuation { albedo: Color { x: 0.5, y: 0.5, z: 0.8 }, constant: 0.8 } ) }); - world.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: 1.0, z: 0.0 }, radius: 1.0, material: material1 })); - - let material2 = Arc::new(Lambertian { albedo: Arc::new(SolidColor::from_color(Color { x: 0.4, y: 0.2, z: 0.1 })) }); - world.add(Arc::new(Sphere { center: Point3 { x: -4.0, y: 1.0, z: 0.0 }, radius: 1.0, material: material2 })); - - let material3 = Arc::new(Metal { albedo: Color { x: 0.7, y: 0.6, z: 0.5 }, fuzz: 0.0 }); - world.add(Arc::new(Sphere { center: Point3 { x: 4.0, y: 1.0, z: 0.0 }, radius: 1.0, material: material3 })); - - (Arc::new(BVHNode::new(&world, 0.0, 1.0)), Point3 { x: 13.0, y: 2.0, z: 3.0}, Point3::new(), 20.0, 0.1, Color { x: 0.7, y: 0.8, z: 1.0 }) + let material1 = Arc::new(Dielectric { + index_of_refraction: 1.5, + attenuation: Some(DielectricAttenuation { + albedo: Color { + x: 0.5, + y: 0.5, + z: 0.8, + }, + constant: 0.8, + }), + }); + world.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: 1.0, + z: 0.0, + }, + radius: 1.0, + material: material1, + })); + + let material2 = Arc::new(Lambertian { + albedo: Arc::new(SolidColor::from_color(Color { + x: 0.4, + y: 0.2, + z: 0.1, + })), + }); + world.add(Arc::new(Sphere { + center: Point3 { + x: -4.0, + y: 1.0, + z: 0.0, + }, + radius: 1.0, + material: material2, + })); + + let material3 = Arc::new(Metal { + albedo: Color { + x: 0.7, + y: 0.6, + z: 0.5, + }, + fuzz: 0.0, + }); + world.add(Arc::new(Sphere { + center: Point3 { + x: 4.0, + y: 1.0, + z: 0.0, + }, + radius: 1.0, + material: material3, + })); + + ( + Arc::new(BVHNode::new(&world, 0.0, 1.0)), + Point3 { + x: 13.0, + y: 2.0, + z: 3.0, + }, + Point3::new(), + 20.0, + 0.1, + Color { + x: 0.7, + y: 0.8, + z: 1.0, + }, + ) } fn two_spheres() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); - let checker = Arc::new(Lambertian { albedo: Arc::new(CheckerTexture::from_colors(Color { x: 0.2, y: 0.3, z: 0.1 } , Color { x: 0.9, y: 0.9, z: 0.9 })) }); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: -10.0, z: 0.0 }, radius: 10.0, material: checker.clone() })); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: 10.0, z: 0.0 }, radius: 10.0, material: checker })); - (Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 13.0, y: 2.0, z: 3.0}, Point3::new(), 20.0, 0.0, Color { x: 0.7, y: 0.8, z: 1.0 }) + let checker = Arc::new(Lambertian { + albedo: Arc::new(CheckerTexture::from_colors( + Color { + x: 0.2, + y: 0.3, + z: 0.1, + }, + Color { + x: 0.9, + y: 0.9, + z: 0.9, + }, + )), + }); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: -10.0, + z: 0.0, + }, + radius: 10.0, + material: checker.clone(), + })); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: 10.0, + z: 0.0, + }, + radius: 10.0, + material: checker, + })); + ( + Arc::new(BVHNode::new(&objects, 0.0, 1.0)), + Point3 { + x: 13.0, + y: 2.0, + z: 3.0, + }, + Point3::new(), + 20.0, + 0.0, + Color { + x: 0.7, + y: 0.8, + z: 1.0, + }, + ) } fn two_perlin_spheres() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); - let pertext = Arc::new(Lambertian { albedo: Arc::new(NoiseTexture::new(4.0)) }); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: -1000.0, z: 0.0 }, radius: 1000.0, material: pertext.clone() })); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: 2.0, z: 0.0 }, radius: 2.0, material: pertext.clone() })); - (Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 13.0, y: 2.0, z: 3.0}, Point3::new(), 20.0, 0.0, Color { x: 0.7, y: 0.8, z: 1.0 }) + let pertext = Arc::new(Lambertian { + albedo: Arc::new(NoiseTexture::new(4.0)), + }); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: -1000.0, + z: 0.0, + }, + radius: 1000.0, + material: pertext.clone(), + })); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: 2.0, + z: 0.0, + }, + radius: 2.0, + material: pertext.clone(), + })); + ( + Arc::new(BVHNode::new(&objects, 0.0, 1.0)), + Point3 { + x: 13.0, + y: 2.0, + z: 3.0, + }, + Point3::new(), + 20.0, + 0.0, + Color { + x: 0.7, + y: 0.8, + z: 1.0, + }, + ) } fn earth() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); - let earth_texture = Arc::new(ImageTexture::from_bmp_data(&include_bytes!("../res/earthmap.bmp").to_vec())); - let earth_surface = Arc::new(Lambertian { albedo: earth_texture }); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: 0.0, z: 0.0 }, radius: 2.0, material: earth_surface })); - (Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 13.0, y: 2.0, z: 3.0}, Point3::new(), 20.0, 0.0, Color { x: 0.7, y: 0.8, z: 1.0 }) + let earth_texture = Arc::new(ImageTexture::from_bmp_data( + &include_bytes!("../res/earthmap.bmp").to_vec(), + )); + let earth_surface = Arc::new(Lambertian { + albedo: earth_texture, + }); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + radius: 2.0, + material: earth_surface, + })); + ( + Arc::new(BVHNode::new(&objects, 0.0, 1.0)), + Point3 { + x: 13.0, + y: 2.0, + z: 3.0, + }, + Point3::new(), + 20.0, + 0.0, + Color { + x: 0.7, + y: 0.8, + z: 1.0, + }, + ) } fn simple_light() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); - let pertext = Arc::new(Lambertian { albedo: Arc::new(NoiseTexture::new(4.0)) }); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: -1000.0, z: 0.0 }, radius: 1000.0, material: pertext.clone() })); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: 2.0, z: 0.0 }, radius: 2.0, material: pertext.clone() })); - let diff_light = Arc::new(DiffuseLight::from_color(Color { x: 4.0, y: 4.0, z: 4.0 })); - objects.add(Arc::new(XYRect { material: diff_light, x0: 3.0, x1: 5.0, y0: 1.0, y1: 3.0, k: -2.0 })); - (Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 26.0, y: 3.0, z: 6.0}, Point3 { x: 0.0, y: 2.0, z: 0.0}, 20.0, 0.0, Color::new()) + let pertext = Arc::new(Lambertian { + albedo: Arc::new(NoiseTexture::new(4.0)), + }); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: -1000.0, + z: 0.0, + }, + radius: 1000.0, + material: pertext.clone(), + })); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: 2.0, + z: 0.0, + }, + radius: 2.0, + material: pertext.clone(), + })); + let diff_light = Arc::new(DiffuseLight::from_color(Color { + x: 4.0, + y: 4.0, + z: 4.0, + })); + objects.add(Arc::new(XYRect { + material: diff_light, + x0: 3.0, + x1: 5.0, + y0: 1.0, + y1: 3.0, + k: -2.0, + })); + ( + Arc::new(BVHNode::new(&objects, 0.0, 1.0)), + Point3 { + x: 26.0, + y: 3.0, + z: 6.0, + }, + Point3 { + x: 0.0, + y: 2.0, + z: 0.0, + }, + 20.0, + 0.0, + Color::new(), + ) } fn cornell_box() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); - let red = Arc::new(Lambertian::from_color(Color { x: 0.65, y: 0.05, z: 0.05 })); - let white = Arc::new(Lambertian::from_color(Color { x: 0.73, y: 0.73, z: 0.73 })); - let green = Arc::new(Lambertian::from_color(Color { x: 0.12, y: 0.45, z: 0.15 })); - let light = Arc::new(DiffuseLight::from_color(Color { x: 15.0, y: 15.0, z: 15.0 })); - - objects.add(Arc::new(YZRect { material: green, y0: 0.0, y1: 555.0, z0: 0.0, z1: 555.0, k: 555.0 })); - objects.add(Arc::new(YZRect { material: red, y0: 0.0, y1: 555.0, z0: 0.0, z1: 555.0, k: 0.0 })); - objects.add(Arc::new(XZRect { material: light, x0: 213.0, x1: 343.0, z0: 227.0, z1: 332.0, k: 554.0 })); - objects.add(Arc::new(XZRect { material: white.clone(), x0: 0.0, x1: 555.0, z0: 0.0, z1: 555.0, k: 0.0 })); - objects.add(Arc::new(XZRect { material: white.clone(), x0: 0.0, x1: 555.0, z0: 0.0, z1: 555.0, k: 555.0 })); - objects.add(Arc::new(XYRect { material: white.clone(), x0: 0.0, x1: 555.0, y0: 0.0, y1: 555.0, k: 555.0 })); + let red = Arc::new(Lambertian::from_color(Color { + x: 0.65, + y: 0.05, + z: 0.05, + })); + let white = Arc::new(Lambertian::from_color(Color { + x: 0.73, + y: 0.73, + z: 0.73, + })); + let green = Arc::new(Lambertian::from_color(Color { + x: 0.12, + y: 0.45, + z: 0.15, + })); + let light = Arc::new(DiffuseLight::from_color(Color { + x: 15.0, + y: 15.0, + z: 15.0, + })); + + objects.add(Arc::new(YZRect { + material: green, + y0: 0.0, + y1: 555.0, + z0: 0.0, + z1: 555.0, + k: 555.0, + })); + objects.add(Arc::new(YZRect { + material: red, + y0: 0.0, + y1: 555.0, + z0: 0.0, + z1: 555.0, + k: 0.0, + })); + objects.add(Arc::new(XZRect { + material: light, + x0: 213.0, + x1: 343.0, + z0: 227.0, + z1: 332.0, + k: 554.0, + })); + objects.add(Arc::new(XZRect { + material: white.clone(), + x0: 0.0, + x1: 555.0, + z0: 0.0, + z1: 555.0, + k: 0.0, + })); + objects.add(Arc::new(XZRect { + material: white.clone(), + x0: 0.0, + x1: 555.0, + z0: 0.0, + z1: 555.0, + k: 555.0, + })); + objects.add(Arc::new(XYRect { + material: white.clone(), + x0: 0.0, + x1: 555.0, + y0: 0.0, + y1: 555.0, + k: 555.0, + })); //objects.add(Arc::new(HittableBox::new(Point3 { x: 130.0, y: 0.0, z: 65.0 }, Point3 { x: 295.0, y: 165.0, z: 230.0 }, white.clone()))); //objects.add(Arc::new(HittableBox::new(Point3 { x: 265.0, y: 0.0, z: 295.0 }, Point3 { x: 430.0, y: 330.0, z: 460.0 }, white.clone()))); - let box_1 = Arc::new(HittableBox::new(Point3 { x: 0.0, y: 0.0, z: 0.0 }, Point3 { x: 165.0, y: 330.0, z: 165.0 }, white.clone())); + let box_1 = Arc::new(HittableBox::new( + Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + Point3 { + x: 165.0, + y: 330.0, + z: 165.0, + }, + white.clone(), + )); let box_1 = Arc::new(RotateY::new(box_1, 15.0)); - let box_1 = Arc::new(Translate { hittable: box_1, offset: Point3 { x: 265.0, y: 0.0, z: 295.0 } }); + let box_1 = Arc::new(Translate { + hittable: box_1, + offset: Point3 { + x: 265.0, + y: 0.0, + z: 295.0, + }, + }); objects.add(box_1); - let box_2 = Arc::new(HittableBox::new(Point3 { x: 0.0, y: 0.0, z: 0.0 }, Point3 { x: 165.0, y: 165.0, z: 165.0 }, white.clone())); + let box_2 = Arc::new(HittableBox::new( + Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + Point3 { + x: 165.0, + y: 165.0, + z: 165.0, + }, + white.clone(), + )); let box_2 = Arc::new(RotateY::new(box_2, -18.0)); - let box_2 = Arc::new(Translate { hittable: box_2, offset: Point3 { x: 130.0, y: 0.0, z: 65.0 } }); + let box_2 = Arc::new(Translate { + hittable: box_2, + offset: Point3 { + x: 130.0, + y: 0.0, + z: 65.0, + }, + }); objects.add(box_2); - (Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 278.0, y: 278.0, z: -800.0}, Point3 { x: 278.0, y: 278.0, z: 0.0}, 40.0, 0.0, Color::new()) + ( + Arc::new(BVHNode::new(&objects, 0.0, 1.0)), + Point3 { + x: 278.0, + y: 278.0, + z: -800.0, + }, + Point3 { + x: 278.0, + y: 278.0, + z: 0.0, + }, + 40.0, + 0.0, + Color::new(), + ) } fn cornell_smoke() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); - let red = Arc::new(Lambertian::from_color(Color { x: 0.65, y: 0.05, z: 0.05 })); - let white = Arc::new(Lambertian::from_color(Color { x: 0.73, y: 0.73, z: 0.73 })); - let green = Arc::new(Lambertian::from_color(Color { x: 0.12, y: 0.45, z: 0.15 })); - let light = Arc::new(DiffuseLight::from_color(Color { x: 7.0, y: 7.0, z: 7.0 })); - - objects.add(Arc::new(YZRect { material: green, y0: 0.0, y1: 555.0, z0: 0.0, z1: 555.0, k: 555.0 })); - objects.add(Arc::new(YZRect { material: red, y0: 0.0, y1: 555.0, z0: 0.0, z1: 555.0, k: 0.0 })); - objects.add(Arc::new(XZRect { material: light, x0: 113.0, x1: 443.0, z0: 127.0, z1: 432.0, k: 554.0 })); - objects.add(Arc::new(XZRect { material: white.clone(), x0: 0.0, x1: 555.0, z0: 0.0, z1: 555.0, k: 0.0 })); - objects.add(Arc::new(XZRect { material: white.clone(), x0: 0.0, x1: 555.0, z0: 0.0, z1: 555.0, k: 555.0 })); - objects.add(Arc::new(XYRect { material: white.clone(), x0: 0.0, x1: 555.0, y0: 0.0, y1: 555.0, k: 555.0 })); + let red = Arc::new(Lambertian::from_color(Color { + x: 0.65, + y: 0.05, + z: 0.05, + })); + let white = Arc::new(Lambertian::from_color(Color { + x: 0.73, + y: 0.73, + z: 0.73, + })); + let green = Arc::new(Lambertian::from_color(Color { + x: 0.12, + y: 0.45, + z: 0.15, + })); + let light = Arc::new(DiffuseLight::from_color(Color { + x: 7.0, + y: 7.0, + z: 7.0, + })); + + objects.add(Arc::new(YZRect { + material: green, + y0: 0.0, + y1: 555.0, + z0: 0.0, + z1: 555.0, + k: 555.0, + })); + objects.add(Arc::new(YZRect { + material: red, + y0: 0.0, + y1: 555.0, + z0: 0.0, + z1: 555.0, + k: 0.0, + })); + objects.add(Arc::new(XZRect { + material: light, + x0: 113.0, + x1: 443.0, + z0: 127.0, + z1: 432.0, + k: 554.0, + })); + objects.add(Arc::new(XZRect { + material: white.clone(), + x0: 0.0, + x1: 555.0, + z0: 0.0, + z1: 555.0, + k: 0.0, + })); + objects.add(Arc::new(XZRect { + material: white.clone(), + x0: 0.0, + x1: 555.0, + z0: 0.0, + z1: 555.0, + k: 555.0, + })); + objects.add(Arc::new(XYRect { + material: white.clone(), + x0: 0.0, + x1: 555.0, + y0: 0.0, + y1: 555.0, + k: 555.0, + })); //objects.add(Arc::new(HittableBox::new(Point3 { x: 130.0, y: 0.0, z: 65.0 }, Point3 { x: 295.0, y: 165.0, z: 230.0 }, white.clone()))); //objects.add(Arc::new(HittableBox::new(Point3 { x: 265.0, y: 0.0, z: 295.0 }, Point3 { x: 430.0, y: 330.0, z: 460.0 }, white.clone()))); - let box_1 = Arc::new(HittableBox::new(Point3 { x: 0.0, y: 0.0, z: 0.0 }, Point3 { x: 165.0, y: 330.0, z: 165.0 }, white.clone())); + let box_1 = Arc::new(HittableBox::new( + Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + Point3 { + x: 165.0, + y: 330.0, + z: 165.0, + }, + white.clone(), + )); let box_1 = Arc::new(RotateY::new(box_1, 15.0)); - let box_1 = Arc::new(Translate { hittable: box_1, offset: Point3 { x: 265.0, y: 0.0, z: 295.0 } }); - let box_2 = Arc::new(HittableBox::new(Point3 { x: 0.0, y: 0.0, z: 0.0 }, Point3 { x: 165.0, y: 165.0, z: 165.0 }, white.clone())); + let box_1 = Arc::new(Translate { + hittable: box_1, + offset: Point3 { + x: 265.0, + y: 0.0, + z: 295.0, + }, + }); + let box_2 = Arc::new(HittableBox::new( + Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + Point3 { + x: 165.0, + y: 165.0, + z: 165.0, + }, + white.clone(), + )); let box_2 = Arc::new(RotateY::new(box_2, -18.0)); - let box_2 = Arc::new(Translate { hittable: box_2, offset: Point3 { x: 130.0, y: 0.0, z: 65.0 } }); - - objects.add(Arc::new(ConstantMedium::new(box_1, 0.01, Arc::new(SolidColor::from_color(Color { x: 0.0, y: 0.0, z: 0.0 }))))); - objects.add(Arc::new(ConstantMedium::new(box_2, 0.01, Arc::new(SolidColor::from_color(Color { x: 1.0, y: 1.0, z: 1.0 }))))); - - (Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 278.0, y: 278.0, z: -800.0}, Point3 { x: 278.0, y: 278.0, z: 0.0}, 40.0, 0.0, Color::new()) + let box_2 = Arc::new(Translate { + hittable: box_2, + offset: Point3 { + x: 130.0, + y: 0.0, + z: 65.0, + }, + }); + + objects.add(Arc::new(ConstantMedium::new( + box_1, + 0.01, + Arc::new(SolidColor::from_color(Color { + x: 0.0, + y: 0.0, + z: 0.0, + })), + ))); + objects.add(Arc::new(ConstantMedium::new( + box_2, + 0.01, + Arc::new(SolidColor::from_color(Color { + x: 1.0, + y: 1.0, + z: 1.0, + })), + ))); + + ( + Arc::new(BVHNode::new(&objects, 0.0, 1.0)), + Point3 { + x: 278.0, + y: 278.0, + z: -800.0, + }, + Point3 { + x: 278.0, + y: 278.0, + z: 0.0, + }, + 40.0, + 0.0, + Color::new(), + ) } fn final_scene() -> (Arc, Point3, Point3, f64, f64, Color) { let mut boxes_1 = HittableList::new(); - let ground = Arc::new(Lambertian::from_color(Color { x: 0.48, y: 0.83, z: 0.53 })); + let ground = Arc::new(Lambertian::from_color(Color { + x: 0.48, + y: 0.83, + z: 0.53, + })); const BOXES_PER_SIDE: usize = 20; for i in 0..BOXES_PER_SIDE { @@ -183,70 +691,310 @@ fn final_scene() -> (Arc, Point3, Point3, f64, f64, Color) { let x1 = x0 + w; let y1 = 1.0 + 100.0 * rand::random::(); let z1 = z0 + w; - boxes_1.add(Arc::new(HittableBox::new(Point3 { x: x0, y: y0, z: z0 }, Point3 { x: x1, y: y1, z: z1 }, ground.clone()))); + boxes_1.add(Arc::new(HittableBox::new( + Point3 { + x: x0, + y: y0, + z: z0, + }, + Point3 { + x: x1, + y: y1, + z: z1, + }, + ground.clone(), + ))); } } let mut objects = HittableList::new(); objects.add(Arc::new(BVHNode::new(&boxes_1, 0.0, 1.0))); - let light = Arc::new(DiffuseLight::from_color(Color { x: 7.0, y: 7.0, z: 7.0 })); - objects.add(Arc::new(XZRect { material: light.clone(), x0: 123.0, x1: 423.0, z0: 147.0, z1: 412.0, k: 554.0 })); - - let center_1 = Point3 { x: 400.0, y: 400.0, z: 200.0 }; - let center_2 = ¢er_1 + Vec3 { x: 30.0, y: 0.0, z: 0.0 }; - - let moving_sphere_material = Arc::new(Lambertian::from_color(Color { x: 0.7, y: 0.3, z: 0.1 })); - objects.add(Arc::new(Moving { hittable: Arc::new(Sphere { center: Point3::new(), radius: 50.0, material: moving_sphere_material }), offset_start: center_1, offset_end: center_2, time_start: 0.0, time_end: 1.0, })); - - objects.add(Arc::new(Sphere { center: Point3 { x: 260.0, y: 150.0, z: 45.0 }, radius: 50.0, material: Arc::new(Dielectric { index_of_refraction: 1.5, attenuation: None }) })); - objects.add(Arc::new(Sphere { center: Point3 { x: 0.0, y: 150.0, z: 145.0 }, radius: 50.0, material: Arc::new(Metal { albedo: Color { x: 0.8, y: 0.8, z: 0.9 }, fuzz: 1.0 }) })); - - let boundary = Arc::new(Sphere { center: Point3 { x: 360.0, y: 150.0, z: 145.0 }, radius: 70.0, material: Arc::new(Dielectric { index_of_refraction: 1.5, attenuation: None }) }); + let light = Arc::new(DiffuseLight::from_color(Color { + x: 7.0, + y: 7.0, + z: 7.0, + })); + objects.add(Arc::new(XZRect { + material: light.clone(), + x0: 123.0, + x1: 423.0, + z0: 147.0, + z1: 412.0, + k: 554.0, + })); + + let center_1 = Point3 { + x: 400.0, + y: 400.0, + z: 200.0, + }; + let center_2 = ¢er_1 + + Vec3 { + x: 30.0, + y: 0.0, + z: 0.0, + }; + + let moving_sphere_material = Arc::new(Lambertian::from_color(Color { + x: 0.7, + y: 0.3, + z: 0.1, + })); + objects.add(Arc::new(Moving { + hittable: Arc::new(Sphere { + center: Point3::new(), + radius: 50.0, + material: moving_sphere_material, + }), + offset_start: center_1, + offset_end: center_2, + time_start: 0.0, + time_end: 1.0, + })); + + objects.add(Arc::new(Sphere { + center: Point3 { + x: 260.0, + y: 150.0, + z: 45.0, + }, + radius: 50.0, + material: Arc::new(Dielectric { + index_of_refraction: 1.5, + attenuation: None, + }), + })); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: 150.0, + z: 145.0, + }, + radius: 50.0, + material: Arc::new(Metal { + albedo: Color { + x: 0.8, + y: 0.8, + z: 0.9, + }, + fuzz: 1.0, + }), + })); + + let boundary = Arc::new(Sphere { + center: Point3 { + x: 360.0, + y: 150.0, + z: 145.0, + }, + radius: 70.0, + material: Arc::new(Dielectric { + index_of_refraction: 1.5, + attenuation: None, + }), + }); objects.add(boundary.clone()); - objects.add(Arc::new(ConstantMedium::new(boundary.clone(), 0.2, Arc::new(SolidColor::from_color(Color { x: 0.2, y: 0.4, z: 0.9 }))))); - let boundary = Arc::new(Sphere { center: Point3 { x: 0.0, y: 0.0, z: 0.0 }, radius: 5000.0, material: Arc::new(Dielectric { index_of_refraction: 1.5, attenuation: None }) }); - objects.add(Arc::new(ConstantMedium::new(boundary.clone(), 0.0001, Arc::new(SolidColor::from_color(Color { x: 1.0, y: 1.0, z: 1.0 }))))); - - let emat = Arc::new(Lambertian { albedo: Arc::new(ImageTexture::from_bmp_data(&include_bytes!("../res/earthmap.bmp").to_vec())) }); - objects.add(Arc::new(Sphere { center: Point3 { x: 400.0, y: 200.0, z: 400.0 }, radius: 100.0, material: emat })); - let pertext = Arc::new(Lambertian { albedo: Arc::new(NoiseTexture::new(0.1)) }); - objects.add(Arc::new(Sphere { center: Point3 { x: 220.0, y: 280.0, z: 300.0 }, radius: 80.0, material: pertext })); + objects.add(Arc::new(ConstantMedium::new( + boundary.clone(), + 0.2, + Arc::new(SolidColor::from_color(Color { + x: 0.2, + y: 0.4, + z: 0.9, + })), + ))); + let boundary = Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + radius: 5000.0, + material: Arc::new(Dielectric { + index_of_refraction: 1.5, + attenuation: None, + }), + }); + objects.add(Arc::new(ConstantMedium::new( + boundary.clone(), + 0.0001, + Arc::new(SolidColor::from_color(Color { + x: 1.0, + y: 1.0, + z: 1.0, + })), + ))); + + let emat = Arc::new(Lambertian { + albedo: Arc::new(ImageTexture::from_bmp_data( + &include_bytes!("../res/earthmap.bmp").to_vec(), + )), + }); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 400.0, + y: 200.0, + z: 400.0, + }, + radius: 100.0, + material: emat, + })); + let pertext = Arc::new(Lambertian { + albedo: Arc::new(NoiseTexture::new(0.1)), + }); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 220.0, + y: 280.0, + z: 300.0, + }, + radius: 80.0, + material: pertext, + })); let mut boxes_2 = HittableList::new(); - let white = Arc::new(Lambertian::from_color(Color { x: 0.73, y: 0.73, z: 0.73 })); + let white = Arc::new(Lambertian::from_color(Color { + x: 0.73, + y: 0.73, + z: 0.73, + })); for _ in 0..1000 { - boxes_2.add(Arc::new(Sphere { center: Point3::random_in_range(0.0, 165.0), radius: 10.0, material: white.clone() })); + boxes_2.add(Arc::new(Sphere { + center: Point3::random_in_range(0.0, 165.0), + radius: 10.0, + material: white.clone(), + })); } - objects.add(Arc::new(Translate { hittable: Arc::new(RotateY::new(Arc::new(BVHNode::new(&boxes_2, 0.0, 1.0)), 15.0)), offset: Vec3 { x: -100.0, y: 270.0, z: 395.0 } })); - (Arc::new(objects), Point3 { x: 478.0, y: 278.0, z: -600.0}, Point3 { x: 278.0, y: 278.0, z: 0.0}, 40.0, 0.0, Color::new()) + objects.add(Arc::new(Translate { + hittable: Arc::new(RotateY::new( + Arc::new(BVHNode::new(&boxes_2, 0.0, 1.0)), + 15.0, + )), + offset: Vec3 { + x: -100.0, + y: 270.0, + z: 395.0, + }, + })); + ( + Arc::new(objects), + Point3 { + x: 478.0, + y: 278.0, + z: -600.0, + }, + Point3 { + x: 278.0, + y: 278.0, + z: 0.0, + }, + 40.0, + 0.0, + Color::new(), + ) } fn test_scene() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); //let earth_texture = Arc::new(ImageTexture::from_bmp_data(&include_bytes!("../res/earthmap.bmp").to_vec())); //let earth_surface = Arc::new(Lambertian { albedo: earth_texture }); - let pertext = Arc::new(Lambertian { albedo: Arc::new(NoiseTexture::new(4.0)) }); - objects.add(Arc::new(XZRect { material: pertext, x0: -f64::INFINITY, x1: f64::INFINITY, z0: -f64::INFINITY, z1: f64::INFINITY, k: 0.0 })); + let pertext = Arc::new(Lambertian { + albedo: Arc::new(NoiseTexture::new(4.0)), + }); + objects.add(Arc::new(XZRect { + material: pertext, + x0: -f64::INFINITY, + x1: f64::INFINITY, + z0: -f64::INFINITY, + z1: f64::INFINITY, + k: 0.0, + })); //(Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 13.0, y: 2.0, z: 3.0}, Point3::new(), 20.0, 0.0, Color { x: 0.7, y: 0.8, z: 1.0 }) - (Arc::new(objects), Point3 { x: 13.0, y: 2.0, z: 3.0}, Point3::new(), 20.0, 0.0, Color { x: 0.7, y: 0.8, z: 1.0 }) + ( + Arc::new(objects), + Point3 { + x: 13.0, + y: 2.0, + z: 3.0, + }, + Point3::new(), + 20.0, + 0.0, + Color { + x: 0.7, + y: 0.8, + z: 1.0, + }, + ) } fn triangle_scene() -> (Arc, Point3, Point3, f64, f64, Color) { let mut objects = HittableList::new(); - let checker = Arc::new(CheckerTexture::from_colors(Color { x: 0.2, y: 0.3, z: 0.1 } , Color { x: 0.9, y: 0.9, z: 0.9 })); + let checker = Arc::new(CheckerTexture::from_colors( + Color { + x: 0.2, + y: 0.3, + z: 0.1, + }, + Color { + x: 0.9, + y: 0.9, + z: 0.9, + }, + )); let ground_material = Arc::new(Lambertian { albedo: checker }); - objects.add(Arc::new(Sphere{ center: Point3 { x: 0.0, y: -1001.0, z: 0.0 }, radius: 1000.0, material: ground_material })); + objects.add(Arc::new(Sphere { + center: Point3 { + x: 0.0, + y: -1001.0, + z: 0.0, + }, + radius: 1000.0, + material: ground_material, + })); //let pertext = Arc::new(Lambertian { albedo: Arc::new(NoiseTexture::new(4.0)) }); //let pertext = Arc::new(Lambertian { albedo: Arc::new(SolidColor::from_color(Color {x: 0.0, y: 0.0, z: 0.0}) ) }); //objects.add(Arc::new(Triangle { material: Arc::new(Metal { albedo: Color { x: 0.7, y: 0.6, z: 0.5 }, fuzz: 0.0 }), v0 : Vec3::new(), v1: Vec3 { x: 0.0, y: 0.0, z: 1.0 }, v2: Vec3 { x: 0.0, y: 1.0, z: 0.5 } })); - let monkey = Arc::new(Model::from_obj(include_str!("../res/monkey.obj"), Arc::new(Dielectric { index_of_refraction: 1.5, attenuation: Some(DielectricAttenuation { albedo: Color { x: 0.5, y: 0.5, z: 0.8 }, constant: 0.8 } ) }))); + let monkey = Arc::new(Model::from_obj( + include_str!("../res/monkey.obj"), + Arc::new(Dielectric { + index_of_refraction: 1.5, + attenuation: Some(DielectricAttenuation { + albedo: Color { + x: 0.5, + y: 0.5, + z: 0.8, + }, + constant: 0.8, + }), + }), + )); // let monkey = Arc::new(Model::from_obj(include_str!("../res/monkey.obj"), Arc::new(Metal { albedo: Color { x: 0.7, y: 0.6, z: 0.5 }, fuzz: 0.5 }))); let monkey = Arc::new(RotateX::new(monkey, 45.0)); let monkey = Arc::new(RotateZ::new(monkey, 45.0)); objects.add(monkey); //(Arc::new(objects), Point3 { x: 5.0, y: 5.0, z: 5.0}, Point3::new(), 20.0, 0.0, Color { x: 0.7, y: 0.8, z: 1.0 }) - (Arc::new(BVHNode::new(&objects, 0.0, 1.0)), Point3 { x: 5.0, y: 5.0, z: 5.0}, Point3 { x: 0.0, y: 0.0, z: 0.0}, 20.0, 0.0, Color { x: 0.7, y: 0.8, z: 1.0 }) + ( + Arc::new(BVHNode::new(&objects, 0.0, 1.0)), + Point3 { + x: 5.0, + y: 5.0, + z: 5.0, + }, + Point3 { + x: 0.0, + y: 0.0, + z: 0.0, + }, + 20.0, + 0.0, + Color { + x: 0.7, + y: 0.8, + z: 1.0, + }, + ) } diff --git a/src/texture/checker_texture.rs b/src/texture/checker_texture.rs index 385017b..d10166e 100644 --- a/src/texture/checker_texture.rs +++ b/src/texture/checker_texture.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use super::{Texture, SolidColor}; +use super::{SolidColor, Texture}; use crate::{vec3::Color, vec3::Point3}; pub struct CheckerTexture { diff --git a/src/texture/image_texture.rs b/src/texture/image_texture.rs index 763c3f0..d90b9b6 100644 --- a/src/texture/image_texture.rs +++ b/src/texture/image_texture.rs @@ -50,8 +50,12 @@ impl Texture for ImageTexture { let mut i = (u * self.width as f64) as usize; let mut j = (v * self.height as f64) as usize; - if i >= self.width { i = self.width - 1 }; - if j >= self.height { j = self.height - 1 }; + if i >= self.width { + i = self.width - 1 + }; + if j >= self.height { + j = self.height - 1 + }; let color_scale = 1.0 / 255.0; let pixel = j * self.bytes_per_scanline + i * BYTES_PER_PIXEL; Color { diff --git a/src/texture/noise_texture.rs b/src/texture/noise_texture.rs index 92ac166..7fe3cdb 100644 --- a/src/texture/noise_texture.rs +++ b/src/texture/noise_texture.rs @@ -1,4 +1,4 @@ -use super::{Texture, perlin::Perlin}; +use super::{perlin::Perlin, Texture}; use crate::{vec3::Color, vec3::Point3}; pub struct NoiseTexture { @@ -17,6 +17,11 @@ impl NoiseTexture { impl Texture for NoiseTexture { fn value(&self, _: f64, _: f64, p: &Point3) -> Color { - Color { x: 1.0, y: 1.0, z: 1.0 } * 0.5 * (1.0 + (self.scale * p.z + 10.0 * self.noise.turb(p, 7)).sin()) + Color { + x: 1.0, + y: 1.0, + z: 1.0, + } * 0.5 + * (1.0 + (self.scale * p.z + 10.0 * self.noise.turb(p, 7)).sin()) } } diff --git a/src/texture/perlin.rs b/src/texture/perlin.rs index 43d8f64..a796a43 100644 --- a/src/texture/perlin.rs +++ b/src/texture/perlin.rs @@ -1,4 +1,4 @@ -use crate::vec3::{Vec3, Point3}; +use crate::vec3::{Point3, Vec3}; const POINT_COUNT: usize = 256; @@ -55,7 +55,8 @@ impl Perlin { ^ self.perm_z.get(((k + dk as i32) & 255) as usize).unwrap()) as usize, ) - .unwrap().clone(); + .unwrap() + .clone(); } } } @@ -73,11 +74,15 @@ impl Perlin { let i_f = i as f64; let j_f = j as f64; let k_f = k as f64; - let weight_v = Vec3 { x: u - i_f, y: v - j_f, z: w - k_f }; - accum += (i_f * uu + (1.0 - i_f) * (1.0 - uu)) * - (j_f * vv + (1.0 - j_f) * (1.0 - vv)) * - (k_f * ww + (1.0 - k_f) * (1.0 - ww)) * - c[i][j][k].dot(&weight_v); + let weight_v = Vec3 { + x: u - i_f, + y: v - j_f, + z: w - k_f, + }; + accum += (i_f * uu + (1.0 - i_f) * (1.0 - uu)) + * (j_f * vv + (1.0 - j_f) * (1.0 - vv)) + * (k_f * ww + (1.0 - k_f) * (1.0 - ww)) + * c[i][j][k].dot(&weight_v); } } } diff --git a/src/texture/solid_color.rs b/src/texture/solid_color.rs index 3af46ca..1bbc463 100644 --- a/src/texture/solid_color.rs +++ b/src/texture/solid_color.rs @@ -7,9 +7,7 @@ pub struct SolidColor { impl SolidColor { pub fn from_color(color_value: Color) -> Self { - Self { - color_value, - } + Self { color_value } } } diff --git a/src/vec3.rs b/src/vec3.rs index 8525fdd..e2f253a 100644 --- a/src/vec3.rs +++ b/src/vec3.rs @@ -88,7 +88,7 @@ impl Vec3 { if p.length_squared() < 1.0 { return p; } - }; + } } pub fn random_unit_vector() -> Vec3 { @@ -98,8 +98,8 @@ impl Vec3 { pub fn random_in_unit_disk() -> Vec3 { loop { let p = Vec3 { - x: 2.0 * rand::random::() -1.0, - y: 2.0 * rand::random::() -1.0, + x: 2.0 * rand::random::() - 1.0, + y: 2.0 * rand::random::() - 1.0, z: 0.0, }; if p.length_squared() < 1.0 { @@ -166,7 +166,7 @@ impl<'a> Iterator for Vec3Iterator<'a> { } } -impl_op_ex!(- |a: &Vec3| -> Vec3 { +impl_op_ex!(-|a: &Vec3| -> Vec3 { Vec3 { x: -a.x, y: -a.y, -- cgit v1.2.3