diff options
Diffstat (limited to 'src')
33 files changed, 0 insertions, 2062 deletions
diff --git a/src/camera/camera.rs b/src/camera/camera.rs deleted file mode 100644 index 7f9e79d..0000000 --- a/src/camera/camera.rs +++ /dev/null @@ -1,135 +0,0 @@ -//! Generates rays from screen coordinates -//! -//! Generates rays in world space from screen coordinates. -//! Future versions should also simulate depth of field. -//! -//! # Examples -//! -//! ``` -//! use rendering::camera::{CameraSettings, Camera}; -//! use rendering::core::{Vector3f, Vector2f, Vector2i}; -//! use rendering::sample::UniformSampler; -//! -//! let set = CameraSettings { -//! origin: Vector3f::new(10.0), -//! target: Vector3f::new(0.0), -//! up: Vector3f::new_xyz(0.0, 1.0, 0.0), -//! fov: 90.0, -//! filmsize: Vector2i::new(10), -//! focus: None, -//! aperture: None, -//! }; -//! -//! let cam = Camera::new(&set); -//! let mut sampler = UniformSampler::new(); -//! -//! let (r, _) = cam.generate_ray(&Vector2f::new(5.0), &mut sampler); -//! let dir = r.direction; -//! -//! assert!( -//! dir.x == -0.6031558065478413 && -//! dir.y == -0.6599739684616743 && -//! dir.z == -0.4479257014065748 -//! ); -//! -//! ``` -use crate::Float; -use crate::core::{Vector3f, Vector2f, Vector2i, Ray}; -use crate::sample::Sampler; - -/// A simple perspective camera -pub struct Camera { - /// The camera origin in the screen - origin: Vector3f, - /// Vector from camera origin to the screen lower left corner of the film plane - screen_origin: Vector3f, - /// Scaling vectors from screen_origin - qx: Vector3f, - qy: Vector3f, - - /// Value for depth of view - lens_radius: Option<Float>, -} - -/// Settings for initializing camera -pub struct CameraSettings { - /// Where rays originate from - pub origin: Vector3f, - /// Point where center of image is pointed at - pub target: Vector3f, - /// Vector that will be up in the resulting image - pub up: Vector3f, - /// The vertical field of view in degrees. - /// Currently must be between [0; 180[. - pub fov: Float, - /// The film aspect ratio, height / width - pub filmsize: Vector2i, - /// The lens aperture - /// - /// Depth of view is disabled if None - pub aperture: Option<Float>, - /// The distance to the focus plane - /// - /// if None it will be set to the distance between origin and target - pub focus: Option<Float>, -} - -impl Camera { - /// Create a new camera look at a target - pub fn new(set: &CameraSettings) -> Camera { - let filmsize = Vector2f::from(set.filmsize); - // Calculate translation vectors - let mut forward = set.target - set.origin; - - let focus = set.focus.unwrap_or_else(|| forward.length()); - - forward.norm_in(); - - let right = set.up.cross(&forward).norm(); - let newup = forward.cross(&right).norm(); - - let aspect = (filmsize.y) / (filmsize.x); - // Calculate screen size from fov and focus distance - let width = 2.0 * focus * (set.fov / 2.0).to_radians().tan(); - let height = aspect * width; - - // Calculate screen scaling vectors - let qx = right * (width / (filmsize.x - 1.0)); - let qy = newup * (height / (filmsize.y - 1.0)); - - let screen_origin = forward * focus - (right * (width/2.0)) + (newup * (height/2.0)); - - Camera { - origin: set.origin, - screen_origin, - qx, - qy, - lens_radius: set.aperture.map(|a| a / 2.0), - } - } - - /// Generates a ray a screen space point - /// - /// The point coordinates should be between [0,1) with (0, 0) being the upper left corner - /// - /// Will return a ray and a weight - /// - /// The direction of the returned way is normalized - pub fn generate_ray(&self, point: &Vector2f, sampler: &mut dyn Sampler) -> (Ray, Float) { - // Depth of view origin offset - let ooffset = match self.lens_radius { - Some(r) => { - let rand_dir = sampler.get_in_circle() * r; - self.qx * rand_dir.x + self.qy * rand_dir.y - }, - None => Vector3f::ZERO, - }; - - let dir = self.screen_origin + (self.qx * point.x) - (self.qy * point.y) - ooffset; - - ( - Ray { origin: self.origin + ooffset, direction: dir.norm() }, - 1.0 - ) - } -} diff --git a/src/camera/film.rs b/src/camera/film.rs deleted file mode 100644 index 852ae9e..0000000 --- a/src/camera/film.rs +++ /dev/null @@ -1,145 +0,0 @@ -use crate::core::*; -use crate::Float; -use image::{RgbImage, Rgb}; - -/// Contains the necesary values when doing calculations -/// -/// This is not the final RGB value -#[derive(Clone)] -pub struct Pixel { - /// The sum of the collected samples - rgb: Spectrum, - /// The amount of samples collected - samples: u32, -} - -pub struct Film { - pub size: Vector2i, - pub frame: Bound2i, - - pixels: Vec<Pixel>, -} - -/// FilmTile is a small version of the Film used when rendering -/// -/// This means that multiple threads can work on the same area and commit their changed when they -/// are done. -pub struct FilmTile { - pub bounds: Bound2i, - pub size: Vector2i, - - pixels: Vec<Pixel>, -} - -impl Pixel { - fn new() -> Pixel { - Pixel { - rgb: Default::default(), - samples: 0, - } - } - - fn add(&mut self, c: &Spectrum, weight: Float) { - self.rgb += &(*c * weight); - self.samples += 1; - } - - fn finalize_rgb(&self) -> [u8; 3] { - let spc = (self.rgb / (self.samples as Float)).gamma_correct(); - let (r, g, b) = spc.to_rgb(255.0); - [ - r as u8, - g as u8, - b as u8, - ] - } -} - -impl std::ops::AddAssign<&Self> for Pixel { - fn add_assign(&mut self, op: &Self) { - self.rgb += &op.rgb; - self.samples += op.samples; - } -} - -impl Film { - pub fn new(size: Vector2i) -> Film { - let area = size.x * size.y; - Film { - size, - frame: Bound2i::new(&Vector2i::new(0), &size), - pixels: vec![Pixel::new(); area as usize], - } - } - - /// Creates a new FilmTile from the specified bounds - /// - /// This tile can later be commited with the commit_tile function - pub fn get_tile(&self, bound: &Bound2i) -> FilmTile { - FilmTile::new( - bound, - ) - - } - - /// Commit a tile back on the film - /// - /// This will lock the Film while the changes from the Tile is written - pub fn commit_tile(&mut self, tile: &FilmTile) { - let offset = tile.bounds.min; - - for y in 0 .. tile.size.y { - let rowindex = (offset.y + y) * self.size.x; - let prowindex = y * tile.size.x; - - for x in 0 .. tile.size.x { - let index = offset.x + x + rowindex; - let pindex: i32 = x + prowindex; - - self.pixels[index as usize] += &tile.pixels[pindex as usize]; - } - } - } - - pub fn finalize_image(&self) -> RgbImage { - let mut img = RgbImage::new(self.size.x as u32, self.size.y as u32); - - for y in 0..self.size.y { - let index = y * self.size.x; - for x in 0..self.size.x { - img.put_pixel( - x as u32, - y as u32, - Rgb(self.pixels[(index + x) as usize].finalize_rgb()), - ); - } - } - - img - } -} - -impl FilmTile { - fn new(bounds: &Bound2i) -> FilmTile { - FilmTile { - bounds: bounds.clone(), - pixels: vec![Pixel::new(); bounds.area() as usize], - size: bounds.diagonal(), - } - } - - /// Add a single sample sampled from the scene - pub fn add_sample(&mut self, inp: &Vector2f, c: Spectrum) { - let point = Vector2i::from(inp.floor()); - // Subtract the offset - let point = (point - self.bounds.min).cap(self.size.x-1, self.size.y-1); - - let index = point.x + point.y * self.size.x; - - if let Some(pixel) = self.pixels.get_mut(index as usize) { - pixel.add(&c, 1.0); - } else { - println!("Could not get pixel {} inp: {}, index: {}", point, inp, index); - } - } -} diff --git a/src/camera/filter/mod.rs b/src/camera/filter/mod.rs deleted file mode 100644 index 01d094c..0000000 --- a/src/camera/filter/mod.rs +++ /dev/null @@ -1,32 +0,0 @@ -use crate::vector::Vector2f; -use crate::Float; - -trait Eval { - fn eval(&self, point: &Vector2f) -> Float; -} - -pub struct Filter { - eval: Box<dyn Eval>, - pub radius: Vector2f, -} - -struct BoxFilter {} - -// The same a no filter, and can give aliasing in final image -impl Eval for BoxFilter { - fn eval(&self, _: &Vector2f) -> Float { - 1.0 - } -} - -impl Eval for Filter { - fn eval(&self, point: &Vector2f) -> Float { - self.eval.eval(point) - } -} - -impl Filter { - pub fn new_box(radius: Vector2f) -> Filter { - Filter { radius: radius, eval: Box::new(BoxFilter {}) } - } -} diff --git a/src/camera/mod.rs b/src/camera/mod.rs deleted file mode 100644 index 999b5b5..0000000 --- a/src/camera/mod.rs +++ /dev/null @@ -1,13 +0,0 @@ -//! Implements how light is captured on film and how rays are generated -//! -//! The Film module specifies how calculated spectrum values contribute to the final image. -//! -//! The Camera class generated rays that can be cast into the scene. -//! This requires converting the film coordinates into real coordinates - -pub mod film; -//pub mod filter; -mod camera; - -pub use camera::{Camera, CameraSettings}; -pub use film::Film; diff --git a/src/core/bound2.rs b/src/core/bound2.rs deleted file mode 100644 index bc0e7cd..0000000 --- a/src/core/bound2.rs +++ /dev/null @@ -1,127 +0,0 @@ -//! Implements a 2d axis aligned bounding box -use crate::{Number, Float}; -use super::vector2::Vector2; -use crate::core; -use crate::core::{min, max}; - -/// Implements a region between min and max -#[derive(Clone)] -pub struct Bound2<T: Number> { - pub min: Vector2<T>, - pub max: Vector2<T> -} - -pub type Bound2i = Bound2<i32>; -pub type Bound2f = Bound2<Float>; - -impl<T: Number> Bound2<T> { - /// Creates a new bound from two points - /// - /// p0 does not have to be smaller than p1 - pub fn new(p0: &Vector2<T>, p1: &Vector2<T>) -> Self { - let min = Vector2::new_xy(min(p0.x, p1.x), min(p0.y, p1.y)); - let max = Vector2::new_xy(max(p0.x, p1.x), max(p0.y, p1.y)); - - Self { min, max } - } - - pub fn new_xyxy(x1: T, y1: T, x2: T, y2: T) -> Self { - Self::new( - &Vector2::new_xy(x1, y1), - &Vector2::new_xy(x2, y2), - ) - } - - /// Finds the intersected area between two bounds - pub fn intersect(&self, b: &Bound2<T>) -> Bound2<T> { - Bound2::new( - &Vector2::new_xy(max(self.min.x, b.min.x), max(self.min.y, b.min.y)), - &Vector2::new_xy(min(self.max.x, b.max.x), min(self.max.y, b.max.y)), - ) - } - - - /// Calculates the diagonal vector - /// - /// Can be used to calculate the size of the bound - /// - /// # Examples - /// - /// ``` - /// use rendering::core::Bound2i; - /// let b = Bound2i::new_xyxy(2, 2, 6, 7); - /// let diag = b.diagonal(); - /// - /// assert!(diag.x == 4 && diag.y == 5); - /// ``` - pub fn diagonal(&self) -> Vector2<T> { - self.max - self.min - } - - /// Calculates the area of of the bounded region - /// - /// # Examples - /// - /// ``` - /// use rendering::core::Bound2i; - /// let b = Bound2i::new_xyxy(10, 10, 20, 20); - /// - /// assert!(b.area() == 100); - /// ``` - pub fn area(&self) -> T { - let diag = self.diagonal(); - diag.x * diag.y - } -} - -impl From<&Bound2i> for Bound2f { - fn from(b: &Bound2i) -> Self { - Self { - min: core::Vector2f::from(b.min), - max: core::Vector2f::from(b.max), - } - } -} - -impl From<&Bound2f> for Bound2i { - fn from(b: &Bound2f) -> Self { - Self { - min: core::Vector2i::from(b.min), - max: core::Vector2i::from(b.max), - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn create_test() -> Bound2<i32> { - Bound2::new( - &Vector2::new_xy(1, 2), - &Vector2::new_xy(10, 3) - ) - } - - #[test] - fn area() { - let b = create_test(); - - assert!(b.area() == 9); - } - - #[test] - fn intersect_test() { - let b1 = Bound2i::new_xyxy(10, 10, 20, 20); - let b2 = Bound2i::new_xyxy(2, 11, 22, 17); - - let b = b1.intersect(&b2); - - assert!( - b.min.x == 10 && - b.min.y == 11 && - b.max.x == 20 && - b.max.y == 17 - ) - } -} diff --git a/src/core/bound3.rs b/src/core/bound3.rs deleted file mode 100644 index ce6bb09..0000000 --- a/src/core/bound3.rs +++ /dev/null @@ -1,113 +0,0 @@ -//! Implements 3d axis aligned bounding box -use crate::{Number, Float}; -use super::vector3::{Vector3, Vector3f}; -use crate::core::{min, max}; -use crate::core::Ray; - -#[derive(Clone)] -pub struct Bound3<T: Number> { - pub min: Vector3<T>, - pub max: Vector3<T> -} - -pub type Bound3f = Bound3<Float>; - -impl<T: Number> Bound3<T> { - /// Creates a bound from two points - pub fn new(p0: Vector3<T>, p1: Vector3<T>) -> Self { - // Elliminate some code duplication here - let min = Vector3::new_xyz( - min(p0.x, p1.x), - min(p0.y, p1.y), - min(p0.z, p1.z) - ); - let max = Vector3::new_xyz( - max(p0.x, p1.x), - max(p0.y, p1.y), - max(p0.z, p1.z) - ); - - Self {min, max} - } - - pub fn combine(&self, op: &Self) -> Self { - let min = Vector3::new_xyz( - min(self.min.x, op.min.x), - min(self.min.y, op.min.y), - min(self.min.z, op.min.z) - ); - let max = Vector3::new_xyz( - max(self.max.x, op.max.x), - max(self.max.y, op.max.y), - max(self.max.z, op.max.z) - ); - - Self {min, max} - } - - pub fn and(&self, op: &Self) -> Self { - let min_b = Vector3::new_xyz( - max(self.min.x, op.min.x), - max(self.min.y, op.min.y), - max(self.min.z, op.min.z) - ); - let max_b = Vector3::new_xyz( - min(self.max.x, op.max.x), - min(self.max.y, op.max.y), - min(self.max.z, op.max.z) - ); - - Self {min: min_b, max: max_b} - } - - pub fn area(&self) -> T { - let diag = self.max - self.min; - diag.x * diag.y * diag.z - } -} - -impl Bound3f { - pub const EMPTY: Bound3f = Bound3f{min: Vector3f::ZERO, max: Vector3f::ZERO}; - - /// Calculate whether there is a intersect between a bounding box and a ray - /// - /// # Examples: - /// - /// ``` - /// use rendering::core::{Bound3f, Vector3f, Ray}; - /// use rendering::INFTY; - /// let b = Bound3f::new(Vector3f::new(7.0), Vector3f::new(10.0)); - /// let r1 = Ray::new_to(Vector3f::new(0.0), Vector3f::new(5.0)); - /// let r2 = Ray::new_to(Vector3f::new(-0.0), Vector3f::new(-5.0)); - /// let r3 = Ray::new(Vector3f::new_xyz(-1.0, 0.0, 0.0), Vector3f::new_xyz(1.0, 0.0, 0.0)); - /// - /// assert!(b.intersect(&r1, 0.0, INFTY)); - /// assert!(!b.intersect(&r2, 0.0, INFTY)); - /// assert!(!b.intersect(&r3, 0.0, INFTY)); - /// ``` - pub fn intersect(&self, ray: &Ray, t_min: Float, t_max: Float) -> bool { - println!("BIN: {} -> {}", self.min, self.max); - // Method stolen from Ray tracing the next week. - // They mention its from pixar - for i in 0..3 { - let inv = 1.0 / ray.direction[i]; - let mut t0 = (self.min[i] - ray.origin[i]) * inv; - let mut t1 = (self.max[i] - ray.origin[i]) * inv; - - if inv < 0.0 { - let tmp = t0; - t0 = t1; - t1 = tmp; - } - - let t_min = max(t0, t_min); - let t_max = min(t1, t_max); - - if t_max <= t_min { - return false; - } - } - - return true; - } -} diff --git a/src/core/mod.rs b/src/core/mod.rs deleted file mode 100644 index 95d450c..0000000 --- a/src/core/mod.rs +++ /dev/null @@ -1,34 +0,0 @@ -//! Contains a collection of core modules used by other modules -//! -//! Also creates a shortcut for some common types - -mod vector2; -mod vector3; -mod bound2; -mod bound3; -mod spectrum; -mod ray; - -pub use vector2::{Vector2i, Vector2f}; -pub use vector3::Vector3f; -pub use bound2::{Bound2i, Bound2f}; -pub use bound3::Bound3f; -pub use spectrum::Spectrum; -pub use ray::Ray; - -use crate::Number; - -pub fn min<T: Number> (a: T, b: T) -> T { - if b < a { - return b; - } - a -} - -pub fn max<T: Number> (a: T, b: T) -> T { - if b > a { - return b; - } - a -} - diff --git a/src/core/ray.rs b/src/core/ray.rs deleted file mode 100644 index 19d3cf1..0000000 --- a/src/core/ray.rs +++ /dev/null @@ -1,35 +0,0 @@ -//! The ray class used when probing the 3d scene -use crate::core::Vector3f; -use crate::Float; - -/// A ray that is sent into the world. -/// This is the main type used for testing intersections. -pub struct Ray { - /// Origin of the ray - pub origin: Vector3f, - /// Direction is assumed to be a unit vector. - pub direction: Vector3f, -} - -impl Ray { - pub fn new(origin: Vector3f, direction: Vector3f) -> Ray { - Ray { - origin, - direction, - } - } - - pub fn new_to(origin: Vector3f, target: Vector3f) -> Ray { - let dir = (target - origin).norm(); - Ray { - origin, - direction: dir - } - } - - /// Resolve a point on the ray at time t - pub fn at(&self, t: Float) -> Vector3f { - self.origin + self.direction * t - } -} - diff --git a/src/core/spectrum.rs b/src/core/spectrum.rs deleted file mode 100644 index ed3505b..0000000 --- a/src/core/spectrum.rs +++ /dev/null @@ -1,88 +0,0 @@ -//! Used to represent color -//! -//! Currently only implements RGB colors -use crate::Float; - -// TODO implement SampledSpectrum instead for nicer images - -#[derive(Clone, Copy, Default)] -pub struct Spectrum { - c: [Float; 3], -} - -impl Spectrum { - pub const ZERO: Self = Spectrum { c: [0.0; 3] }; - pub const WHITE: Self = Spectrum { c: [1.0; 3] }; - - pub fn new_rgb(r: Float, g: Float, b: Float) -> Spectrum { - Spectrum { c: [r, g, b] } - } - - pub fn to_rgb(&self, scale: Float) -> (Float, Float, Float) { - (self.c[0] * scale, self.c[1] * scale, self.c[2] * scale) - } - - pub fn gamma_correct(&self) -> Self { - Self::new_rgb( - self.c[0].sqrt(), - self.c[1].sqrt(), - self.c[2].sqrt(), - ) - } -} - -impl std::ops::Mul<Float> for Spectrum { - type Output = Spectrum; - - fn mul(self, op: Float) -> Self::Output { - Self::Output::new_rgb( - self.c[0] * op, - self.c[1] * op, - self.c[2] * op, - ) - } -} - -impl std::ops::Mul for Spectrum { - type Output = Spectrum; - - fn mul(self, op: Self) -> Self::Output { - Self::Output::new_rgb( - self.c[0] * op.c[0], - self.c[1] * op.c[1], - self.c[2] * op.c[2], - ) - } -} - -impl std::ops::Div<Float> for Spectrum { - type Output = Spectrum; - - fn div(self, op: Float) -> Self::Output { - Self::Output::new_rgb( - self.c[0] / op, - self.c[1] / op, - self.c[2] / op, - ) - } -} - -impl std::ops::Add for Spectrum { - type Output = Spectrum; - - fn add(self, op: Self) -> Self::Output { - Self::Output::new_rgb( - self.c[0] + op.c[0], - self.c[1] + op.c[1], - self.c[2] + op.c[2], - ) - } -} - -impl std::ops::AddAssign<&Self> for Spectrum { - fn add_assign(&mut self, op: &Self) { - self.c[0] += op.c[0]; - self.c[1] += op.c[1]; - self.c[2] += op.c[2]; - } -} diff --git a/src/core/vector2.rs b/src/core/vector2.rs deleted file mode 100644 index 405b12a..0000000 --- a/src/core/vector2.rs +++ /dev/null @@ -1,167 +0,0 @@ -//! Implements 2d vectors -//! -//! This is implemented generictly with types that fit in the Number trait -use crate::{Float, Number}; -use std::ops::{Sub, Add, Mul, Div}; -use std::fmt; -use std::cmp::min; - -#[derive(Clone, Copy)] -pub struct Vector2<T: Number> { - pub x: T, - pub y: T, -} - -pub type Vector2f = Vector2<Float>; -pub type Vector2i = Vector2<i32>; - - -impl<T: Number> Vector2<T> { - pub fn new(initial: T) -> Vector2<T> { - Vector2 { x: initial, y: initial } - } - - pub fn new_xy(x: T, y: T) -> Vector2<T> { - Vector2 { x, y } - } -} - -impl<T: Number> Sub for Vector2<T> { - type Output = Self; - fn sub(self, op: Self) -> Self::Output { - Self::new_xy( - self.x - op.x, - self.y - op.y, - ) - } -} - -impl<T: Number> Add for Vector2<T> { - type Output = Self; - fn add(self, op: Self) -> Self::Output { - Self::new_xy( - self.x + op.x, - self.y + op.y, - ) - } -} - -impl<T: Number> Mul for Vector2<T> { - type Output = Self; - fn mul(self, op: Self) -> Self::Output { - Self::new_xy( - self.x * op.x, - self.y * op.y, - ) - } -} - -impl<T: Number> Mul<T> for Vector2<T> { - type Output = Self; - fn mul(self, op: T) -> Self::Output { - Self::new_xy( - self.x * op, - self.y * op, - ) - } -} - -impl<T: Number> Div for Vector2<T> { - type Output = Self; - fn div(self, op: Self) -> Self::Output { - Self::new_xy( - self.x / op.x, - self.y / op.y, - ) - } -} - -impl<T: Number> fmt::Display for Vector2<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_fmt(format_args!("[{}, {}]", self.x, self.y)) - } -} - -impl From<Vector2i> for Vector2f { - fn from(v: Vector2i) -> Self { - Self { - x: v.x as Float, - y: v.y as Float, - } - } -} - -impl From<Vector2f> for Vector2i { - fn from(v: Vector2f) -> Self { - Self { - x: v.x as i32, - y: v.y as i32, - } - } -} - -impl Vector2i { - pub const ZERO: Self = Vector2i {x: 0, y: 0}; - - pub fn cap(&self, x: i32, y: i32) -> Self { - Self::new_xy( - min(self.x, x), - min(self.y, y), - ) - } -} - -impl Vector2f { - pub fn length(&self) -> Float { - (self.x*self.x + self.y*self.y).sqrt() - } - - pub fn ceil(&self) -> Self { - Self::new_xy( - self.x.ceil(), - self.y.ceil() - ) - } - - pub fn floor(&self) -> Self { - Self::new_xy( - self.x.floor(), - self.y.floor() - ) - } -} - - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn new_vec2() { - let v = Vector2::new_xy(2.0, 10.0); - - assert!(v.x == 2.0 && v.y == 10.0); - - let v = Vector2::new(3); - - assert!(v.x == 3 && v.y == 3); - } - - #[test] - fn sub_vec2() { - let v1 = Vector2::new_xy(10, 11); - let v2 = Vector2::new_xy(2, 3); - - let v3 = v1-v2; - assert!(v3.x == 8 && v3.y == 8); - } - - #[test] - fn add_vec2() { - let v1 = Vector2::new_xy(10, 11); - let v2 = Vector2::new_xy(2, 3); - - let v3 = v1+v2; - assert!(v3.x == 12 && v3.y == 14); - } -} diff --git a/src/core/vector3.rs b/src/core/vector3.rs deleted file mode 100644 index 1cc6f60..0000000 --- a/src/core/vector3.rs +++ /dev/null @@ -1,185 +0,0 @@ -//! Implements 3d vectors -//! -//! Also add more 3d math things needed for shading and 3d calculations. -use crate::{Float, Number, NEAR_ZERO}; -use std::ops::{Mul, Sub, Add, DivAssign, Neg, AddAssign, Index}; -use std::fmt; - -#[derive(Clone, Copy)] -pub struct Vector3<T: Number> { - pub x: T, - pub y: T, - pub z: T, -} - -pub type Vector3f = Vector3<Float>; - -impl<T: Number> Vector3<T> { - pub fn new(initial: T) -> Vector3<T> { - Vector3 { - x: initial, - y: initial, - z: initial, - } - } - - pub fn new_xyz(x: T, y: T, z: T) -> Vector3<T> { - Vector3 { x, y, z} - } -} - -impl<T: Number> Sub for Vector3<T> { - type Output = Self; - fn sub(self, op: Self) -> Self::Output { - Self::new_xyz( - self.x - op.x, - self.y - op.y, - self.z - op.z, - ) - } -} - -impl<T: Number> Add for Vector3<T> { - type Output = Self; - fn add(self, op: Self) -> Self::Output { - Self::new_xyz( - self.x + op.x, - self.y + op.y, - self.z + op.z, - ) - } -} - -impl<T: Number> Add<T> for Vector3<T> { - type Output = Self; - - fn add(self, op: T) -> Self::Output { - Self::new_xyz( - self.x + op, - self.y + op, - self.z + op, - ) - } -} - -impl<T: Number> Mul<T> for Vector3<T> { - type Output = Self; - fn mul(self, op: T) -> Self::Output { - Self::Output::new_xyz( - self.x * op, - self.y * op, - self.z * op, - ) - } -} - -impl<T: Number> Neg for Vector3<T> { - type Output = Self; - - fn neg(self) -> Self::Output { - Self::Output::new_xyz( - -self.x, - -self.y, - -self.z, - ) - } -} - -impl<T: Number> AddAssign<&Self> for Vector3<T> { - fn add_assign(&mut self, op: &Self) { - self.x += op.x; - self.y += op.y; - self.z += op.z; - } -} - -impl<T: Number> DivAssign<T> for Vector3<T> { - fn div_assign(&mut self, op: T) { - self.x /= op; - self.y /= op; - self.z /= op; - } -} - -impl<T: Number> fmt::Display for Vector3<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_fmt(format_args!("[{}, {}, {}]", self.x, self.y, self.z)) - } -} - -// Ohh god -impl<T: Number> Index<u32> for Vector3<T> { - type Output = T; - - fn index(&self, i: u32) -> &Self::Output { - match i { - 0 => &self.x, - 1 => &self.y, - 2 => &self.z, - _ => panic!("index out of bounds: index {} is not possible with 3d vector", i) - } - } -} - -impl Vector3f { - pub const ZERO: Self = Vector3f {x: 0.0, y: 0.0, z: 0.0}; - - /// Calculates the length times itself - /// - /// This is faster than using len * len as the square is ommited - pub fn len_squared(&self) -> Float { - self.x * self.x + self.y * self.y + self.z * self.z - } - - pub fn length(&self) -> Float { - self.len_squared().sqrt() - } - - pub fn dot(&self, op: &Self) -> Float { - self.x * op.x + self.y * op.y + self.z * op.z - } - - /// Inplace normal instead of creating a new vector - /// - /// # Example - /// - /// ``` - /// use rendering::core::Vector3f; - /// let mut v = Vector3f::new_xyz(10.0, 0.0, 0.0); - /// v.norm_in(); - /// assert!(v.x == 1.0); - /// ``` - pub fn norm_in(&mut self) { - // TODO Experiment with checking for normality with len_squared - let len = self.length(); - if len == 0.0 { - *self = Self::new(0.0); - } - - *self /= len; - } - - pub fn norm(&self) -> Self { - let mut new = *self; - new.norm_in(); - new - } - - pub fn cross(&self, op: &Self) -> Self { - Self::new_xyz( - self.y * op.z - self.z * op.y, - self.z * op.x - self.x * op.z, - self.x * op.y - self.y * op.x, - ) - - } - - /// Check if vector is close to [0, 0, 0] - /// - /// This is based on the NEAR_ZERO constant - pub fn near_zero(&self) -> bool { - (self.x.abs() < NEAR_ZERO) && - (self.y.abs() < NEAR_ZERO) && - (self.z.abs() < NEAR_ZERO) - } -} diff --git a/src/lib.rs b/src/lib.rs deleted file mode 100644 index 0e6674d..0000000 --- a/src/lib.rs +++ /dev/null @@ -1,41 +0,0 @@ -pub mod core; -pub mod camera; -pub mod render; -pub mod world; -pub mod trace; -pub mod sample; -pub mod material; - -use std::ops::{Add, Sub, Mul, DivAssign, AddAssign, Neg, Div}; -use std::cmp; -use std::fmt; -use std::f64::consts::PI; - -/// Trait used to implement generics -/// -/// This is used in Bound and Vectors -pub trait Number: - Copy + - cmp::PartialOrd + - Sub<Output = Self> + - Add<Output = Self> + - Mul<Output = Self> + - Neg<Output = Self> + - Div<Output = Self> + - DivAssign + - AddAssign + - fmt::Display -{} - -impl Number for i32 {} -impl Number for f32 {} -impl Number for f64 {} - -/// Used for representing floating point values throughout the program -/// -/// A higher precision type will require more ram -pub type Float = f64; - -pub const M_PI: Float = PI; -pub const NEAR_ZERO: Float = 1e-8; -pub const INFTY: Float = f64::INFINITY; diff --git a/src/main.rs b/src/main.rs deleted file mode 100644 index dd67fdc..0000000 --- a/src/main.rs +++ /dev/null @@ -1,63 +0,0 @@ -use rendering::camera::{Camera, Film, CameraSettings}; -use rendering::world::{Scene, Object, shapes::Sphere}; -use rendering::trace::DefaultTracer; -use rendering::core::{Vector2i, Vector3f, Spectrum}; -use rendering::render::{RenderContext, RenderCoord}; -use rendering::sample::UniformSampler; -use rendering::material::*; - -use std::sync::Arc; - -fn main() { - let res = Vector2i::new_xy(500, 500); - - let cam = Camera::new(&CameraSettings { - target: Vector3f::new_xyz(0.0, 0.0, -1.0), - origin: Vector3f::new_xyz(0.0, 0.0, 1.0), - up: Vector3f::new_xyz(0.0, 1.0, 0.0), - fov: 45.0, - filmsize: res, - focus: None, - aperture: Some(10.0), - //aperture: None, - }); - - let brown = Arc::new(Lambertian::new(Spectrum::new_rgb(0.5, 0.3, 0.0))); - let blue = Arc::new(Lambertian::new(Spectrum::new_rgb(0.0, 0.3, 0.7))); - let green = Arc::new(Lambertian::new(Spectrum::new_rgb(0.0, 0.7, 0.3))); - let metal = Arc::new(Reflectant::new(Spectrum::new_rgb(0.8, 0.8, 0.9), Some(1.0))); - let glass = Arc::new(Dielectric::new(1.5)); - let sun = Arc::new(DiffuseLight::new_white(50.0)); - - let mut scn = Scene::new(); - scn.add_objects(vec![ - Object::new(glass, Sphere::new(0.2, Vector3f::new_xyz(0.0, 0.0, -1.0))), - Object::new(blue, Sphere::new(0.5, Vector3f::new_xyz(1.0, 0.0, -1.5))), - Object::new(green, Sphere::new(0.3, Vector3f::new_xyz(0.5, 0.0, -2.5))), - Object::new(brown, Sphere::new(100.0, Vector3f::new_xyz(0.0, -100.5, -1.0))), - Object::new(metal, Sphere::new(0.2, Vector3f::new_xyz(-0.5, 0.0, -1.0))), - Object::new(sun, Sphere::new(0.4, Vector3f::new_xyz(-1.0, 3.0, 0.0))), - ]); - - let tracer = DefaultTracer::new(&scn, Some(50), - //Some(Box::new(SkyLight::new())) - None - ); - - let mut sampler = UniformSampler::new(); - - let ctx = RenderContext { cam: &cam, trc: &tracer }; - - let mut film = Film::new(res); - { - let coord = RenderCoord::new(&mut film, Vector2i::new_xy(50, 50), 16000); - - coord.run_threaded(&ctx, &mut sampler, 8); - } - - let image = film.finalize_image(); - if let Err(e) = image.save("test.png") { - println!("Failed to save {}", e); - } - -} diff --git a/src/material/dielectric.rs b/src/material/dielectric.rs deleted file mode 100644 index c8dc279..0000000 --- a/src/material/dielectric.rs +++ /dev/null @@ -1,56 +0,0 @@ -use super::Material; -use crate::core::{min, Vector3f, Spectrum, Ray}; -use crate::world::Intersection; -use crate::sample::Sampler; -use crate::Float; -use crate::material::reflectant::reflect; - -pub struct Dielectric { - ratio: Float, -} - -// Implementation from RTIOW -fn refract(v: Vector3f, n: Vector3f, r_ratio: Float, cos_theta: Float) -> Vector3f { - let r_perp = (v + n * cos_theta) * r_ratio; - let r_parallel = n * (-(1.0 - r_perp.len_squared()).abs().sqrt()); - - r_perp + r_parallel -} - -// Schlick Approximation, explained in RTIOW -fn fresnel(cos: Float, ratio: Float) -> Float { - let mut r0 = (1.0-ratio) / (1.0+ratio); - r0 = r0 * r0; - - r0 + (1.0-r0)*(1.0-cos).powi(5) -} - -impl Dielectric { - pub fn new(ratio: Float) -> Self { - Self { ratio } - } -} - -impl Material for Dielectric { - // Implementation from RTIOW - fn scatter(&self, ray: &Ray, i: &Intersection, sampler: &mut dyn Sampler) -> Option<(Spectrum, Ray)> { - let ratio = if i.front {1.0/self.ratio} else {self.ratio}; - - let ray_dir = ray.direction.norm(); - let cos_theta = min((-ray_dir).dot(&i.n), 1.0); - let sin_theta = (1.0 - cos_theta*cos_theta).sqrt(); - - // Test if it is possible for the ray the retract or if it must reflect. - let cannot_refract = (ratio * sin_theta) > 1.0; - let direction = if cannot_refract || (fresnel(cos_theta, ratio) > sampler.get_sample()) { - reflect(ray_dir, i.n) - } else { - refract(ray_dir, i.n, ratio, cos_theta) - }; - - Some(( - Spectrum::WHITE, - Ray::new(i.p, direction), - )) - } -} diff --git a/src/material/diffuse_light.rs b/src/material/diffuse_light.rs deleted file mode 100644 index fe462a8..0000000 --- a/src/material/diffuse_light.rs +++ /dev/null @@ -1,27 +0,0 @@ -use super::Material; -use crate::core::{Ray, Spectrum}; -use crate::Float; - -pub struct DiffuseLight { - color: Spectrum, -} - -impl DiffuseLight { - pub fn new(c: Spectrum) -> Self { - Self { - color: c, - } - } - - pub fn new_white(s: Float) -> Self { - Self { - color: Spectrum::new_rgb(s, s, s), - } - } -} - -impl Material for DiffuseLight { - fn emitted(&self, _: &Ray) -> Option<Spectrum> { - Some(self.color) - } -} diff --git a/src/material/lambertian.rs b/src/material/lambertian.rs deleted file mode 100644 index 3df6522..0000000 --- a/src/material/lambertian.rs +++ /dev/null @@ -1,38 +0,0 @@ -use super::Material; -use crate::core::{Ray, Spectrum}; -use crate::world::Intersection; -use crate::sample::Sampler; - -use std::rc::Rc; - -pub struct Lambertian { - color: Spectrum, -} - -impl Lambertian { - pub fn new(c: Spectrum) -> Lambertian { - Lambertian { - color: c, - } - } - - pub fn new_rc(c: Spectrum) -> Rc<dyn Material> { - Rc::new(Self::new(c)) - } -} - -impl Material for Lambertian { - fn scatter(&self, _: &Ray, i: &Intersection, sampler: &mut dyn Sampler) -> Option<(Spectrum, Ray)> { - let mut newray = Ray { - origin: i.p, - direction: i.n + sampler.get_unit_vector(), - }; - - // Make sure that the resulting direction is not (0, 0, 0) - if newray.direction.near_zero() { - newray.direction = i.n; - } - - Some((self.color, newray)) - } -} diff --git a/src/material/mod.rs b/src/material/mod.rs deleted file mode 100644 index 6732598..0000000 --- a/src/material/mod.rs +++ /dev/null @@ -1,25 +0,0 @@ -use crate::core::{Ray, Spectrum}; -use crate::world::Intersection; -use crate::sample::Sampler; - -mod lambertian; -mod diffuse_light; -mod sky_light; -mod dielectric; -pub mod reflectant; - -pub use lambertian::Lambertian; -pub use diffuse_light::DiffuseLight; -pub use sky_light::SkyLight; -pub use dielectric::Dielectric; -pub use reflectant::Reflectant; - -pub trait Material: Sync + Send { - fn scatter(&self, _: &Ray, _: &Intersection, _: &mut dyn Sampler) -> Option<(Spectrum, Ray)> { - None - } - - fn emitted(&self, _: &Ray) -> Option<Spectrum> { - None - } -} diff --git a/src/material/reflectant.rs b/src/material/reflectant.rs deleted file mode 100644 index b5ec0ae..0000000 --- a/src/material/reflectant.rs +++ /dev/null @@ -1,40 +0,0 @@ -use crate::Float; -use crate::core::{Ray, Spectrum, Vector3f}; -use crate::world::Intersection; -use super::Material; -use crate::sample::Sampler; - -pub struct Reflectant { - color: Spectrum, - fuzz: Option<Float>, -} - -impl Reflectant { - pub fn new(c: Spectrum, fuzz: Option<Float>) -> Reflectant { - Reflectant { - color: c, - fuzz, - } - } -} - -pub fn reflect(v: Vector3f, n: Vector3f) -> Vector3f { - v - n * (2.0 * v.dot(&n)) -} - -impl Material for Reflectant { - fn scatter(&self, ray: &Ray, i: &Intersection, sampler: &mut dyn Sampler) -> Option<(Spectrum, Ray)> { - // Find reflectance vector - let mut reflected = reflect(ray.direction, i.n); - if let Some(fuzz) = self.fuzz { - reflected += &(sampler.get_unit_vector() * fuzz); - } - - Some(( - self.color, - Ray::new(i.p, reflected.norm()), - )) - } -} - - diff --git a/src/material/sky_light.rs b/src/material/sky_light.rs deleted file mode 100644 index e499b6e..0000000 --- a/src/material/sky_light.rs +++ /dev/null @@ -1,19 +0,0 @@ -use super::Material; -use crate::core::{Ray, Spectrum}; - -pub struct SkyLight { -} - -impl SkyLight { - pub fn new() -> Self { - Self {} - } -} - -impl Material for SkyLight { - fn emitted(&self, ray: &Ray) -> Option<Spectrum> { - let t = (ray.direction.norm().y + 1.0) * 0.5; - - Some(Spectrum::new_rgb(1.0, 1.0, 1.0) * (1.0-t) + Spectrum::new_rgb(0.5, 0.7, 1.0) * t) - } -} diff --git a/src/render/coordinator.rs b/src/render/coordinator.rs deleted file mode 100644 index e2f825b..0000000 --- a/src/render/coordinator.rs +++ /dev/null @@ -1,126 +0,0 @@ -//! Split a image into small tiles -//! -//! This enables multithreaded rendering. - -use super::{RenderTask, RenderContext}; -use crate::camera::Film; -use crate::core::{Bound2i, Vector2i}; -use crate::sample::Sampler; - -use std::sync::{Mutex}; - -struct Tiler { - tilesize: Vector2i, - - fullbound: Bound2i, - tilemap_size: Vector2i, - tilemap_area: i32, - - next_tile: i32, - tiles_done: i32, -} - -pub struct RenderCoord<'a> { - film: Mutex<&'a mut Film>, - samples: u32, - tiler: Mutex<Tiler>, -} - -impl Tiler { - pub fn new(fullsize: Vector2i, tilesize: Vector2i) -> Tiler { - assert!(tilesize.x != 0 && tilesize.y != 0); - - let tilemap_size = fullsize / tilesize; - - Self { - tilesize, - - fullbound: Bound2i::new(&Vector2i::ZERO, &fullsize), - tilemap_size, - tilemap_area: (tilemap_size.x * tilemap_size.y), - - next_tile: 0, - tiles_done: 0, - } - - } - - pub fn next_tile(&mut self) -> Option<(Bound2i, i32)> { - // Check if we are outside - if self.next_tile >= self.tilemap_area { - return None; - } - - // Convert the tile to xy in tilemap - let tile = Vector2i::new_xy(self.next_tile / self.tilemap_size.x, self.next_tile % self.tilemap_size.x); - let tile_index = self.next_tile; - - self.next_tile += 1; - - // Create a bound from the tilecoordinate - let tile_start = tile * self.tilesize; - // We need to make sure the resulting tile is inside the image bound - Some(( - Bound2i::new(&tile_start, &(tile_start + self.tilesize)).intersect(&self.fullbound), - tile_index, - )) - } - - /// Mark a index as done and return the overall process - pub fn mark_done(&mut self, _index: i32) -> f32 { - self.tiles_done += 1; - - println!("Progress: {}/{}", self.tiles_done, self.tilemap_area); - self.tiles_done as f32 / self.tilemap_area as f32 - } -} - -impl<'a> RenderCoord<'a> { - pub fn new(film: &'a mut Film, tilesize: Vector2i, samples: u32) -> Self { - let size = film.size; - - Self { - film: Mutex::new(film), - samples, - tiler: Mutex::new(Tiler::new(size, tilesize)), - } - } - - pub fn next_task(&self) -> Option<RenderTask> { - let (tile_bound, index) = self.tiler.lock().unwrap().next_tile()?; - - let film_tile = { - let film = self.film.lock().unwrap(); - Box::new(film.get_tile(&tile_bound)) - }; - - Some(RenderTask::new(film_tile, self.samples, index)) - } - - pub fn finish_task(&self, task: &RenderTask) { - { - let mut film = self.film.lock().unwrap(); - film.commit_tile(task.tile.as_ref()); - } - - self.tiler.lock().unwrap().mark_done(task.tile_index); - } - - pub fn work(&self, ctx: &RenderContext, sampler: &mut dyn Sampler) { - while let Some(mut task) = self.next_task() { - task.render(ctx, sampler); - self.finish_task(&task); - } - } - - pub fn run_threaded(&self, ctx: &RenderContext, sampler: &mut (dyn Sampler + Send), threads: u32) { - crossbeam::scope(|scope| { - for _ in 0..threads { - let mut sampler = sampler.clone_and_seed(); - scope.spawn(move |_| { - self.work(ctx, sampler.as_mut()); - }); - } - }).unwrap(); - } -} diff --git a/src/render/mod.rs b/src/render/mod.rs deleted file mode 100644 index b81aaf5..0000000 --- a/src/render/mod.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod task; -mod coordinator; - -pub use task::{RenderContext, RenderTask}; -pub use coordinator::RenderCoord; diff --git a/src/render/task.rs b/src/render/task.rs deleted file mode 100644 index 017fe24..0000000 --- a/src/render/task.rs +++ /dev/null @@ -1,49 +0,0 @@ -//! Implements the main render loop -//! -//! This is not a final design -use crate::camera::film::FilmTile; -use crate::camera::Camera; -use crate::trace::{DefaultTracer, Tracer}; -use crate::sample::Sampler; - -use crate::core::{Vector2f}; -use crate::Float; - -pub struct RenderTask { - pub tile: Box<FilmTile>, - samples: u32, - pub tile_index: i32, -} - -pub struct RenderContext<'a> { - pub cam: &'a Camera, - pub trc: &'a DefaultTracer<'a>, -} - -impl RenderTask { - pub fn new(tile: Box<FilmTile>, samples: u32, tile_index: i32) -> Self { - Self { tile, samples, tile_index } - } - - fn render_at(&mut self, ctx: &RenderContext, x: i32, y: i32, sampler: &mut dyn Sampler) { - let corner = Vector2f::new_xy(x as Float, y as Float); - - for _ in 0..self.samples { - let p = corner + sampler.get_sample_2d(); - - // Create a ray - let (r, _) = ctx.cam.generate_ray(&p, sampler); - - self.tile.add_sample(&p, ctx.trc.trace(sampler, &r)); - } - } - - pub fn render(&mut self, ctx: &RenderContext, sampler: &mut dyn Sampler) { - let b = self.tile.bounds.clone(); - for y in b.min.y .. b.max.y { - for x in b.min.x .. b.max.x { - self.render_at(ctx, x, y, sampler); - } - } - } -} diff --git a/src/sample/mod.rs b/src/sample/mod.rs deleted file mode 100644 index 1a53921..0000000 --- a/src/sample/mod.rs +++ /dev/null @@ -1,46 +0,0 @@ -use crate::{M_PI, Float}; -use crate::core::{Vector3f, Vector2f}; - -mod uniform; - -pub use uniform::UniformSampler; - -fn distribute_between(x: Float, a: Float, b: Float) -> Float { - x * (b - a) + a -} - -pub trait Sampler { - fn get_sample(&mut self) -> Float; - - fn get_sample_2d(&mut self) -> Vector2f { - Vector2f::new_xy(self.get_sample(), self.get_sample()) - } - - fn clone_and_seed(&mut self) -> Box<dyn Sampler + Send>; - - fn get_unit_vector(&mut self) -> Vector3f { - let s2d = self.get_sample_2d(); - - let lambda = distribute_between(s2d.x, -M_PI, M_PI); - let costheta = 2.0 * s2d.y - 1.0; - let sintheta = costheta.acos().sin(); - - Vector3f::new_xyz( - lambda.cos() * sintheta, - lambda.sin() * sintheta, - costheta, - ) - } - - fn get_in_circle(&mut self) -> Vector2f { - let s2d = self.get_sample_2d(); - - let d = s2d.x.sqrt(); - let theta = s2d.y * 2.0 * M_PI; - - Vector2f::new_xy( - d * theta.cos(), - d * theta.sin(), - ) - } -} diff --git a/src/sample/uniform.rs b/src/sample/uniform.rs deleted file mode 100644 index c144f27..0000000 --- a/src/sample/uniform.rs +++ /dev/null @@ -1,39 +0,0 @@ -use crate::Float; -use super::Sampler; - -use rand::prelude::*; -use rand::distributions::Uniform; -use rand_pcg::Pcg32; - -#[derive(Clone)] -pub struct UniformSampler { - r: Pcg32, - d: Uniform<Float>, -} - -impl UniformSampler { - pub fn new() -> Self { - Self::default() - } -} - -impl Default for UniformSampler { - fn default() -> Self { - Self { - r: Pcg32::seed_from_u64(1), - d: Uniform::new(0.0, 1.0), - } - } -} - -impl Sampler for UniformSampler { - fn get_sample(&mut self) -> Float { - self.d.sample(&mut self.r) - } - - fn clone_and_seed(&mut self) -> Box<dyn Sampler + Send> { - let mut n = self.clone(); - n.r = Pcg32::seed_from_u64(self.r.next_u64()); - Box::new(n) - } -} diff --git a/src/trace/mod.rs b/src/trace/mod.rs deleted file mode 100644 index d45fb23..0000000 --- a/src/trace/mod.rs +++ /dev/null @@ -1,41 +0,0 @@ -use crate::world::{Hittable, Scene}; -use crate::core::{Spectrum, Ray, Vector3f}; -use crate::sample::Sampler; - -mod pathtrace; -pub use pathtrace::PathTracer; - -/// Simple surface normal tracer -/// -/// This ray tracer bases color values on the hit surface normals -pub struct NormTracer<'a> { - scn: &'a Scene, -} - -/// Alias for chosen trace implementation. -/// -/// This is swiched at compile time to save alot of time. -pub type DefaultTracer<'a> = PathTracer<'a>; - -pub trait Tracer { - fn trace(&self, sampler: &mut dyn Sampler, ray: &Ray) -> Spectrum; -} - -impl NormTracer<'_> { - pub fn new(scn: &Scene) -> NormTracer { - NormTracer {scn} - } -} - -impl Tracer for NormTracer<'_> { - fn trace(&self, _: &mut dyn Sampler, ray: &Ray) -> Spectrum { - // Trace ray, we dont care about material - if let Some(i) = self.scn.intersect(ray) { - let norm = i.n * 0.5 + Vector3f::new(0.5); - - return Spectrum::new_rgb(norm.x, norm.y, norm.z); - } - - Spectrum::new_rgb(0.0, 0.0, 0.0) - } -} diff --git a/src/trace/pathtrace.rs b/src/trace/pathtrace.rs deleted file mode 100644 index f53e433..0000000 --- a/src/trace/pathtrace.rs +++ /dev/null @@ -1,60 +0,0 @@ -use crate::world::{Hittable, Scene}; -use crate::core::{Ray, Spectrum}; -use crate::material::Material; -use crate::sample::Sampler; -use super::Tracer; - -pub struct PathTracer<'a> { - depth: i32, - scn: &'a Scene, - background: Option<Box<dyn Material>>, -} - -impl PathTracer<'_> { - pub fn new(scn: &Scene, depth: Option<i32>, background: Option<Box<dyn Material>>) -> PathTracer { - let depth = depth.unwrap_or(-1); - - PathTracer { - depth, - scn, - background, - } - } - - pub fn trace_recur(&self, sampler: &mut dyn Sampler, ray: &Ray, depth: i32) -> Spectrum { - - if depth == 0 { - return Spectrum::ZERO; - } - - if let Some(i) = self.scn.intersect(ray) { - // Extract material or default - if let Some(mat) = i.m { - let mut col = Spectrum::ZERO; - - if let Some((scalar, nray)) = mat.scatter(ray, &i, sampler) { - col += &(self.trace_recur(sampler, &nray, depth-1) * scalar); - } - - if let Some(c) = mat.emitted(ray) { - col += &c; - } - - return col; - } - } - - // If no color return background - if let Some(back) = &self.background { - back.emitted(ray).unwrap_or(Spectrum::ZERO) - } else { - Spectrum::ZERO - } - } -} - -impl Tracer for PathTracer<'_> { - fn trace(&self, sampler: &mut dyn Sampler, ray: &Ray) -> Spectrum { - self.trace_recur(sampler, ray, self.depth) - } -} diff --git a/src/world/container/list.rs b/src/world/container/list.rs deleted file mode 100644 index 22b6d88..0000000 --- a/src/world/container/list.rs +++ /dev/null @@ -1,56 +0,0 @@ -use crate::world::{Object, Hittable, Intersection}; -use crate::core::{Bound3f, Ray}; - - -pub struct HittableList { - elems: Vec<Object>, -} - -impl HittableList { - pub fn new() -> Self { - Self::default() - } - - pub fn add(&mut self, h: Object) { - self.elems.push(h); - } -} - -impl Hittable for HittableList { - fn intersect(&self, ray: &Ray) -> Option<Intersection> { - let mut min: Option<Intersection> = None; - - for e in self.elems.iter() { - if let Some(i) = e.intersect(&ray) { - match min { - // Do nothing if distance is bigger than min - Some(ref min_i) if min_i.t < i.t => {}, - // If no existing min or closer than - _ => min = Some(i), - } - } - } - - min - } - - fn bounding_box(&self) -> Bound3f { - let mut bound: Bound3f = Bound3f::EMPTY; - - for e in self.elems.iter() { - let eb = e.bounding_box(); - bound = bound.combine(&eb); - } - - bound - } -} - -impl Default for HittableList { - fn default() -> Self { - Self { - elems: Vec::new(), - } - } -} - diff --git a/src/world/container/mod.rs b/src/world/container/mod.rs deleted file mode 100644 index 35d4693..0000000 --- a/src/world/container/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -mod list; - -pub use list::HittableList; diff --git a/src/world/hittable.rs b/src/world/hittable.rs deleted file mode 100644 index e11a3bc..0000000 --- a/src/world/hittable.rs +++ /dev/null @@ -1,41 +0,0 @@ -use crate::core::{Vector3f, Bound3f, Ray}; -use crate::Float; -use crate::material::Material; - -/// Returns the context of a intersection -pub struct Intersection<'a> { - /// Normal vector at intersection - pub n: Vector3f, - pub p: Vector3f, - pub front: bool, - pub t: Float, - pub m: Option<&'a dyn Material>, -} - -impl<'a> Intersection<'a> { - pub fn new(out_normal: Vector3f, point: Vector3f, ray: &Ray, t: Float) -> Self { - let front = ray.direction.dot(&out_normal) < 0.0; - Intersection { - n: { if front { out_normal } else { -out_normal } }, - front, - p: point, - m: None, - t, - } - } - - pub fn add_material_if_none(&mut self, mat: &'a dyn Material) { - if let None = self.m { - self.m = Some(mat); - } - } -} - -/// Defines a common trait for objects in the scene -pub trait Hittable: Sync + Send { - /// Returns the intersection with ray - fn intersect(&self, ray: &Ray) -> Option<Intersection>; - - /// Returns the axis alligned bounding box containing self - fn bounding_box(&self) -> Bound3f; -} diff --git a/src/world/mod.rs b/src/world/mod.rs deleted file mode 100644 index cba6ddc..0000000 --- a/src/world/mod.rs +++ /dev/null @@ -1,42 +0,0 @@ -//! Manages world objects, and implements intersection -pub mod shapes; - -mod scene; -pub mod container; -mod hittable; -pub use scene::*; -pub use hittable::{Intersection, Hittable}; -pub use shapes::Shape; - -use std::sync::Arc; -use crate::material::Material; -use crate::core::{Bound3f, Ray}; - -pub struct Object { - pub shape: Shape, - pub mat: Arc<dyn Material>, -} - -impl Object { - pub fn new<T: Into<Shape>>(mat: Arc<dyn Material>, shape: T) -> Self { - Object { - mat, - shape: shape.into(), - } - } -} - -impl Hittable for Object { - fn intersect(&self, ray: &Ray) -> Option<Intersection> { - if let Some(mut inter) = self.shape.intersect(ray) { - inter.add_material_if_none(self.mat.as_ref()); - Some(inter) - } else { - None - } - } - - fn bounding_box(&self) -> Bound3f { - self.shape.bounding_box() - } -} diff --git a/src/world/scene.rs b/src/world/scene.rs deleted file mode 100644 index 87bec1f..0000000 --- a/src/world/scene.rs +++ /dev/null @@ -1,43 +0,0 @@ -use crate::core::{Bound3f, Ray}; - -use super::{Object, container, Hittable, Intersection}; - -type Container = container::HittableList; - -pub struct Scene { - content: Container, -} - -impl Scene { - pub fn new() -> Self { - Self::default() - } - - pub fn add_object(&mut self, obj: Object) { - self.content.add(obj); - } - - pub fn add_objects(&mut self, objs: Vec<Object>) { - for obj in objs { - self.add_object(obj); - } - } -} - -impl Hittable for Scene { - fn intersect(&self, ray: &Ray) -> Option<Intersection> { - self.content.intersect(ray) - } - - fn bounding_box(&self) -> Bound3f { - self.content.bounding_box() - } -} - -impl Default for Scene { - fn default() -> Self { - Self { - content: Container::new(), - } - } -} diff --git a/src/world/shapes/mod.rs b/src/world/shapes/mod.rs deleted file mode 100644 index a11df5d..0000000 --- a/src/world/shapes/mod.rs +++ /dev/null @@ -1,30 +0,0 @@ -mod sphere; - -pub use sphere::Sphere; - -use crate::world::{Hittable, Intersection}; -use crate::core::{Bound3f, Ray}; - -pub enum Shape { - Sphere(Sphere), -} - -impl Hittable for Shape { - fn intersect(&self, ray: &Ray) -> Option<Intersection> { - match self { - Self::Sphere(sph) => sph.intersect(ray) - } - } - - fn bounding_box(&self) -> Bound3f { - match self { - Self::Sphere(sph) => sph.bounding_box() - } - } -} - -impl From<Sphere> for Shape { - fn from(s: Sphere) -> Self { - Self::Sphere(s) - } -} diff --git a/src/world/shapes/sphere.rs b/src/world/shapes/sphere.rs deleted file mode 100644 index 1df9c35..0000000 --- a/src/world/shapes/sphere.rs +++ /dev/null @@ -1,98 +0,0 @@ -//! Implements sphere -//! -//! Spheres are relatively easy to calculate intersections between -use crate::{Float, NEAR_ZERO}; -use crate::core::{Ray, Vector3f, Bound3f}; -use crate::world::{Hittable, Intersection}; - -pub struct Sphere { - radius: Float, - center: Vector3f, -} - -impl Sphere { - pub fn new(radius: Float, center: Vector3f) -> Sphere { - Sphere { - radius, - center, - } - } - - fn norm_at(&self, point: &Vector3f) -> Vector3f { - let mut v = *point - self.center; - v /= self.radius; - v - } -} - -impl Hittable for Sphere { - // Implementation from ray tracing in a weekend - fn intersect(&self, ray: &Ray) -> Option<Intersection> { - let oc = ray.origin - self.center; - let a = ray.direction.len_squared(); - let half_b = oc.dot(&ray.direction); - let c = oc.len_squared() - self.radius * self.radius; - let disc = half_b*half_b - a*c; - - if disc < 0.0 { - None - } else { - let disc_sqrt = disc.sqrt(); - - let mut distance = -half_b - disc_sqrt; - if distance <= NEAR_ZERO { - distance = -half_b + disc_sqrt; - } - if distance <= NEAR_ZERO { - return None; - } - - distance /= a; - let w = ray.at(distance); - Some(Intersection::new( - self.norm_at(&w), - w, - ray, - distance, - )) - } - - } - - /// Box containing the circle - /// - /// # Examples - /// - /// ``` - /// use rendering::core::Vector3f; - /// use rendering::world::{Hittable, shapes::Sphere}; - /// - /// let sph = Sphere::new(1.0, Vector3f::new(0.0)); - /// let b = sph.bounding_box(); - /// - /// assert!(b.min.x == -1.0 && b.min.y == -1.0 && b.min.z == -1.0); - /// assert!(b.max.x == 1.0 && b.max.y == 1.0 && b.max.z == 1.0); - fn bounding_box(&self) -> Bound3f { - let offset = Vector3f::new(self.radius); - - Bound3f::new(self.center - offset, self.center + offset) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn sphere_intersect() { - let sph = Sphere::new(2.0, Vector3f::new_xyz(2.0, 3.0, 4.0)); - - let ray = Ray { - origin: Vector3f::new_xyz(1.0, 0.0, 0.0), - direction: Vector3f::new_xyz(0.0, 1.0, 1.5).norm(), - }; - - let dist = sph.intersect(&ray).unwrap(); - assert!((dist.t - 3.28).abs() < 0.01); - } -} |